Java接口

最新推荐文章于 2024-06-16 09:46:44 发布

沐夏

最新推荐文章于 2024-06-16 09:46:44 发布

阅读量982

点赞数 21

文章标签： java 开发语言

本文链接：https://blog.csdn.net/2302_76764006/article/details/136212993

版权

一、使用接口的原因

package interfacedemo.demo01;

public abstract class Door {

// 定义门的开门和关门的抽象方法
public abstract void openDoor();
public abstract void closeDoor();
}

package interfacedemo.demo01;

public abstract class Lock {

// 定义开锁和上锁的两个抽象方法
public abstract void openLock();
public abstract void closeLock();
}

package interfacedemo.demo01;

// 定义SecurityDoor类，继承抽象类Door，重写Door类中所有的抽象方法
// SecurityDoor还有锁的功能，所以SecurityDoor还应该继承Lock类
// 但是类与类之间是单根继承，也就是说SecurityDoor在继承了Door类之后，不能再继承Lock类
public class SecurityDoor extends Door{

@Override
public void openDoor() {
System.out.println("轻推开门");
}

@Override
public void closeDoor() {
System.out.println("轻拉关门");
}

// 类与类之间是单根继承
// SecurityDoor 继承Door类后无法继承Lock
}

二、实现接口防盗门案例

门有开和关的功能，锁有上锁和开锁的功能

package interfacedemo.demo02;

public abstract class Door {

// 定义门的开门和关门的抽象方法
public abstract void openDoor();
public abstract void closeDoor();
}

package interfacedemo.demo02;

// 定义一个类SecurityDoor继承抽象类Door，实现接口Lock
// 一个类在实现一个接口后，必须重写接口中所有的抽象方法，否则这个类也要定义为抽象类
public class SecurityDoor extends Door implements Lock,Camera {

@Override
public void openDoor() {
System.out.println("轻推开门");
}

@Override
public void closeDoor() {
System.out.println("轻拉关门");
}

@Override
public void openLock() {
System.out.println("插入钥匙，左转三圈开锁");
}

@Override
public void closeLock() {
System.out.println("插入钥匙，右转三圈开锁");
}

// 定义防盗门中特有的方法
public void m1() {
System.out.println("防盗门中特有的方法");
}

@Override
public void takePhoto() {
System.out.println("咔擦拍照，注意注意");
}
}

package interfacedemo.demo02;

public interface Camera {

// 定义一个拍照方法
public abstract void takePhoto();
}

package interfacedemo.demo02;

public class Test {
public static void main(String[] args) {

SecurityDoor securityDoor = new SecurityDoor();

securityDoor.closeDoor(); // 轻拉关门
securityDoor.closeLock(); // 插入钥匙，右转三圈关锁
System.out.println("出门有事，然后回家"); // 出门有事，然后回家
securityDoor.openLock(); // 插入钥匙，左转三圈开锁
securityDoor.openDoor(); // 轻推开门

System.out.println("------ ------ ------");

// 接口不能直接实例化，也就是说不能通过new的形式创建接口的引用
// 但是可以通过多态的形式将接口的引用指向它的实现类
Lock lock = new SecurityDoor();
lock.openLock(); // 插入钥匙，左转三圈开锁
lock.closeLock(); // 插入钥匙，右转三圈关锁

// 向下转型
SecurityDoor securityDoor1 = (SecurityDoor) lock;
securityDoor1.m1(); // 防盗门中特有的方法

System.out.println("------ ------ ------");
securityDoor.closeDoor();
securityDoor.closeLock();
securityDoor.takePhoto(); // 咔擦拍照，注意注意
System.out.println("出门有事，然后回家");
securityDoor.openLock();
securityDoor.takePhoto(); // 咔擦拍照，注意注意
securityDoor.openDoor();

}
}

三、认识接口

public interface MyInterface {
public void foo();
// 其它方法
}
// 所有方法默认都是public abstract

接口特点：

1）接口不可以被实例化

2）实现类必须实现接口的所有方法

3）实现类可以实现多个接口

implements、多个接口使用逗号隔开

4）接口中的变量都是静态常量（public static final）

四、实现接口描述USB案例

package interfacedemo.demo03;

public interface Usb {

// USB接口功能，充电、传输
void electric();
void data();
}

package interfacedemo.demo03;

public class UsbFeng implements Usb{

@Override
public void electric() {
System.out.println("获取5A电流，风扇开始转动");
}

@Override
public void data() {

}

public void m1() {
System.out.println("UsbFeng中特有的方法m1()");
}
}

package interfacedemo.demo03;

