接口（interface）

一、接口是与类并行的概念（单继承，多实现）

1.定义

     1）是一个特殊的抽象类，是抽象类和常量值的定义的集合，不能包含变量和一般的方法
     2）接口是没有构造器的，意味着接口不能被实例化
     3）它仅仅是定义一种功能去实现。此功能可以被类所实现（implements ）
     4）实现接口的类，必须重写所有的抽象方法，方可实例化。若没有重写所有的抽象方法，则此类仍是一个抽象类
     5）一个类可以有多个接口，接口也可以继承其它接口
     6）类只能继承一个父类，但是可以实现多个接口（相当于多重继承的效果）
     7）接口仅仅是定义了一种功能，继承是定义了共同的属性和方法

  2.基本要求

    1）接口中必须定义成常量（不能定义变量），所有常量都必须使用public static final修饰
     2）接口中的方法必须定义成抽象方法，所有方法必须使用public abstract修饰

  二、接口与接口之间的关系

     1）接口可以继承接口，接口和接口之间也是继承的关系
     2)java中类中的继承为单继承，而接口中的继承为多继承

实例：

常量：所有常量都用public static final修饰

    public static final int I =12;
    public static final boolean FLAG = false;
    int i = 12;

 抽象方法：所有的都用public abstract修饰

    void method1();
    void method2();

 接口仅仅是定义一种功能，是要被类所实现的。

class BB implements AA{
   public void method1() {
        
    }
    public void method2() {
        
    }
}

实现接口的类，必须重写所有的抽象方法，方可实例化。若没有重写所有的抽象方法，则此类仍需要定义为一个抽象类

class CC extends DD implements AA,EE{
    public void method1() {
        
    }
    public void method2() {
        
    }
    @Override
    public void method3() {
        
    }
}

 

三、接口方法的应用总结

    1.通过接口可以实现不相关的相同的行为，而不需要考虑这些类之间的层次
    2.通过接口可以指明多个类需要实现的方法，一般用于定义对象的扩张功能
    3.接口主要用来定义规范。解除耦合关系（耦合关系：原本的功能方法等都需要从类去继承，但是引入方法之后可以解除类与类之间的关系，直接从接口中获取）

四、接口的两种设计模式

     1.工厂模式（FactoryMethod）

        1）定义一个用于创建对象的接口，让子类觉得实例化哪一个类，FactoryMethod使一个类的实例化延迟到其子类
        2）使用性
            ①当一个类不知道他所必须创建的类的时候
            ②当一个类希望由它的子类来指定它所创建的对象的时候
            ③当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候

     2.代理方法（proxy）:为其他对象提供一种代理以控制对这个对象的访问

         1)代理类：

                ①定义接口的对象
                ②建造构造器，并实例化被代理对象
                ③实现接口中的抽象方法，并通过接口对象调用方法
         2)被代理类：

                   ①继承接口
                   ②实现接口中的方法
         3)实现流程：

                   ①（main）使用多态性：接口创建对象，实例化代理类
                   ②代理类调用方法action()
                   ③方法中的obj对象在构造器中调用被代理类的实例进行执行
                   ④看似执行的是代理类的方法action(),实际执行的是被代理类中的实例

工厂模式和代理方法实例

public class ApplyInterface {
	public static void main(String[] args) {
		
		//工厂模式
		WorkFactory w = new StudentFactory();
		w.getWork().dowork();
		
		WorkFactory w1 = new TeacherFactory();
		w1.getWork().dowork();
		
		//代理模式
		Object obj = new ProxyObject();//造一个代理类的对象
		obj.action();
	}
}


//工厂设计模式
interface WorkFactory{
	Work getWork();
}
class StudentFactory implements WorkFactory{

	@Override
	public Work getWork() {
		return new StudentWork();   //work相当于父类，StudentWork相当于子类
	}
	
}
class TeacherFactory implements WorkFactory{

	@Override
	public Work getWork() {
		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("老师批改作业");
	}
	
}

//代理模式
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("---被代理类执行完毕---");
	}
	
}

五、接口的多态性（和子类继承父类相似，这时的子类相当于原本的类，父类相当于接口）

public class TestInterface {
	public static void main(String[] args) {
		Duck d = new Duck();   //Duck定义了接口,对象便可以有了接口的几个功能
		TestInterface.test1(d);
		TestInterface.test2(d);
		TestInterface.test3(d);
		
	}
	//定义方法区声明一个接口
	public static void test1(Swimming s) {   //Swimming s = new Duck(); 
		s.swim();
	}
	public static void test2(Filer f) {      //Filer f = new Duck();
		f.fly();
	}
	public static void test3(Walker w) {      //Walker w = new Duck;
		w.work();
	}
}
interface Swimming{
	void swim();
}
interface Filer{
	void fly();
}
interface Walker{
	void  work();
}
class Duck implements Swimming,Filer,Walker{
	@Override
	public void work() {
		System.out.println("丑小鸭走路一摇一摆！");
	}
	@Override
	public void fly() {
		System.out.println("丑小鸭变成白天鹅飞走了!");
		
	}
	@Override
	public void swim() {
		System.out.println("丑小鸭和白天鹅都会游泳！");
	}
} 

六、接口的应用

//一、实现接口的匿名类的对象
		USB phone = new USB(){

			@Override
			public void start() {
				System.out.println("手机开始执行！");
			}
			@Override
			public void stop() {
				System.out.println("手机执行结束！");
			}
		};
		com.doWork(phone);
		//二、实现接口的匿名类对象
		com.doWork(new USB() {
			@Override
			public void start() {
				System.out.println("手机开始执行！");
			}
			@Override
			public void stop() {
				System.out.println("手机执行结束！");
			}
		});