2021-04-20

学习java第十三天

接口的多实现
JAVA中类不直接支持多继承，因为会出现调用的不确定性
所以JAVA将多继承机制进行改良，在JAVA中变成了多实现
但接口和接口之间是继承关系且可以多继承。

一个类可以实现多个接口
因为Test进行覆盖时，会同时覆盖A和B中的show( )；
注：
多继承之所以不能被直接支持，是因为方法内有方法体
因为有方法体，所以会导致运行结果不确定性
接口中没有方法体，所以不会出现不确定性

注：
接口A和B中的同名方法需要返回值相同。
否则在子类覆盖时只能覆盖其中一个
从而造成子类变成一个抽象类
并且因为返回值类型不能区分重载，
所以在子类中也无法同时定义两个同名同参不同返回值的方法。

package com.hg.day13.demo02;

public class Demo02Interface {
    public static void main(String[] args) {
        Zi zi=new Zi();
        zi.method();
    }
}

package com.hg.day13.demo02;

public interface MyInterface {
    public default void method() {
        System.out.println("我是接口里面的默认方法");
    }
}

package com.hg.day13.demo02;

public interface MyInterfaceA {
    //错误写法 接口中不能有静态代码块
    //static {}
    //错误写法 接口中不能有构造方法
    //public MyInterfaceA()

    public abstract void methodA();

    public abstract void methodAbs();

    public default void methodDefault() {
        System.out.println("默认方法AAA");
    }
}

package com.hg.day13.demo02;

public interface MyInterfaceB {
    public abstract void methodB();

    public abstract void methodAbs();

    public default void methodDefault() {
        System.out.println("默认方法BBB");
    }
}

package com.hg.day13.demo02;

public abstract class MyInterfaceAbs implements MyInterfaceB,MyInterfaceA{
    @Override
    public void methodB() {

    }

    @Override
    public void methodAbs() {

    }

    @Override
    public void methodDefault(){
        MyInterfaceA.super.methodDefault();

    }
}

package com.hg.day13.demo02;

public class MyInterfaceImpl implements  MyInterfaceA,MyInterfaceB{

    @Override
    public void methodB() {

    }

    @Override
    public void methodA() {

    }

    //只需要写一次
    @Override
    public void methodAbs() {

    }

    @Override
    public void methodDefault(){
        MyInterfaceA.super.methodDefault();

    }
}

package com.hg.day13.demo02;

public class Fu {
    public void method() {
        System.out.println("我是父类的方法");
    }
}

package com.hg.day13.demo02;

public class Zi  extends Fu implements MyInterface{

}

按照理解，一般都是说Java 类是单继承，但可以实现多个接口。但是可以通过接口来实现类的多继承。（如何通过接口来实现多继承？？？）
一个类只能extends一个父类，但可以implements多个接口。java通过使用接口的概念来取代C++中多继承。与此同时，一个接口则可以同时extends多个接口，却不能implements任何接口。因而，Java中的接口是支持多继承的。

下面先对接口做个总结：

1.接口中的成员变量默认都是public,static,final(都可省略)，必须被显示初始化，即接口中的成员变量必须是常量。

2.接口中的方法默认都是public abstract类型的(都可省略)，没有方法体。

3.接口中只能包含public abstract类型的成员方法和public static final类型的成员变量。

4.接口中没有构造方法，不能被实例化

5.一个接口不能实现（implements）另一个接口，但是可以多继承接口

6.Java中必须通过类来实现接口中的抽象方法

7.当类实现了某个Java接口时,它必须实现接口中的所有抽象方法,否则这个类必须声明为抽象类

8.不允许创建接口的实例(实例化),但允许定义接口类型的引用变量,该引用变量引用实现了这个接口的类的实例
9.一个类只能继承一个直接的父类,但可以实现多个接口,间接的实现了多继承

package com.hg.day13.demo03;

import com.hg.day13.demo02.MyInterface;

public class Demo03Relations {
    //MyInterface myinterface=new MyInterface(); 错误写法
}

package com.hg.day13.demo03;

