Java多态实例详解三步走（三）【接口多态】

缺乏、安全感 2022-05-19 09:45 183阅读 0赞

**一、接口的功能：**接口主要是对类功能的补充。比如说猫和狗，它们都属于动物，有一些共有的属性和方法可以。但是现在如果对狗和猫中的一部分进行训练，使它们拥有与其他猫、狗不一样的能力，这时就需要用接口来实现了。

多态分为三种：

*  具体类多态（几乎没有）：  
    　　class Fu \{ \}  
    　　class Zi extends Fu \{ \}
    
    　　Fu f = new Zi();  
    　　请看 [Java多态实例详解三步走（一）【具体类多态】][Java]
 *  抽象类多态（常用）：  
    　　abstract class Fu \{ \}  
    　　class Zi extends Fu \{ \}
    
    　　Fu f = new Zi();  
    　　请看 [Java多态实例详解三步走（二）【抽象类多态】][Java 1]
 *  接口类多态（最常用）：  
    　　interface class Fu \{ \}  
    　　class Zi implements Fu \{ \}
    
    　　Fu f = new Zi();

**二、接口的特点：**

*  接口用关键字interface表示。  
    　 interface 接口名 \{ \}
 *  类实现接口用 implements 表示
 *  接口不能实例化，但可以按照多态的方式来实例化
 *  接口的子类  
    　　1、可以是抽象类。但是意义不大。  
    　　2、可以是具体类。要重写接口中的所有抽象方法。（推荐方案）

public class Main { 
        public static void main(String[] args) {
            //会报错，接口不能实例化
            //AnimalTrain at = new AnimalTrain();
        }
    }
    
    interface AnimalTrain { 
    
        public abstract void jump();
    
    }
    //可以定义为抽象类，但这样的话就需要再向下定义子类了，所以无意义。
    //abstract class Cat implements AnimalTrain {}
    
    //要重写接口中所有抽象方法
    class Dog implements AnimalTrain { 
        public void jump() {
            System.out.println("狗跳高");
        }
    }

**三、接口成员特点：**

*  成员变量：只能是常量，并且是静态的。  
    　　默认修饰符：public static final  
    　　建议：自己手动给出
 *  构造方法：接口没有构造方法
 *  成员方法：只能是抽象方法  
    　　默认修饰符：public abstract  
    　　建议：自己手动给出

所有类都默认继承自一个类：Object  
类Object是类层次结构的根类。每个类都是用Object作为超类。  
当没有父类的时候，默认为Object

public class Main {
        public static void main(String[] args) {
            Inter a = new InterImpl();
            System.out.println(a.num);
            System.out.println(a.num2);
            System.out.println("-------------------");
            //这两个都会报错，因为接口中的成员变量都为最终变量
            //a.num = 88;
            //a.num2 = 777;
    
            //接口中的成员变量可以通过接口名调用，说明是静态的
            System.out.println(Inter.num);
            System.out.println(Inter.num2);
            //a = new InterImpl();
            a.show();
        }
    }
    
    interface Inter {
        //格式不全的会用默认的格式
        public int num = 100;
        public final int num2 = 99;
        //虽然会默认给出，但建议手动给出
        public static final int num3 = 78;
    
        //会报错，接口没有构造方法
        //public Inter() {}
    
        //接口方法中不能带有主体
        //public void show() {}
    
        //这句虽然没有abstract，但是不会报错，因为默认 public abstract
        //public void show();
    
        public abstract void show();
    
    }
    
    //接口的实现类明明格式：接口名+Impl
    //约定俗成的，并不是说必须要这样写，但这样写容易看懂
    class InterImpl implements Inter {
        public InterImpl() {
            super();
        }
    
        //因为接口默认public ，而如果没有给出权限默认最低权限，所以报错。
        //void show() {}
    
        //正确
        public void show() {
            System.out.println("dfdg");
        }
    }

**关系：**

*  类与类：继承关系，只能单继承，可以多层继承。
 *  类与接口：  
    　　实现关系，可以单实现，也可以多实现。  
    　　并且还可以在继承一个类的同时实现多个接口。
 *  接口与接口：  
    　　继承关系，可以单继承，也可以多继承。

**最后，一个完整的多态的代码：**

interface JumpingImpl {
        public abstract void Jump();
    }
    
    interface ZuanHuoQuan {
        public abstract void Z();
    }
    
    abstract class Animal {
        private int age;
        private String name;
    
        public Animal() {}
        public Animal(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public void setName(String name) {
            this.name = name;
        }
        public String getName() {
            return name;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
        public int getAge() {
            return age;
        }
    
        public abstract void eat();
        public abstract void sleep();
    }
    
    class Dog extends Animal{
    
    
        public Dog() {}
        public Dog(String name, int age) {
            super(name, age);
        }
    
        public void eat() {
            System.out.println("狗吃肉");
        }
    
        public void sleep() {
            System.out.println("狗睡觉");
        }
    
    }
    
    class JumpDog extends Dog implements JumpingImpl,ZuanHuoQuan {
    
    
        public JumpDog() {}
        public JumpDog(String name, int age) {
            super(name, age);
        }
    
        public void Z() {
            System.out.println("钻火圈狗");
        }
        public void Jump() {
            System.out.println("跳高狗");
        }
    
    
    }
    
    public class Main {
        public static void main(String[] args) {
            Animal a = new Dog();
            a.eat();
            a.sleep();
            a.setName("旺财");
            System.out.println(a.getName());
            a.setAge(8);
            System.out.println(a.getAge());
    
            JumpDog d = new JumpDog("小花", 7);
            d.Jump();
            d.Z();
        }
    }

[Java]: https://blog.csdn.net/k_young1997/article/details/81156929
[Java 1]: https://blog.csdn.net/k_young1997/article/details/81169726