后端开发 \ Java \ 接口(interface /implements/停车场/父接口和父类转化)

接口(interface /implements/停车场/父接口和父类转化)

总点击12
简介:什么是接口? 接口定义:接口是一个抽象方法与全局常量(staticfinal是全局常量)的集合。

什么是接口?


接口定义:接口是一个抽象方法与全局常量(static final是全局常量)的集合。


为什么要有接口?


抽象类与普通类相比最大的特点是约定了子类的实现要求,但是抽象类存在单继承局限。如果要约定子类的实现要求并避免单继承局限就需要使用接口。接口可以实现多继承即一个子类可以继承多个接口。

接口优先原则:在一个操作中既可以使用抽象类又可以使用接口的时候,优先考虑使用接口。(抽象类必须有is -a关系,接口没有is-a关系)

接口使用interface关键字定义;


接口的命名规范:接口前加I 来区分接口与类。


子类实现接口使用implements关键字,并且子类可以同时实现多个父接口(可以使用接口实现多继承),一般使用接口名+Impl来命名子类。

定义一个简单的接口:

interface IA //IA是一个接口,为了区别类在接口前加I

{

abstract public void func(); //抽象方法

static final int a=10; //全局常量,必须在声明时初始化,因为用final声明

}

子类实现接口和父接口之间的相互转化:

interface IA //IA是一个接口,为了区别类在接口前加I

{

abstract public void func1(); //抽象方法

static final int a=10; //全局常量,必须在声明时初始化,因为用final声明

}

interface IB

{

abstract public void func2(); //抽象方法

}

class AImpl implements IA ,IB

{

public void func1() //覆写func1()

{

System.out.println("子类实现接口IA");

}

public void func2() //覆写func2()

{

System.out.println("子类实现接口IB");

}

}

public class Interface1

{

public static void main(String[] args)

{

IA a1=new AImpl(); //向上转型,为父接口实例化对象

a1.func1(); //调用子类覆写的func1() ->子类实现接口IA

IB b1=(IB)a1; //父接口之间的相互转化,a1是通过子类AImpl new出来的

b1.func2(); //调用子类覆写的func2() ->子类实现接口IB

}

}

为什么可以实现父接口的相互转化?


因为父类都是子类new出来的,只要看new 在哪儿即可,不用看期间的各种类名。

接口使用限制:


接口中只有public 权限(不管是属性还是方法,其权限均是public),所以可以将权限public省略。另外接口中public static final abstract均可以省略(因为抽象类只有抽象方法和全局常量,那么不写就会这样默认)


阿里编码规约:接口中的属性和方法不要加任何修饰符,public也不要加,保证代码简洁性。

当一个子类既需要实现接口又需要继承抽象类时,要先使用extends继承一个抽象类,而后保证implements实现多个接口。(因为不知道接口有多少个,而继承只有一个)

同样,父接口和父类之间可以实现相互转化:

interface IA //IA是一个接口,为了区别类在接口前加I

{

void func1(); // 默认为抽象方法

int a=10; //默认全局常量,

}

interface IB

{

void func2(); //抽象方法

}

abstract class C

{

abstract public void func3();

}

class ABCImpl extends C implements IA,IB //继承了抽象类,2个接口

{

public void func3()

{

System.out.println("子类实现抽象类C");

}

public void func2()

{

System.out.println("子类实现接口IB");

}

public void func1()

{

System.out.println("子类实现接口IA");

}

}

public class Interface1 //主类

{

public static void main(String[] args)

{

IA a1=new ABCImpl(); //向上转型,为父接口实例化对象

a1.func1(); //调用子类覆写的func1() ->子类实现接口IA

IB b1=(IB)a1; //父接口之间的相互转化,a1是通过子类AImpl new出来的

b1.func2(); //调用子类覆写的func2() ->子类实现接口IB

C c1=(C)b1;

c1.func3(); // 父接口和父类之间的相互专户 ->子类实现抽象类C

}

}

