Java面向对象-接口

接口

---

---

---

一、认识接口

public interface MyInterface {
		public void foo();
		// 其它方法
}
// 所有方法默认都是public abstract

接口特点：

1）接口不可以被实例化

2）实现类必须实现接口的所有方法

3）实现类可以实现多个接口

implements、多个接口使用逗号隔开

4）接口中的变量都是静态常量（public static final）

二、实现接口描述USB案例

public interface Usb {

    // USB接口功能，充电、传输
    void electric();
    void data();
}

public class UsbFeng implements Usb{

    @Override
    public void electric() {
        System.out.println("获取5A电流，风扇开始转动");
    }

    @Override
    public void data() {
    
    }

    public void m1() {
        System.out.println("UsbFeng中特有的方法m1()");
    }
}

public class UsbMouse implements Usb{

    @Override
    public void electric() {
        System.out.println("获取3A电流，鼠标开始工作");
    }

    @Override
    public void data() {
        System.out.println("移动鼠标，开始传输数据");
    }

    public void m2() {
        System.out.println("UsbMouse类中特有的方法m2()");
    }
}

public class UsbDisk implements Usb{

    @Override
    public void electric() {
        System.out.println("获取2A电流，U盘开始工作");
    }

    @Override
    public void data() {
        System.out.println("复制剪切，传输数据");
    }

    public void m3() {
        System.out.println("UsbDisk类中特有的方法m3()");
    }
}

public class Test {

    public static void main(String[] args) {

        // 直接创建接口实例不可以
        // 但是可以通过多态的形式将接口的引用指向实现类的实例
        // 多态：同一个父类引用指向不同的子类实现，实现不同的操作

        // 向上转型：父类（接口）的引用指向不同的子类（实现类）实例
        Usb usb1 = new UsbFeng();
        usb1.electric(); // 获取5A电流，风扇开始转动
        usb1.data();
        // 父类引用无法调用子类中特有的方法，需要通过向下转型为其指向的实现类对象才能调用
        // 向下转型：将子类的引用指向父类的引用
        UsbFeng usbFeng = (UsbFeng)usb1;
        usbFeng.m1(); // UsbFeng中特有的方法m1()

        System.out.println("------ ------ ------");

        usb1 = new UsbMouse();
        usb1.electric(); // 获取3A电流，鼠标开始工作
        usb1.data(); // 移动鼠标，开始传输数据

        System.out.println("------ ------ ------");

        usb1 = new UsbDisk();
        usb1.electric(); // 获取2A电流，U盘开始工作
        usb1.data(); // 复制剪切，传输数据

        if(usb1 instanceof UsbFeng){
            UsbFeng usbFeng1 = (UsbFeng)usb1;
            usbFeng1.m1();
        }else if(usb1 instanceof UsbMouse){
            UsbMouse usbMouse = (UsbMouse)usb1;
            usbMouse.m2();
        }else if(usb1 instanceof UsbDisk){
            UsbDisk usbDisk = (UsbDisk) usb1;
            usbDisk.m3(); // UsbDisk类中特有的方法m3()
        }
        
    }
}

三、接口的使用

1）接口中的成员变量

默认都是public static final的，必须初始化

2）接口中的方法

默认都是public abstract的

3）接口没有构造方法，不能被实例化

4）一个接口不能实现另一个接口，但可以继承多个其它接口

5）一个类必须实现接口抽象方法（implements）除非这个类也是抽象类

/*
* 类与类之间是继承关系，单根继承，一个类只能直接继承另一个类
* 类与接口之间是实现关系，多实现，一个类可以实现多个接口，多个接口之间使用逗号,隔开
* 接口与接口之间是继承关系，多继承，一个接口可以继承多个接口
* */
public interface Demo01 {

    // 接口中的变量都是静态常量值，默认修饰符public static final
    // int num = 100;
    public static final int num = 100;

    // 接口中没有构造方法
    // public Demo01(){}
    
    void m1();
}

// 一个类实现了一个接口，必须将接口中的方法都进行重写，如果不重写，该类要定义为抽象类
public class Demo01Son implements Demo01{

    public static void main(String[] args) {
        
        Demo01 demo01 = new Demo01Son();
        System.out.println(demo01.num);

        // demo01.num = 200;
    }

    @Override
    public void m1() {

    }
}

public interface Demo02 {
}

// 一个接口可以继承多个接口，多个接口之间使用逗号,隔开
public interface Demo03 extends Demo01,Demo02{
}

// 一个类实现了一个接口，必须将接口中的方法都进行重写，如果不重写，该类要定义为抽象类
public abstract class Demo01Son2 implements Demo01{
}

四、抽象类和接口比较

接口是特殊的抽象类

1、相同点

1）代表系统的抽象层

2）都不能被实例化

3）都能包含抽象方法

用于描述系统提供的服务，不必提供具体实现

2、不同点

1）在抽象类中可以为部分方法提供默认实现，而接口中只能包含抽象方法

抽象类便于复用，接口便于代码维护

2）一个类只能继承一个直接的父类，但可以实现多个接口

3、使用原则

1）接口做系统与外界交互的窗口

接口提供服务

2）接口本身一旦制定，就不允许随意修改

3）抽象类可完成部分功能实现，还有部分功能可作为系统的扩展点

五、面向对象设计原则

1、多用组合，少用继承

2、针对接口编程

3、针对扩展开放，针对改变关闭

六、接口总结

1、Java中的接口

1）属性全都是全局静态常量

2）方法都是全局抽象方法

3）无构造方法

2、一个类可以实现多个接口，非抽象类实现接口时必须实现接口中的全部方法

3、抽象类利于代码复用，接口利于代码维护