系列文章目录
文章目录
前言
接口是更加抽象的类。
一、接口
usb插槽就是现实中的接口,厂家都遵守了统一的规定包括尺寸,排线等。这样的设计在java编程中也是大量存在的。
java
复制代码
package com.hspedu.interface_;
public interface UsbInterface { //接口
//规定接口的相关方法,老师规定的.即规范...
public void start();
public void stop();
}
package com.hspedu.interface_;
public class Camera implements UsbInterface{//实现接口,就是把接口方法实现
@Override
public void start() {
System.out.println("相机开始工作...");
}
@Override
public void stop() {
System.out.println("相机停止工作....");
}
}
package com.hspedu.interface_;
//Phone 类 实现 UsbInterface
//解读 1. 即 Phone 类需要实现 UsbInterface 接口 规定/声明的方法
public class Phone implements UsbInterface {
@Override
public void start() {
System.out.println("手机开始工作...");
}
@Override
public void stop() {
System.out.println("手机停止工作.....");
}
}
package com.hspedu.interface_;
public class Interface01 {
public static void main(String[] args) {
//创建手机, 相机对象
//Camera 实现了 UsbInterface
Camera camera = new Camera();
//Phone 实现了 UsbInterface
Phone phone = new Phone();
//创建计算机
Computer computer = new Computer();
computer.work(phone);//把手机接入到计算机
System.out.println("===============");
computer.work(camera);//把相机接入到计算机
}
}
接口就是给出一些没有实现的方法,封装到一起,到某个类要使用的时候,在根据具体情况把这些方法写出来。
java
复制代码
//语法形式
interface 接口
{
//属性
//方法
}
class 类名 implements 接口
{
//自己属性
//自己方法
//必须实现的接口的抽象方法
}
接口本质 |
接口就是更加抽象的类,抽象类里的方法可以有方法体,接口里的所有方法都没有方法体【JDK7.0】 |
接口体现了程序设计的多态和高内聚低耦合的设计思想 |
【JDK8.0】后接口可以有静态方法,成员方法,也就是说接口中可以有方法的具体实现 |
java
复制代码
package com.hspedu.interface_;
public interface DBInterface { //项目经理
public void connect();//连接方法
public void close();//关闭连接
}
package com.hspedu.interface_;
//A 程序
public class MysqlDB implements DBInterface {
@Override
public void connect() {
System.out.println("连接 mysql");
}
@Override
public void close() {
System.out.println("关闭 mysql");
}
}
package com.hspedu.interface_;
//B 程序员连接 Oracle
public class OracleDB implements DBInterface{
@Override
public void connect() {
System.out.println("连接 oracle");
}
@Override
public void close() {
System.out.println("关闭 oracle");
}
}
package com.hspedu.interface_;
public class Interface03 {
public static void main(String[] args) {
MysqlDB mysqlDB = new MysqlDB();
t(mysqlDB);
OracleDB oracleDB = new OracleDB();
t(oracleDB);
}
public static void t(DBInterface db) {
db.connect();
db.close();
}
}
接口使用细则part1 |
1)接口不能被实例化 |
2)接口中所有的方法是public方法,接口中抽象方法,可以不用abstract修饰 |
3)一个普通类实现接口,就必须将该接口的所有方法都实现 |
4)抽象类实现接口,可以不用实现接口的方法 |
java
复制代码
package com.hspedu.interface_;
public class InterfaceDetail01 {
public static void main(String[] args) {
//new IA();
}
}
//1.接口不能被实例化
//2.接口中所有的方法是 public 方法, 接口中抽象方法, 可以不用 abstract 修饰
//3.一个普通类实现接口,就必须将该接口的所有方法都实现,可以使用 alt+enter 来解决
//4.抽象类去实现接口时, 可以不实现接口的抽象方法
interface IA {
void say();//修饰符 public protected 默认 private
void hi();
}
class Cat implements IA{
@Override
public void say() {}
@Override
public void hi() {}
}
abstract class Tiger implements IA {
}
接口使用细则part2 |
5)一个类可以同时实现多个接口 |
6)接口中的属性,只能是final的,而且是public static final 修饰符。比如:int a = 1;实际上是public static final int a = 1;(必须初始化) |
7)接口中的属性的访问形式:接口名.属性名 |
8)接口不能继承其他类,但可以继承多个别的接口 |
9)接口的修饰符 只能是public和默认,这点和类的修饰符是一样的 |
java
复制代码
package com.hspedu.interface_;
public class InterfaceDetail02 {
public static void main(String[] args) {
//老韩证明 接口中的属性,是 public static final
System.out.println(IB.n1);//说明 n1 就是 static
//IB.n1 = 30; 说明 n1 是 final
}
}
interface IB {
//接口中的属性,只能是 final 的, 而且是 public static final 修饰符
int n1 = 10; //等价 public static final int n1 = 10;
void hi();
}
interface IC {
void say();
}
//接口不能继承其它的类,但是可以继承多个别的接口
interface ID extends IB,IC {}
//接口的修饰符 只能是 public 和默认, 这点和类的修饰符是一样的
interface IE{}
//一个类同时可以实现多个接口
class Pig implements IB,IC {
@Override
public void hi() {}
@Override
public void say() {}
}
二、实现接口与继承类
实现接口和继承类的区别 |
当子类继承了父类,就自动的拥有父类的功能,解决代码的复用性和可维护性 |
如果子类需要扩展功能,可以通过实现接口的方式扩展,设计好各种规范(方法),让其它类去实现这些方法,即更加灵活 |
接口比继承更加灵活,继承是满足is - a的关系,而接口只需满足 like - a的关系 |
可以理解实现接口是对java单继承机制的一种补充,接口在一定程度上实现代码解耦,即接口规范性+动态绑定机制 |
java
复制代码
package com.hspedu.interface_;
public class ExtendsVsInterface {
public static void main(String[] args) {
LittleMonkey wuKong = new LittleMonkey("悟空");
wuKong.climbing();
wuKong.swimming();
wuKong.flying();
}
}
//猴子
class Monkey {
private String name;
public Monkey(String name) {
this.name = name;
}
public void climbing() {
System.out.println(name + " 会爬树...");
}
public String getName() {
return name;
}
}
//接口
interface Fishable {
void swimming();
}
interface Birdable {
void flying();
}
//继承
//小结: 当子类继承了父类, 就自动的拥有父类的功能
// 如果子类需要扩展功能, 可以通过实现接口的方式扩展.
// 可以理解 实现接口 是 对 java 单继承机制的一种补充.
class LittleMonkey extends Monkey implements Fishable,Birdable {
public LittleMonkey(String name) {
super(name);
}
@Override
public void swimming() {
System.out.println(getName() + " 通过学习, 可以像鱼儿一样游泳...");
}
@Override
public void flying() {
System.out.println(getName() + " 通过学习, 可以像鸟儿一样飞翔...");
}
}
三、接口的多态特性
接口的多态性 |
多态参数:接口引用可以指向实现了接口的类的对象 |
多态数组:数组引用可以指向实现了接口的类的对象 |
多态传递:接口继承父接口可以被接口实现并实现接口的类的引用 |
java
复制代码
package com.hspedu.interface_;
public class InterfacePolyParameter {
public static void main(String[] args) {
//接口的多态体现
//接口类型的变量 if01 可以指向 实现了 IF 接口类的对象实例
IF if01 = new Monster();
if01 = new Car();
//继承体现的多态
//父类类型的变量 a 可以指向 继承 AAA 的子类的对象实例
AAA a = new BBB();
a = new CCC();
}
}
interface IF {}
class Monster implements IF{}
class Car implements IF{}
class AAA {}
class BBB extends AAA {}
class CCC extends AAA {}
java
复制代码
package com.hspedu.interface_;
public class InterfacePolyArr {
public static void main(String[] args) {
//多态数组 -> 接口类型数组
Usb[] usbs = new Usb[2];
usbs[0] = new Phone_();
usbs[1] = new Camera_();
/*
给 Usb 数组中, 存放 Phone 和 相机对象, Phone 类还有一个特有的方法 call() ,
请遍历 Usb 数组, 如果是 Phone 对象, 除了调用 Usb 接口定义的方法外,
还需要调用 Phone 特有方法 call
*/
for(int i = 0; i < usbs.length; i++) {
usbs[i].work();//动态绑定..
//和前面一样, 我们仍然需要进行类型的向下转型
if(usbs[i] instanceof Phone_) {//判断他的运行类型是 Phone_
((Phone_) usbs[i]).call();
}
}
}
}
interface Usb{
void work();
}
class Phone_ implements Usb {
public void call() {
System.out.println("手机可以打电话...");
}
@Override
public void work() {
System.out.println("手机工作中...");
}
}
class Camera_ implements Usb {
@Override
public void work() {
System.out.println("相机工作中...");
}
}
java
复制代码
ackage com.hspedu.interface_;
/**
* 演示多态传递现象
*/
public class InterfacePolyPass {
public static void main(String[] args) {
//接口类型的变量可以指向, 实现了该接口的类的对象实例
IG ig = new Teacher();
//如果 IG 继承了 IH 接口, 而 Teacher 类实现了 IG 接口
//那么, 实际上就相当于 Teacher 类也实现了 IH 接口.
//这就是所谓的 接口多态传递现象.
IH ih = new Teacher();
}
}
interface IH {
void hi();
}
interface IG extends IH{ }
class Teacher implements IG {
@Override
public void hi() {}
}
总结
接口的使用更多是对类继承的一种补充。