Java接口学习

1.什么是接口

接口相当于特殊的抽象类，定义方式、组成部分与抽象类类似。

• 微观概念:接口是一种能力。

  • 接口的定义:代表了某种能力。（实现类来实现这种能力）
  • 方法的定义:能力的具体要求。（实现类来实现这些方法）

• 宏观概念：接口是标准

为什么需要接口： Java为单继承，当父类的方法种类无法满足子类需求时，可实现接口扩充子类能力。接口支持多实现，可为类扩充多种能力。

注意点：

• 接口使用interface作为关键字
• 接口没有构造方法，不能创建对象
• 接口只能定义：公开的静态常量，公开的抽象方法

//创建一个接口代码
interface MyInterface{
    //创建公开的静态常量
    //public static final String NAME="接口1";
    //public static final默认包含，可以省略
    String NAME="接口1";
    //创建公开的抽象方法
    //public abstract void method();
    //public abstract默认包含，可以省略
    void method();
}

接口无法实例化对象，下面这条语句是错误的。

MyInterface myInterface = new MyInterface();

但是接口可以创建引用，想要实现接口需要一个实现类，实现类通过关键字implements继承接口。

//对上面建立的接口创建实现类，实现类中必须对接口中的方法重写
public class Impl implements MyInterface{
    @Override
    public void method() {
        System.out.println("method");
    }
}
/*测试类
public class TestInterface {
    public static void main(String[] args) {
         MyInterface myInterface=new Impl();//父类引用指向子类对象
         myInterface.method();
    }
}
*/

2.如何创建接口和实现类

接下来看一个使用接口的例子：

创建一个Person类，有姓名，年龄两种属性，有吃和睡两种方法，Person类代码如下：

public class Person {
    String name;
    int age;

    public Person() {
    }

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

    public void eat(){
        System.out.println(name+"吃东西...");
    }
    public void sleep(){
        System.out.println(name+"睡觉...");
    }
}

我希望对Person这个类扩充两种能力，飞和喷火，因此建立两个接口来代表这两种能力：

//喷火
public interface Fireable {
    void fire();
}

//飞
public interface Flyable {
    void fly();
}

创建了这两个接口以后，我需要人来实现这两种能力，因此需要Person类使用implements关键字来实现这两种能力，并在Person类中实现这两个接口的方法重写，现在Person类如下：

public class Person implements Flyable,Fireable{//多继承
    String name;
    int age;

    public Person() {
    }

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

    public void eat(){
        System.out.println(name+"吃东西...");
    }
    public void sleep(){
        System.out.println(name+"睡觉...");
    }

    @Override//方法重写
    public void fly() {
        System.out.println(name+"飞...");
    }

    @Override//方法重写
    public void fire() {
        System.out.println(name+"喷火...");
    }
}

目前为止，Person类已经实现了两个接口，获得了飞和喷火的能力，写一个测试类看一下结果：

public class TestInterface {
    public static void main(String[] args) {
        Person person=new Person("小明",22);//创建对象来实现方法调用
        person.fly();
        person.fire();
        System.out.println("========多态=========");//使用多态来实现方法调用
        Flyable flyable=new Person("小张",22);
        flyable.fly();//flyable只能调用Flyable接口中的方法，不能调用Person类中的其他方法
        Fireable fireable=new Person("小红",23);
        fireable.fire();
    }
}

实现接口时要注意：

• 任何类在实现接口时，必须实现接口中所有的抽象方法，否则此类为抽象类。

• 实现接口中的抽象方法时，访问修饰符必须是public。

• 同父类一样，接口也可声明为引用，并指向实现类对象。但是要注意:1.仅可调用接口中所声明的方法，不可调用实现类中独有的方法；2.可强转回实现类本身类型，进行独有方法调用。3.通过接口可调用Object中的公开方法。

3.接口的多态

我们来看这样一个例子，有一个动物类Animal：

//Animal类有两个方法，吃和睡
public abstract class Animal {
    public void eat(){
        System.out.println("吃");
    }
    public void sleep(){
        System.out.println("睡");
    }
}

同时，有一个Dog类继承了Animal类和两个接口：

//接口1，跑
public interface Runnable {
    void run();
}

//接口2.游泳
public interface Swimable {
    void swim();
}

//Dog类继承了Animal类和两个接口：
//同时继承父类和接口时，父类要写在前
public class Dog extends Animal implements Runnable,Swimable{
    public void shout(){
        System.out.println("狗狗开始叫...");
    }

    @Override
    public void run() {
        System.out.println("狗狗跑步");
    }

    @Override
    public void swim() {
        System.out.println("狗狗游泳");
    }
}

