接口
1 为什么有接口
1.定义接口：有一系列的方法（规范）
public interface UsbInterface { //接口
//规定接口的相关方法,老师规定的.即规范...
public void start();
public void stop();
}
2.使用接口的设备
//Phone 类 实现 UsbInterface
//解读1. 即 Phone类需要实现 UsbInterface接口 规定/声明的方法
public class Phone implements UsbInterface {
@Override
public void start() {
System.out.println("手机开始工作...");
}
@Override
public void stop() {
System.out.println("手机停止工作.....");
}
}
public class Camera implements UsbInterface {//实现接口,就是把接口方法实现
@Override
public void start() {
System.out.println("相机开始工作...");
}
@Override
public void stop() {
System.out.println("相机停止工作....");
}
}
3.电脑使用接口
public class Computer {
//编写一个方法, 计算机工作
//解读:
//1. UsbInterface usbInterface 形参是接口类型 UsbInterface
//2. 看到 接收 实现了 UsbInterface接口的类的对象实例
public void work(UsbInterface usbInterface) {
//通过接口，来调用方法
usbInterface.start();
usbInterface.stop();
}
}
4.测试
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);//把相机接入到计算机
}
}
2 基本介绍
public interface AInterface {
//写属性
public int n1 = 10;
//写方法
//在接口中，抽象方法，可以省略abstract关键字
public void hi();
//在jdk8后，可以有默认实现方法,需要使用default关键字修饰
default public void ok() {
System.out.println("ok ...");
}
//在jdk8后, 可以有静态方法
public static void cry() {
System.out.println("cry ....");
}
}
////1.如果一个类 implements实现 接口
////2. 需要将该接口的所有抽象方法都实现
//class A implements AInterface {
// @Override
// public void hi() {
// System.out.println("hi()....");
// }
//}
3 什么时候使用接口呢？
编写接口
public interface DBInterface { //项目经理
public void connect();//连接方法
public void close();//关闭连接
}
编写类实现接口中的所有方法
//A程序
public class MysqlDB implements DBInterface {
@Override
public void connect() {
System.out.println("连接mysql");
}
@Override
public void close() {
System.out.println("关闭mysql");
}
}
//B程序员连接Oracle
public class OracleDB implements DBInterface{
@Override
public void connect() {
System.out.println("连接oracle");
}
@Override
public void close() {
System.out.println("关闭oracle");
}
}
体会接口带来的统一规范的便利性
将实现接口的类的对象作为参数传入某个方法中，而且该方法的参数就是类的对象所实现的接口。
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();
}
}
4 注意事项和细节
1)接口不能被实例化;
2)接口中所有的方法是 public方法，接口中抽象方法，可以不用abstract修饰图示:
3)一个普通类实现接口,就必须将该接口中的所有方法都实现。
4)抽象类实现接口，可以不用实现接口的方法。
5)一个类同时可以实现多个接口。
6)接口中的属性,只能是final的，而且是 public static final修饰符。比如:int a=1;实际上是public static final int a=1;(必须初始化)
7)接口中属性的访问形式:接口名.属性名。
8)接口不能继承其它的类,但是可以继承多个别的接口。
接口和接口之间是继承关系，用extends关键字；接口和类之间是实现关系，用implements关键字。
9)接口的修饰符只能是public 和默认，这点和类的修饰符是一样的。
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 {
}
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() {
}
}
5 练习1
//public class InterfaceExercise01 {
// public static void main(String[] args) {
// B b = new B();//ok
// System.out.println(b.a); //23
// System.out.println(A.a); //23
// System.out.println(B.a); //23
// }
//}
//
//interface A {
// int a = 23; //等价 public static final int a = 23;
//}
//
//class B implements A {//正确
//}
6 实现接口 vs 继承类
实现接口这种机制是对java中单继承的一种补充
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() + " 通过学习，可以像鸟儿一样飞翔...");
}
}
小结：
- 继承的价值主要在于:解决代码的复用性和可维护性。
- 接口的价值主要在于:设计，设计好各种规范(方法)，让其它类去实现这些方法。即更加的灵活。
- 接口比继承更加灵活，继承是满足is - a的关系，而接口只需满足like - a的关系。
- 接口在一定程度上实现代码解耦[即:接口规范性+动态绑定机制]
7 接口的多态特性
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 {}
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("相机工作中...");
}
}
/**
* 演示多态传递现象
*/
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() {
}
}
8 练习2
public class InterfaceExercise02 {
public static void main(String[] args) {
}
}
interface A { // 1min 看看
int x = 0;
} //想到 等价 public static final int x = 0;
class B {
int x = 1;
} //普通属性
class C extends B implements A {
public void pX() {
//System.out.println(x); //错误，原因不明确x
//可以明确的指定x
//访问接口的 x 就使用 A.x
//访问父类的 x 就使用 super.x
System.out.println(A.x + " " + super.x);
}
public static void main(String[] args) {
new C().pX();
}
}
9 小结
类的五大成员
- 属性
- 方法
- 构造器
- 代码块
- 内部类（难点）
