面向对象三大特性（封装、继承、多态）
面向对象三大特性（封装、继承、多态）
1. 封装
1.1对于封装的一些表面理解
1.装起来，只留一个口 该露的露，该藏得藏
2.高内聚（类的内部数据操作细节自己完成，不允许外部干涉）低耦合（仅暴露少量的方法给外部使用）
3.封装（数据的隐藏）：通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
1.2 封装的意义优点：
/*
* 封装的好处
* 1.提高程序的安全性，保护数据，防止破坏程序（如输入不切实际的年龄660岁）
* 2.隐藏代码的实现细节。
* 3.统一接口 get set
* 4.提高系统的可维护性。
* */
1.3 关键点
- 记住属性私有private，get/set方法 一般属性要私有
（以前public属性 可以直接调用和赋值，现在private属性不能那样了，所以想操作这些私有属性，通过get、set来操作）
- 封装一般使对于属性 ，对于方法很少使用
2. 继承
1.1 关于继承的说明
1.继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
1.1 继承的关键点
- 在Java中，所有的类都默认直接或间接继承Object类
- 继承是类和类之间的一种关系。（类和类之间的关系有：继承，依赖，组合，聚合）
- 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，用关键字extends表示。
- extends 扩展，子类（派生类）是父类（基类）的扩展
- Java中类只有单继承，没有多继承！（一个子类只能有一个父类，但一个父类可以有多个子类）子类直接的只能继承一个父类，能间接的继承多个
- 子类继承了父类，就会拥有父类全部的方法（当然父类的私有方法不行哦，子类不能继承父类的私有方法或者属性）
- 子类和父类之间，从意义上讲应该具有is a的关系。
- 父类若没有无参构造器，子类则也写不了无参构造器 （只能在子类中 调用父类的有参构造 super("123");）
所以一般任何类写了有参构造之后，要把无参构造加上，即显示表达出来
1.2 this 和 super
this 指当前类的什么
super 指父类的什么
# super注意点
1.super调用父类的构造方法，必须在构造方法的第一个，第一行
2.super必须只能出现在子类的方法或者构造方法中（若在父类中调用super，则调用到父类的父类Object中去了）
3.super 和this 不能同时调用构造方法！ super() 和this()不能同时出现
# this
和super 代表的对象不同：
this: 本身调用者的这个对象
super:代表调用者的父类对象的引用
前提
this:没有继承也可以使用
super：只能在继承条件下才能使用
构造方法
this(); 调用本类的无参构造 this("123"); 调用本类的有参构造
super(); 调用父类的无参构造！super("123"); 调用父类的有参构造
调用子类的无参构造器时，父类的无参构造器先执行，（默认在子类的构造器中，有super()在第一行）
1.3 方法的重写
1.3.1 重写关键点：
-
重写都是方法的重写，和属性无关，且重写是针对非静态方法的，与静态方法无关，与属性无关
-
重写的方法只能是
public的 ,不能是private的 -
方法重写是子类父类才有的，子类继承父类之后，子类重写父类的方法，是执行子类的方法，并不是改变父类的方法
重写的方法跟父类的被重写方法长的一样，只是方法的实现不同（方法体不同）
-
///静态方法和非静态方法区别很大！
//静态方法：静态方法的调用只和左边，定义的数据类型有关。
//非静态方法：才是重写！！ -
//静态方法的调用只和左边，定义的数据类型有关。 B b = new A();//父类的引用指向了子类 父类：B 父类的引用：b 指向了子类：= new A();
1.3.2 总结方法的重写
# 总结：方法的重写 Alt + Insert 选Override Methods
前提：需要有继承关系，子类父类中才有的，子类继承父类，子类重写父类的方法。
重写是针对方法的，而且是非静态方法（与静态方法无关），与属性无关。
1. 方法名需要相同（子类中重写的方法和父类中被重写的方法名需要相同）
重写：子类的方法和父类必须一致，方法体不同！
2. 参数列表必须相同
3. 修饰符：范围可以扩大，不能缩小 （public > protected > default > private）
4. 抛出的异常：范围可以被缩小，但不能扩大 ClassNotFoundException --> Exception(大)
## 为什么需要重写？
1.父类的功能，子类不一定需要，或者不一定满足！
1.3.3 哪些方法不能被重写？？
* 哪些方法不能被重写？
* 1.static方法 ，属于类，不属于实例。
* 2.final 常量池里的 不能改变
* 3.private 方法 私有的 也不能被重写！
1.3.4 代码演示
public class Application {
public static void main(String[] args) {
System.out.println("Hello World !");
A a = new A();
System.out.println(a);
a.test();
B b = new B();
System.out.println(b);
b.test();
//方法重写 方法重写是针对非静态方法的，与静态方法无关，与属性无关
System.out.println("---------方法重写--（针对非静态方法）--修饰符范围可以变大，不能缩小------");
//抛出的异常：范围可以被缩小，但不能扩大 ClassNotFoundException --> Exception(大)
//父类 和子类都是public方法 可重写
//父类是protected方法 ，子类修饰符范围不能变小，可以是protected方法，也可以是public方法
//（public > protected > default > private）
B a1 = new A();
System.out.println(a1);
a1.test();
}
}
3. 多态
3.1 一些说明
动态编译 ：类型 ：可扩展性
同一方法可以根据发送对象的不同而采用多种不同的行为方式。（都是run（），执行的结果不一样）
3.2 关键点
-
对象能执行哪些方法，主要看对象左边的类型（和继承关系），和右边关系不大！（子类重写父类方法，那就执行子类的方法）
-
一个对象的实际类型是确定的，但是它可以指向的引用类型就不确定了（父类或者有关系的类）
-
对象能执行哪些方法，主要看对象左边的类型（和继承关系），和右边关系不大！
没重写时，父亲自己有这个方法,父亲对象执行父亲的方法 2.子类重写了父类的方法，所以父亲对象执行的是子类的方法
3.3 多态的注意事项
/*多态的注意事项
* 1.多态是方法的多态，属性没有多态 重写也是针对非静态方法的，与属性和静态方法无关
* 2.父类和子类，有联系，String Perosn 类型转换异常ClassCastException
String s4 = new Student(); 是不行的 （因为String 和Student无关）
* 3.多态存在的条件: 有继承关系，方法需要重写, 父类引用指向子类对象！ Father f1 = new Son();
*
*
*
* 哪些方法不能被重写？
* 1.static方法 ，属于类，不属于实例。
* 2.final 常量池里的 不能改变
* 3.private 方法 私有的 也不能被重写！
*
* */
3.4 代码演示
//一个对象的实际类型是确定的。
//它可以指向的引用类型就不确定了:父类的引用指向了子类的类型
Student s1 = new Student();/*一个类的实际对象的类型是确定的 都是Student*/
Person s2 = new Student();/*但它指向的引用类型是不确定的，现在是它的父类型*/父类的引用指向了子类的类型
Object s3 = new Student();/*但它指向的引用类型是不确定的，现在是它的祖宗类型*/祖宗类型的引用指向了子类的类型
//多态：都是new的Student()，但是对象的类型不同（Student Person Object）
//前提 ，有父子关系或祖宗关系！例如Student继承了Person,
没关系的肯定不行(Student 和 String 无关，所以不能String s4 = new Student();)
//Student 能调用的方法都是自己的或者继承父类的！
Student s1 = new Student();
//Person 父类型，可以指向子类，但是不能调用子类独有的方法
/*****父类的引用指向了子类*******/
Person s2 = new Student();
Object s3 = new Student();
4. 总结
1. 封装是对于属性，很少封装方法
2. 继承是类和类之间的一种关系 （所有类默认都继承Object类,Object类是所有类的父类或祖宗类）
（类和类之间的关系有：继承，依赖，组合，聚合）
3. 多态是方法的多态，属性没有多态
方法重写是针对非静态方法的，与静态方法无关，与属性无关
判断两个方法是否相同（1.方法名 2. 参数）
封装 之后 才能继承 继承之后才能多态
对象能执行哪些方法，主要看对象左边的类型（和继承关系），和右边关系不大！
*没重写时，父亲自己有这个方法,父亲对象执行父亲的方法 2.子类重写了父类的方法，所以父亲对象执行的是子类的方法
