接口

                                               接口

一、接口的定义与使用

抽象类与普通类相比最大的特点就是约定了子类的实现要求，但是抽象类存在单继承的局限。如果既要约定子类的实现要求且要避免单继承局限就要使用接口。（接口优先）

1、接口的基本概念

   接口就是抽象方法和全局常量的集合，在Java中接口欧使用interface关键字定义。（一般为区分接口，建议在接口前面加大写字母I）

   子类若想使用接口，要使用implements关键字来实现接口。且一个子类可以实现多个接口（即可以使用接口来实现多继承），对于接口的子类（非抽象类）必须覆写接口中的所有抽象方法。可以利用子类的向上转型通过实例化子类来得到接口的实例化对象。

//接口

interface IMessage{

    //可省略

public static final String MSG = "我是一个学生";

//抽象方法

public abstract void fun();

}

interface INews{

public abstract String getNews();

}

class MessageImpl implements IMessage,INews{

//覆写IMessage的抽象方法

public void fun(){

System.out.println(IMessage.MSG);

}

//覆写INews的抽象方法

public String getNews(){

return IMessage.MSG;

}

}

public class Test6{

public static void main(String[] args) {

IMessage message = new MessageImpl();//向上转型，为父类接口实例化对象

message.fun();//被子类覆写的方法

INews news = (INews)message;//向下转型

System.out.println(news.getNews());

}

}

 

2、接口的使用限制

a.接口中只允许使用public权限，不论是属性耗时方法，其权限都是public.

错误代码

//接口中抽象方法的权限是public(即使不写也是)

interface IMessage{

abstract void fun();//接口中方法不写权限默认为pubic

}

class MessageImpl implements IMessage{

//普通类中方法不写权限默认为default

//所以有比其接口更严格的控制权限，不能实现覆写

void fun(){

System.out.println("hehe");

}

}

public class Test6{

public static void main(String[] args) {

IMessage message = new MessageImpl();

message.fun();

}

}

b.当一个子类既需要实现接口又需要继承抽象类时，应先使用extends继承一个抽象类，再使用implements实现多个接口。

interface IMessage{

//接口中抽象方法的public abstract可省略，且默认为public

void fun();

}

abstract class News{

//抽象类中的抽象方法的abstract不可以省略，否则为普通方法

public abstract void getNews();

}

class MessageImpl extends News implements IMessage{

public void fun(){

System.out.println("haha");

}

public void getNews(){

System.out.println("hehe");

}

}

public class Test6{

public static void main(String[] args) {

IMessage message = new MessageImpl();//向上转型实例化接口对象

message.fun();//调用被覆盖方法

News news = (News)message;//向下转型实例化抽象类

news.getNews();//调用被覆写的方法

}

}

 

c.一个抽象类可以使用implements实现多个接口，但是接口不可继承抽象类。

interface IMessage{

void fun();

}

//抽象类实现接口

abstract class News implements IMessage{

//News为抽象类，可以不实现接口中的抽象方法

public abstract void getNews();

}

//MessageImpl类继承抽象类News

class MessageImpl extends News{

public void fun(){

System.out.println("我是实现接口的方法");

}

public void getNews(){

System.out.println("我是覆写抽象类中的抽象方法");

}

}

public class Test6{

public static void main(String[] args) {

IMessage message = new MessageImpl();//向上转型实例化接口对象

message.fun();//调用被覆盖方法

News news = (News)message;//向下转型实例化抽象类

news.getNews();//调用被覆写的方法

}

}

 

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

interface IA{

void fun1();

}

interface IB{

void fun2();

}

interface IC extends IA,IB{

void fun3();

}

class Message implements IC{

public void fun1(){

System.out.println("我是接口IA的实现");

}

public void fun2(){

System.out.println("我是接口IB的实现");

}

public void fun3(){

System.out.println("我是接口IC的实现");

}

}

public class Test6{

public static void main(String[] args) {

 IA a = new Message();

 a.fun1();

 IB b = new Message();

 b.fun2();

 IC c = new Message();

 c.fun1();

}

}

 

3、接口的应用

   定义标准、表示能力、在分布式开发中暴露远程服务方法

 定义标准：

    

//定义一个USB标准

interface USB{

public void setup();//安装USB驱动

public void work();//进行工作

}

//定义电脑类

class Computer{

//只能插usb设备

public void plugin(USB usb){

usb.setup();//安装

usb.work();//工作

}

}

//定义USB子类

class UDisk implements USB{

public void setup(){

System.out.println("安装U盘驱动");

}

public void work(){

System.out.println("u盘开始工作");

}

}

class printDisk implements USB{

public void setup(){

System.out.println("安装打印机驱动");

}

public void work(){

System.out.println("打印机开始工作");

}

}

public class Test6{

public static void main(String[] args) {

Computer computer = new Computer();

computer.plugin(new UDisk());

computer.plugin(new printDisk());

}

}