Java：接口，内部类，设计模式（代理模式，工厂模式）

接口 interface

概念：是一个全部由抽象方法组成的集合，用interface定义，里面只能有抽象的方法和常量。

接口体现的是事物扩展的功能，接口定义了一个实体可能发生的动作，只有一个声明，没有具体的行为。

前提：当一个方法在很多类中有不同体现时，可把这个方法抽象出来做成一个接口

注意：接口里面只能有不可修改的全局变量，只能有抽象的方法，接口没有构造方法。

接口的分类

1. 接口的非匿名对象的非匿名实现类

Usb usb = new Printer();

2. 接口的匿名对象的非匿名实现类

computer.trandferDate(new Flash());

3. 接口的非匿名对象的匿名实现类

Usb usb1 = new Usb() {
	public void start(){}
	public void stop() {}
};
computer.transferDate(usb1);

4. 接口的匿名对象的匿名实现类

computer.transferDate(new Usb(){
	public void start(){}
	public void stop() {}
});

接口与抽象类的区别

1. 接口和抽象都不能有实例
2. 抽象类中可以有构造可以有普通方法和普通的成员变量；接口中只能声明静态公共常量，默认都是抽象方法
3. 接口需要被实现，抽象类需要被继承
4. 抽象类如果子类不想实现抽象类中的方法，那么该子类也必须是抽象类
5. 接口可以多继承接口，实现类可以多实现接口，抽象类只能单继承
6. 抽象类是重构的结果，接口是设计的结果

内部类

Java允许在一个内部类中去定义另外一个类，前者称为内部类，后者称为外部类
内部类的分类：

1. 成员内部类（惊涛内部类和非静态内部类）
2. 局部内部类（匿名内部类）

成员内部类：

成员内部类是作为一个类的成员

1. 可以使用protected 和private 进行修饰
2. 内部类可以调用外部类的结构
3. 内部类可以声明为static，但此时就不能在使用外部类的非static结构了
4. 内部类定义属性方法，构造器等等
5. 可以使用abstract进行修饰，需要被其他内部类继承
6. 可以声明final

局部内部类：

只能声明在方法体或者是代码块当中，而且先声明后使用，其他地方不能调用

注意：局部内部类的对象可以通过外部方法的返回值使用，返回类型只能是局部累不累的父类或者是父接口

implement和extends的区别

java中不支持多重继承，但多重继承可以通过接口来实现

1. extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承
2. JAVA中不支持多重继承，但是可以用接口来实现，这样就要用到implements，
3. 继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了 ,比如 class A extends B implements C,D,E

补充：接口的应用

1. 代理模式

概念：为其他对象提供一个代理以控制对象的访问（静态代理，动态代理）
静态代理：代理接口，被代理类，代理类

//模拟点外卖
public class daili {
	public static void main(String[] args) {
		OrderApp sub = new OrderApp(new People());
		sub.receive();
	}
}

//代理接口（模拟食品）
interface Order{
	void receive();
}

//被代理类（模拟点餐人）
class People implements Order{

	@Override
	public void receive() {
		// TODO Auto-generated method stub
		System.out.println("eat food");
	}
	
}

//代理类（模拟点餐APP）
class OrderApp implements Order{
	//在其内部定义点餐人，并创建有参构造函数
	private Order man;
	
	public OrderApp(People NeedFood) { 
	  this.man = NeedFood; 
	}
	 
	public void MakeFood() {
	    System.out.println("make food");
	}

	public void PostFood() {
	    System.out.println("post food");
	}
	
	public void comment() {
		System.out.println("Five Starts");
	}
	//作为代理，将用户需求提交并进行输出动作
	@Override
	public void receive() {
		// TODO Auto-generated method stub
		this.MakeFood();
		this.PostFood();
		this.man.receive();		//调用被代理类的函数
		this.comment();
	}
	
}

2. 工厂模式

概念：实现了创建者和调用者的分离，即创建对象的具体过程屏蔽隔离，提高程序的灵活性

面向对象的设计原则：OCP（开闭原则，允许扩展，不允许修改）

分类：简单工厂模式、工厂简单模式、抽象工厂模式
核心：实例化对象，用工厂代替new操作

//模拟奶茶或者咖啡制造机器工厂

public class guess {
	public static void main(String[] args) {
		Machine cup1 = guess.guess("coffee");
		cup1.work();
		Machine cup2 = guess.guess("milktea");
		cup2.work();
	}
}
//设置机器接口
interface Machine{
	void work();
}

//制作咖啡的机器继承总机器
class coffee implements Machine{

	@Override
	public void work() {
		// TODO Auto-generated method stub
		System.out.println("one coffee");
	}
	
}

//制作奶茶的机器继承总机器
class milktea implements Machine{

	@Override
	public void work() {
		// TODO Auto-generated method stub
		System.out.println("one milktea");
	}
	
}

//写顾客类，进行模拟点餐（工厂模式中的工厂）
class order{
	public static Machine guess(String people) {
	//将点餐数据进行对比，若是奶茶则返回创建一个新奶茶类；反之咖啡类
		if("coffee".equals(people)) {
			return new coffee();
		}else if("milktea".equals(people)) {
			return new milktea();
		}else {
			return null;
		}
	}
}