Java之接口

---

1. 思考

抽象类中可以定义抽象方法的 。当一个抽象类中的方法全是抽象的。这时，可以通过另一种特殊的形式来体现。

用interface接口来表示。

接口该如何定义呢？

用interface关键字
interface Demo {

}

2. 接口中的成员已经被限定为固定的几种

2.1 定义变量

变量必须有固定的修饰符修饰：public static final ,所以接口中的变量也称之为常量。

2.2 定义方法

方法也有固定的修饰符：public abstract

接口中的成员都是公共的。
如果修饰符不写，编译器会自动加上

3. 接口的特点

• 接口不可以创建对象。
• 子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。

4. 接口使用

4.1 接口定义

interface Demo //定义一个名称为Demo的接口。
{
	public static final int NUM = 3;
	public abstract void show1();
	public abstract void show2();
}

// 可以简化
interface Demo //定义一个名称为Demo的接口。
{
	public static final int NUM = 3;
	void show1();
	void show2();
}

4.2 接口实现

//定义子类去覆盖接口中的方法。子类必须和接口产生关系，类与类的关系是继承，类与接口之间的关系是 实现。
//通过 关键字 implements
class DemoImpl implements Demo //子类实现Demo接口。
{
	//重写接口中的方法。
	public void show1(){}
	public void show2(){}
}

5. 接口最重要的体现：多实现

解决多继承的弊端。将多继承这种机制在java中通过多实现完成了。

interface A
{
	void show1();
}
interface B
{
	void show2();
}
class C implements A, B // 多实现。同时实现多个接口。
{
	public void show1(){}
	public void show2(){}
}

怎么解决多继承的弊端呢？

弊端：多继承时，当多个父类中有相同功能时，子类调用会产生不确定性。其实核心原因就是在于多继承父类中功能有主体，而导致调用运行时，不确定运行哪个主体内容。

为什么多实现就解决了呢？

因为接口中的功能都没有方法体，由子类来明确。

6. 继承同时多实现

6.1 基于接口的扩展

class Fu
{
	public void show(){}
}
//子类通过继承父类扩展功能，通过继承扩展的功能都是子类应该具备的基础功能。
//如果子类想要继续扩展其他类中的功能呢？这时通过实现接口来完成。
interface Inter
{
	pulbic void show1();
}
class Zi extends Fu implements Inter
{
	public void show1()
	{
		
	}
}

6.2 作用

• 接口的出现避免了单继承的局限性。
• 父类中定义的事物的基本功能。
• 接口中定义的事物的扩展功能。

7. 接口出现后的一些小细节

• 类与类之间是继承(is a)关系
• 类与接口之间是实现(like a)关系
• 接口与接口之间是继承关系，而且可以多继承。

interface InterA
{
	void show1();
}
interface InterAA
{
	void show11();
}
interface InterB extends InterA, InterAA //接口的多继承。
{
	void show2();
}

class Test implements InterB
{
	public void show1(){}
	public void show2(){}
	public void show11(){}
}
class InterfaceDemo 
{
	public static void main(String[] args) 
	{
		DemoImpl d = new DemoImpl();
		d.show1();
		d.show2();
	}
}

8. 没有抽象方法的抽象类的由来

定义一个接口：

interface Inter
{
	//定义四种显示功能。
	public void show1();
	public void show2();
	public void show3();
	public void show4();
}

定义子类，要使用第一种显示方式。

/定义子类，要使用第一种显示方式。
class InterImpl1 implements Inter
{
	//覆盖show1方法。
	public void show1()
	{
		System.out.println("show1 run");
	}
	//为了让该类实例化。还需要覆盖其他三个方法，虽然该类用不上。
	public void show2(){}
	public void show3(){}
	public void show4(){}
}

定义另一个子类,需要使用显示3方法。

//另一个子类需要使用显示3方法。
class InterImpl3 implements Inter
{
	//覆盖show3方法。
	public void show3()
	{
		System.out.println("show3 run");
	}
	//为了让该类实例化。还需要覆盖其他三个方法，虽然该类用不上。
	public void show2(){}
	public void show1(){}
	public void show4(){}
}

出现问题：

为了使用接口中的部分方法。而覆盖了全部的方法，而且每一个子类都要这么做，复用性差。

怎么办？

将这些不用的方法都单独抽取到一个独立的类中。让这个类去实现接口，并覆盖接口中的所有方法。

这个类知道这些方法的具体实现内容吗？

不知道。
所以只能为了后期子类创建对象方便，而进行空实现。

而这时，这个类创建对象有意义吗？

没有意义。这个类创建对象就不需要，直接将其抽象化。这就是没有抽象方法的抽象类。

完整代码：

abstract class InterImpl implements Inter
{
	//实现Inter接口中的所有方法。
	public void show1(){}
	public void show2(){}
	public void show3(){}
	public void show4(){}
}
//如果有子类去使用显示1方法。让子类继承InterImpl实现类就可以了。
class InterImpl11 extends InterImpl
{
	public void show1()
	{
		System.out.println("show1 run");
	}
}

class InterImpl33 extends InterImpl
{
	public void show3()
	{
		System.out.println("show3 run");
	}
}

class InterfaceDemo2 
{
	public static void main(String[] args) 
	{
		InterImpl1 in1  = new InterImpl1();
		in1.show1();
		InterImpl3 in3  = new InterImpl3();
		in3.show3();
	}
}

9. 接口的思想

举例：

笔记本电脑，USB接口的故事。

• 接口的出现对功能是实现了扩展。
• 接口的出现定义了规则。
• 接口的出现降低了耦合性(解耦)。

接口的出现，完成了解耦，说明有两方，一方在使用这个规则，另一方在实现这个规则。比如笔记本电脑使用这个规则，而外围设备在实现这个规则。

10. 接口和抽象类的区别

描述事物。

犬。按照功能分类。导盲犬，缉毒犬...

犬：
    吼叫();
    吃饭();

代码实现：

abstract class 犬
{
	public abstract void 吼叫();
	public abstract void 吃饭();
	
}
class 缉毒犬 extends 犬
{
	public void 吼叫(){}
	public void 吃饭(){}
	public void 缉毒(){}
}

但是对于缉毒，有可能还有缉毒猪，具备者缉毒功能，应该将缉毒功能抽取。

//对缉毒进行描述。
abstract class 缉毒
{
	public abstract void 缉毒();
}

缉毒犬既需要犬的功能又需要缉毒的功能。但无法直接多继承。是否可以多实现呢？

可以的。

那定义成类好还是接口呢？

如果犬是接口，缉毒也是接口。那么缉毒犬多实现即可。

注意：

类负责描述的是事物的基本功能。接口负责描述事物的扩展功能。
缉毒犬是犬中一种。is a 关系，

所以

这时应该将犬定义成类。而缉毒是犬的一个扩展功能。这时将缉毒定义接口。

这时描述就变成了这样：

abstract class 犬
{
	public abstract void 吼叫();
	public abstract void 吃饭();
	
}

interface 缉毒able
{
	public abstract void 缉毒();
}

class 缉毒犬 extends 犬 implements 缉毒able
{
	public  void 吼叫(){
        ...
    }
	public  void 吃饭(){
        ...
    }
	public  void 缉毒(){
        ...
    }
}

小结：

• 抽象类是描述事物的基本功能，可以定义非抽象的方法。
• 接口中定义只能是抽象方法，负责功能的扩展。
• 类与类之间是继承关系 is a关系。
• 类与接口之间是实现关系 like a 关系。