JAVA学习第十四课（接口：implements及其基本应用）

接口：

我们知道抽象类中可以定义抽象方法，也可以定义非抽象方法，当一个抽象类中的方法都是抽象方法的时候，我们就可以定义另一种表现方式：接口（interface），所以接口是一种特殊的抽象类

接口的出现将“多继承”通过另一种形式表示出来，即“多实现”。

注意：接口的定义不是class，而是interface,当然最后编译时还是class文件

interface Demo
{
	abstract void show();
	abstract void show1();
	
}

接口中常见的成员：（全部是固定的修饰符）

1.全局常量（public static final）
2.抽象方法（public abstract）
3.当然还有别的

interface Demo
{
	public static final int num = 4;//num终身为4
	public int num = 4;//不写，会自动加上去，默认的，最好写上，否则阅读性差
	public abstract void show();
}

由此得出结论： 接口里的成员是公共的，->权限最大

如果是类的话，会用继承，如果用接口的话，就不用继承了，用另外一种更加直观的表述方式，叫 实现 （implements） 。

为什么叫实现？

接口里的方法都是抽象的，所以必要要全实现，对于抽象类里，有一些不是抽象的，子类拿过来直接用的。继承可以拿过来一些我不需要做，直接可以用的东西，而实现是我全部都要用的，都要覆盖，都要自己重写。

所以：类与类之间是继承关系，类与接口之间是实现关系

接口实现的特点：

import java.util.Scanner;

interface Demo
{
	public abstract void show();
	public abstract void show1();
	public static final int num = 4;
}
 //类与类是继承关系，类与接口之间是实现关系(implements)
/*
 * 接口不可以实例化
 * 只能由实现了接口的子类，并且覆盖了接口中所有的抽象方法后才可以实例化
 * 否则，这个子类只是一个抽象类
 * */
class Demo1_Imple implements Demo
//一个类实现接口后，必须覆盖接口里所有的方法，才能实现类implements接口
{
	public void show()
	{
		System.out.println("show打印"+num);
	}
	public void show1()
	{
		System.out.println("show1打印"+num);
	}
}
public class Main 
{
	public static void main(String[] args)
	{
		Scanner in = new Scanner(System.in);
		Demo1_Imple BLF = new Demo1_Imple();
		BLF.show();
		BLF.show1();
		BLF.num = 5;//错误，num是final修饰的
		System.out.println(BLF.num);//对象用num
		System.out.println(Demo.num);//接口的静态成员
		System.out.println(Demo1_Imple.num);//实现接口的子类的静态成员num
	}
}

接口的优点：

java不直接支持多继承，因为会出现调用的不确定性（存在隐患），所以java将C++的多继承机制，进行了改良，在java中变成了多实现（一个类实现多个接口）

多继承：同是继承一个或两个父类，一个父类有A,B两功能，一个父类有C,D两个功能，子类一继承就具备A,B,C,D四个功能
多实现：一个父类有A,B两抽象功能，一个父类有C,D两个抽象功能，一个子类实现就具备这4个功能
（与多继承的小区别）
我们注重的是事物的功能，至于功能该怎么用，由子类明确，如果父类的功能已经符合子类的需求，子类直接用就可以了，如果不符合，子类还是具备这个功能，但是要重写，但是功能干什么，子类说的算

为什么java的多实现称为改良的多继承？

多继承的弊端就是如果两个的父类的方法名相同，就会出现不确定性，而多实现呢？就不存在了，因为show（）的方法体是子类自己写的，而多继承，继承的是方法体，java改良后，没有方法体，方法体是子类决定的

多实现，小练习：

interface A
{
	public abstract void show();
}
interface B
{
	public abstract void show();
	public abstract int add(int a,int b);
}
class C implements A,B
{
	public void show()
	{
		System.out.println("你好");
	}
	public int add(int a,int b)
	{
		return a+b+10;
	}
}

public class Main 
{
	public static void main(String[] args)
	{
		C BLF = new C();
		BLF.show();
		System.out.println(BLF.add(1, 3));
	}
}

故：多实现，对多继承实现了改良

当然，以下两种test的代码方式，是java不能忍受的

interface A
{
	public abstract void show();
}
interface B
{
	public abstract int show();
}
Test 1：
class C implements A,B
{
	public void show()//如果这样写的C还是一个抽象类，因为没有覆盖所以的方法
	{
		System.out.println("你好");
	}
}
Test 2：


class C implements A,B
{
	public void show()
	{
	    System.out.println("你好");
	}
	
	public int show()
	{
	    System.out.println("你好,世界");//C中已经定义了show，调用show，返回值确定不了，int还是void
	}


}

当然，接口的功能，远不于只如此

一个类在继承，另一个类在多实现（也就是先给该类找一个父类，然后在扩展这些功能）

见代码：

interface A
{
	public abstract void show();
}
interface B
{
	public abstract void show();
	public abstract int add(int a,int b);
}
class D
{
	public void  print() 
	{
		System.out.println("你好好");
	}
}
//很猛！！！
class E extends D implements A,B//E继承了D，实现了A和B，这样E的功能就丰富多了
{
	//E单继承了D中的print功能，但是还想用A,B中的功能，但是这些功能无发通过继承了，
	//那么就同时实现接口的方式，来扩展E中的功能
	public void show()
	{
		System.out.println("你好");
	}
	public int add(int a,int b)
	{
		return a+b+10;
	}
	public void test()
	{
		System.out.println("测试");
	}
}
/*
 * 接口的出现，避免了单继承的局限性*/
