java继承与多态-接口的学习

接口即使多个类的公共规范。
接口时一种引用数据类型，最重要的内容就是其中的：抽象方法。
如何定义一个接口的格式：
public interfa 接口名称{
//接口内容
}
备注：换成了关键字interface之后，编译生成的字节码文件任然是：Java—>.class。
如果是Java 7 那么接口中可以包含的内容有
1.常量
2.抽象方法
如果时Java 8，还可以包含
3.默认方法
4.静态方法
5.私有方法
接口使用步骤：1.接口不能直接使用，必须有一个“实现类”来”实现“该接口。
格式：public class 实现类名称implement 接口名称{
//。。。
}
2.接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。
实现：去掉abstr关键词，加上方法体大括号。
3.创建实现类的对象进行使用。
注意事项：如果实现类并没有覆盖重写接口中所有抽象方法，那么这个实现类自己就必须时抽象类。
原因；继承接口之后将接口中所有的抽象方法都继承下来了，抽象方法所在的类就是抽象类。

public class demo01Interface {
    public static void main(String[] args) {
        //MyInterfaceAbstract myInterfaceAbstract=new MyInterfaceAbstract();错误，不能直接new接口对象使用
        //需要创建实现类的对象使用
        MyInterfaceAbstrctlmpl impl=new MyInterfaceAbstrctlmpl();
        impl.methodAbs1();
        impl.methodAbs2();
        impl.methidAbs3();
        impl.methodAbs4();
    }
}

在任何版本的Java中，接口都能定义抽象方法：
public abstract 返回值类型 方法名称（参数列表）
注意事项：1.接口当中的抽象方法，修饰符必须时两个固定的关键字：publicabstr
2.这两个关键字修饰符，可以选择性的省略。
3.方法三要素，可以随意定义。
定义一个接口名为MyInterfaceAbstract

public interface MyInterfaceAbstract {
    public abstract void methodAbs1();//这是一个抽象方法，当我们省略public或者abstract或者都省略都不会出错
    public abstract void methodAbs2();
    public abstract void methidAbs3();
    public abstract void methodAbs4();
}

定义一个类来实现接口方法重写

public class MyInterfaceAbstrctlmpl implements MyInterfaceAbstract{
    @Override
    public void methodAbs1() {
        System.out.println("这是第一个方法");
    }
    @Override
    public void methodAbs2() {
        System.out.println("这是第二个方法");
    }
    @Override
    public void methidAbs3() {
        System.out.println("这是第三个方法");
    }
    @Override
    public void methodAbs4() {
        System.out.println("这是第四个方法");
    }
}

运行结果：
这是第一个方法
这是第二个方法
这是第三个方法
这是第四个方法

接口静态方法的使用

注意事项：不能通过接口名称实现类的对象来调用接口当中的静态方法。
正确用法：通过接口名称直接使用其中的静态方法。
格式：接口名称.静态方法名（参数）；
静态跟类有关系，所以不需要创建对象。

public class demo01 {
    public static void main(String[] args) {
        MyInterfaceStatic imp=new MyinterfaceImpl();//静态跟类有关系所以不用创建对象。
        //imp.methodStatic():错误写法
        MyInterfaceStatic.methodStatic();

    }
}

从Java 8开始，接口当中允许定义静态方法。

• 格式：public static 返回值 方法名称（参数列表）{
  方法体
  }
  提示：就是将abstract或者default换成static即可
  创建接口MyInterfaceStatic

public interface MyInterfaceStatic {
    public static void methodStatic(){
        System.out.println("这是一个静态方法！");
    }
}

创建一个实现类MyinterfaceImpl

public class MyinterfaceImpl implements MyInterfaceStatic{
}

问题描述：我们需要抽取一个共有的方法用来解决两个默认方法之间的重复代码问题，但是这个共有方法
应该是私有化的
解决方案：从Java 9开始，接口当中允许定义虽有方法。
1.普通死于方法，解决多个默认方法之间重复代码问题
格式：private 返回值类型 方法名称（参数列表）{
方法体
}
2.静态私有方法，解决多个静态方法之间重复代码问题
格式：平壤v阿特static 返回值类型 方法名称（参数列表）{
方法体
}
创建一个接口名为MyInterfaceprivate

public interface MyInterfaceprivate {
    public default void methodDefault1(){
        System.out.println("默认方法1");
        methodCommon();
    }
    public default void methodDefault2(){
        System.out.println("默认方法2");
        methodCommon();
    }
    private void methodCommon(){
        System.out.println("AAAA");
        System.out.println("BBBB");
        System.out.println("CCCC");
    }
}

再创建一实现类名为MyIterfaceprivateImpl
在接口中，公共方法使用public default修饰方法，
那么在实现类中就会直接访问到了接口中的方法，这是错误的，不能只接访问到接口中的公共方法，只有接口中的默认方法可以使用
接口中的公共方法只能被接口中的私有方法调用。

