脚本宝典收集整理的这篇文章主要介绍了20 接口，脚本宝典觉得挺不错的，现在分享给大家，也给大家做个参考。

1. 接口

1.1 接口的概述（理解）

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。 Java中的接口更多的体现在对行为的抽象

1.2 接口的特点（记忆）

• 接口用关键字interface修饰

public interface 接口名 {}

public interface Jumpping{
    public abstract void jump();
}

• 类实现接口用implements表示

public class 类名 implements 接口名 {}


public class Cat implements Jumpping {
    @override
    public void jump() {
        System.out.PRintln("mao");
    }
}

• 接口不能实例化

  接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态。

  多态的形式：具体类多态，抽象类多态，接口多态。

public class Demo00 {
    public static void main(String[] args) {
        Jumpping a = new Cat();
        a.jump();
    }
}

• 接口的子类

  要么重写接口中的所有抽象方法 要么子类也是抽象类

1.3 接口的成员特点（记忆）

• 成员特点

  • 成员变量

    只能是常量 默认修饰符：public static final

  • 构造方法

    没有，因为接口主要是扩展功能的，而没有具体存在

  • 成员方法

    只能是抽象方法 默认修饰符：public abstract 关于接口中的方法，JDK8和JDK9中有一些新特性，后面再讲解

• 接口

public interface Inter {
    	public int num = 10;
        public final int num2 = 20;
        // public static final int num3 = 30;
        int num3 = 30;//默认修饰符：public static final
            
        // public Inter() {}
        // public void show() {}
            
        public abstract void method();
        void show();//默认修饰符：public abstract
}

• 实现类

public class InterImpl extends Object implements Inter {
    public InterImpl() {
        suPEr();
    } @Override
        public void method() {
        System.out.println("method");
    } @Override
        public void show() {
        System.out.println("show");
    }
}

• 测试类

public class InterfaceDemo {
    public static void main(String[] args) {
        Inter i = new InterImpl();
            // i.num = 20;
            System.out.println(i.num);
            // i.num2 = 40;
            System.out.println(i.num2);
            System.out.println(Inter.num);
    }
}

案例1:猫和狗

• 接口Jumpping:

public interface Jumpping {
    public abstract void jump();
}

• 动物类Animal：

public abstract class Animal {
    private String name;
    private int age;

    public Animal (){}
    public Animal(String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public abstract void eat();
}

• 猫类继承Animal类，实现Jumpping

public class Cat extends Animal implements Jumpping{
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void jump() {
        System.out.println("猫跳高");
    }
}

• 狗类继承Animal类，实现Jumpping

public class Dog extends Animal implements Jumpping{
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃屎");
    }

    @Override
    public void jump() {
        System.out.println("狗真能跳");
    }
}

• 测试类

public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Jumpping j = new Cat();
        j.jump();
        System.out.println("-------------------");

        Animal a = new Cat("jiafei",1);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println("-------------------");

        //一般使用的时候是使用具体的实用类，因为它里面有最多的方法
        Cat c = new Cat();
        c.setName("12121");
        c.setAge(12);
        System.out.println(c.getName()+","+c.getAge());
        c.eat();
        c.jump();
    }
}

案例2：运动员和教练

说英语接口：

public interface SpeakE {
    public abstract void speakEg();
}

抽象人类:

public abstract class Person {
    private String name;
    private int age;

    public Person() {}

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public abstract void eat();
}

抽象教练类继承人类：

public abstract class Coach extends Person {
    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract void teach();

}

抽象运动员类继承人类：

public abstract class Sportsman extends Person{
    public Sportsman() {
    }

    public Sportsman(String name, int age) {
        super(name, age);
    }

    public abstract void study();
}

具体篮球教练类继承教练类：

public class NBAcoach extends Coach {
    public NBAcoach() {
    }

    public NBAcoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("NBA教练在吃饭");
    }

    @Override
    public void teach() {
        System.out.println("NBA教练教学");
    }
}

具体乒乓球教练类继承教练类，实现说英语接口：

public class PPcoach extends Coach implements SpeakE{
    public PPcoach() {
    }

    public PPcoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("乒乓球教练在吃饭");
    }

    @Override
    public void teach() {
        System.out.println("乒乓球教练在教学");
    }

    @Override
    public void speakEg() {
        System.out.println("乒乓球教练在说英语");
    }
}

具体篮球运动员类继承运动员类：

public class NBASportsman extends Sportsman {
    public NBASportsman() {
    }

    public NBASportsman(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("NBA球员在吃饭");
    }

    @Override
    public void study() {
        System.out.println("NBA球员在学习");
    }
}

具体乒乓球运动员类继承运动员类，实现说英语接口：

public class PPSportsman extends Sportsman implements SpeakE {
    public PPSportsman() {
    }

    public PPSportsman(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("乒乓球运动员在吃饭");
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员在学习");
    }

    @Override
    public void speakEg() {
        System.out.println("乒乓球运动员在说英语");
    }
}

测试类：

public class Alltest {
    public static void main(String[] args) {
        PPcoach a = new PPcoach("胖子",45);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        a.speakEg();
        a.teach();
    }
}

脚本宝典总结

以上是脚本宝典为你收集整理的20 接口全部内容，希望文章能够帮你解决20 接口所遇到的问题。

如果觉得脚本宝典网站内容还不错，欢迎将脚本宝典推荐好友。

本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ：384754419，请注明来意。