JAVA面向对象12（接口）

接口的理解

is-a关系，父子类关系。比如 官员 is a person。

运动员和技能的关系，如果说运动员is a技能，运动员是一个技能，子父类关系，不太合适，
只能说运动员具有这个技能，而且这里不能是多继承，所以运动员和技能的关系是接口关系。
接口其余的和类相似，接口中实现的功能，运动员也就获取到了。

接口的定义和使用、接口的多实现和继承性

/*
 * 接口的使用
 * 1.接口使用interface来定义
 * 2.Java中，接口和类是并列的两个结构
 * 3.如何定义接口：定义接口中的成员
 * 		
 * 		3.1 JDK7及以前：只能定义全局常量和抽象方法
 * 			>全局常量：public static final的.但是书写时，
 *     可以省略不写（static final）（ final）（什么都不写）都行，
 *    因为接口中默认常量是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. 接口，实际上可以看做是一种规范（引入：USB接口是一个规范，usb接口是全世界都用的同一种的，包括深度，针孔，金属点，都规定好了。）
 * //（java中接口都定义了一堆常量，定义的那些抽象方法，就是一些规范，有时候电脑插上usb口，但是数据根本传播不了，因为电脑只识别要求的那些功能，
 * 就用某个方法，要是usb没写就不行，所以说还得把usb中那些方法实现一个，这些很多接口实现类的集合称之为驱动）
 *
 * 
 */
public class InterfaceTest {
	public static void main(String[] args) {
		System.out.println(Flyable.MAX_SPEED);
		System.out.println(Flyable.MIN_SPEED);
//		Flyable.MIN_SPEED = 2;
//		Flyable.MIN_SPEED 说明其是静态的，
//		Flyable.MIN_SPEED = 2;后边不让赋值2，说明其是final的，
		
		Plane plane = new Plane();
		plane.fly();
	}
}


interface Flyable{
	
	//全局常量
	public static final int MAX_SPEED = 7900;//第一宇宙速度
	int MIN_SPEED = 1;//省略了public static final
	
	//抽象方法
	public abstract void fly();//抽象方法
	//省略了public abstract
	void stop();//抽象方法
	
	
	//Interfaces cannot have constructors接口中不能定义构造器
//	public Flyable(){
//		
//	}
}

interface Attackable{
	
	void attack();//抽象方法
	
}
//此处class Plane implements Flyable实现了接口
//如果实现类重写覆盖了接口中的所有抽象方法，则此实现类就可以实例化

//抽象的方法重写更愿意说是 实现，而不是重写。
class Plane implements Flyable{

	@Override//抽象类的实现
	public void fly() {
		System.out.println("通过引擎起飞");
	}

	@Override
	public void stop() {
		System.out.println("驾驶员减速停止");
	}
	
}
//如果实现类没有重写覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
abstract class Kite implements Flyable{
	@Override
	public void fly() {
		
	}
	
}
//先写继承，后写接口
//Java类可以实现多个接口
//要把所有继承的接口的所有抽象方法都实现才能 实例化
class Bullet extends Object implements Flyable,Attackable,CC{
	@Override
	public void attack() {
		// 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 method1() {
		// TODO Auto-generated method stub
		
	}
	@Override
	public void method2() {
		// TODO Auto-generated method stub
		
	}
	
}
//************************************

interface AA{
	void method1();
}
interface BB{
	
	void method2();
}
//接口与接口之间可以继承，而且可以多继承
interface CC extends AA,BB{
	//这个接口中相当于有两个抽象方法，有父继承接口中的所有抽象方法。
}

实例演示接口是一种规范

**（代码同见#创建接口匿名实现类的对象） **
（了解）项目的具体需求是多变的，我们必须以不变应万变才能从容开发，此处的不变就是规范，因此，我们开放项目时往往都是面向接口编程。

创建接口匿名实现类的对象

1、创建了接口的 非匿名实现类 的 非匿名对象（类和对象都有名）
2、 创建了接口的非匿名实现类 的 匿名对象（类有名，对象没名）
3、 创建了接口的匿名实现类的非匿名对象（类没名，对象有名）
4、创建了接口的匿名实现类的匿名对象（对象和类都没名）

/*
 * 接口的使用
 * 1.接口使用上也满足多态性
 * 2.接口，实际上就是定义了一种规范
 * 3.开发中，体会面向接口编程！
 * 
 */
