Java之接口的使用（interface）#代理设计模式 #接口和抽象类的区别

•  接口的使用规范

1.接口使用interface来定义
 2.Java中，接口和类是并列的两个结构
 3.如何定义接口：定义接口中的成员  
         3.1 JDK7及以前：只能定义全局常量和抽象方法
               >全局常量：public static final的.但是书写时，可以省略不写
               >抽象方法：public abstract的        
         3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法   

          静态方法：使用 static 关键字修饰。可以通过接口直接调用静态方法，并执行 其方法体。我们经常在相互一起使用的类中使用静态方法。你可以在标准库中 找到像Collection/Collections或者Path/Paths这样成对的接口和类。                                                                                                                    默认方法：默认方法使用 default 关键字修饰。可以通过实现类对象来调用。我们在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性。 比如：java 8 API中对Collection、List、Comparator等接口提供了丰富的默认 方法。                                                      
 4. 接口中不能定义构造器的！意味着接口不可以实例化
 5. Java开发中，接口通过让类去实现(implements)的方式来使用.
     如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
     如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
 6. Java类可以实现多个接口   --->弥补了Java单继承性的局限性
    格式：class AA extends BB implements CC,DD,EE
 7. 接口与接口之间可以继承，而且可以多继承
 8. 接口的具体使用，体现多态性
 9. 接口，实际上可以看做是一种规范

代码演示

public class InterfaceTest {
    public static void main(String[] args) {
        Student1 s = new Student1();
        s.bus();
        s.car();
        s.walk();
        s.twoWays();
        System.out.println(s.MAX_DISTANCE);
        System.out.println(toSchool1.MIN_DISTANCE);
    }
}

interface toSchool1{
    public static final  int MAX_DISTANCE = 10000;//距离学校最大距离为10000米
    int MIN_DISTANCE = 100; //省略了public static final

    //抽象方法
    public abstract void car();
    void bus();//省略了public abstract
}

interface toSchool2{
    void walk();
}

//抽象类继承实现接口
abstract class toSchools implements toSchool1,toSchool2{
    public abstract void twoWays();
}

//类继承抽象类+实现多个接口
class Student1 extends toSchools implements toSchool1,toSchool2{
    @Override
    public void twoWays() {
        System.out.println("坐公交+走路去学校");
    }

    @Override
    public void car() {
        System.out.println("打车去学校");
    }

    @Override
    public void bus() {
        System.out.println("坐88路公交去学校");
    }

    @Override
    public void walk() {
        System.out.println("走路去学校");
    }
}

//执行结果
/*
坐88路公交去学校
打车去学校
走路去学校
坐公交+走路去学校
10000
100
*/

思考：接口和抽象类定义同一个变量名，该如何调用？ 

interface A {
	int x = 0;
}

class B {
	int x = 1;
}

调用如下代码：

class C extends B implements A {
	public void pX() {
		//编译不通过。因为x是不明确的
		// System.out.println(x);
		System.out.println(super.x);//1
		System.out.println(A.x);//0
		
	}

关于接口JDK8的默认方法和静态方法的注意事项

1.接口中定义的静态方法，只能通过接口来调用。
2.通过实现类的对象，可以调用接口中的默认方法。如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
3.如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。-->类优先原则
4.若一个接口中定义了一个默认方法，而另外一个接口中也定义了一个同名同 参数的方法（不管此方法是否是默认方法），在实现类同时实现了这两个接 口时，会出现：接口冲突。 解决办法：实现类必须覆盖接口中同名同参数的方法，来解决冲突。    
5.如何在子类(或实现类)的方法中调用父类、接口中被重写的方法  （调用父类的方法：super.方法名（）；调用接口中的方法：接口名.super.方法名（））

代码演示 

public class InterfaceDefaultTest {
    public static void main(String[] args) {
        new Man().help();
    }
}
class Mother{
    public void help(){
        System.out.println("儿子，快来救我");
    }
}

interface Filial {
    default void help(){
        System.out.println("老妈，我来救你了");
    }
}

interface Spoony{
    default void help(){
        System.out.println("老公，快来救我");
    }
}

class Man extends Mother implements Filial,Spoony{
    @Override
    public void help() {
        System.out.println("我到底救谁啊");
        super.help();
        Filial.super.help();
        Spoony.super.help();
    }
}

//执行结果
/*
我到底救谁啊
儿子，快来救我
老妈，我来救你了
老公，快来救我
*/

• 接口和抽象类的区别 

在开发中，常看到一个类不是去继承一个已经实现好的类，而是要么继承抽象类， 要么实现接口。

• 接口的应用：代理模式

public class NetworkTest1 {
    public static void main(String[] args) {
        Proxy proxy = new Proxy(new RealStar());
        proxy.confer();
        proxy.signContract();
        proxy.bookTicket();
        proxy.sing();
        proxy.collectMoney();
    }
}

interface Star{
    void confer();// 面谈
    void signContract();// 签合同
    void bookTicket();// 订票
    void sing();// 唱歌
    void collectMoney();// 收钱
}

//被代理类
class RealStar implements Star{
    @Override
    public void confer() {
    }

    @Override
    public void signContract() {
    }

    @Override
    public void bookTicket() {
    }

    @Override
    public void sing() {
        System.out.println("明星唱歌");
    }

    @Override
    public void collectMoney() {
    }
}

//代理类
class Proxy implements Star{
    private Star star;

    public Proxy(Star star) {
        this.star = star;
    }

    @Override
    public void confer() {
        System.out.println("经纪人面谈");
    }

    @Override
    public void signContract() {
        System.out.println("经纪人签合同");
    }

    @Override
    public void bookTicket() {
        System.out.println("经纪人订票");
    }

    @Override
    public void sing() {
        star.sing();
    }

    @Override
    public void collectMoney() {
        System.out.println("经纪人收钱");
    }
}

//执行结果
/*
经纪人面谈
经纪人签合同
经纪人订票
明星唱歌
经纪人收钱
*/