java基础之接口、多态

一、接口：是Java语言中一种引用类型【组数、类也是引用类型】，内部主要就是封装了方法，

包括（抽象方法、默认方法、静态方法、私有方法）

  格式：
    public interface 接口名称 {
            // 抽象方法  作用：该方法供子类实现使用
               public abstract void  show1();
            // 抽象方法简写
               void  show2();
           // 默认方法:  使用 default 修饰，不可省略，供子类调用或者子类重写  作用为了防止在接口升级中，而不音响子类对接口的实现，lambda表达式
               default void show3(){}
          // 静态方法: 使用  static 修饰，供接口直接调用
               static void show4(){}
          // 私有方法:  供接口中的默认方法或者静态方法调用。
               private void show5()
        }

二、接口的多实现: 一个类是可以实现多个接口

  格式：
        class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
            // 重写接口中抽象方法【必须】
           // 重写接口中默认方法【不重名时可选】
        }

  特点：
        接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。
        接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次。
        接口中，无法定义成员变量，但可以定义常量，默认的修饰public static final修饰
              格式：public static final 数据类型 常量名 =
        接口中，无构造方法，无方法创建对象
        接口中，没有静态代码块。

三、多态：一个对象拥有多种形态

例：小明是一个学生，同时也是一个人，即小明这个对象即拥有学生形态，也拥有人类形态

  使用多态的前提【重点】
        1 . 继承或者实现【二选一】
        2. 方法的重写【意义体现：不重写，无意义】
        3. 父类引用指向子类对象【格式体现】

        格式：
            父类类型 变量名 = new 子类名称（）-->父类引用指向子类对象
                  或者
            接口名称 变量名 = new 实现类名称（）

        多态下成员方法访问规则：
            变量名.方法名a(); //看右边 new 的是谁就运行谁的方法，条件：子类重写父类的情况下
            变量名.方法名b(); //该方法是父类特有的方法，此时将 new 子类名称（）当作 new 父类名称（）使用
            a、看 new的谁，就优用先,没有则向上找，条件：子类重写父类的情况下

        多态下成员变量访问规则：
            a、直接通过对象访问成员变量，看等号左边是谁，优先用谁，没有向上找
            b、间接通过成员方法访问成员变量，看该方法属于谁，优先用水，没有向上找

        定义子类：
           public class Zi extends Fu{
               @Override
               public void method() {
                System.out.println("子类的方法.....");
            }
              int num = 20;
          }

        定义父类：
           public class Fu {
             public void method(){
                System.out.println("父类方法.....");
            }
          public void methodFu(){
                System.out.println("父类特有方法.....");
            }
            int num = 10;
            int sum = 50;
         public void shou(){System.out.println(sum)};

       }

        测试：
          public class DemoTest {
          public static void main(String[] args) {
                System.out.println("...<多态下使用成员方法>...");
                Fu f = new Zi();
                f.method(); //父子类都有，优先用子
                f.methodFu(); //子类没有，父类有，向上找到父类
               System.out.println("...<多态下使用成员变量>...");
               System.out.println(f.num);
                f.shou();
            }
        }

四、引用类型转换

        向上转型：多态本身写法，父类引用指向一个子类对象时，便是向上转型
                    格式：
                          父类类型  变量名 = new 子类类型();
                          如：Animal animal  = new Cat();  创建一只猫，把它当做动物看待
                    含义：右侧创建一个对象，把它当做父类来看待
                    注意事项：向上转型一定是安全的，从小范围转向大范围

                    存在问题：向上转型，不能访问子类特有的方法，所以需要向下转型

        向下转型：其实是一个【还原】的动作
                    格式：子类类型 对象名 = （子类类型）父类对象
                    含义：将父类对象，【还原】成为本来的子类对象

                    Animal animal = new Cat();  //本来是猫，向上转型成为动物
                    Cat cat = (Cat)animal;  //本来是猫，已经被当做动物了，还原回来成为本来的猫
                    注意事项：
                    a、必须保证对象本来创建的时候，就是猫，才能向下转型成为猫
                    b、如果对象创建的时候本来不是猫，现在非要向下转型成为猫，就会报错

        变量名 instanceof 数据类型：这将会得到一个boolean直结果，也就是判断前面的对象能不能当做后面类型实例