07.多态，接口

public interface 接口名称{}

//抽象方法，抽象方法用abstract关键字修饰，没有方法体，该方法供子类实现

public abstract void method(){};

//默认方法，针对于子类的调用和重写，可以解决接口升级问题，接口添加新的抽象方法，每个实现类必须重新实现，牵一发动全身，使用默认方法解决公共新方法的实现，实现类可以继承接口的默认方法，默认方法要有方法体

public default void mehthod(){方法体};

//静态方法，静态方法是不于对象发生关系的，只和类发生关系。静态方法也要有方法体。

public static void method(){方法体};

//私有方法；私有方法和私有静态方法，使用private修饰供接口中的方法和静态方法调用 不是私有默认方法，私有方法是为了不让实现类得到然后给接口内部调用的。

private void method(){方法体};

private static void method(){方法体};

//常量；定义了不可变的成员变量，相当于常量；必须直接赋值，常量大写。

public static final MUN = 10  

class 类名 implements 接口名{

    //重写接口的抽象方法

    //重写接口的默认方法（非必须）

}

public interface LiveAble {     

    // 定义抽象方法     

    public abstract void eat();     

    public abstract void sleep(); 

}

//实现接口

public class Animal implements LiveAble {     

    @Override     public void eat() {         System.out.println("吃东西");     }     

    @Override     public void sleep() {         System.out.println("晚上睡");     } 

}

//测试类

public class InterfaceDemo {    

    public static void main(String[] args) {        

    // 创建子类对象          

    Animal a = new Animal();        

    // 调用实现后的方法        

    a.eat();        

    a.sleep();    

            }   

} 

输出结果： 吃东西 晚上睡

//继承默认方法，创建子类对象，直接调用

Animal a = new Animal();

a.fly();

//重写默认方法，创建子类对象，调用后使用重写以后的方法。谁调用使用谁的方法。

public class Animal implements LiveAble {    

    @Override     

    public void fly() { System.out.println("自由自在的飞"); } 

}

public interface LiveAble {     public static void run(){         System.out.println("跑起来~~~");     } }

public class Animal implements LiveAble { // 无法重写静态方法      }

public class InterfaceDemo {     

    public static void main(String[] args) {       

        // Animal.run(); // 【错误】无法继承方法,也无法调用     

        LiveAble.run();  //静态方法直接使用接口点方法调用   } 

    } 

    输出结果： 跑起来~~~   

普通私有方法：private 返回值类型 方法名称(参数列表) { 方法体 }

静态私有方法：private static 返回值类型 方法名称(参数列表) { 方法体 }

注意：private的方法只有接口自己才能调用，不能被实现类或别人使用。

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {    

    // 重写接口中抽象方法【必须】    // 重写接口中默认方法【不重名时可选】  

    }

父类类型 变量名 = new 子类对象

变量名.方法名；

调用方法的时候，使用父类类型的变量，调用方法，首先编译的时候会检查父类是否有该方法，如果没有，会报错，如果有会执行子类的重写方法

调用成员变量的时候，使用什么变量调用就使用哪个变量的值。

使用多态的好处，不用定义子类的单独方法，首先用父类的类型变量，调用方法，本身自己是父类类型，都是抽象方法，没法调用，只能调用包含的子类的重写方法。很完美，这就是左面编译，有运行的概念，左面是父类的抽象方法，所以可以通过编译，但是子类的重写方法可以通过new的子类对象调用，

这就是静态绑定，和动态绑定。

public class Test {     

    public static void main(String[] args) {        

        // 向上转型          

        Animal a = new Cat();           

        a.eat();               

        if (a instanceof Cat){             

            Cat c = (Cat)a;                    c.catchMouse();      //调用的是Cat的catchMouse

                             } 

        else if (a instanceof Dog){             Dog d = (Dog)a;                    d.watchHouse();       // 调用的是 Dog的watchHouse         }    

                                                         }  

    }

public boolean equals (Obejct object)

    用来比较 本类 的两个对象是否在 逻辑上相等 , 而不是地址上相等

    相等返回 true  反之false

    该方法是 Object 定义  , 所有类都拥有该方法

equals 默认比较的是地址  子类如果有该需求 一定记得重写 equals 

    /**

     * 如果有属性是引用数据类型 , 一定不能 == 来比较

     * 而是调用属性对象的 equals 方法 

     */

    /**

     *  instanceof  关系运算符  

     *  使用格式 : 

     *      对象 instanceof 类名 ; 

     *  返回 布尔值

     *  如果 对象是该类的对象 , 那么返回true  反之false

     *  

     */

    /**

     * 基本数据类型强转 ： 可能会丢失数据

     * 引用数据类型强转 ： 可能会有类型不匹配异常  java.lang.ClassCastException

     *                    如果没有继承关系 不能强转

     */

    @Override

    public boolean equals(Object obj) {

        if( this == obj)

            return true;

        // 判断 obj 是本类对象

        if( !(obj instanceof Person) )

            return false;

        // 引用数据强转  经过判断之后可以放心的强转了

        Person p = (Person)obj;

        // 接下来是 具体的判断是否相等的 业务逻辑

        if( this.age == p.age)

            if(this.sex == p.sex)

                return this.name.equals(p.name);

        return false;

    }

    /**

     * 按照 age 进行比较

     */

    @Override

    public int compareTo(Object o) {

        System.out.println("Person.compareTo()");

        Person p = (Person)o;

        int result = this.age - p.age;

        return result;

    }

    /**

     * 按照 sex 进行比较    boolean 不能直接 - , 可以把boolean 替换成 1 和  0 ;

     */

    @Override

    public int compareTo(Object o) {

        Person p = (Person)o;

        int result = this.sex ? 1 : 0  - (p.sex ? 1 : 0);

        return result;

    }