抽象类可以用implements实现接口,但是接口不能用extends继承抽象类(因为接口中只有抽象方法和全局常量,而抽象类中不止只有抽象方法,还有普通方法…)

/////抽象类实现(interface)接口

interface IA

{

void func1();

}

abstract class AImpl implements IA //AImpl是抽象类,抽象类可以不覆写接口中的抽象方法

{

abstract public void func2(); //抽象方法,而且abstract不可省略,否则是普通方法

}

class A extends AImpl

{

public void func1()

{

System.out.println("抽象类interface接口");

}

public void func2()

{

System.out.println("子类实现抽象类抽象方法");

}

}

public class Interface1

{

public static void main(String[] args)

{

IA a=new A();

a.func1(); //抽象类interface接口

//A是接口IA和抽象类AImpl的共同子类

AImpl ai=(AImpl)a;

ai.func2(); //子类实现抽象类抽象方法

}

}

接口可以使用extends继承多个父接口。

/////一个接口继承多个接口

interface IA

{

void func1();

}

interface IB

{

void func2();

}

interface IC extends IA,IB

{

void func3();

}

class ABCImpl implements IC

{

public void func1()

{

System.out.println("接口C继承接口A");

}

public void func2()

{

System.out.println("接口C继承接口B");

}

public void func3()

{

System.out.println("接口C");

}

}

public class Interface1

{

public static void main(String[] args)

{

IC c=new ABCImpl(); //向上转型

c.func3(); //接口C

IA a=(IA)c;

a.func1(); //接口C继承接口A

IB b=(IB)a;

b.func2(); //接口C继承接口A

IA a2=new ABCImpl();

a2.func1(); //接口C继承接口A

IB b2=(IB)a2;

b2.func2(); //接口C继承接口A

IC c2=(IC)b2;

c2.func3(); //接口C

//上面例子更加印证了是否可以强转或者转换,主要看new 后面的对象。

}

}

接口作用:

定义操作标准

表示一种能力,进行一项操作

在分布式开发中暴露远程服务方法


接下来,主要介绍接口标准化,通过电脑的接口和停车场停车两个例子进行结合:


首先是电脑接口:

////电脑有接口,而接口都是一样的,只是接口类别不同,那么就可以利用接口统一化,完成一些操作

interface IUsb //定义一个Usb接口

{

void setUp(); //安装

void work(); //工作

}

class Computer //电脑类

{

public void plugin(IUsb usb) //用接口实现标准化,通过向上转型

{

usb.setUp();

usb.work();

}

}

class printUsbImpl implements IUsb

{

public void setUp()

{

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

}

public void work()

{

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

}

}

class uDiskImpl implements IUsb

{

public void setUp()

{

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

}

public void work()

{

System.out.println("U盘工作");

}

}

public class InterStander

{

public static void main(String[] args)

{

Computer computer=new Computer();

computer.plugin(new printUsbImpl()); //安装打印机 打印机工作

computer.plugin((new uDiskImpl())); //安装U盘 U盘工作

}

}

接下来是停车场停车:停车场停车,但车有很多种,可以将车定义为一个接口,停车场是一个类,再根据不同类型的车实现接口:

////停车场停车

interface Ivehicle //定义一个车的接口

{

void kind(); //车的类型 假设只有一个抽象方法

}

class Park

{

public void whoPark(Ivehicle vehicle)

{

vehicle.kind();

}

}

class AutiImple implements Ivehicle

{

public void kind()

{

System.out.println("奥迪在停车");

}

}

class BenzImpl implements Ivehicle

{

public void kind()

{

System.out.println("奔驰在停车");

}

}

public class InterStander

{

public static void main(String[] args)

{

Park park=new Park();

park.whoPark(new AutiImple()); //奥迪在停车

park.whoPark((new BenzImpl())); //奔驰在停车

}

}

意见反馈 常见问题 官方微信 返回顶部