接口interface

一、 知识清单

1、接口使用interface来定义。
2、Java中，接口和类是并列的两个结构。
3、如何定义接口：定义接口中的成员
  3.1 JDK7及以前：只能定义全局常量和抽象方法
    >全局常量：public static final的，但是书写时可以省略不写（并且只能是public static final变量，用private修饰会报编译错误）
    >抽象方法：方法会被隐式地指定为public abstract方法 且只能是public abstract方法（用其他关键字，比如private、protected、static、 final等修饰会报编译错误），并且接口中所有的方法不能有具体的实现，也就是说，接口中的方法必须都是抽象方法。从这里可以隐约看出接口和抽象类的区别，接口是一种极度抽象的类型，它比抽象类更加“抽象”，并且一般情况下不在接口中定义变量。
  3.2JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
4、接口中不能定义构造器的！意味着接口不可以实例化
5、Java开发中，接口通过类去实现（implements）的方式来使用

• 如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
• 如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类

6、Java类可以实现多个接口 —>弥补了Java单继承性的局限性

格式：class AA extends BB implements CC,DD,EE

7、接口与接口之间可以继承，而且可以多继承
8、接口的具体使用，体现多态性
9、接口，实际上可以看做是一种规范
10、抽象类与接口有哪些异同（见）

二、接口概述

三、代码演示

/*
 * 接口的使用
 * 1.接口使用interface来定义
 * 2.Java中，接口和类是并列的两个结构
 * 3.如何定义接口：定义接口中的成员
 * 		3.1 JDK7及以前：只能定义全局常量和抽象方法
 * 			>全局常量：public static final的，但是书写时可以省略不写
 * 			>抽象方法：public abstract的
 * 		3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法（略）
 * 4.接口中不能定义构造器的！意味着接口不可以实例化
 * 
 * 5.Java开发中，接口通过类去实现（implements）的方式来使用
 *   如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
 *   如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
 *   
 * 6.Java类可以实现多个接口 --->弥补了Java单继承性的局限性
 * 		格式：class AA extends BB implements CC,DD,EE
 * 7.接口与接口之间可以继承，而且可以多继承
 * 8.接口的具体使用，体现多态性
 * 9.接口，实际上可以看做是一种规范
 * 
 * 10.面试题：抽象类与接口有哪些异同
 */
public class InterfaceTest {
	public static void main(String[] args) {
		System.out.println(Flyable.MAX_SPEED);//7900
		System.out.println(Flyable.MIN_SPEED);//1
//		Flyable.MAX_SPEED=2;
		
		Plane plane =new Plane();
		plane.fly();//通过引擎起飞
		
		//下面都发生了多态
		//class Bullet extends Object implements Flyable,AA,BB, Attackable
		Attackable b=new Bullet();
		b.attack();//我是子弹我很牛逼
		Flyable b1=new Bullet();
		BB b2=new Bullet();
		AA b3=new Bullet();
		
		/*
		 * 输出结果
		 * 7900
			1
			通过引擎起飞
			我是子弹我很牛逼
		 */
	}
}

interface Flyable{
	
	//全局常量
	public static final int MAX_SPEED=7900;//第一宇宙速度
	int MIN_SPEED=1;//省略了public static final
	
	//抽象方法
	public abstract void fly();
	//省略了public abstract
	void stop();
	//public void stop1();
	//abstract void stop2();
	
	//接口中不能有构造器
	//com.liuyongbin.abstraxtExer3
//	public Flyable(){
//		
//	}
}

interface Attackable{
	void attack();
}

class Plane implements Flyable{

	String name;
	
	//实现抽象方法时，eclipse这一行前面会有一个白色的三角形
	@Override
	public void fly() {
		System.out.println("通过引擎起飞");
	}

	@Override
	public void stop() {
		System.out.println("驾驶员减速停止");
	}
	
}

abstract class Kite implements Flyable{
	//重写不重写都不报错
//	@Override
//	public void fly() {
//		
//	}
	public Kite(){
		
	}
}

class Bullet1 extends Kite {

	@Override
	public void stop() {//实现了stop方法，前面是个白色三角
		
	}
	@Override
	public void fly() {//重写Kite中的fly方法，看前面是个绿色三角，这个方法可有可无
						//因为Kite实现了该方法，再写一遍相当于重写	
	}
}

interface AA{
	void method1();
}

interface BB{
	void method2();
}

//接口可以多继承
interface cc extends AA,BB{
	
}


class Bullet extends Object implements Flyable,AA,BB, Attackable{

