多态

重写

1.父类的静态方法和实例方法都可以继承

2.父类的静态方法和实例方法都可以重写（覆盖）吗？

静态方法可以被继承 不能被覆盖

public class Fu {
    public void a(){
        System.out.println("父类实例方法a");
    }
    public static void b(){
        System.out.println("父类静态方法b");
    }
}

public class Zi extends Fu{
    public void a(){
        System.out.println("子类实例方法a");
    }
    public static void b(){
        System.out.println("子类静态方法b");
    }
}

public class Test1 {
    public static void main(String[] args) {
        //测试父类
        Fu fu = new Fu();
        fu.a();
        fu.b();

        System.out.println("------------------");

        //测试子类
        Zi zi = new Zi();
        zi.a();
        zi.b();

        System.out.println("------------------");

        //多态测试
        Fu fu1 = new Zi();
        fu1.a();
        fu1.b();

    }
}

父类实例方法a
父类静态方法b
------------------
子类实例方法a
子类静态方法b
------------------
子类实例方法a
父类静态方法b

重写object类的equals方法

1.Object类的equals()方法：

比较两个对象是否是同一个对象，是则返回true
Object类是所有类的父类，它的equals方法自然会被所有类继承，有一个子 类String对equals方法进行了覆盖（重写），使其具有了新功能
2.操作符==
简单数据类型或常量值，直接比较值。如12，“你好”“你好”
引用类型，比较是否为同一个对象。
（1）Object类的equals()方法与==没区别
（2）Java.lang.String重写了equals()方法，把equals()方法的判断变为了判断其值
（3）当有特殊需求，如认为属性相同即为同一对象时，需要重写equals()

总结：

1. 基本数据类型数据值只能用==
2. 对于引用数据类型，==和Object的equals方法是一样的。（查看源码）
3. 由于String类对父类Object的equals方法的重写，导致==与equals唯一的区别在于：
   

instanceof

java中的instanceof运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例
使用格式： 对象 instanceof 类
使用解析：
形参 和实参 和 右边的类型
主要是看实参对象是否属于右边的类型

多态

学习完封装以后，我们可以使用两种方式为对象属性赋值，set方法和有参构造。
什么时候使用set，什么时候使用有参构造。
Set可以在创建对象以后，反复的对属性值进行修改。而有参构造是在产生对象的同时就为属性赋值，且同一个对象只能使用一次。

1. 什么是多态？
   //把子类的实例化对象赋值给父类的引用类型
   继承 Fu f=new Zi(); Pet p=new Dog(); Pet p=new Penguin();
   重写 f.a();
   多种状态 多态=继承+重写
2. 案例理解：
3. 使用多态实现宠物看病
4. 使用多态实现宠物喂食。
5. 捐献宠物系统
   应用：
   1.父类作为方法的形参 （多态最常用的使用方式）
   案例：狗狗和企鹅都有看病的方法，如果健康值<50,主人就带它们去看病。
   2.父类作为方法的返回值
   例：捐献动物

向上转型和向下转型

public class Test1 {
    public static void main(String[] args) {
        //向上转型
        Object a = new Animal();//升一级
        Animal e1=new Elephant();//升一级
        Object e2=new Elephant();//升两级
        //向下转型----要先向上转型
        /*Elephant a1= (Elephant) new Animal();//降1级
        Elephant a2= (Elephant) new Object();//降2级
        Animal a3= (Elephant) new Object();//降1级*/
        Animal a1 = (Animal) a;
        Elephant ee1= (Elephant) e1;
        Animal e3= (Animal) e2;
        Elephant e4= (Elephant) e2;

       /* instanceof  形参 和实参 和  右边的类型
        主要是看实参对象是否属于右边的类型*/
        System.out.println(a instanceof  Object);
        System.out.println(a instanceof  Animal);
        System.out.println(a instanceof  Elephant);//false
        System.out.println("------------------");
        System.out.println(e1 instanceof  Object);
        System.out.println(e1 instanceof  Animal);
        System.out.println(e1 instanceof  Elephant);
        System.out.println("------------------");
        System.out.println(e2 instanceof  Object);
        System.out.println(e2 instanceof  Animal);
        System.out.println(e2 instanceof  Elephant);
    }
}

true
true
false
------------------
true
true
true
------------------
true
true
true

多态的接地气的理解：父类作为形参，子类类型作为实参。

.Final

修饰的变量称为常量，值不能被修改
修饰的方法不能被重写，保证安全性和稳定性
修饰的类不能被继承，避免功能被覆盖。

要想让一个类不被其它类继承：

1. 用final修饰
2. 构造方法私有化