/*
这个接口中一共有4个方法
methodA（接口A的方法)  methodB（接口B的方法) methodCommon(接口AB的方法)  method（自己的方法）
 */
public interface MyInterface extends MyInterfaceA,MyInterfaceB{
    public abstract void method();

    @Override
    default void methodDefault(){
        MyInterfaceA.super.methodDefault();

    }
}

package com.hg.day13.demo03;

public interface MyInterfaceA {
    public abstract void methodA();

    public abstract void methodCommon();

    public default void methodDefault() {
        System.out.println("AAAAA");
    }
}

package com.hg.day13.demo03;

public interface MyInterfaceB {
    public abstract void methodB();

    public abstract void methodCommon();

    public default void methodDefault() {
        System.out.println("BBBBB");
    }
}

package com.hg.day13.demo03;

//import com.hg.day13.demo02.MyInterface;

public class MyInterfaceImpl implements MyInterface {
    @Override
    public void methodA(){

    }
    @Override
    public void methodB(){

    }
    @Override
    public void method(){

    }
    @Override
    public void methodCommon(){

    }

    @Override
    public void methodDefault(){


    }
}

java中4种权限修饰符

package com.hg.day13.demo04;

/*
java 中有四种权限修饰符

                   public    protected   default    private
同一个类中(我自己）     yes        yes        yes         yes
同一个包中(我的邻居)    yes        yes        yes         no
同一包中的子类(儿子)    yes        yes        yes         no
不同包中的子类(儿子)    yes        yes        no          no
不同包的非子类         yes        no         no          no

 */
public class Demo01Main {
}

Java语言4种访问权限修饰符，但是仅有3个关键字，因为不写访问权限，在Java中被称为默认权限，或同包权限，本文中以(default)代替。下面按照权限从小到大的顺序对4种访问权限分别介绍

1、默认权限(default)

类，数据成员，构造方法，方法成员，都能够使用默认权限，即不写任何关键字。默认权限即同包权限，同包权限的元素只能在定义它们的类中，以及同包的类中被调用。

2、受保护权限(protected)

protected可以修饰数据成员，构造方法，方法成员，不能修饰类(此处指外部类，不考虑内部类)。被protected修饰的成员，能在定义它们的类中，同包的类中被调用。如果有不同包的类想调用它们，那么这个类必须是定义它们的类的子类。

3、私有权限(private)

private可以修饰数据成员，构造方法，方法成员，不能修饰类(此处指外部类，不考虑内部类)。被private修饰的成员，只能在定义它们的类中使用，在其他类中不能调用。

4、公共权限(public)

public可以修饰类，数据成员，构造方法，方法成员。被public修饰的成员，可以在任何一个类中被调用，不管同包或不同包，是权限最大的一个修饰符。

有关Java语言的修饰符，需要注意的问题有如下几个：

1.并不是每个修饰符都可以修饰类(指外部类)，只有public和default可以。

2.所有修饰符都可以修饰数据成员，方法成员，构造方法。

3.为了代码安全起见，修饰符不要尽量使用权限大的，而是适用即可。比如，数据成员，如果没有特殊需要，尽可能用private.

4.修饰符修饰的是“被访问”的权限。

package com.hg.day13.demo04;

public class MyAnother {
    public void anotherMthode() {
        MyClass myclass =new MyClass() ;
        System.out.println(myclass.num);
    }
}

package com.hg.day13.demo04;

public class MyClass {
    public int num =5;

    public void method() {
        System.out.println(num);
    }

    int sum=num+1;
}

package com.hg.day13.demo04;

public class MySon1 extends MyClass{
    public void method() {
        //System.out.println(super.num);
    }
}

package com.hg.day13.demo05;

import com.hg.day13.demo04.MyClass;

public class MySon2 extends MyClass {
    public void method(){
        //System.out.println(super.num);
    }
}

package com.hg.day13.demo05;

import com.hg.day13.demo04.MyClass;

public class Stranger {
    public static void main(String[] args) {
        MyClass myclass=new MyClass();
    }
}