一、接口的定义

        接口的本质其实就是一种规范，可以理解为编写一段程序的规则，当几个人分工的时候都实现这个接口的话，就必须满足这个接口的要求，这样就能提高合作的效率。当然也可以把接口（interface）看成是一个特殊的抽象类，因为接口和抽象类是类似的，接口类的对象也不能直接在主方法中进行实例化，如果要实例化就需要通过匿名内部类的方式来实现这个接口中所有未实现的方法，那么这个new出来的对象就是这段程序中的临时对象，在其他地方是不能调用这个内部类的设定的。而且和抽象类一样，接口类也不能直接在接口中定义方法的内容，必须由实现类来进行实现，不同的实现类可以有不用的实现方式，接口所有成员和方法的默认关键字是public static final。

package demo;

public interface USB {
	public static final int size = 10;
	void standard();
}

//主方法
public class main {
	
	public static void main(String[] args) {
		
		USB u = new USB() {			
			//必须要实现接口中未实现的类才能new对象
			public void standard() {
								
			}
		};
	}
}

二、接口的使用

1、接口的一般实现

        当我们写完一个接口之后，需要一个特定的类去实现接口之中的方法。这样在主方法中就可以调用实现类的对象来进行操作。

package demo;
//接口类（抽象类）
public interface USB {
	public static final int size = 10;
	void standard();
}

//实现类
public class USBimpl implements USB{

	@Override
	public void standard() {
		System.out.println("say");
	}

}

//主方法
public class main {
	
	public static void main(String[] args) {
		
		USBimpl u = new USBimpl();
		u.standard();
	}
}

2、接口的多重实现

        一个实现类可以实现多个接口，实现多个标准。

package demo;
//接口1
public interface USB {
	public static final int size = 10;
	void standard();
}
//接口2
public interface Bottle {
	void say();
}

//接口的多重实现
public class DoubleImpl implements USB,Bottle{

	@Override
	public void say() {
		System.out.println("实现Bottle接口中的方法");
		
	}

	@Override
	public void standard() {
		System.out.println("实现USB接口中的方法");
	}

}

3、接口的向上转型和向下转型

        当我们new了一个接口类对象时，可以通过向上转型将一个实现类的对象赋值给他从而调用实现类的具体功能。因为只要是继承了这个接口的实现类，操作的顺序和过程都是一样的，如果我们想实现不同的功能，只需要修改一下转型的那一行代码，不用对下面的过程进行修改，大大降低了代码的后期维护成本。

package demo;
//接口
public interface USB {
	void start();
	void run();
	void close();
}

//实现类1
public class Light implements USB{

	@Override
	public void start() {
		System.out.println("light start");
		
	}

	@Override
	public void run() {
		System.out.println("light run");
		
	}

	@Override
	public void close() {
		System.out.println("light close");
		
	}
	
}

//实现类2
public class Bollte implements USB{

	@Override
	public void start() {
		System.out.println("Bollte start");
		
	}

	@Override
	public void run() {
		System.out.println("Bollte run");
		
	}

	@Override
	public void close() {
		System.out.println("Bollte close");
		
	}

}

public class main {
	
	public static void main(String[] args) {
		USB usbService = null; //新建一个USB的服务对象
		
		usbService = new Light(); //这里调用的是Light的实现类
        usbService = new Bottle(); //这里调用的是Bottle的实现类 二者择其一即可
		usbService.start();
		usbService.run();
		usbService.close();
		
 		
	}
}

        与抽象类的向下转型类似，如果接口对象在进行了实现类的赋值之后，这个向上转型的对象只能调用该接口的功能，不能调用实现类中独有的功能（接口中没有的功能）。这时，如果想要再调用接口实现类中的独有功能就要进行向下转型或者再new一个实现类的对象。

public interface USB {
	void start();
	void run();
	void close();
}


public class Light implements USB{

	public void start() {
		System.out.println("light start");
		
	}

	public void run() {
		System.out.println("light run");
		
	}

	public void close() {
		System.out.println("light close");
		
	}
	//实现类中独有的功能，不能通过接口对象的向上转型来调用
	public void turn() {
		System.out.println("开关设计");
	}
}

public class main {
	
	public static void main(String[] args) {
		USB usbService = null; //新建一个USB的服务对象
		
		usbService = new Light();
		usbService.start();
		usbService.run();
		usbService.close();
		
		Light light = (Light)usbService;//向下转型来调用Light类中的独有方法turn()
		light.turn();
		
	}
}