接口

一，为什么有接口

　　接口的快速入门

public interface UsbInterface {
    //规定接口的相关方法,老师规定的. 即规范...
    public void start();
    public void stop();
}
//--------------------------------------------------------------
public class Camera implements UsbInterface {
    @Override
    public void start() {
        System.out.println("相机工作了");
    }

    @Override
    public void stop() {
        System.out.println("相机停止工作");
    }
}
//-------------------------------------------------------------------
public class Phone implements UsbInterface {
    @Override
    public void start() {
        System.out.println("手机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("手机停止工作");
    }
}
//---------------------------------------------------------
public class Computer {
    public void work(UsbInterface usbInterface){
        usbInterface.start();
        usbInterface.stop();
    }
}
//==================================
public class InterfactTest {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Camera camera = new Camera();
        Computer computer = new Computer();
        computer.work(phone);
        System.out.println("===============");
        computer.work(camera);
    }
}
//手机开始工作
//手机停止工作
//===============
//相机工作了
//相机停止工作

　　1. 基本介绍

　　　　接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，在根据具体情况把这些方法写出来，语法：

　　　　interface 接口名{

　　　　　　//属性

　　　　　　//抽象方法，可以省略abstract关键字

　　　　}

　　　　class 类名 implements 接口{

　　　　　　自己属性；

　　　　　　自己方法；

　　　　　　必须实现的接口的抽象方法

　　　　}

　　小结：接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体。接口体现了程序设计的多态和高内聚低耦合的设计思想，jdk8.0 后接口类可以有静态方法，默认方法。也就是说接口中可以有方法的具体实现，需要加关键字default 。

interface MyInterfact01{
     default public void myMethod(){
         System.out.println("接口可以有方法体");
     }
     public static void t2(){
         System.out.println("接口可以有静态的");
     }
 }
 class A implements MyInterfact01{
     
 }

　　2.注意事项和细节

　　　　1）接口不能被实例化

　　　　2）接口中所有的方法都是public ，接口中抽象方法，可以不用abstract修饰

　　　　　　　　void aaa(); 实际上等于 abstract void aa();

　　　　3) 一个普通类实现接口，就必须将该接口的所有方法都实现

　　　　4）抽象类实现接口，可以不用实现接口的方法

　　　　5）一个类同时可以有多个接口

　　　　6）接口中的属性，只能是final的，而且是public static final 修饰符

　　　　　　比如：int a = 1; 实际上是 public static final int a = 1; (必须初始化）

　　　　7）接口中属性的访问形式：接口 . 属性名

　　　　8）接口中不能继承其它的类，但是可以继承多个别的接口 interface A extends B,C{}

　　　　9) 接口的修饰符只能是 public 和默认，这点和类的修饰符是一样的

　　3. 实现接口 VS 继承类

class Monkey{
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Monkey(String name) {
        this.name = name;
    }
    public void eat(){
        System.out.println( name +"猴子吃香蕉");
    }
}
//--------------------------------------------------------
//接口
interface Fishable {
    void swimming();
}
interface Birdable {
    void flying();
}
//--------------------------------------------------------------
class LittleMonkey extends Monkey implements Fishable,Birdable{
//    当子类继承了父类，就自动的拥有父类的功能
//    如果子类需要扩展功能，可以通过实现接口的方式扩展.
//可以理解 实现接口 是 对java  单继承机制的一种补充.
    public LittleMonkey(String name) {
        super(name);
    }
    @Override
    public void eat() {
        super.eat();
    }

    @Override
    public void swimming() {
        System.out.println(getName() + "猴子游泳");
    }

    @Override
    public void flying() {
        System.out.println(getName() + "学飞翔");
    }
}

　　接口和继承解决的问题不同

　　　　继承的价值主要在于：解决代码的复用性和可维护性

　　　　接口的价值主要在于：设计，设计好各种规范（方法），让其它类去实现这些方法，即更加的灵活

　　接口比继承更加灵活，继承满足 is - a 的关系，而接口只需满足 like - a 的关系

　　接口在一定程度上实现了代码的解耦即：接口规范性 + 动态绑定机制

　4. 接口的多态特性

　　　　1）多态参数 //前面的usb接口案例体现出多态

public class InterfacePolyParameter {
    public static void main(String[] args) {
        //接口的多态体现
        //接口类型的变量 if01  可以指向 实现了IF 接口类的对象实例
        IF if01 = new Monster();
        if01 = new Car();
        //继承体现的多态
        //父类类型的变量 a  可以指向 继承 AAA 的子类的对象实例
        AAA a = new BBB();
        a = new CCC();
    }
}
interface IF {}
class Monster implements IF{}
class Car implements    IF{}

class AAA { }
class BBB extends AAA {}
class CCC extends AAA {}

　　　　2) 多态数组

　　　　举例：给Usb一个数组中存放 phone和相机对象，phone 类还有一个特有的方法call() ，请遍历usb数组，如果是phone对象，除了调用usb 接口定义的方法外，还需要调用pohoe 特有的方法call()

interface Usb{
    void work();
}
class Phone_ implements Usb {
    public void call() {
        System.out.println("手机可以打电话...");
    }
    @Override
    public void work() {
        System.out.println("手机工作中...");
    }
}
class Camera_ implements Usb {
    @Override
    public void work() {
        System.out.println("相机工作中...");
    }
}
//============================
public class InterfacePolyArr {
    public static void main(String[] args) {
        //多态数组 ->  接口类型数组
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Camera_();
        for (int i = 0; i < usbs.length; i++) {
            usbs[i].work();//动态绑定
            //和前面一样，我们仍然需要进行类型的向下转型
            if (usbs[i] instanceof Phone_){//判断他的运行类型是 Phone_
                ((Phone_) usbs[i]).call();
            }
        }
    }
}

　　　　3）接口存在多态传递现象　　

public class InterfacePolyPass {
    public static void main(String[] args) {
        //接口类型的变量可以指向，实现了该接口的类的对象实例
        IG ig = new Teacher();
        //如果 IG  继承了 IH  接口，而 Teacher  类实现了 IG 接口
        //那么，实际上就相当于 Teacher  类也实现了 IH 接口.
        //这就是所谓的 接口多态传递现象.
        IH ih = new Teacher();
    }
}
interface IH {
    void hi();
}
interface IG extends IH{ }
class Teacher implements IG {
    @Override
    public void hi() {
    }
}

　　　继承实现如果属性相同那么代码如下

　　　　　　//System.out.println(x); //错误，原因不明确 x

interface AA {    // 1min  看看
    int x = 0;
}    //想到 等价 public static final int x = 0;
class B {
    int x = 1;   //普通属性
}           
class C extends B implements AA {
    public void pX() {
//System.out.println(x); //错误，原因不明确 x
// 可以明确的指定 x
//访问接口的 x  就使用 A.x
//访问父类的 x  就使用 super.x
System.out.println(AA.x + " " + super.x);
}

　　抽象类和接口的区别

posted @ 2022-11-27 23:05 阿文程序猿阅读(182) 评论(0) 收藏举报

刷新页面返回顶部

p1121

接口

公告