这时，写一个测试类：

public class TestInterface {
    public static void main(String[] args) {
        Dog dog=new Dog();
        Animal a=dog;//父类引用指向子类对象
        Runnable r=dog;//父类引用指向子类对象
        Swimable s=dog;//父类引用指向子类对象
        dog.run();//dog可以调用Dog类内的所有方法
        dog.shout();
        dog.swim();
        dog.eat();
        dog.sleep();
        a.eat();//a只能调用Animal类的方法
        a.sleep();
        r.run();//r只能调用接口Runable中的方法
        s.swim();////s只能调用接口Swimable中的方法
    }
}

从上面这个例子可以看到，多种不同类型的引用指向同一个对象时，表示看待对象的视角不同。

• Dog myDog: 将狗当狗看

• Animal a:将狗当动物看

• Runnable r:将狗当会跑的东西看

• Swimmable s:将狗当会游的东西看

  不同引用所能看到的对象范围不同，只能调用自身类型中所声明的部分

4.常见关系

1. 类与类:
   ●单继承
   ●extends 父类名称
2. 类与接口:
   ●多实现
   ●implements 接口名称1，接口名称2，接口名称n
3. 接口与接口:
   ●多继承
   ●extends 父接口1，父接口2，父接口n

5.常量接口

常量接口将多个常用于表示状态或固定值的变量，以静态常量的形式定义在
接口中统一管理， 提高代码可读性。

//常量接口，只有公开的静态常量
public interface ConstInterface {
    String CONST1="aaa";
    String CONST2="bbb";
    String CONST3="ccc";
}

静态常量的访问：

public class TestConstInterface {
    public static void main(String[] args) {
        if(ConstInterface.CONST1.equals("aaa")){
            System.out.println("123");
        }
    }
}

6.标记接口

标记接口中没有包含任意成员,仅仅用作标记。

• Serializable

public interface Serializable {
}

• Cloneable

public interface Cloneable {
}

7.接口回调

接口回调：先有接口的使用者，后有接口的实现者。

现有一个Usb接口：

public interface Usb {
    void Service();
}

有一台电脑有三个Usb接口：

public class Computer {
    Usb usb1;
    Usb usb2;
    Usb usb3;
    public void run(){
        System.out.println("电脑开始工作...");
        if (usb1!=null){
            usb1.Service();
        }
        if (usb2!=null){
            usb2.Service();
        }
        if (usb3!=null){
            usb3.Service();
        }
    }
}

此时，三个Usb接口都为空，但是电脑可以正常工作，为了使用这三个接口，定义三个实现类：

//U盘类
public class Upan implements Usb {
    @Override
    public void Service() {
        System.out.println("U盘连接电脑成功，开始工作...");

    }
}

//风扇类
public class Fan implements Usb{
    @Override
    public void Service() {
        System.out.println("风扇连接电脑成功，开始工作...");
    }
}

//鼠标类
public class Mouse implements Usb {
    @Override
    public void Service() {
        System.out.println("鼠标连接电脑成功，开始工作...");
    }
}

写一个测试类：

//测试类
public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer();

        Usb mouse=new Mouse();
        Usb upan=new Upan();
        Usb fan=new Fan();
        computer.usb1=mouse;
        computer.usb2=upan;
        computer.usb3=fan;

        computer.run();
    }
}

我们可以看到，在测试类中，不写下面六句语句，电脑仍可正常运行，这就叫先有接口的使用者（电脑），后有接口的实现者。

Usb mouse=new Mouse();
Usb upan=new Upan();
Usb fan=new Fan();
computer.usb1=mouse;
computer.usb2=upan;
computer.usb3=fan;

接口的好处：

• 程序的耦合度降低。

• 更自然的使用多态。

• 设计与实现完全分离。

• 更容易搭建程序框架。

• 更容易更换具体实现。

8.小结

2. 什么是接口:

   • 微观:接口是一种能力和约定。

   • 宏观:接口是一种标准。

3. 接口与类的异同:

   没有构造方法，仅可定义公开静态常量与公开抽象方法。

4. 接口的应用
   Java为单继承， 当父类的方法种类无法满足子类需求时，可实现接口扩充子类能力。

5. 接口的规范

• 任何类在实现接1时，必须实现接11中所有的抽象方法，否则此类为抽象类。
• 实现接口中的抽象方法时，访问修饰符必须是public.

5. 什么是常量接口
   将多个常用于表示状态或固定值的变量，以静态常量的形式定义在接口中统一管理。

6. 什么是接口回调
   先有接口的使用者，后有接口的实现者。

Java接口学习

原文：https://www.cnblogs.com/Ng3061851/p/14404189.html