java的封装、继承、多态

java是面向对象程序设计语言，具有面向对象的三大特征：封装、继承、多态。
一、封装
封装即是指将对象的内部的信息封装（隐藏）在对象内部，通过类提供的方法来实现内部信息的操作和访问。
其目的：
1）隐藏类的实现细节
2）让使用者只能使用事先预定的方法进行访问数据，可以避免一些不合理访问
3）可进行数据检查，从而有利于保证对象信息的完整性
4）便于修改，提高代码维护性
java提供了3个访问控制符：private、protected、public。下表为其访问权限

二、继承
(1)
java的继承是单继承的，每个子类只能继承（extends）一个直接父类。但是java类可以有无限多个间接父类。

class Fruit extends Plant{....}//Plant 是 Fruit 的直接父类
class Apple extends Fruit{....}//Plant 是 Apple 的间接父类

子类包含与父类同名方法的现象为方法重写（覆盖）。方法重写的规则有：
1）子类方法的返回值类型应比父类方法的返回值类型更小或相等
2）子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等
3）子类方法的访问权限应比父类方法的访问权限更大或相等
⚠️注意：重写时注意方法的类型（static？）以及权限（private？）

(2)super限定
子类方法调用父类被重写的方法时，用super限定

public class Bird{//父类
    public void fly(){
        System.out.println("I am flying...");
    }
}
public class Duck extends Bird{//子类
    public void fly(){//重写父类fly()方法
        System.out.println("I am running...");
    }
    public void haveWing(){
        super.fly();//调用父类fly()方法
    }
}

不过正如this不能出现在static修饰的方法中一样，super同样不能。因为static修饰的方法是属于类的，独立于该类的任何一个对象（因为static方法独立于任何对象，因此static方法必须被实现，而不能是抽象的abstract），其直接通过类名调用，任何的实例对象也都可以调用。
注：static用法详见另一篇博客java static用法
在调用父类构造器的时候，使用super和this调用很像，区别在于super调用的是其父类的构造器，this调用的是同一个类中重载的构造器。⚠️使用super调用父类构造器也必须出现在子类构造器执行体的第一行。

class Base{
    public double size;
    public String name;
    public Base(double size, String name){
        this.size = size;
        this.name = name;
    }
}
public class Sub extends Base{
    public String color;
    public Sub(double size, String name, String color){
        super(size, name);//通过super调用父类构造器，且在执行体第一行
        this.color = color;
    }
}

三、多态
通俗的讲就是编译时类型和运行时类型不一样。即只有在运行时才知道具体类。编译时为父类，运行时为子类。
多态存在的三个必要条件
（1）要有继承；
（2）要有重写；
（3）父类引用指向子类对象。（向上转型（upcasting））

class BaseClass{
    public int book = 6;
    public void base(){
        System.out.println("父亲的普通方法");
    }
    public void test(){
        System.out.println("父亲的被覆盖方法");
    }
}
public class SubClass extends BaseClass{
    public String  book = "轻量级java ee";
    public void test(){
        System.out.println("子类覆盖父类的方法");
    }
    public void sub(){
        System.out.println("子类的普通方法");
    }
    public static void main (String[] args){
    BaseClass bc = new BaseClass();
    System.out.println(bc.book);
    bc.base();
    bc.test();
    SubClass sc = new SubClass();
    System.out.println(sc.book);
    sc.base();
    sc.test();
    BaseClass ploymophicBc = new SubClass();//多态的体现
    System.out.println(ploymophicBc.book);
    ploymophicBc.test();
    ploymophicBc.base();
    }
}

输出结果为
BaseClass ploymophicBc = new SubClass()；
编译时类型为BaseClass,运行时为SubClass，所以调用的子类SubClass的方法。即第三个条件父类引用指向子类对象，最终是运行子类对象的方法。
所以，相同类型的变量、调用同一个方法时呈现出多种不同的行为特征，这就是多态。结合例子更容易理解。
instanceof运算符：a instaceof Math
a是变量，Math是类（或接口），它用于判断前面的对象（a）是否是后面的类（Math），或者其子类、实现类的实例。如果是返回true，否则返回false。