Java中的接口

一·基本介绍

1.概念

1.接口就是将一些没有实现的方法封装到一起，当某个类要使用的时候，将其实现
2.关键字：implements

2.代码

package interface_pj;

public interface UsbInterface {//接口
	//规定接口的相关方法
	public void start();
	public void stop();

}

package interface_pj;

public class Phone implements UsbInterface{
	//Phone 类实现UsbInterface
	//解读1.即Phone类需要实现UsbInterface接口，规定/声明的方法
	   
	@Override
	public void start() {
		// TODO 自动生成的方法存根
	    System.out.println("手机开始工作~~~");	
	}

	@Override
	public void stop() {
		// TODO 自动生成的方法存根
		System.out.println("手机停止工作~~~");
	}
}

package interface_pj;

public class Camera implements UsbInterface{

	@Override
	public void start() {
		// TODO 自动生成的方法存根
		System.out.println("相机开始工作");
	}

	@Override
	public void stop() {
		// TODO 自动生成的方法存根
		System.out.println("相机停止工作");
	}
        
}

package interface_pj;

public class Computer {
	//编写一个类，计算机工作
	//1.UsbInterface usbinterface 形参是接口类型 UsbInterface
	//2.看到接收实现了UsbInterface接口的类的对象实例
      public void work(UsbInterface usbinterface)
      {
    	  //通过接口调用方法
    	  usbinterface.start();
    	  usbinterface.stop();
      }
}

package interface_pj;

public class interface_pj01 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		//创建手机，相机对象
		//Camera实现了UsbInterface
        Camera camera=new Camera();
        //Phnoe实现了UsbInterface
        Phone phone=new Phone();
        //创建计算机
        Computer computer=new Computer();
        computer.work(phone);//把手机接入到计算机
        System.out.println("========");
        computer.work(camera);//把相机接入到计算机
	}

}

上面的代码牵涉到了一个接口多态的问题,就是可以使用接口去创建一个实现了该接口的类（代码是跟着韩顺平老师敲的）
我的理解：接口其实就是一个特殊的父类，不过它的方法都需要子类实现
接口可以实现多继承，不过子类需要将它所实现的接口的所有方法实现算了，我是个傻逼

二·使用细节

1.注意事项一

1.接口不能被实例化
2.接口中的所有方法都是public的，接口中的抽象方法不需要用abstract修饰
3.一个类将接口实现，就必须将接口的所有方法实现
4.抽象类实现接口，可以不用实现接口的方法

2.代码一

package interface04;

public class Interface04 {
      //new IA();
}
//1.接口不能被实例化
//2.接口中的所有的方法是public方法，接口中抽象方法，可以不用abstract修饰
//3.一个普通类实现接口，就必须将该接口的所有方法都实现
//4.抽象类实现接口时，可以不用实现接口的方法
interface IA{
	void say();
    void hi();
}
class Cat implements IA{

	@Override
	public void say() {
		// TODO 自动生成的方法存根
		System.out.println("say~~");
	}

	@Override
	public void hi() {
		// TODO 自动生成的方法存根
		System.out.println("hi~~");
	}
}
abstract class Tiger implements IA{
	
}

3.注意事项二

5.一个类可以实现多个接口
6.接口中的属性只能是final的，而且是public static final 修饰的。比如int a=1；实际上是public static final int a=1。
7.接口中属性的访问形式：接口名.属性名
8.一个接口不能继承其他的类，但是可以继承多个别的接口
9.接口的修饰符 只能是public 和默认(default)，这点和类的修饰符是一样的

4.代码二

package interface04;

public class Interface041 {
     public static void main(String[] args)
     {
    	 System.out.println(IB.n1);//说明n1就是static的
    	 //IB.n1=30;//不允许，说明n1是final
     }
}
interface IB{
	           //接口中属性的访问形式：接口名.属性名
	int n1=10;//等价于public static final int n1=10;
	void hi();
}
interface IC{
	void say();
}
//一个类同时可以实现多个接口
class Pig implements IB,IC{

	@Override
	public void say() {
		// TODO 自动生成的方法存根
		System.out.println("say~~~");
	}

	@Override
	public void hi() {
		// TODO 自动生成的方法存根
		System.out.println("hi~~~");
	}	
}
//接口不能继承其他的类，但是可以继承多个别的接口
interface ID extends IB,IC{	
}
//接口的修饰符，只能是public和默认（default），这点和类的修饰符一样

三·接口多态

1.理解

这其实和前面学的多态很像，前面所说的多态中：提起一个类，它在运行的时候是它自己或者它的子类，这里的多态就是：提起一个接口，它在运行的时候是实现了它的类。

2.代码

package interfaceandpoly;

public class Interfacepoly01 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
        //接口的多态体现
		//接口类型的变量if01可以指向实现了IF接口的对象实例
		IF if01=new Monster();
		if01=new Car();
		//继承体现的多态
		AAA a=new BBB();
		a=new CCC();
	}

}
interface IF{}
class Monster implements IF{}
class Car implements IF{}
class AAA{
	
}
class BBB extends AAA{}
class CCC extends AAA{}

也可以和前面的多态数组一样创建接口数组
代码如下

package interfaceandpoly;

public class interfaceandpoly02 {
         public static void main(String[] args)
         {
        	 //多态数组-》接口类型的数组
        	 Usb[] usbs=new Usb[2];
        	 usbs[0]=new Phone();
        	 usbs[1]=new Camera();
        	 /*
              * 给Usb数组中，存放Phone和Camera对象，Phone类还有一个特有的方法call()；
              * 请遍历Usb数组，如果是Phone对象，除了调用Usb接口定义的方法外
              * 还需要调用Phone特有方法call
              */
            for(int i=0;i<usbs.length;i++)
            {
            	usbs[i].work();
            	//类型判断，我们仍然需要进行类型的向下转型
            	if(usbs[i] instanceof Phone)//判断它的运行类型是Phone
            	{
            		((Phone)usbs[i]).call();
            	}
            }
         }
}
interface Usb{
	void work();
}
class Phone implements Usb{
	public void call()
	{
		System.out.println("手机可以打电话~~~");
	}

	@Override
	public void work() {
		// TODO 自动生成的方法存根
		System.out.println("手机工作中~~~");
	}
	
}
class Camera implements Usb{
	@Override
	public void work() {
		// TODO 自动生成的方法存根
		System.out.println("相机机工作中~~~");
	}
	
}

还有就是接口的多态传递
代码如下

package interfaceandpoly;

public class Interfaceandpoly03 {
	//接口多态的传递
	public static void main(String[] args)
	{
		//接口类型的变量可以指向 实现了该接口的类的对象实例
		IG ig=new Teacher();
		//如果IG 继承了IH 接口，而Teacher类实现了IG接口
		//那么，实际上就相当于Teacher 类也实现了IH接口
		//这就是所谓的接口多态 多态传递现象
		IH ih=new Teacher();
	}

}
interface IH{
	void hi();
}
interface IG extends IH{}
class Teacher implements IG{
	@Override
	public void hi() {
		//IG继承了IH接口，而Teacher类需要实现IG接口，即Teacher类也需要实现IH接口
		// TODO 自动生成的方法存根
		System.out.println("hi~~");
	}
}