接口
           场景：一个类中，所有的方法，都是抽象方法 (指定规则)
        接口介绍：
            当一个类中的所有方法都是抽象方法的时候，我们就可以将其定义为接口
            接口是一种引用数据类型，他比抽象还要抽象
        接口存在的两个重要意义：
        1.规则的定义
        2.程序的扩展性
        例子： USB数据线接口   长方形的接口，笔记本插口也是长方形的   定义了一种规则   USB的扩展下 可以接鼠标 耳机等等
        
    接口的定义格式：
        public interface 接口名{}
    接口不可以实例化 
    接口和类之间是实现关系，通过implements关键字表示 
        public class 类名 implements 接口名{}
    接口的子类(实现类)
        要么重写接口中的所有抽象方法
        要么是个抽象类
    注意：接口和类得实现关系，可以单实现，也可以多实现
            public class 类名 implements 接口名1,接口名2{}
    代码：
接口类

public interface inter {
    public abstract void study();
}

 接口实现类

public class interImpl implements inter{
    @Override
    public void study() {
        System.out.println("我是实现类中得实现方法");
    }
}

 测试类

public class TestInterface {
    /*
    接口的定义格式：
		public interface 接口名{}

		接口和类之间是实现关系，通过implements关键字表示
		public class 类名 implements 接口名{}
     */
    public static void main(String[] args) {
    //inter i=new inter();会报错，不能被实例化
    interImpl i=new interImpl();
    i.study();
    }
}

接口中成员得特点：
            成员变量：只能是常量，系统会默认加入三个关键字
                    public static final
            构造方法：
                    接口当中没有构造方法
            成员方法：
                    只能是抽象方法，系统会默认加上public abstract 
            关于接口中得方法，JDK9和JDK9有一些新特性
            1.JDK8版本之后，Java只对接口得成员方法进行了改进
            如何能在丰富接口方法得同时，不对子类代码进行修改嫩 
            允许接口中定义带有方法体得方法
            允许在接口中定义非抽象得方法，但是需要使用关键字default修饰，这些方法就是默认方法
            作用：解决接口升级得问题
            格式： 
            public default 返回值类型 方法名(参数列表){}
            范例：
            public default void show(){}
            默认方法不强制重写 如果多个接口定义相同得声明  必须得重写    如果重写默认方法 一定不要写default
            2.接口中允许定义static 静态方法 
            格式：public static 返回值类型  方法名(参数列表){}
            范例：public static void  show(){}
            静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
            public可以省略,static不能省略
            JDK9版中接口成员得特点
            格式1：private 返回值类型 方法名(参数列表){}
            范例1：private void show(){}
            格式2：private static    返回值类型 方法名(参数列表){}
            范例2：private static    void show(){}

    接口得使用思路
        如果发现一个类中所有得方法都是抽象方法，那么就可以将该类，改进为一个接口
        设计到了 接口大面积更新方法，而不想修改每一个是实现类，就可以将更新得方法，定义为带有方法体得默认方法
        希望默认方法调用更加简介，可以考虑设计为static 静态方法(需要去掉default关键字)
        默认方法中出现了重复得代码，可以考虑抽取出一个私有方法
    类和接口得关系
    类和类得关系：
        继承关系，只能单继承，但可以多层继承
    类和接口得关系：
        实现关系，可以单实现，也可以多实现，还可以在继承一个类得同时 实现多个接口
    接口和接口得关系
        继承关系，可以单继承，也可以多继承  (两个接口要是有同样得声明，就会接口实现类就会重写方法)
    
    
    多态 
        多态概述：同一个对象，在不同时刻表现出来得不同形态
        举例 猫
        我们可以说猫是猫  猫 cat=new 猫();
        我们可以说猫是动物   动物  animal=new 猫();
        这里猫在不同得时刻表现出来不同得心态，这就是多态
    多态得前提和体现
        有继承/实现关系
        有方法重写
        有父类引用指向子类对象

代码实例：

public class test4 {
    /*
    有继承/实现关系
		有方法重写
		有父类引用指向子类对象
     */
    public static void main(String[] args) {
        //当前事物是一只猫
        Cat c=new Cat();
        // 当前事物，是一只动物
        Animal animal=new Cat();
    }

}
class  Animal{
    public  void eat(){
        System.out.println("动物吃饭");
    }
}
class Cat extends Animal{
    @Override
    public  void eat() {
        System.out.println("猫吃鱼");
    }
}

多态中成员访问特点
    构造方法：同继承一样，子类会通过super访问父类构造方法
    成员变量： 编译看左边(父类)，执行看左边(父类)
    成员方法： 编译看左边(父类)，执行看右边(子类)

public class test4 {
    /*
    有继承/实现关系
		有方法重写
		有父类引用指向子类对象
		成员变量： 编译看左边(父类)，执行看左边(父类)
	成员方法： 编译看左边(父类)，执行看右边(子类)
     */
    public static void main(String[] args) {
       Fu f=new Zi();
        System.out.println(f.num);//10
        f.method();   //Zi.....method
    }
}
class  Fu{
    int num =10;
    public  void method(){
        System.out.println("Fu.....method");
    }
}
class Zi extends Fu{
    int num=20;
    @Override
    public  void method() {
        System.out.println("Zi.....method");
    }
}

多态得好处和弊端
    好处： 扩展性得提高   具体体现  使用父类性作为参数，该方法就可以接收这父类得任意子类对象
    弊端：不能调用子类   不能调用子类得特有功能  

public class test4 {
    public static void main(String[] args) {
        userAnimal(new userDog());
        userAnimal(new userCat());
    }
    public static void userAnimal(Animal a){
        a.eat();
        a.watchHome();  //会报错  不能调用特有得方法
    }
}
abstract class  Animal{
   public abstract void eat();
}
class userDog extends Animal{
    @Override
    public  void eat() {
        System.out.println("狗吃肉");
    }
    public void watchHome(){
        System.out.println("看家护院");
    }
}
class userCat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃肉");
    }
}

 多态中得转型
    向上转型 
        从子到父
        父类引用指向子类对象
    向下转型
        从父到子
        父类引用转为子类对象

public class test4 {
    public static void main(String[] args) {
       // 1.向上转型  父类引用指向子类对象
        Fu f=new Zi();
        f.show();
        //多态得弊端  不能调用子类特有成员
        //f.method
        //方案一  直接创建子类对象
        //方案二 向下转型  从父类转换为子类类型
        Zi z=(Zi) f;
        z.method();
        z.show();
    }

}
 class  Fu{
   public  void show(){
       System.out.println("Fu....show");
   };
}
class Zi extends Fu{
    @Override
    public  void show() {
        System.out.println("Zi.....show");
    }
    public void method(){
        System.out.println("子类特有方法");
    }
}

码不动了 这一段时间 疫情   工作到晚上十点回来  这两天中午打球出汗还感冒了  真是难受啊   明天继续！！！