2020/7/6 JAVA接口及多态

            public
            interface
             接口名 {
抽象方法1;
抽象方法2;
抽象方法3;
}
        

            //
            格式：
            class 类 implements 接口 {
    重写接口中方法
} 

            interface Demo { ///定义一个名称为Demo的接口。publicstaticfinalint NUM = 3;// NUM的值不能改变publicabstractvoid show1();
    publicabstractvoid show2();
}

//定义子类去覆盖接口中的方法。类与接口之间的关系是 实现。通过 关键字 implementsclass DemoImpl implements Demo { //子类实现Demo接口。
    //重写接口中的方法。publicvoid show1(){}
    publicvoid show2(){}
}

            class
             Fu {
    
            public
            void
             show(){}
}

            interface
             Inter {
    pulbic 
            abstract
            void
             show1();
}

            class Zi extends Fu implements Inter {
    publicvoid show1() {
    }
}

            interface
             Fu1{
    
            void
             show();
}

            interface
             Fu2{
    
            void
             show1();
}

            interface
             Fu3{
    
            void
             show2();
}

            interface Zi extends Fu1,Fu2,Fu3{
    void show3();
}

            //
            普通类多态定义的格式
父类 变量名 = new 子类();
如：    class Fu {}
    class Zi extends Fu {}
    //类的多态使用
Fu f = new Zi();

//抽象类多态定义的格式
抽象类 变量名 = new 抽象类子类();
如：    abstractclass Fu {
         publicabstractvoid method();
         }
class Zi extends Fu {
publicvoid method(){
              System.out.println(“重写父类抽象方法”);
}
}
//类的多态使用
Fu fu= new Zi();

//接口多态定义的格式
接口 变量名 = new 接口实现类();
如： interface Fu {
             publicabstractvoid method();
}
class Zi implements Fu {
             publicvoid method(){
              System.out.println(“重写接口抽象方法”);
}
}
//接口的多态使用
Fu fu = new Zi();

            //
            使用格式：
            boolean  b  = 对象  instanceof  数据类型;
//如
Person p1 = new Student(); // 前提条件，学生类已经继承了人类boolean flag = p1 instanceof Student; //flag结果为trueboolean flag2 = p1 instanceof Teacher; //flag结果为false

            /*
            向上转型：当有子类对象赋值给一个父类引用时，便是向上转型，多态本身就是向上转型的过程。
使用格式：
            */
            
父类类型  变量名 = new 子类类型();
如：Person p = new Student();
/*向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用转为子类引用，这个过程是向下转型。如果是直接创建父类对象，是无法向下转型的！
使用格式：*/
子类类型 变量名 = (子类类型) 父类类型的变量;
如:Student stu = (Student) p;  //变量p 实际上指向Student对象

            /*
            什么时候使用向上转型：
当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作，这时就可以使用向上转型。
如：
            */
            
    Animal a = new Dog();
    a.eat();
/*什么时候使用向下转型
当要使用子类特有功能时，就需要使用向下转型。
    如：*/
            Dog d = (Dog) a; //向下转型
        d.lookHome();//调用狗类的lookHome方法
/*向下转型的好处：可以使用子类特有功能。
弊端是：需要面对具体的子类对象；在向下转型时容易发生ClassCastException类型转换异常。在转换之前必须做类型判断。
如：*/if( !a instanceof Dog){…}