public class Main 
{
	public static void main(String[] args)
	{
		E BLF = new E();
		BLF.show();
		System.out.println(BLF.add(1, 3));
		BLF.test();
		BLF.print();
	}
}

类与类之间是继承关系，类与接口之间是实现关系，接口与接口之间呢？

java不支持多继承的原因，就在于方法体

interface A
{
	public abstract void show();
}
interface B
{
	public abstract void show();
	public abstract int add(int a,int b);
}

interface E extends A,B//继承关系，且可以多继承，更猛！！！
{
	//多继承，差就差在方法体上，接口没方法体，所以可以多继承
	public abstract void test();
	
	
}
class G implements E
{
	public void show()
	{
		System.out.println("你好好啊");
	}
	public int add(int a,int b)
	{
		return 250;
	}

	public void test()
	{
		System.out.println("你不好");
	}

}
public class Main 
{
	public static void main(String[] args)
	{
		
	G BLF = new G();
		System.out.println(BLF.add(3, 4));
		BLF.show();
	}
}

哥们只能说，java真的特别猛！！！
以上为接口的基本实现。。。

接口的特点：

接口是对外暴露的规则
接口是程序的功能扩展
接口的出现降低耦合性
接口可以用来多实现
类和接口是实现关系，并且类可以继承一个类同时实现多个接口
接口与接口是继承关系

接口的概念非常大，凡是对外暴露的内容都是接口，比如电脑的USB插口，来连接鼠标，规则是只能连接USB鼠标。
耦合性：可以理解为紧密相联，降低耦合性就是降低了两者紧密相连的程度，比如早期的笔记本电脑，电脑和鼠标是相连的，非常不方便，而USB接口的出现，使很多不同的鼠标都可以连接电脑，只要这个鼠标是USB的（即符合USB这个规则），这就叫降低了电脑和鼠标的耦合性，同时呢，USB还可以插U盘，这就体现了功能的扩展。

接口和抽象类的区别：

共性：都是不断向上抽取出来的抽象的概念
区别：

1.抽象类体现继承关系，一个类只能但继承
  接口是实现关系，一个接口可以多实现

2.抽象类是继承，是“A  is a  B”，（A是一种B），定义体系的基本共性内容（我今年上大二，我就是一个大二的学生）
  接口是实现，是“A like a  B”，A类似于B，定义体系的额外的功能 （大二学生，基本功能是学习，有的会抽烟，有的不会，会抽烟的属于大二学生这个体系，抽烟是他具备的额外功能）

3.抽象类中可以定义抽象的，还可以定义非抽象的，供子类直接使用其非抽象方法
  接口，必须全是定义抽象的，其方法子类必须自己实现，而且其内成员还必须是固定的修饰符

abstract 犬
{
	public static vois 叫();
}
interface 导盲 //导盲的方式可能不一样，导盲是犬的额外功能，所以定义接口
{// 导盲 为什么不定义类？无法多继承。
	//又有疑问为什么犬不定义为接口？
	//犬中可能存在一些相同的共性，所有犬科都是一样的，那么这些共性内容，就没必要定义
	//为抽象方法了，定义为一般方法就可以了，而这些接口是实现不了的
	public static void 导盲();
}
class 导盲犬 extends 犬 implements 导盲//这里甚至可以多实现
{
	public void 叫()
	{
		
	}
	public void 导盲()//导盲嘛，不一定就是犬，猪，猫，训练好，也能导盲
	{                //那么导盲就是一个共性内容->抽取
		//可能会想大不了每个类里（导盲犬、猫。猪），都写导盲这个方法，何必抽取？
	//这样想：导盲犬上，导盲猫上，导盲猪上，这样好，还是具备导盲功能的都上好
		//答案不言而喻 	
	}
}

所以,在不同的问题领域，有不同的分析方式，不要固化思维方式

接口的应用：

/*
 * 笔记本电脑的使用
 * 为了扩展笔记本电脑的功能，但是如何会用到什么功能不知道
 * 所以，定义一个规则，只要满足这个规则，那么笔记本就可以具备这个功能
 * 这个规则呢，就是USB接口，鼠标、键盘、视频都可以用，只有满足USB规则
 * 这个规则在java中就是interface*/

interface USB//暴露的规则
{
	public abstract void open();//开启
	public abstract void close();//关闭
}
class Mouse implements USB//实现规则
{
	public void open()
	{
		System.out.println("Mouse open");
	}
	public void close()
	{
		System.out.println("Mouse close");
	}
}
class Upan implements USB
{
	public void open()
	{
		System.out.println("Upan open");
	}
	public void close()
	{
		System.out.println("Upan close");
	}
}
//这些设备和电脑的耦合性就降低了
public class Main 
{
	public static void main(String[] args)
	{
		UseUsb(new Upan());//功能扩展
		UseUsb(new Mouse());
	}
	//使用规则
	public static void UseUsb(USB a)//接口型引用，用于接受接口的子类的对象
	{
		a.open();
		a.close();
	}
}