	@Override
	public void method2() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void method1() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void fly() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void stop() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void attack() {
		System.out.println("我是子弹我很牛逼");
	}

练习1

/*
 * 接口的使用
 * 1.接口使用上也满足多态性
 * 2.接口，实际上就是定义了一种规范
 * 3.开发中，体会面向接口编程
 */
public class USBTest {
	public static void main(String[] args) {
		
		Computer com=new Computer();
		//1.创建了接口的非匿名实现类的非匿名对象
		Flash flash=new Flash();
		com.transferData(flash);
		
		//2.创建了接口的非匿名实现类的匿名对象
		com.transferData(new Printer());
		
		//3.创建了接口的匿名实现类的非匿名对象
		USB phone =new USB(){//注意：这里虽然写的是new USB()其实是new的它的子类(所以说创建了接口的匿名实现类)
			//因为接口都不能有构造器，怎么能造对象呢

			@Override
			public void start() {
				System.out.println("手机开始工作");
			}

			@Override
			public void stop() {
				System.out.println("手机结束工作");
			}
		};
		com.transferData(phone);
		
		//4.创建了接口的匿名实现类的匿名对象
		com.transferData(new USB(){

			@Override
			public void start() {
				System.out.println("mp3开始工作");
			}

			@Override
			public void stop() {
				System.out.println("mp3停止工作");
			}			
		});
		
		/*
		 * U盘开启工作
			具体传输数据的细节
			U盘结束工作
			打印机开启工作
			具体传输数据的细节
			打印机结束工作
			手机开始工作
			具体传输数据的细节
			手机结束工作
			mp3开始工作
			具体传输数据的细节
			mp3停止工作

		 */
	}
}

interface USB{
	
	//常量：定义了长、宽、最大最小的传输速度等
	
	public abstract void start();
	void stop();
}

class Computer{
	
	public void transferData(USB usb){//USB usb=new Flash();//多态
		
		usb.start();
		System.out.println("具体传输数据的细节");
		
		usb.stop();
	}
}

class Flash implements USB{

	@Override
	public void start() {
		System.out.println("U盘开启工作");
	}

	@Override
	public void stop() {
		System.out.println("U盘结束工作");
	}
	
}

class Printer implements USB{

	@Override
	public void start() {
		System.out.println("打印机开启工作");
	}

	@Override
	public void stop() {
		System.out.println("打印机结束工作");
	}
	
}

四、接口的应用代理模式与工厂模式

代理与工厂

五、Java8中关于接口的新规范

1、JDK8：除了定义全局常量和抽象方法外，还可以定义静态方法、默认方法
代码演示

/*
 * JDK8：除了定义全局常量和抽象方法外，还可以定义静态方法、默认方法
 */
public interface CompareA {
	
	//静态方法
	public static void method1(){
		System.out.println("CompareA：北京");
	}
	
	//默认方法
	public  default void method2(){
		System.out.println("CompareA：上海");
	}
	
	default void method3(){//可以通过OutLine查看这个方法类型
		System.out.println("CompareA:上海");
	}
}

2、接口中定义的静态方法，只能通过接口名来调用。
声明一个接口A里面有一个静态方法 :method1()

interface A{
	public static  void method1(){
		System.out.println("interface A中的静态方法：method1");
	}
}

Test实现这个接口，只能通过接口名.方法名调用，通过实现类的对象不能调用

3、通过实现类的对象，可以调用接口中的默认方法。如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法。
在上述的接口中增加一个默认的default方法

interface A{
	public static  void method1(){
		System.out.println("interface A中的静态方法：method1");
	}
	public default void method2(){
		System.out.println("interface A中的default方法：method2");
	}
}

通过实现类Test的对象进行调用

在实现类中重写method2方法，输出如下：

4、如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，那么子类在没重写此方法的情况下，默认调用的是父类中的同名同参数的方法。–>类优先原则
接口A的声明

interface A{
	public default void method2(){
		System.out.println("interface A中的default方法：method2");
	}
}

声明一个父类具有一个与接口A中同名同参的方法

class FatherClass{
	
	public  void method2(){
		System.out.println("interface A中的default方法：method2");
	}
}

Test类继承FatherClass类、实现接口A

public class Test extends FatherClass  implements A{
	
	public static void main(String[] args) {
		Test t=new Test();
		t.method2();
	}
}

输出结果：

5、如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没重写此方法的情况下，报错。–>接口冲突。这就需要我们必须在实现类中重写此方法。
接口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类

6、如何在子类(或实现类)的方法中调用父类、接口中被重写的方法
接口A有一个method

interface A{
	public default void method(){
		System.out.println("interface A中的method方法");
	}
}

接口B中有一个method

interface B{
	public default void method(){
		System.out.println("interface B中的method方法");
	}
}

父类FatherClass有一个method

class FatherClass{
	
	public  void method(){
		System.out.println("FatherClass 中的method方法");
	}
}

Test类继承父类FatherClass实现接口A，B并重写method方法，且增加一个method3，在method3中调用接口A、B，父类FatherClass中的method方法如下：

public class Test extends FatherClass  implements A,B{
	
	@Override
	public void method() {
		System.out.println("自己定义的method方法");
	}
	
	//?如何在子类(或实现类)的方法中调用父类、接口中被重写的方法
	public  void method2(){
		method();//调用自己重写的method
		super.method();//调用父类的method
		A.super.method();//调用抽象类A的method
		B.super.method();//调用抽象类B的method
	}
	
	public static void main(String[] args) {
		Test t=new Test();
		t.method2();
	}
}

知识点六的一个练习

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

interface Spoony{//痴情的
	default void help(){
		System.out.println("媳妇，别怕，我来了");
	}
}

class Father{
	public void help(){
		System.out.println("儿子，救我媳妇");
	}
}

public class Man extends Father implements Filial,Spoony{
	@Override
	public void help() {
		System.out.println("我该就谁呢？");
		Filial.super.help();
		Spoony.super.help();
	}
}

六、接口的面试题

接口的面试题