基本概念
如果一个类之中只有全局常量和抽象方法,则这个类就可以定义为接口。
接口就是全局常量和抽象方法的集合,在Java里面使用关键字interface定义接口 范例如下:
interface A{
public static final String MSG = "Hello World."; //全局常量
public abstract void fun(); //抽象方法
}
接口无法使用关键字new进行实例化,接口的使用原则如下:
- 接口必须有子类,子类使用implements进行接口实现,一个子类可以同时实现多个接口
- 接口的子类(如果不是抽象类),则一定要覆写接口内的全部抽象方法
- 接口的子类可以利用子类的向上转型,进行实例化操作
实例
interface A{
public static final String MSG = "Hello World."; //全局常量
public abstract void fun(); //抽象方法
}
interface B{
public abstract void print();
}
class X implements A,B{ //X同时实现了A,B两个接口
public void fun(){
System.out.println("Hello");
}
public void print(){
System.out.println(MSG);
}
}
public class TextDemo13{
public static void main(String args[]){
A a = new X();
B b = new X();
a.fun();
b.print();
}
}
现已经学习普通类、抽象类、接口三个概念,如果说现在有一个类既要继承抽象类又要实现接口的话,则应该先继承(extends 父类)后实现(implements 接口,......)
范例
interface A{
public static final String MSG = "Hello World."; //全局常量
public abstract void fun(); //抽象方法
}
interface B{
public abstract void print();
}
abstract class C{ //抽象类
public abstract void get();
}
class X extends C implements A , B{ //X同时实现了A,B两个接口
public void fun(){
System.out.println("Hello");
}
public void print(){
System.out.println(MSG);
}
public void get(){
System.out.println("你好!");
}
}
public class TextDemo13{
public static void main(String args[]){
A a = new X();//子类为父接口实例化
B b = new X();//子类为父接口实例化
C c = new X();//子类为父接口实例化
a.fun();
b.print();
c.get();
}
}
清楚了接口的基本概念还需要有几个说明
说明一:接口之中的全部方法访问权限但是public,不管写与不写都一样,大部分的方法规范都是由接口规定的,所以这才有了只要是方法大部分都使用public定义的原因
说明二:在接口里面既然全部是由全局常量和抽象方法组成,所以在定义的时候以下两种方式相同
| interface A{ public static final String MSG = "Hello"; public abstract void fun(); } | interface A{ String MSG = "Hello"; void fun(); } |
但是为了防止初级人员犯错,所以定义接口的时候往往都加上public
说明三:一般在定义接口的时候定义方法是比较多的,而定义全局常量相对较少
说明四:一个抽象类可以使用implements实现接口
abstract class C implements A , B{ //抽象类实现接口
public abstract void get();
}
但是一个接口却不能继承一个抽象类,可是一个接口却可以使用extends关键字继承多个父接口
说明五:任何内部结构实际都不受定义的限制,所以在一个接口里面也可以继续定义内部接口或内部类,而且使用static定义的内部接口就是一个外部接口。
在实际中,接口有三大核心功能
- 使用接口定义规范标准
- 接口表示一种能力
- 将服务器的远程视图暴露给客户端
接口应用---定义规范标准
“接口”这一名词随处可见,那么下面通过程序模拟这样一个概念 。打印机、U盘都可以插在电脑上的USB接口使用,而使用的规则假设就只有两个:工作、退出,那么这个时候设计如下
图解:
代码
interface USB{
public void work(); //USB工作设备
public void exit(); //退出USB设备
}
class Computer{ //电脑
public void plugin(USB usb){ //接收USB设备
usb.work();
usb.exit();
}
}
class Flash implements USB{
public void work(){
System.out.println("U盘开始拷贝文件。");
}
public void exit(){
System.out.println("U盘结束操作。");
}
}
class Print implements USB{
public void work(){
System.out.println("打印机开始文档打印。");
}
public void exit(){
System.out.println("打印机结束打印,完成工作。");
}
}
public class TextDemo13{
public static void main(String args[]){
Computer com = new Computer();
com.plugin(new Flash());
com.plugin(new Print());
}
}
可以发现此工程之中电脑和打印机还是两个彼此独立的类,没有直接定义联系,但是有标准联系
接口(和抽象类)就是对类的再次抽象,但是以接口为主(抽象类具备单继承局限,而接口没有)
接口应用---工厂设计模式(Factory)
程序在主方法(客户端)直接使用关键new实例化了接口对象,那么就表示这个时候在客户端,接口就与子类绑在一起了,如果要更改子类,则需要修改客户端代码,而这种形式是不可能使用的,最好的设计是后面可以动的,但是客户操作端不能动。
即:“A到B”属于点对点的操作就会造成扩展问题,那么可以借鉴JVM的操作原理(程序到JVM到操作系统,A到B到C)这样的做法反而更容易进行程序维护。也就是最好加入一个第三方。
例如
interface Fruit{
public void eat();
}
class Apple implements Fruit{
public void eat(){
System.out.println("吃苹果。");
}
}
class Orange implements Fruit{
public void eat(){
System.out.println("吃橘子。");
}
}
class cherry implements Fruit{
public void eat(){
System.out.println("看樱花。");
}
}
class Factory{
public static Fruit getInstance(String className){
if("apple".equals(className)){
return new Apple();
}
if("orange".equals(className)){
return new Apple();
}
if("cherry".equals(className)){
return new Apple();
}
return null;
}
}
public class TextDemo13{
public static void main(String args[]){
Fruit f = Factory.getInstance(args[0]);
f.eat();
}
}
此时修改使用子类的时候,客户端没有进行任何的修改。而如果说此时Fruit要扩充子类的话,那么只需要修改Factory类即可,即:某一局部的修改不影响程序的其他组成部分。
接口应用---代理设计模式(Proxy)
实现以上功能
interface Network{ //网络连接
public void browse(String url);
}
class RealNetwork implements Network{
public void browse(String url){
System.out.println("访问地址:" + url);
}
}
class ProxyNetwork implements Network{
private Network net; //保存真正的上网连接
public ProxyNetwork(Network net){
this.net = net;
}
public boolean check(String url){
if(url.contains("whitehouse")){
System.out.println("警告,访问非法网站!!!");
return false ;
}
return true;
}
public void browse(String url){
if (this.check(url)){ //通过检查了
this.net.browse(url);
}
}
public void record(String url){
System.out.println("上网记录:" + url);
}
}
public class TextDemo13{
public static void main(String args[]){
Network nw = new ProxyNetwork(new RealNetwork());
nw.browse("www.weibo.com");
nw.browse("www.whitehouse.com");
}
}
在本结构之中,发现一个接口定义了两个子类,一个子类完成核心的真实业务主体,而另一个子类要为核心业务提供所有辅助功能。
接口与抽象类区别
| No | 区别 | 抽象类 | 接口 |
| 1 | 关键字 | abstract class 类名称{} | interface 接口名称{} |
| 2 | 组成 | 普通方法、抽象方法、构造方法、常量、变量 | 全局常量、抽象方法 |
| 3 | 权限 | 各类权限 | 只能是public权限 |
| 4 | 使用 | 子类使用extends只能够继承一个父类 | 子类使用implements可以实现多个接口 |
| 5 | 关系 | 抽象类可以实现多个接口 | 接口不能够继承抽象类,但是可以继承多个接口,实现接口多继承 |
| 6 | 设计模式 | 模板设计模式 | 工厂设计模式、代理设计模式、 |
| 7 | 局限 | 单继承局限 | 无局限 |
以此可知,在项目中使用抽象类或者接口都是一样的,可是由于接口没有抽象类的单继承性局限,那么整个开发之中如果发现抽象类和接口都可以使用,则优先使用接口,避免单继承局限



