【Java基础】Java8新特性—接口中使用default和static关键字

一.为什么需要接口

在java中只允许继承一个父类。现实生活中的对象功能越来越强大，一个对象具备多种功能，如何进行描述这类对象的行为。

譬如:

• 手机，基础功能是通话，发送信息； 高级功能: 拍照， 播放音乐 导航，播放视频。
• 电视: 基础功能播放电视剧新闻；高级功能: 联网，播放硬盘视频，播放MP3,连接笔记本电脑，视频通话，学习课程等等。

如何描述:

• 电视是一个家用电器，可以继承；但是电视的联网的方法如何描述

我们可以这样理解:

• 联网是电视的扩展功能，通过接口进行实现。电视有USB接口，HDMI接口，网线接口，视频接口(连接电脑)。电视就通过丰富的接口扩展他的功能的。

二.接口概念

接口就是一个规范，描述功能的具体要求。

三.接口的语法

public interface 接口名称{
     返回值 方法1();
     返回值 方法2();
     
    static 返回值 方法3(){
        //静态方法
    }
    
    default 返回值 方法4(){
        //缺省方法
    }
} 

注意的问题:

1. 接口的方法都是无方法体的，公有的、抽象的方法，Java8之后可以有带方法体静态方法和默认方法（可以直接调用通过接口名#方法名的方式调用）

   public abstract void m1( ); //public abstract 可以略
   

