java--interface

接口（interface）  是与类并行的一个概念

1.接口可以看做是一个特殊的抽象类。是常量与抽象方法的一个集合，不能包含变量、一般的方法。
2.接口是没有构造器的。
3.接口定义的就是一种功能。此功能可以被类所实现（implements）。
比如：class CC extends DD implements AA
4.实现接口的类，必须要重写其中的所有的抽象方法，方可实例化。若没有重写所有的抽象方法，则此类仍为一个抽象类
5.类可以实现多个接口。----java 中的类的继承是单继承的
6.接口与接口之间也是继承的关系，而且可以实现多继承
>5,6描述的是java中的继承的特点。

public class TestInterface {
	public static void main(String[] args) {
		System.out.println(AA.I);
//		AA.I = 13;
	}
}

interface AA{
	//常量:所有的常量都用public static final修饰
	int I = 12;
	boolean FLAG = false;
//	int i;
	//抽象方法:所有的都用public abstract修饰
	void method1();
	void method2();
}

abstract class BB implements AA{
	
}
class DD{
	
}
interface MM{
	void method3();
}
class CC extends DD implements AA,MM{
	public void method1(){
		
	}
	public void method2(){
		
	}
	public void method3(){
		
	}
}
//接口之间仍为继承关系！(多继承)
interface JJ extends MM,AA{
	void method4();
}

class GG implements JJ{

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

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

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

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

接口与具体的实现类之间也存在多态性

package test11;

public class Testinterface {

	public static void main(String[] args) {
       Duck d = new Duck();
       Testinterface.test1(d);
       Testinterface.test2(d);
       Testinterface.test3(d);
		

	}
	public static void test1(Runner r) {
		r.run();
	}
	public static void test2(Swimmer s) {
		s.swim();
	}
	public static void test3(Flier f) {
		f.fly();
	}

}
interface Runner{
	public abstract void run();
}
interface Swimmer{
    void swim();
}
interface Flier{
	void fly();
}
class Duck implements Runner,Swimmer,Flier{

	@Override
	public void fly() {
		System.out.println("我会飞");
	}

	@Override
	public void swim() {
        System.out.println("我会游泳");
	}

	@Override
	public void run() {
		System.out.println("我会跑");
	}
	
}

工厂方法

概述：定义一个用于创建对象的接口，让子类决定实例化哪一个类。

FactoryMethod使一个类的实例化延迟到其子类。

适用性：

1、当一个类不知道它所必须创建的对象的类的时候

2、当一个类希望由它的子类来指定它所创建的对象的时候

3、当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候

package test11;
//工厂方法的设计模式
public class TestFactoryMethod {

	public static void main(String[] args) {
		IFactoryWork i = new StudentWorkFactory();
		i.getWork().dowork();
		
		IFactoryWork i1 = new TeacherWorkFactory();
		i1.getWork().dowork();

	}

}
interface IFactoryWork{
	Work getWork();
}
class StudentWorkFactory implements IFactoryWork{

	@Override
	public Work getWork() {
		return new StudentWork();
	}
	
}
class TeacherWorkFactory implements IFactoryWork{

	@Override
	public Work getWork() {
		// TODO Auto-generated method stub
		return new TeacherWork();
	}
	
}

interface Work{
	void dowork();
}
 class StudentWork implements Work{

	@Override
	public void dowork() {
		System.out.println("我爱学习");
		
	}
	 
 }
 class TeacherWork implements Work{

	@Override
	public void dowork() {
		System.out.println("我爱工作");
		
	}
	 
 }

代理模式：为其他对象提供一种代理以控制对这个对象的访问

package test11;
//代理类
public class TestProxyObject {

	public static void main(String[] args) {
		Object obj = new ProxyObject();
		obj.action();

	}

}
interface Object{
	void action();
}
class ProxyObject implements Object{
     Object obj;
     
     public ProxyObject() {
    	 System.out.println("代理类创建成功");
    	 obj = new ObjectImpl();
     }

	@Override
	public void action() {
		System.out.println("代理类开始执行");
		obj.action();
		System.out.println("代理类执行结束");
		
	}
	
	
}
class ObjectImpl implements Object{

	@Override
	public void action() {
	    System.out.println("======被代理开始执行=====");
	    System.out.println("======具体操作=====");
	    System.out.println("======被代理执行完毕=====");
	}
	
}