Java--继承父类并实现多个接口、接口之间的多继承、多态的格式和使用、多态中成员变量的使用特点、以及对象的向上转型和向下转型

1.继承父类并实现多个接口

使用接口的时候，需要注意：

1）接口没有静态代码块或者构造方法的。

2）一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。

格式：
public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB{
        //覆盖重写所有抽象方法
}

3）如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。

4）如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。

5）如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。

6）一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。

//定义接口A
public interface MyInterfaceA {

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

    public abstract void methodA();

    public abstract void methodAbs();

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

}

//定义接口B
public interface MyInterfaceB {

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

    public abstract void methodB();
    public abstract void methodAbs();
    public default void methodDefault(){
        System.out.println("默认方法BB");
    }
}

//定义实现类
public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB {
    @Override
    public void methodA() {
        System.out.println("覆盖重写了A方法");
    }

    @Override
    public void methodAbs() {
        System.out.println("覆盖重写了AB接口都有的抽象方法");
    }

    @Override
    public void methodB() {
        System.out.println("覆盖重写了B方法");

    }

    @Override
    public void methodDefault() {
        System.out.println("对多个接口当中冲突的默认方法进行了覆盖重写");
    }
}

//定义实现类
//如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
public abstract class MyInterfaceAbstract implements MyInterfaceA,MyInterfaceB {
    @Override
    public void methodA() {
    }

    @Override
    public void methodAbs() {
    }

    @Override
    public void methodDefault() {
    }
}

父类优先于接口

//定义父类
public class Fu {
    public void method(){
        System.out.println("父类方法");
    }
}

//定义接口
public interface MyInterface {
    public default void method(){
        System.out.println("接口的默认方法");
    }
}

//定义子类，继承父类，实现接口
public class Zi extends Fu implements MyInterface {
}

//主程序
public class Demo01Interface {

    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();//父类方法
    }
}

2.接口之间的多继承

1）类与类之间是单继承的，直接父类只有一个。

2）类与接口之间是多实现的。一个类可以实现多个接口。

3）接口与接口之间是多继承的。

//定义接口A
public interface MyInterfaceA {

    public abstract void methodA();
    public abstract void methodCommon();
    public default void methodDefault(){
        System.out.println("AAA");
    }
}

//定义接口B
public interface MyInterfaceB {

    public abstract void methodB();
    public abstract void methodCommon();
    public default void methodDefault(){
        System.out.println("BBB");
    }
}

//定义子接口
/*
这子接口当中有几个方法---4个
methodA() 来源于接口A
methodB() 来源于接口B
methodCommon() 来源于接口A和B
method() 来源于自己

 */
public interface MyInterface extends MyInterfaceA,MyInterfaceB {

    public abstract void method();
    @Override
    public default void methodDefault() {

    }
}

//定义接口实现类
public class MyInterfaceImpl implements MyInterface {
    @Override
    public void method() {
    }

    @Override
    public void methodA() {
    }

    @Override
    public void methodB() {
    }

    @Override
    public void methodCommon() {
    }
}

注意事项：

1）多个父接口当中的抽象方法如果重复，没关系。

2）多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，而且带着default关键字。

3.多态的格式和使用

代码当中体现多态性：其实就是一句话，父类引用指向子类对象。

格式： 父类名称 对象名= new 子类名称（）；

或者 接口名称名称 对象名= new 实现类名称（）；

//定义父类
public class Fu {
    public void method(){
        System.out.println("父类方法");
    }
}

//定义子类继承父类
public class Zi extends Fu {
    @Override
    public void method() {
        System.out.println("子类方法");
    }
}

//多态
public class Demo01Multi {

    public static void main(String[] args) {
        //使用多态的写法
        //左侧父类的引用，指向了右侧子类的对象
        Fu obj = new Zi();

        obj.method();
    }
}

4.多态中成员变量的使用特点

访问成员变量的两种方法：

1）直接通过对象名称访问。

2）间接通过成员方法访问。

//定义父类
public class Fu {

    int num = 10;

    public void showNum(){
        System.out.println(num);
    }
    public void method(){
        System.out.println("父类方法");
    }
    public void methodFu(){
        System.out.println("父类特有方法");
    }
}

//定义子类
public class Zi extends Fu {

    int num = 20;
    int age = 16;

    @Override
    public void showNum() {
        System.out.println(num);
    }
    @Override
    public void method() {
        System.out.println("子类方法");
    }
    public void methodZi(){
        System.out.println("子类特有方法");
    }
}

//主程序
public class Demo01MultiField {

    public static void main(String[] args) {
        //使用多态的写法，父类引用指向子类对象
        Fu obj = new Zi();//多态：左边父类，右边子类
        System.out.println(obj.num);//父：10
//        System.out.println(obj.age);//错误写法
        System.out.println("==============");

        obj.showNum();//子类没有覆盖重写，就是父：10
        // 子类覆盖重写就是属于子类，结果为20。
    }
}

在多态的代码当中，成员方法的访问规则： 看new的是谁，就优先用谁，没有则向上找。

口诀：编译看左边，运行看右边。

对比一下：

成员变量：编译看左边，运行看左边。

成员方法：编译看左边，运行看右边。

public class Demo02MultiMethod {
    public static void main(String[] args) {
        Fu obj = new Zi();//多态

        obj.method();//父子都有，优先用子
        obj.methodFu();//子类没有，父类有，向上找到父类

        //编译看左边，左边是Fu,Fu当中没有methodZi方法，所以编译报错
//        obj.methodZi();//错误写法

    }
}

5.对象的向上转型和向下转型

1）对象的向上转型，其实就是多态写法：

格式：父类名称 对象名 = new 子类名称（）；

含义：右边创建一个子类对象，把它当做父类来看待使用。

注意事项：向上转型一定是安全的。从小范围转向了大范围。

类似于：
double num = 100 ;//正确，int-->double,自动类型转换。

向上转型一定是安全的，正确的，但是也有弊端：
对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。

解决方案：
用对象的向下转型还原。

2）对象的向下转型，其实是一个还原的动作。

格式: 子类名称 对象名 = （子类名称）父类对象；

含有：将父类对象，还原成为本来的子类对象。

类似于： int num = (int) 10.0;//可以
int num =(int) 10.5;//不可以，精度损失

//定义动物类
public abstract class Animal {

    public abstract void eat();
}

//定义猫类
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    //子类特有方法
    public void catchMouse(){
        System.out.println("猫捉老鼠");
    }
}

//定义狗类
public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃狗粮");
    }

    public void watchHouse(){
        System.out.println("狗看家");
    }
}

public class Demo01Main {

    public static void main(String[] args) {
        //对象的向上转型，就是：父类引用指向子类对象
        Animal animal = new Cat();//本来创建的时候是一只猫
        animal.eat();//猫吃鱼

//        animal.catchMouse();//错误写法

        //向下转型，进行还原动作
        Cat cat = (Cat) animal;
        cat.catchMouse();//猫捉老鼠

        // 下面是错误的向下转型
        // 本来new的时候就是一只猫，现在非要当成狗
        Dog dog = (Dog) animal;//错误写法，编译不会报错，但是运行会出现异常。
        // 异常：Exception in thread "main" java.lang.ClassCastException，类转换异常

    }
}