封装；继承（有super；方法重写）；多态

封装（数据的隐藏）

将属性隐藏起来，避免进行直接的访问，应通过接口方法来操作。
该露的露，该藏的藏

属性私有，get/set
属性要用private修饰符，然后用get/方法
当使用private之后，别的类里就无法再直接使用private修饰的属性和方法了，但是属性可以用get/set来使用（前提是类中定义了get/set方法）

alt+insert 这个按键用处很大，在此处可以自动生成get/set方法。
set的可以对属性设置条件，这样的话可以使s1.setName（）输入时有很多限制

封装的好处：

1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口，所有的方法都是get/set
4. 系统的可维护性增加了

继承 （extends）扩展，子类是父类的扩展

• 继承的本质是对某一批类的抽象，从而对现实世界更好的建模
• JAVA中类只有单继承，没有多继承！（一个儿子只能有一个爸爸，一个爸爸可以有多个儿子）
• 继承是类和类之间的一种关系，除此之外还有依赖、组合、聚合等；
• 继承关系的两个类，一个是子类（派生类），一个是父类（基类）。子类继承父类，使用extends
• 子类和父类之间，从意义上来讲应具有“is a”的关系。
• 在java中所有的类，都默认直接或者间接继承Object
• 父类使用private之后，子类无法直接继承父类的该属性或方法

super

1. 在子类构造器中用super调用父类的构造方法，必须在子类构造方法的第一个
2. super 必须只能出现在子类的方法或者构造方法中
3. super和this不能同时调用构造方法
4. 子类的无参构造中会默认调用父类的无参构造，如果父类没有无参构造，只有有参构造，则子类只可以调用有参构造。

VS this：
代表的对象不同:

• this:本身调用者这个对象
• super：代表父类对象的应用

前提：

• this：没有继承也可以使用
• super：只能在继承条件下才可以使用

构造方法：

• this（）：本类的构造
• super（）：父类的构造
  

方法重写

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

1. 重写都是方法的重写，与属性无关
2. 方法名必须相同
3. 参数列表必须相同
4. 修饰符：范围可以扩大，不可以缩小public>Protected>Default>private
5. 抛出的异常：范围可以被缩小，但不能扩大。ClassNotFoundException—>Exception(大)
6. 重写只和非静态方法有关，和静态方法无关，因为static和类一起加载（想要重写就不要加static）

子类中：
public class A extents B{
@Override
public void test（）{System.out.println(“haha”)；}
}
父类中：
public class B{
public void test（）{System.out.println(“hehe”); }
}
主函数中
A a = new A();
B b = new A();

a.test(); //子类和父类中都没有static，这是重写，所以这两个调用方法都是输出haha
b.test(); //如果两个类中的方法都加上static，则这两个方法则是根据左边（A B）数据类型来判断

B c = new B();
c.test();//输出hehe，虽然重写了，但是和他没关系。他的实际类型和引用类型都是B

当子类和父类的同一个方法都是由static来修饰的时候，方法就是静态方法，方法的调用只和左边，定义的数据类型有关。
当子类和父类的同一个方法是非静态方法时，就为重写，方法的调用就会执行子类的方法。

重写，子类的方法和父类必要一致，方法体不同
为什么要重写？
7. 父类的功能太多，子类不一定需要，或者父类的功能太少不一定满足！
8. alt+insert : override

多态：同一方法可以根据发送对象的不同而采用多种不同的行为方式

注意事项：

1. 多态是方法的多态，属性没有多态
2. 父类和子类有联系，多态才可以存在否则会ClassCastException！
3. 存在的条件：
   1.继承关系，2.子类重写父类方法，3.父类引用指向子类对象 Father f1 = new Son（）；
4. 该引用只能调用父类中定义的方法和变量；
5. 如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）
6. 变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错。

不可被重写的方法：
1.static修饰的方法，属于类，他不属于实例
2.final 常量修饰的方法；
3.private修饰的方法，他是私有的，不能重写

成员变量，静态方法看左边；非静态方法：编译看左边，运行看右边
一个对象的实际类型是确定的。
//new Student();
//new Person();
可以指向的引用类型就不确定了；多态就是父类的引用指向子类的对象。
Student s1 = new Student;
Person s2 = new Student;

public class ceshi {
    public static void main(String[] args) {
        //student 子类能调用的方法都是自己的或者继承父类的
       Student s1 = new Student();
       //person 父类可以指向子类，但是不能调用子类独有的方法
       Person s2 = new Student();**//父类的引用s2指向了子类的对象new Student（）
       Object s3 = new Student();

       //******对象能执行哪些方法，主要看对象左边的类型，和右边关系不大********
       s1.run();//子类重写父类的方法，执行子类的方法
       s2.run();
       s1.eat();
       //s2.eat();//会报错
    }}

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

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

instanceof

这个关键字是判断是否存在父子关系
问题：
Person c = new Person();
System.out.println(c instanceof Student);
为什么这句话结果是false？（已经定义了两个类，Student类继承自Person类）

类型转换

类型之间的转换要有父子关系（继承）
例子：
Student类里面有go方法
Person a = new Student ();
Person是高，Student是低，这句是低转高Student类型转换为Person类型，所以不用强制转换
a.go();//会出错，因为Person类里面没有go方法
所以要将a这个对象转换为Student类型，然后就可以使用Student类型的方法了
((Student)a).go(); //这样就可以使用子类的方法了

//子类转换为父类，可能丢失自己的本来的一些方法
Student student = new Student（）；
student.go();
Person person = student;

多态：

1. 父类引用指向子类的对象（子类引用不可以指向父类对象）
2. 把子类转换为父类，向上转型
3. 把父类转换为子类，向下转型：强制转换（可能会丢失一些子类的方法）
4. 方便方法的调用，减少重复的代码！
   抽象：封装、继承、多态