2. 接口的属性都是public static final修饰的常量（ public static final 可以略，可以直接通过接口名#属性名来访问）
3. 非抽象类必须实现接口的所有方法
4. 一个接口可以继承一个或者多个接口

   public interface MyApi extends MyApi2,MyApi3 {//}
   

5. 一个类可以继承一个父类实现多个接口
6. 接口不能有构造方法，抽象类可以有；因为接口不能创建对象
7. 接口可以定义一种类型，指向接口的实现类；在用接口调用方法时，只能是接口中定义的方法

---

接口中的变量默认类型是public static final，也是就是说是 公有静态常量 。 而方法默认是public abstract，公有抽象方法，但是事实真的是这样吗？

四.接口的实现

/**
 * java中一个类只允许继承一个父类，单继承；不能继承多个父类
 * 
 * 电视: 不是一个普通的电视，可以上网，听音乐， 电视能不能继承电脑，不合适，
 * 家用电器类
 */
class HomeAppliances{
	private String name;
	public void start() {
		System.out.println("开始工作");
	}
}


/**
 * 如何描述上网的功能？ 不能再创建一个类了， java用使用接口实现： 接口描述一个功能
 * 
 * 定义一个网络功能接口
 */
interface NetWork{
	//链接网络
	public abstract void connect();
	//断开网络
	void disconnect();
}

/**
 * 拍照功能接口
 */
interface Photoable{
	void takePhoto();
}

/**
 * 电视类： 一个类可以实现多个接口。接口的所有方法都要实现，否则该类必须定义为抽象类
 */
class TV extends HomeAppliances implements NetWork,Photoable{
	//品牌
	private String brand;
	public void show() {
		System.out.println("开始播放电视剧");
	}
	
	@Override
	public void connect() {
		System.out.println("电视链接到互联网.....");
	}

	@Override
	public void takePhoto() {
		System.out.println("使用TCL电视机拍照....");

	}
	
	@Override
	public void disconnect() {
		System.out.println("电视断开网络连接.....");
	}
}


public class Test1 {
	public static void main(String[] args) {
		TV tv = new TV();
		tv.show();
		tv.connect();
	}
}

五.Java8关于接口新特性

Java 1.8对接口有两个方面的增强：接口中可以添加使用default或者static修饰的方法

• 增加default方法：又叫做接口扩展方法， 该方法 "只能通过接口实现类的对象来调用"。实现类可以重写默认方法。可以实现不破坏java现有实现架构的情况下能往接口里增加新方法，子类可以直接调用！

  如果想对接口增加一个新方法，那么需要对实现该接口的所有类进行修改，如果接口实的现类很多，就会带来很大的工作量，而且还很容易破坏以前的代码，带来一些问题。如果把新的方法定义为default方法，就可以避免对其他实现类的修改。尽管如此，Default 方法不适合过多使用

• 增加static方法: 接口中用static修饰的方法也可以有方法体, "只能通过接口名调用"，不可以通过实现类的类名或者实现类的对象调用

注意：

• default方法可以被 其子接口继承 也可被其实现类所调用。
• default方法被继承时，可以被其子接口、实现类重写
• 接口里的静态方法不会被继承或者实现，但是静态变量会被继承，且静态变量是所有实现类共享的
• 如果2个接口中定义了一模一样的static方法，并且一个实现类同时实现了这2个接口，此时并不会产生错误，因为只能通过接口类调用接口中的静态方法，所以对编译器来说是可以区分的。
• 如果两个接口中定义了一模一样的default方法，并且一个实现类同时实现了这2个接口，那么必须在实现类中重写默认方法，否则编译失败。

六.defalut方法

1. 实现类会继承接口中的default方法

如果接口A中有default方法：

public interface A {
	public default void a(){
		System.out.println("这是AAA");
	}
}

B类实现接口A：

public class B implements A{
	
}

那么B类将会继承接口A中的a方法：

public class Main {
	public static void main(String[] args) {
		B b = new B();
		b.a();
	}
}

执行结果:

2. 如果一个类同时实现接口A和B，接口A和B中有相同的default方法，这时，该类必须重写接口中的default方法

为什么要重写呢？是因为，类在继承接口中的default方法时，不知道应该继承哪一个接口中的default方法。

接口A：

public interface A {
	public default void a(){
		System.out.println("这是A");
	}
}

接口B：

public interface B {
	public default void a(){
		System.out.println("这是B");
	}
}

Test类：

com.demo.test.Test inherits unrelated defaults for a() from types com.demo.test.A and com.demo.test.B

可以看出，接口的实现类可以直接调用接口中用default修饰的方法，并且不需要实现该方法（也可以实现）

3. 如果子类继承父类，父类中有a方法，该子类同时实现的接口中也有a方法（被default修饰），那么子类会继承父类的a方法而不是继承接口中的a方法

接口A：

public interface A {
	public default void a(){
		System.out.println("AAA");
	}
}

类B：

public class B {
	public void a(){
		System.out.println("BBB");
	}
}

子类C：

public class C extends B implements A{
	public static void main(String[] args) {
          C c = new C();
          c.a();
    }
}

执行结果:

说明子类继承的b方法为父类C中的b方法，不是接口中的default b(){}方法。

七.static方法

static关键字常用于修饰类的属性和方法，同样，在Java8，static也可以修饰接口的方法

接口A:

public interface A {
	public static void a(){
		System.out.println("AAA");
	}
}

调用接口A的静态方法:

public class B {
    public static void main(String[] args) {
            A.a();
    }
}

执行结果:

可以看出，在接口中用static修饰的方法，可以直接用接口名.方法名（这里A.a()）调用，并且实现类不能实现接口中static修饰的方法。

八.综合案例

public interface Calculate {
	//加法
    int add(int a, int b);
    //除法
    double divide(int a, int b);
    
    /**
     * 这个时候突然来了个新功能，我们要新增一个方法， 实现（两个数的和）* (两个数的商),
     * 而现在这个Calculate 接口又有很多实现的方法，JDK1.8之前，我们要在接口定义一个方法，
     * 然后每个实现类都要去实现这个方法，代码修改量很大。而有了default方法， 我们可以直接
     * 在Calculate接口新增一个方法
     */
    //默认方法:对实现类没有影响
    default double hybrid(int a, int b){
        return add(a,b) * divide(a,b);
    }
    
    //乘法 增加一个方法带来的影响是:所有的实现类都要修改，代码量修改比较多
    int multiply(int a,int b);
    
    //生成min-max的随机整数
    static int randomNum(int min, int max){
        return new Random().nextInt(max-min+1)+min;
    }
}

实现类

public class CalculateImpl implements Calculate {
    @Override
    public int add(int a, int b) {
        return a + b;
    }

    @Override
    public double divide(int a, int b) {
        return a/b;
    }

	@Override
	public int multiply(int a, int b) {
		return a * b;
	}

    public static void main(String[] args) {
        Calculate calculate = new CalculateImpl();
        //加
        int x = calculate.add(1,2);
        //乘
        double y = calculate.divide(3, 1);
        System.out.println("add: " + x +", divide: "+ y);

        //直接调用接口的默认方法
        double result = calculate.hybrid(100, 50);
        System.out.println(result);

        //调用接口的静态方法,只能通过接口名称调用
        int num = Calculate.randomNum(1, 10);
        System.out.println("随机数:"+num);

        //调用继承自Calculate接口的静态常量
        CONTEXT.put("name","zhangsan");
        System.out.println("静态常量:"+CONTEXT.get("name"));

        //打印name在静态常量中的value值
        CalculateImpl2 calculate2 = new CalculateImpl2();
        calculate2.println("name");
    }
}

实现类2：用于测试Calculate 的实现类是否共享静态常量

public class CalculateImpl2 implements Calculate {
    @Override
    public int add(int a, int b) {
        return a + b;
    }

    @Override
    public double divide(int a, int b) {
        return a/b;
    }


	@Override
	public int multiply(int a, int b) {
		return a * b;
	}
	
	//打印静态常量的value值
    public void println(String key) {
        System.out.println("打印值:"+CONTEXT.get(key));
    }
}

执行CalculateImpl 的main方法