public class UsbMouse implements Usb{

@Override
public void electric() {
System.out.println("获取3A电流，鼠标开始工作");
}

@Override
public void data() {
System.out.println("移动鼠标，开始传输数据");
}

public void m2() {
System.out.println("UsbMouse类中特有的方法m2()");
}
}

package interfacedemo.demo03;

public class UsbDisk implements Usb{

@Override
public void electric() {
System.out.println("获取2A电流，U盘开始工作");
}

@Override
public void data() {
System.out.println("复制剪切，传输数据");
}

public void m3() {
System.out.println("UsbDisk类中特有的方法m3()");
}
}

package interfacedemo.demo03;

public class Test {

public static void main(String[] args) {

// 直接创建接口实例不可以
// 但是可以通过多态的形式将接口的引用指向实现类的实例
// 多态：同一个父类引用指向不同的子类实现，实现不同的操作

// 向上转型：父类（接口）的引用指向不同的子类（实现类）实例
Usb usb1 = new UsbFeng();
usb1.electric(); // 获取5A电流，风扇开始转动
usb1.data();
// 父类引用无法调用子类中特有的方法，需要通过向下转型为其指向的实现类对象才能调用
// 向下转型：将子类的引用指向父类的引用
UsbFeng usbFeng = (UsbFeng)usb1;
usbFeng.m1(); // UsbFeng中特有的方法m1()

System.out.println("------ ------ ------");

usb1 = new UsbMouse();
usb1.electric(); // 获取3A电流，鼠标开始工作
usb1.data(); // 移动鼠标，开始传输数据

System.out.println("------ ------ ------");

usb1 = new UsbDisk();
usb1.electric(); // 获取2A电流，U盘开始工作
usb1.data(); // 复制剪切，传输数据

if(usb1 instanceof UsbFeng){
UsbFeng usbFeng1 = (UsbFeng)usb1;
usbFeng1.m1();
}else if(usb1 instanceof UsbMouse){
UsbMouse usbMouse = (UsbMouse)usb1;
usbMouse.m2();
}else if(usb1 instanceof UsbDisk){
UsbDisk usbDisk = (UsbDisk) usb1;
usbDisk.m3(); // UsbDisk类中特有的方法m3()
}

}
}

五、案例练习实现手机功能

原始的手机，可以发短信，通电话。随着发展，手机增加了功能：音频、视频播放、拍照、上网。使用接口实现手机功能

package interfacedemo.practice01;

public interface Network {
void networkConn();
}

public interface PlayWiring {

void play(String inContent);
}

public interface TakePictures {

void tabkePictures();
}

// 定义一个抽象类HandSet,作为父类使用
public abstract class HandSet {

// 定义属性，使用private进行封装
private String brand;
private String type;

public HandSet() {
}

public HandSet(String brand, String type) {
this.brand = brand;
this.type = type;
}

public String getBrand() {
return brand;
}

public void setBrand(String brand) {
this.brand = brand;
}

public String getType() {
return type;
}

public void setType(String type) {
this.type = type;
}

// 定义发送短信的方法
public abstract void sendInfo();

// 定义打电话的方法
public abstract void call();

// 定义一个普通方法输出手机的品牌和型号
public void info(){
System.out.println("这是一款型号为"+this.getType()+"的"+this.getBrand()+"的手机");
}
}

// 普通手机
public class CommonHandSet extends HandSet implements PlayWiring{

public CommonHandSet(String brand, String type) {
super(brand, type);
}

@Override
public void sendInfo() {
System.out.println("发送文字信息.......");
}

@Override
public void call() {
System.out.println("开始语音通话......");
}

@Override
public void play(String inContent) {
System.out.println("开始播放音乐《"+inContent+"》......");
}
}

public class AptitudeHandSet extends HandSet implements NetWork,PlayWiring,TakePictures{

public AptitudeHandSet(String brand, String type) {
super(brand, type);
}

@Override
public void sendInfo() {
System.out.println("发送带图片与文字的信息......");
}

@Override
public void call() {
System.out.println("开始视频通话......");
}

@Override
public void networkConn() {
System.out.println("已经启动移动网络.......");
}

@Override
public void play(String inContent) {
System.out.println("开始播放视频《"+inContent+"》......");
}

@Override
public void tabkePictures() {
System.out.println("咔嚓.....拍照成功");
}
}

public class Test {
public static void main(String[] args) {

// 创建两个手机类对象
CommonHandSet commonHandSet = new CommonHandSet("索尼爱立信","G502c");

commonHandSet.info();
commonHandSet.play("热雪");
commonHandSet.call();
commonHandSet.sendInfo();

System.out.println("---------------------------");

AptitudeHandSet aptitudeHandSet = new AptitudeHandSet("HTC","T9100");
aptitudeHandSet.info();
aptitudeHandSet.networkConn();
aptitudeHandSet.play("小时代");
aptitudeHandSet.tabkePictures();
aptitudeHandSet.sendInfo();
aptitudeHandSet.call();
}
}