public class USBTest {
	public static void main(String[] args) {
		
		Computer com = new Computer();
		//1.创建了接口的 非匿名实现类 的 非匿名对象（类和对象都有名）
		//	public void transferData(USB usb){//多态 USB usb = new Flash();
		//	声明的是USB，带入的是实现类Flash的对象
		Flash flash = new Flash();
		com.transferData(flash);//多态
		
		//2. 创建了接口的非匿名实现类 的 匿名对象（类有名，对象没名）
		com.transferData(new Printer());
		 
		//3. 创建了接口的匿名实现类的非匿名对象（类没名，对象有名）
		USB phone = new USB(){
            //把USB接口中抽象类实现一下。
			@Override
			public void start() {
				System.out.println("手机开始工作");
			}

			@Override
			public void stop() {
				System.out.println("手机结束工作");
			}
			
		};
		com.transferData(phone);
		
		
		//4. 创建了接口的匿名实现类的匿名对象（对象和类都没名）
		com.transferData(new USB(){
			@Override//把USB接口中抽象类实现一下。
			public void start() {
				System.out.println("mp3开始工作");
			}

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

class Computer{
	
	public void transferData(USB usb){//多态 USB usb = new Flash();声明的是USB，带入的是实现类Flash的对象
		usb.start();
		
		System.out.println("具体传输数据的细节");
		
		usb.stop();
	}
	
	
}

interface USB{
	//常量：定义了长、宽、最大最小的传输速度等
	void start();
	
	void stop();
	
}
//u盘， 谁想运行，就要重写一下USB的抽象方法，谁就要重写以下usb的规范
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("打印机结束工作");
	}
	
}

（了解）接口应用：代理模式

Object是接口，ProxyObject是代理类，Objectlmpl是被代理类，ProxyObject要用action时直接调用Objectlmpl中的函数action就行了。

/*
 * 接口的应用：代理模式
 * 
 */
public class NetWorkTest {
	public static void main(String[] args) {
		Server server = new Server();
		//总之就是在代理类的方法内调用了被代理类的方法，
		// 但是前提是需要将接口对象的引用指向被代理类，
		//NetWork work = server
		// 这也就是为什么代理类的构造器需要接口类型的参数，
		// 创建代理类对象的时候将被代理类的对象传过去就实现动态绑定了。
		ProxyServer proxyServer = new ProxyServer(server);//NetWork work=server，多态
		
		proxyServer.browse();
		
	}
}
//网络
interface NetWork{
	//方法：浏览
	public void browse();
	
}
//服务器Server
//被代理类
class Server implements NetWork{

	@Override
	public void browse() {
		System.out.println("真实的服务器访问网络");
	}

}
//代理类
class ProxyServer implements NetWork{
	
	private NetWork work;//只是声明了接口NetWork类型的对象work，并没有创造对象。
	public ProxyServer(NetWork work){
		this.work = work;
	}
	public void check(){
		System.out.println("联网之前的检查工作");
	} 
	@Override
	public void browse() {
		check();//校验
		
		work.browse();//执行被代理类的browse（）函数
		
	}
	
}

（了解）接口应用：工厂模式

工厂模式：实现了创建者（创建对象者）与调用者（调用对象者）的分离，即将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
1、无工厂模式

2、简单工厂模式

注意到xxxFactory时就是出现工厂模式了

缺点：对于增加新产品，不修改代码的话，是无法扩展的。违反了开闭原则（对
扩展开放；对修改封闭）
扩展功能时需要把原来的代码修改了，风险很大。

3、工厂模式
简单工厂模式只有一个（对于一个项目或者一个独立的模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。


4、抽象工厂模式

略

接口课后两道面试题

第一题

编译不通过，因为x是不明确的不清晰的。
1、调父类的x

2、调接口的x
接口的x是个全局常量，直接用接口名就能调用。

---

一个小知识：
父类的父类x=1；
父类 x=2；
子类调用时，最近原则，this.x和super.x都是2。不能super。super去调用父类的父类的x的1。

---

第二题

此时认为

是对它俩的重写和实现

错误原因：

Java8中接口新特性

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

CompareA.Java 接口A

/*
 * 
 * JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
 * 
 */
public interface CompareA {
	
	//静态方法
	public static void method1(){
		System.out.println("CompareA:北京");
	}
	//默认方法
	public default void method2(){
		System.out.println("CompareA：上海");
	}
	//↓虽然省略了public，但仍然是public 的。
	default void method3(){
		System.out.println("CompareA：上海");
	}
}

SuperClass.Java父类SuperClass

public class SuperClass {
	
	public void method3(){
		System.out.println("SuperClass:北京");
	}
	
}

CompareB.Java 接口B

public interface CompareB {
	
	default void method3(){
		System.out.println("CompareB：上海");
	}
	
}

SubClassTest .java 最终测试类

public class SubClassTest {
	
	public static void main(String[] args) {
		SubClass s = new SubClass();
		
//		s.method1(); //实现类的对象 拿不到接口中定义的静态方法
//		SubClass.method1();//通过 实现类也拿不到接口中定义的静态方法
		//知识点1：接口中定义的静态方法，只能通过接口来调用。
		CompareA.method1();
		
		//知识点2：通过 实现类的对象，可以调用接口中的默认方法。
		//如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
		//SubClass.method2();这样不能调，因为人家method2()方法又不是静态的。
		s.method2();
		//重写前输出CompareA：上海
		// 重新后输出SubClass：上海

		//例：如果SubClass中没有重写method3()，而父类SuperClass和接口interface 
		// CompareA中都定义了method3(),那么s.method3();时优先调用类里面的method3()，详见知识点3
		//知识点3：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，
		//那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。-->类优先原则
		
		//例：接口CompareA和CompareB中都定义了method3（），SubClass implements CompareA,CompareB，
		// 如果SubClass实现了CompareA,CompareB，但是没有重写method3（），就会报错，详见知识点4
		//知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
		//那么在实现类没有重写此方法的情况下，报错。-->接口冲突。
		//这就需要我们必须在实现类中重写此方法
		s.method3();
		
	}
	
}

class SubClass extends SuperClass implements CompareA,CompareB{
	
	public void method2(){
		System.out.println("SubClass：上海");
	}
	
	public void method3(){
		System.out.println("SubClass：深圳");
	}
	
	//知识点5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法↓
	public void myMethod(){
		method3();//调用自己定义的重写的方法
		super.method3();//调用的是父类中声明的
		
		//调用接口中的默认方法
		//CompareA.method3();错误，因为接口中的方法不总是静态的。
		//静态的可以用这个方法调，不静态的不能这样调.下面给出调用接口默认方法的方式，加super算是一种规定
		CompareA.super.method3();
		CompareB.super.method3();
	}
}