1 接口概述
接口： 特殊的抽象类，使用方式及组成部分都与抽象类类似
语法： interface implements
注意： 在接口中只能定义公开的静态常量及公开的抽象方法
接口与抽象类的异同：
相同点：
可以编译成字节码文件
都不能具体化
都可以作为引用对象(多态)
都可以使用Object(祖宗类)的方法（继承）
不同点:
接口属性都是公开的静态常量
接口方法都是公开的抽象方法
接口没有构造方法，动态代码块，静态代码块
问题：在接口中能否有非抽象方法？ 在jdk1.8中提供了default修饰的非抽象方法，一般很少使用
//定义一个接口，名字为MyInterface
interface MyInterface{
//public static final: 公开的静态常量
int SEX_MAN=1; //查看反编译工具
//public abstract: 公开的抽象方法
void test();
public default void show() {
}
}
//MyImpl实现类实现了MyInterface接口，提供两种处理方式：
//1.重写接口的抽象方法 2.把自身变为抽象类
/*abstract*/ class MyImpl implements MyInterface{
@Override
public void test() {
System.out.println("重写接口的抽象方法");
}
}
public class Test1 {
public static void main(String[] args) {
//MyInterface interface1 = new MyInterface(); //不能具体化
MyInterface interface1 = new MyImpl();
interface1.getClass(); //根据继承性, 可以调用Object的方法
}
}
2 接口代表一种能力
=========================接口直接引用实现多态=========================
什么是接口：
从微观上讲，接口代表着一种能力或约定
案例：喷火娃具备喷火能力，飞天娃具备飞天能力
//接口代表某种能力，方法的定义代码具体能力体现
interface Fireable{ //可喷火的接口
void fire(); //可喷火的能力体现
}
interface Flyable{
void fly(); //可飞天的能力体现
}
//接口可以多实现
class Person implements Fireable,Flyable{
String name;
public Person(String name) {
this.name = name;
}
@Override //因为接口的抽象方法是public权限，所以实现类重写方法的权限必须是public
public void fire() {
System.out.println(name+"正在喷火");
}
@Override
public void fly() {
System.out.println(name+"正在飞天");
}
public void eat() {
System.out.println(name+"很能吃..");
}
}
public class Test {
public static void main(String[] args) {
//接口直接赋值方式实现多态： 接口引用指向实现类对象，可调用实现类重写方法
Fireable fireable = new Person("喷火娃");
fireable.fire();
Flyable fiFlyable = new Person("飞天娃");
fiFlyable.fly();
//问题：接口使用能否调用实现类独有方法？ 不能调用，除非强转
Person person = (Person) fireable; //强转后把接口当成Person看待
person.eat();
}
}====================接口与抽象类直接引用实现多态====================
应用： 接口与抽象类的综合应用
案例：狗是动物，具备叫的行为,动物自身有吃的方法，且狗具备可游泳的能力，它自身有一个打印方法
abstract class Animal{
public abstract void bark();
public void eat() {
System.out.println("动物正在吃..");
}
}
interface Swimable{
void swim(); //具备可游泳的能力体现
}
class Dog extends Animal implements Swimable{
@Override
public void bark() {
System.out.println("小狗正在叫..");
}
@Override
public void swim() {
System.out.println("小狗正在游泳..");
}
public void print() {
System.out.println("狗的自我介绍...独有方法");
}
}
public class Test2 {
public static void main(String[] args) {
//把狗当狗来看待，可以调父类吃的方法，可以调重写父类方法叫的方法，可以调自己独有的打印方法；可以调重写接口的方法
/*Dog dog = new Dog();
dog.bark(); dog.eat();dog.print();dog.swim();*/
//把狗当动物看待，可以调父类方法，可以调子类重写方法(抽象类实现多态)
Animal animal = new Dog(); //抽象类实现多态
animal.eat(); //调父类方法
animal.bark(); //调子类重写方法
//把狗当成可游泳的能力
Swimable swimable = new Dog(); //接口实现多态
swimable.swim(); //调实现类重写方法
}
}
=========================接口的细节========================
接口与类的相关关系：
1.类与类之间-----单继承
2.类与接口------多实现
3.接口与接口-----多继承----相当于实现类中，一定要将子接口中继承的所有接口都实现了
class Animal{
}
interface Runable{
}
interface Swimable{
}
//接口与接口，可以多继承； 如果实现类Tiaoable接口，必须把跑和游泳的接口都实现
interface Tiaoable extends Runable,Swimable{
int SEX_MAN=1; //常量接口（其实就是之前写的静态常量--状态值）
int SEX_WOMAN=0;
}
class Dog extends Animal implements Runable,Swimable{
}
public class Test1 {
public static void main(String[] args) {
int sex = Tiaoable.SEX_MAN; //通过接口名调用静态常量
if(sex==Tiaoable.SEX_MAN) {
System.out.println("男性");
}else if(sex==Tiaoable.SEX_WOMAN) {
System.out.println("女性");
}
}
}3 接口代表一种标准
==================接口以传参方式实现多态===================
宏观概念： 接口代表一种标准(接口以传参方式实现多态)
思考案例： 电脑连接usb标准的鼠标，硬盘等设备，这些设备都可以运转
分析：
类： 电脑类 usb接口 鼠标类 硬盘类
方法： 连接 运转 运转 运转
接口的好处：
使程序的耦合度降低,更自然地使用多态
更容易更换具体实现，及更容易使用框架(后续会学习)i
nterface USB{ //遵循usb标准
void run();
}
class Mouse implements USB{
@Override
public void run() {
System.out.println("鼠标正在运转...");
}
}
class Disk implements USB{
@Override
public void run() {
System.out.println("硬盘正在运转...");
}
}
class Computer{
public void connect(USB usb) { //USB usb=new Mouse();
usb.run(); //接口回调：谁传给我，我就回调谁
}
}
public class Test1 {
public static void main(String[] args) {
Computer computer = new Computer();
computer.connect(new Mouse()); //电脑连接鼠标
computer.connect(new Disk()); //电脑连接硬盘
}
}
====================接口及抽象类实现多态===================
案例: 人开门； 安全门，超级防盗门都是门，具备开的行为描述;安全门局部指纹识别标准；超级防盗门具备指纹识别和人脸识别标准
分析：
类: 人 安全门 超级防盗门， 门， 指纹识别， 人脸识别
方法： 开，指纹检测，人脸 描述，1标准 描述，2标准 开的描述 标准 标准
面向对象设计原则：ISP原则：
接口隔离原则： 接口与接口之间是隔离的，往往一个接口只放一种方法
abstract class Door{
public abstract void info(); //开的行为描述
}
class SafeDoor extends Door implements IHandler{
@Override
public void info() {
System.out.println("安全门描述....");
}
@Override
public void handlerStandard() {
System.out.println("安全门的指纹识别检测...");
}
}
class SuperDoor extends Door implements IHandler,IFace{
@Override
public void info() {
System.out.println("超级防盗门描述....");
}
@Override
public void faceStandard() {
System.out.println("超级门的人脸识别...");
}
@Override
public void handlerStandard() {
System.out.println("超级门的指纹识别...");
}
}
interface IHandler{ //指纹检测接口
void handlerStandard();
}
interface IFace{ //人脸检测接口
void faceStandard();
}
class Person{
public void open(Door door) {//传参形式实现多态
door.info(); //门的描述--谁传给我，就就调谁
}
public void handlerCheck(IHandler handler) {
handler.handlerStandard(); //指纹识别的检测标准
}
public void faceCheck(IFace face) {
face.faceStandard(); //人脸识别的检测标准
}
}
public class Test2 {
public static void main(String[] args) {
Person person = new Person();
//------------抽象类实现多态------------
person.open(new SafeDoor()); //人开安全门
person.open(new SuperDoor()); //人开超级门
//------------接口实现多态--------------
person.handlerCheck(new SafeDoor()); //人指纹检测安全门
person.handlerCheck(new SuperDoor()); //人指纹检测超级门
person.faceCheck(new SuperDoor()); //人通过人脸检测超级门
}
}
浙公网安备 33010602011771号