六、面向接口编程打印机

package com.learn.demo05;

public interface InkBox {

// 定义一个方法获取墨盒的颜色
public abstract String getColor();
}

public class BwInkBox implements InkBox{
@Override
public String getColor() {
return "黑白";
}
}

public class ColorInkBox implements InkBox{
@Override
public String getColor() {
return "彩色";
}
}

package com.learn.demo05;

public interface Paper {

// 定义方法获取纸张大小
public abstract String getSize();
}

package com.learn.demo05;

public class A4Paper implements Paper{
@Override
public String getSize() {
return "A4";
}

package com.learn.demo05;

public class B5Paper implements Paper{
@Override
public String getSize() {
return "B5";
}
}

public class Printer {
// 打印机需要有墨盒和纸张，但是没有说明是哪一种颜色的墨盒和哪一种规格的纸张
// 定义属性，使用private进行封装
private InkBox inkBox;
private Paper paper;

public Printer() {
}

public Printer(InkBox inkBox, Paper paper) {
this.inkBox = inkBox;
this.paper = paper;
}

public InkBox getInkBox() {
return inkBox;
}

public void setInkBox(InkBox inkBox) {
this.inkBox = inkBox;
}

public Paper getPaper() {
return paper;
}

public void setPaper(Paper paper) {
this.paper = paper;
}

// 输出打印信息
public void show(){
System.out.println("使用"+this.getInkBox().getColor()+"墨盒在"+this.getPaper().getSize()+"纸张上打印");
}
}

import java.io.*;

public class Test {

public static void main(String[] args) throws FileNotFoundException {

// 接口不能直接实例化，可以使用多态的形式将接口的引用指向实现类的实例
// InkBox inkBox = new InkBox();
InkBox inkBox = new BwInkBox();
// Paper paper = new Paper();
Paper paper = new A4Paper();
paper = new B5Paper();
inkBox = new ColorInkBox();

// 使用有参构造方法创建一个打印机类Printer类对象
// public Printer(InkBox inkBox, Paper paper)
Printer printer = new Printer(inkBox,paper);
// 输出打印机信息
printer.show();

       // 使用黑白墨盒在B5纸张上打印
// paper = new B5Paper();
// Printer printer2 = new Printer(inkBox,paper);
// printer2.show();

// inkBox = new ColorInkBox();
// Printer printer3 = new Printer(inkBox,paper);
// printer3.show();

// paper = new A4Paper();
// Printer printer4 = new Printer(inkBox,paper);
// printer4.show();

/*
* 在调用一个方法的时候，不管这个方法是普通方法还是构造方法，都只需要按照参数列表的要求传递参数
* 1）如果方法需要的是基本数据类型的数据，传递基本数据类型的数据
* 2）如果方法需要的是一个具体的类，传递这个类的对象
* 3）如果方法需要的是一个抽象类或者接口类型的数据，传递这个抽象类的子类对象或者接口的实现类对象
* 4）如果方法需要的是一个数组，按照要求的数组类型传递数组引用
* */

// 根据方法需要的类型传递参数，没有就创建
// 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例
File file = new File("F:/a.txt");
InputStream in = new FileInputStream(file);
Reader reader = new InputStreamReader(in);

BufferedReader bufferedReader = new BufferedReader(reader);

}
}

七、接口使用

1）接口中的成员变量

默认都是public static final的，必须初始化

2）接口中的方法

默认都是public abstract的

3）接口没有构造方法，不能被实例化

4）一个接口不能实现另一个接口，但可以继承多个其它接口

5）一个类必须实现接口抽象方法（implements）除非这个类也是抽象类

/*
* 类与类之间是继承关系，单根继承，一个类只能直接继承另一个类
* 类与接口之间是实现关系，多实现，一个类可以实现多个接口，多个接口之间使用逗号,隔开
* 接口与接口之间是继承关系，多继承，一个接口可以继承多个接口
* */
public interface Demo01 {

// 接口中的变量都是静态常量值，默认修饰符public static final
// int num = 100;
public static final int num = 100;

// 接口中没有构造方法
// public Demo01(){}

void m1();
}

// 一个类实现了一个接口，必须将接口中的方法都进行重写，如果不重写，该类要定义为抽象类
public class Demo01Son implements Demo01{

public static void main(String[] args) {

Demo01 demo01 = new Demo01Son();
System.out.println(demo01.num);

// demo01.num = 200;
}

@Override
public void m1() {

}
}