public class MyInterfaceAImpl implements MyInterfaceprivate {
    public void methodAnother(){
    }

创建一个类demo04Interface

public class demo04Interface {
    public static void main(String[] args) {
        MyInterfaceprivateB.methodstatic1();
        MyInterfaceprivateB.methodstatic2();

    }
}

接口中的常量问题

接口当中也可以定义”成员变量“，但是必须使用public static final三个关键字来修饰。
从效果双看，这其实就是接口的【常量】
格式：public static final数据类型 常量名称=数据值；
备注：一旦使用final关键字进行修饰，说明不可改变，所以当num定下来后就不会改变，
注意事项：1.接口当中的常量，可以省略public static final，注意：不写也照样事这样
2.接口当中的常量，必须赋值，不能不赋值（一般再不能变的常量那么一般就是大写比如：NUM=10如果有多个单词，那么用下划线）
3.接口中常量的名称，使用完全大写的字母。而且用下划线进行分割，使用时直接通过接口去点它就行
创建一个接口，名为MyInterfaceconst

public interface MyInterfaceconst {
    public static final int num =10;//public 事不管接口内还是外都可以用，static存在的情况下就不再属于类，final代表不变
    //这其实就是一个常量，一旦赋值不可修改，即使是int num=10；那么再javac编译时还是相当于public static final int num =10
}

创建一个类

public class demo02 {
    public static void main(String[] args) {
        System.out.println(MyInterfaceconst.num);
    }
}

关于接口的总结：
1.成员变量其实是常量，格式是：
public static final 数据类型 常量名称=数据值；
注意：常量必须进行赋值，而且一旦赋值不能改变，
常量名称完全大写，用下划线进行分割。
2.接口中重要的就是抽象方法，格式：
public abstract 返回值类型 方法名称（参数列表）
3.从Java 8开始接口里允许定义默认方法，格式；
public default 返回值类型 方法名称（参数列表）{方法体}
注意：默认方法也可以被覆盖重写
4.从Java 8开始，接口里允许定义静态方法。格式是：
public static 返回值类型 方法名称（参数列表）{方法体}
注意：应该通过接口名称进行调用，不能通过实现对象调用接口的静态方法
5.从Java 9开始接口里允许定义私有方法。格式：
普通私有方法：private 返回值类型 方法名称（参数列表）{方法体}
静态私有方法：private static 返回值类型 方法名称（参数列表）{方法体}
注意：private的方法只有接口自己才能调用，不能被实现类或者别人调用。

使用接口的时候需要注意
1.接口是没有静态代码块或者构造方法的。
2.一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。
格式：public class MyInterfaceImpl inplements MyInterfaceA,MyInterfaceB{
//覆盖重写所有抽象方法
}
3.如果实现类所实现的多个接口当中存在重复的抽象方法，那么只需要覆盖重写一次即可。
4.如果实现类中没有覆盖重写所有接口中的所有抽象方法，那么实现类就必须是一个抽象类。
5.如果实现类所实现的多个接口当中，存在多个重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写
6.一个类如果直接父类当中的方法和接口当中的默认方法产生的冲突，优先用父类当中的方法
创建一个接口MyInterfaceA

public interface MyInterfaceA {
    //static{};错误写法！接口出不能有静态代码块，
    //public Myingterface(){};错误写法，这是构造方法，如果写上构造方法就能来时创建对象，接口处不能创建对象
    public abstract void methodA();
    public abstract void methodabs();
    public default void methodDefault(){
        System.out.println("默认方法AAA");
    }
}

创建一个接口MyInterfaceB

public interface MyInterfaceB {
    public abstract void methodB();
    public abstract void methodabs();
    public default void methodDefault(){
        System.out.println("默认方法BBB");
    }
}

创建一个实现类MyInterfaceImpl

public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB {//如果再接口中有抽象方法没有再实现类中覆盖重写，那么
    //可以使用public abstract class 。。。。
    @Override
    public void methodA() {
        System.out.println("覆盖重写A");
    }
    @Override
    public void methodB(){
        System.out.println("覆盖重写B");
    }

    @Override
    public void methodabs() {
        System.out.println("覆盖重写了AB接口中都有的抽象方法");//AB都有的抽象方法早实现类中只写一次就行
    }

    @Override
    public void methodDefault() {
        System.out.println("覆盖重写了MyInterfaceA与MyInterfaceB有冲突的默认方法");
    }
}

类与接口的相关关系

类与类之间的接口是单继承的，直接父类只有一个
2.类与接口之间是多继承的，一个类可以实现多个接口。
3.接口与接口之间是多继承的。
注意事项：
1.多个父接口当中的抽象方法如果重复，没关系。
2.多个父类接口当中默认方法重复，那么子接口必须进行默认方法的覆盖重写【而且带着default关键字】