（基础）java中的接口interface

接口Interface

 

接口定义的是一系列行为；

接口真正的应用要落实到多态的应用上，才能达到提高扩展性的目的！

 

 

 

接口的存在意义：

接口侧重于对功能的描述，是一种全局性的功能声明，所以，方法都是abstract的；

接口不负责功能的具体实现，交由子类去做；

接口侧重于为子类提供功能的扩展；

 

接口的一些特点：

接口中的成员都是public的，对外都是可见的；

接口中的属性的都是全局常量；

接口中的方法都是公有的抽象方法；

接口弥补了Jave中没有多继承的缺陷，一个类可以同时实现多个接口；

接口可以多继承其它接口（因为接口中的方法没有方法体，所以可以多继承）；

 

继承与接口结合使用非常强大：

继承提供共性功能的复用

接口提供功能的扩展，解决了Java单继承的局限性，对额外功能提供了无限扩展

 

 

全局常量  

固定修饰符 public static final（不写Java会自动补全）

public interface InterfaceA {
	public static final int MAX_AGE = 140;
}

 

 

抽象方法  

固定修饰符public abstract （不写Java会自动补全）

 

public interface InterfaceA {
	
	public abstract void skillA();
	
	public abstract void skillB();
	
}

 

多实现

 

public interface InterfaceA {
	
	public static final int MAX_AGE = 140;

	
	public abstract void skillA();
	
	public abstract void skillB();
	
}

 

public interface InterfaceB {
	
	public abstract void methodA();
	
}

 

public class ImplementClass implements InterfaceA, InterfaceB{


	@Override
	public void skillA() {
		System.out.println("AAAAAAAAAAAAAAAA");
	}

	@Override
	public void skillB() {
		System.out.println("BBBBBBBBBBBBBBBB");
	}

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

 测试

public class Test {
	public static void main(String[] args) {
		ImplementClass impl = new ImplementClass();
		impl.skillA();
		impl.skillB();
		impl.methodA();
	}
	
	/*
		AAAAAAAAAAAAAAAA
		BBBBBBBBBBBBBBBB
		methodA
	 * */
}

 

========================================================================

 

面向接口编程/面向抽象编程

 

什么是面向接口编程？

即，不针对具体，而是针对抽象进行编程!

程序运行时，只要传入的参数类型正确(实现了某个接口)，程序就能运行!

所谓的扩展，指的是实现接口的子类可以进行无数不同功能的开发，最终以接口子类的身份传入到调用者那里，程序都支持，而且能正确运行，这就是所谓的扩展!

 

在代码中的具体体现

主体程序中方法的入参是一个接口类型的引用

该引用实际指向的是某个具体的实现（多态的支持）

对于方法而言，面向的都是统一的上层接口，处理方式都是一样的

而在实际执行时，由Java动态绑定机制实现对具体实现类的调用

这就是面向接口编程，这就是使用接口能提高程序扩展性的原因!

 

示例：

 1.接口，定义一组行为                                    interface

 2.类实现接口，对行为进行具体的描述        class A  implements InterfaceA

 3.方法入参为接口，多态（运行时有多种形态）的支持

  public void method(InterfaceA  a)

 4.方法内部面向统一的接口进行编程，不关心具体如何实现

 

接口---定义规则

 

/**
 * 接口定义一组行为
 * @author Administrator
 *
 */
public interface InterfaceA {
	
	public static final int MAX_AGE = 140;

	
	public abstract String skill();
	
	
}

 

 

实现类A，A类事物具备InterfaceA的行为--- 实现规则

 

/**
 * 子类根据自身环境决定如何实现接口中的行为
 * @author Administrator
 *
 */

public class SubClassA implements InterfaceA {


	@Override
	public String skill() {
		return "using java";
	}

}

 

 实现类B，B类事物具备InterfaceA的行为--- 实现规则

 

 

/**
 * 实现类
 * @author Administrator
 *
 */
public class SubClassB implements InterfaceA {


	@Override
	public String skill() {
		return "using c";
	}

}

 

 

使用接口的类/面向接口编程的类，凡是符合InterfaceA接口的对象，该类都能处理

这就是扩展性，面向接口进行开发!--- 使用规则

 

public class Main {
	
	//面向接口
	public String invoke(InterfaceA a) {
		return a.skill();
	}
	
}

 

 

测试

public class Test {
	public static void main(String[] args) {
		
		Main main = new Main();
		
		//多态
		InterfaceA a1 = new SubClassA();
		//方法的入参：面向接口
		String s1 = main.invoke(a1);
		System.out.println(s1);
		
		InterfaceA a2 = new SubClassB();
		String s2 = main.invoke(a2);
		System.out.println(s2);
		
		//还可以有无数对InterfaceA的实现，都可以被invoke()接收，这就是扩展
	}
	
}