接口定义限制

接口的使用限制

接口一旦定义完成之后，就需要对其有一个核心的说明，那么首先需要说明的是：

接口里面只允许存在有public权限，也就是说不管是属性还是方法其权限永恒都是public

范例：错误的覆写

interface INews{
	 abstract String get();//即便不写public,也是public
}
class NewsImpl implements INews{
	public String get() {//权限了更加严格了，所以无法覆写
		return "1111";
	}
}
public class TestDemo {

	public static void main(String[] args) {
		INews m=new NewsImpl();
		System.out.println(m.get());
}}

 在以前给过一个核心总结：只要是方法就使用public进行定义，而你如果遵守了这一要求，这些问题都可以回避了。

另外由于接口之中只是全局常量和抽象方法的集合，所以一下的两种的定义形式最终效果都是一样的: 

完整格式	简化格式
interface INews{ public static final String MSG="123"; public abstract String get(); }	interface INews{ String MSG="123";  String get(); }

1、在以后编写接口的时候，99%的接口里面只会提供有抽象方法，

很少会在接口里面看见有许多的全局常量的。    

所以很多的时候为了避免一些开发者出现混乱，

所有接口的方法上往往都会加上public。（abstract是可以省略的）

2、当一个子类需要实现接口又需要继承抽象类的时候，

     请先使用extends继承一个  抽象类， 

     而后再使用implements实现多个接口。

范例：让子类继承抽象类和实现接口

interface INews{
	public String get();
}
//可以再类上进行明确描述，再以后的开发之中也经常出现一下的命名习惯
abstract class AbstractMessage{ //为了区呗普通类还是抽象类
	//只有接口中的abstract才可以省略，抽象类中的不能省略
	abstract  public void print();
}
class NewsImpl extends AbstractMessage implements INews{
	public String get() {//权限了更加严格了，所以无法覆写
		return "1111";
	}
public void print() {}//有方法体就称为覆写
}
public class TestDemo {

	public static void main(String[] args) {
		INews news =new NewsImpl();
		System.out.println(news.get());
		
		//NewsImpl是抽象类和接口的共同子类
		AbstractMessage am=(AbstractMessage) news;//转型
		am.print();
}} 
 

3.一个抽象类可以使用implements实现多个接口，但是接口不能够去继承抽象类

interface INews{//爷爷
	public String get();
}
//可以再类上进行明确描述，再以后的开发之中也经常出现一下的命名习惯
abstract class AbstractMessage implements INews {//父亲
	//只有接口中的abstract才可以省略，抽象类中的不能省略
	abstract  public void print();
}
class NewsImpl extends AbstractMessage {//孙子
	public String get() {
		return "1111"; 
	} 
public void print() {}//有方法体就称为覆写
}
public class TestDemo {

	public static void main(String[] args) {
		INews news =new NewsImpl();//孙子被爷爷实例化
		System.out.println(news.get());
		
		//NewsImpl是抽象类 和接口的共同子类
		AbstractMessage am=(AbstractMessage) news; //爷爷再变成儿子
		am.print();
}} 

实际上此时的结构关系属于三层的继承。

interface INews{
	public String get();
public void print();
}
//假设一个接口可能有无数个子类，但是对于一个方法的实现是一样的
abstract class AbstractMessage implements INews {
	 public void print() {//print()方法被抽象类实现了
		 System.out.println("222");
	 }
}
//生怕别人不知道NewsImpl是INews接口的子类，做一个重复标记而已
class NewsImpl extends AbstractMessage implements INews{
	public String get() {//get()方法是被子类实现了
		return "1111"; 
	} 
	
}

4.一个接口可以使用extends来继承多个父接口

interface A{
	public void printA();
}
interface B{
	public void printB();
}
interface C extends A,B{//接口多继承
	public void printC();
}
class Impl implements C{
	public void printB() {}
public void printA() {}
public void printC() {}
}

5.接口可以定义一系列的内部结构，包括：内部的普通类、内部的抽象类、内部接口，

其中使用static定义的内部的内部接口就相当于外部接口 。

 

interface A{
	static interface B{//使用了static定义描述了一个外部接口
		public void printB();
	}
}
 class X implements A.B{//实现内部接口
	public void pirntB() {}
}

对于内部的结构依然不是我们的首选。要想清楚接口的开发意义，需要大量的项目来论证。