java接口interface接口的使用

接口Interface

格式：interface{ }

• 初期理解，可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过的接口的形式来表示

• 接口中成员修饰符是固定的。
  成员常量：public static final
  成员函数：public abstract

• 接口的出先将“多继承”通过另一种形式体现出来，即多实现

interface Inter
{
	public abstract void show();
}

接口定义时，格式特点：

• 接口中常见定义：常量，抽象方法。
• 结构中的成员都有固定修饰符。
  常量：public static final
  方法：public abstract

interface Inter
{
	public static final int	NUM=3;
	public abstract void show();
}

记住：接口中的成员都是public
怎么实现这个接口了？implements

public Test implements Inter
{
	
}

接口是不可以创建对象的，因为有抽象方法
需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才可以实例化，否则子类是一个抽象类

public Test implements Inter
{
	public void show();
}

这样就可以对象的建立

public static void main(String[] args) 
	{
		Test t=new Test();
		System.out.println(t.NUM);
		System.out.println(Test.NUM);
		System.out.println(Inter.NUM);
	}

把上述的代码进行编译之后，将会产生三个class文件
切记不能在main函数中对NUM进行赋值操作，因为NUM是一个常量

接口可以被类多实现，就是一个类可以实现多个接口，也就是对多继承不支持的转换形式，java支持多实现

interface Inter
{
	public static final int	NUM=3;
	public abstract void show();
}
interface InterA
{
	public void metnod();
	
}
public Test implements Inter,InterA
{
	public void show();
	public void metnod();
}

如果两个接口有同名的方法，覆盖一次就行了

一个类在继承一个类的同时还可以实现多个接口

class Demo
{
	public void function()
	{
		
	}
}
public Test extends Demo implements Inter,InterA
{
	public void show();
	public void method();
}

接口与接口之间是继承关系，举一个简单的例子

interface A
{
	void methodA();
}
interface B extends A
{
	void methodB();
}
interface C extends B
{
	void methodC();
}
class D implements C
{
	public void methodA(){};
	public void methodB(){};
	public void methodC(){};
}

接口可以实现多继承,

interface A
{ 
}
interface B  //extends A
{
}
interface C extends B,A
{
}

接口B没有继承A，接口C可以直接继承A,B

接口的特点

• 接口是对外暴露的规则
• 接口是程序的功能拓展
• 接口可以用来多实现
• 类与接口是实现关系，而且类可以继承一个类的同时实现多个接口
• 接口与接口之间可以有继承关系

接口举例体现

abstract class Student
{
	abstract void study();
	void sleep()
	{
		System.out.println("sleep");
	}
	
}

interface Smoking
{
	void smoke();
}
//不是每个学生smoke
class ZhangSan extends Student implements Smoking
{
	void study(){}
}
class LiSi extends Student
{

}

不是每个学生都smoke，所以smoke是人的一个扩展功能，如果把smoke写在一个抽象类中，那么这个子类继承后都必须要有smoke的这个功能，这显然是不现实的，那么单独将这个功能写成一个接口，那个学生smoke就implements smoke