面向对象编程的三大特性

封装

该露的露，该藏的藏

我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。
封装(数据的隐藏)

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

记住这句话就够了：属性私有，get/set

//类 private: 私有
public class Student {//属性私有
private String name;
private  int age;
private char sex;//提供一些可以操作这些属性的方法
//提供一些public的get,set方法//get 获得这个数据
public String getName(){return this.name;
}//set 给这个数据设置值
public void setName(String name){this.name = name;
}//快捷键 Alt+Insert 自动生成get、set方法public int getAge() {return age;}public void setAge(int age) {if(age>0 && age <=120){this.age = age;}else{this.age = 3;//不合法的}}public char getSex() {return sex;}public void setSex(char sex) {this.sex = sex;}


public class Application {public static void main(String[] args) {Student s1 = new Student();s1.setName("jjlin");System.out.println(s1.getName());//jjlins1.setAge(9);System.out.println(s1.getAge());}}

封装的好处
- 提高程序的安全性，保护数据.
- 隐藏代码的实现细节
- 统一接口
- 系统的可维护性增加了

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extands的意思是“扩展”。子类是父类的扩展。
JAVA中类只有单继承，没有多继承! 一个儿子只能有一个爸爸，但一个爸爸可以有多个儿子
被final修饰的类不能被继承。

继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。

继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
子类和父类之间,从意义上讲应该具有"is a"的关系.
快捷键 Ctrl + H ，可以显示类之间的关系

//先定义一个父类
//在Java中，所有的类，都默认直接或或者间接继承object
//Person一个类 :父类
public class Person /*extends object*/ {/*四个修饰符1.public  方法用继承都用public2.protected3.default4.private  属性一般用private*/private  int money = 10_0000_0000;public void say(){System.out.println("说了一句话");}
}public int getMoney() {return money;
}public void setMoney(int money) {this.money = money;
}

//后定义子类
//Student is 人 ：派生类，子类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person {}//Teacher is 人 ：派生类，子类
public class Teacher extends Person {}

public class Application {public static void main(String[] args) {Student student = new Student();student.say();//说了一句话student.setMoney(10_0000); System.out.println(student.getMoney());//100000}
}

object类

java中的所有类都直接或间接继承Object类

super

//定义一个父类
public class Person /*extends object*/ {protected String name = "kuangshen" ;public void print(){System.out.println("Person");}
}

//定义一个子类
public class Student extends Person {//快捷键 Ctrl + H   显示父类private String name = "qinjiang";public void print(){System.out.println("Student");}public void test1(){print(); //Studentthis.print(); //Studentsuper.print(); //Person}public void test(String name){System.out.println(name);//jjlinSystem.out.println(this.name);//qinjiangSystem.out.println(super.name);//kuangshen}

//应用
public class Application {public static void main(String[] args) {Student student = new Student();student.test("jjlin");student.test1();}
}

注意：请仔细分辨各个输出，理清super和this之间的关系。

构造器的不同

//父类
public class Person {//一个类即使什么都不写，它也会存在个方法//显示的定义构造器public Person(){System.out.println("Person");}//有参构造:一旦定义 了有参构造。无参就必须显示定义public Person(String name){this.name = name ;}}

//子类
public class Student extends Person{public Student() {//super();是隐藏代码，默认是先调用父类的无参构造器再调用子类的构造器super(); // 隐藏代码:调用了父类的无参构造，调用父类的构造器，必领要在子类构造器的第一行System.out.println("Student无参执行了");}public Student(String name) {this .name = name ;}
}

super注意点:

super调用父类的构造方法，必须在构造方法的第一个

super 必须只能出现在子类的方法或者构造方法中!

super和 this 不能同时调用构造方法!

Vs this:

代表的对象不同:
this 本身调用者这个对象
super:代表父类对象的引用

前提
this:没有继承也可以使用
super:只能在继承条件才可以使用

构造方法
this() ; 本类的构造
super():父类的构造!

重写

父类静态方法

//子类
public class A extends B {public static void test(){System.out.println("A==>test()");}
}

//父类
public class B  {public static void test(){System.out.println("B==>test()");}
}

public class Application {public static void main(String[] args) {//方法的调用只和左边，定义的数据类型有关A a = new A();a.test();//A==>test()//父类引用指向了子类B b = new A();b.test();//B==>test()}
}

父类非静态方法

//父类
//重写都是方法的重写，和属性无关
public class B  {public void test(){System.out.println("B==>test()");}
}

//子类
public class A extends B{//Override就是方法的重写//快捷键Alt+Insert，选中Override可以自动生成，不用写@Override //注解：有功能的注释public void test() {super.test();}
}

public class Application {public static void main(String[] args) {/*静态方法和非静态方法区别很大静态方法：方法的调用只和左边，定义的数据类型有关非静态方法：重写，父类方法只能是public*/A a = new A();a.test();//B==>test()//父类引用指向了子类B b = new A();b.test();//B==>test()}}

重写:需要有继承关系，子类重写父类的方法!

方法名必须相同
参数列表列表必须相同
修饰符:范围可以扩大但不能缩小:public>Protected >Default>private
抛出的异常:范围，可以被缩小，但不能扩大: ClassNotFoundException --> Exception(大)
重写，子类的方法和父类必要一致;方法体不同!

为什么需要重写:

父类的功能，子类不一定需要，或者不一定满足!

比如，把子类的方法重写一次，变为

//子类
public class A extends B{public void test(){System.out.println("A==>test()");}}

//父类
//重写都是方法的重写，和属性无关
public class B  {public void test(){System.out.println("B==>test()");}}

public class Application {public static void main(String[] args) {//方法的调用只和左边，定义的数据类型有关A a = new A();a.test();//A==>test()//父类引用指向了子类B b = new A();b.test();//A==>test()}}

注意与上述例子输出的不同，一个是直接继承了父类的方法，输出B==>test()，而子类方法重写之后，输出的是A==>test()

Alt +Insert ;---->override;

多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态存在的条件

有继承关系
子类重写父类方法
父类引用指向子类对象

注意:多态是方法的多态，属性没有多态性。

//父类
public class Person {public void run(){System.out.println("run");}
}

//子类
public class Student extends Person {@Overridepublic void run() {System.out.println("son");;}public void eat(){System.out.println("eat");}
}

public class Application {public static void main(String[] args) {//一个对象的实际类型是确定的//new Student();//new Person();//可以指向的引用类型就不确定了，比如父类的引用可以指向子类//Student 子类型，能调用的方法都是自己的或者继承父类的Student s1 = new Student();//Person 父类型，虽然可以指向子类，但是不能调用子类独有的方法Person s2 = new Student();Object s3 = new Student();//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大s1.run();//son, 子类重写了父类的方法，执行的是子类的方法s2.run();//sons1.eat();}}

多态注意事项:
- 多态是方法的多态，属性没有多态
- 父类和子类，有联系。如果类型转换异常!，就会报错ClassCastException!
- 存在条件: 有继承关系，方法需要重写，父类引用指向子类对象! Father f1 = new Son();如果子类重写了父类的方法，父类引用如果指向了子类对象，执行的就是子类重写的方法。
- 不能进行多态的方法：
  - static 方法，属于类，它不属于实例
  - final常量;
  - private 方法;

instanceof：(类型转换)引用类型，判断一个对象是什么类型~，可以判断两个类之间是否存在父子关系

//父类
public class Person {public void run(){System.out.println("run");}
}

//子类1
public class Student extends Person {public void go(){System.out.println("go");}
}

//子类2
public class Teacher extends Person {}

public class Application {public static void main(String[] args) {//Object > String//Object > Person > Teacher//Object > Person > StudentObject object = new Student();//System.out.println(X instanceof Y); //能不能编译通过，看是否存在父子关系System.out.println(object instanceof Student); //trueSystem.out.println(object instanceof Person); //trueSystem.out.println(object instanceof Object); //trueSystem.out.println(object instanceof Teacher); //falseSystem.out.println(object instanceof String); //falseSystem.out.println("================================");Person person = new Student();System.out.println(person instanceof Student); //trueSystem.out.println(person instanceof Person); //trueSystem.out.println(person instanceof Object); //trueSystem.out.println(person instanceof Teacher); //false// System.out.println(person instanceof String); //编译就已经报错System.out.println("================================");Student student = new Student();System.out.println(student instanceof Student); //trueSystem.out.println(student instanceof Person); //trueSystem.out.println(student instanceof Object); //true//System.out.println(student instanceof Teacher); //编译就已经报错// System.out.println(person instanceof String); //编译就已经报错}}

转换

父类转子类

public class Application {public static void main(String[] args) {//类型之间的转化： 父 -----> 子 需要向下强制转换//父                子Person obj = new Student();//Student 将这个obj对象强制转换为Student类型，就可以使用Student类型的方法了((Student) obj).go();}}

子类转父类

public class Application {public static void main(String[] args) {//子类转换为父类，可以直接转换，但可能会丢失自己本来的一些方法Student student = new Student();student.go();Person person = student;//person.go();  //  person丢失了go方法}}

/*
子转父：向上转型，直接转，但会丢失子类中原本可以直接调用的特有方法
父转子：向下转型，需要强制转换*/

总结

父类引用指向子类的对象
把子类转换为父类，向上转型；
把父类转换为子类，向下转型；强制转换
方便方法的调用，减少重复的代码!j简洁
封装、继承、多态! 抽象类，接口

面向对象编程的三大特性相关推荐

【Java】《Java面向对象编程的三大特性》阅读笔记
前言偶然读到这篇文章(<Java面向对象编程的三大特性>),想来这也算论文?这种还不满网络都是?读罢觉得写得还真不错,这里以我愚见,简单点评一二,不足之处还望指教. 阅读笔记笔记1 文 ...
Go面向对象编程的三大特性
Go面向对象编程的三大特性 1.基本介绍 Golang仍然有面向对象编程的继承,封装和多态的特性,只是实现的方式和其它OOP语言不一样. 2.面向对象编程思想-抽象抽象: 在定义一个结构体类型时,实 ...
python面向对象编程的三大特性_Python面向对象总结及类与正则表达式详解
Python3 面向对象 -------------------------------------------------------------------------------- 一丶面向对象 ...
Java 面向对象编程的三大特性——封装、继承、多态
一.类和对象 1. 首先,什么是对象呢? 对象简单的来说就是一个实物,比如一部 iPhone X 手机,它就是对象.它的屏幕.内存等就是它的属性. 手机能够打电话,发短信,这个功能就是它的方法. 2. ...
Python3面向对象编程的三大特性封装、继承、多态
1.封装封装:将数据与具体操作的实现代码放在某个对象内部,使这些代码的实现细节不被外界发现,外界只能通过接口使用该对象,而不能通过任何形式修改对象内部实现,正是由于封装机制,程序在使用某一对象时不需 ...
面向对象编程及其三大特征（JAVA）
面向对象编程及其三大特征(JAVA) 一.面向对象编程介绍: 面向过程与面向对象: 面向对象的本质: 二.面向对象编程的三大特征: 封装: 封装的概念: 封装的优点: 封装举例(Person类) 继承 ...
【并发编程】并发编程的三大特性
并发编程的书籍都会讲到并发编程的三大特性,这是并发编程中所有问题的根源,我们只有深刻理解了这三大特性,才不会编写出漏洞百出的并发程序. 基本概念 1.原子性,所有操作要么全部成功,要么全部失败. 2. ...
day31 Pyhton 面向对象的基础三大特性
一.内容回顾封装 1.概念笔记 2.__名字在类的外部就不能用了 3.私有化的不能被子类继承,也不能在其他任何类中调用三个装饰器方法(装饰类中的方法) 1.不被修饰的普通方法,会使用对象 ...
韩顺平php视频笔记70 面向对象编程的三大特征1 抽象封装
php面向对象编程的三大特征 ① 封装 ② 继承 ③ 多态 class Account { public $blance; public $no; public function qun(){ } p ...

面向对象编程的三大特性

面向对象编程的三大特性

封装

继承

多态

面向对象编程的三大特性相关推荐

最新文章

热门文章