文章目录
一、接口
1、接口概述
- 接口就是多个类的公共规范
- 接口是一种引用数据类型,最重要的就是其中的:抽象方法
2、接口定义的基本格式
public interface 接口名称{
// 接口内容
}
备注:关键字 class 换成 interface 之后,编译生成的字节码文件仍然是:(源代码).java ——> (字节码).class
接口使用的时候,应该注意:
- 接口中不能有静态代码块或者构造方法;
- 一个类的直接父类是唯一的,但是一个类可以同时实现多个接口。
接口中可以包含的内容:
- 如果是Java 7,那么接口中可以包含的内容有:
- 常量
- 抽象方法
- 如果是Java 8,还可以额外包含有:
- 默认方法
- 静态方法
- 如果是Java 9,还可以额外包含有:
- 私有方法
3、接口的抽象方法
3.1 接口抽象方法的定义
在任何版本的Java中,接口中都能定义抽象方法。
接口中定义抽象方法的格式:
(public) (abstract) 返回值类型 方法名称(参数列表);
注意:抽象方法是没有方法体的。
注意事项:
- 接口当中的抽象方法,修饰符必须是两个固定的关键字:public abstract;
- 这两个关键字修饰符(public abstract),可以选择性地省略;
- 方法的三要素,可以随意定义。
示例
接口MyInterfaceAbstract:
public interface MyInterfaceAbstract {
// 这是一个抽象方法
public abstract void methodAbs1();
// 这也是抽象方法
abstract void methodAbs2();
// 这也是抽象方法
public void methodAbs3();
// 这也是抽象方法
void methodAbs4();
}
3.2 接口抽象方法的使用
接口中抽象方法的使用步骤:
- 接口不能直接使用,必须有一个“实现类”来“实现”该接口;
实现类的定义格式:
public class 实现类名称 implements 接口名称 {
// ...
}
- 接口的实现类必须重写(实现)接口中所有的抽象方法;
(重写)实现:也就是将接口中的抽象方法去掉abstract关键字,加上方法体大括号
- 创建实现类的对象,进行使用。
注意事项:
- 如果实现类并没有重写接口中所有的抽象方法,那么这个实现类自己也就是是抽象类。
实现类:MyInterfaceAbstractImpl 【实现】 接口:MyInterfaceAbstract
public class MyInterfaceAbstractImpl implements MyInterfaceAbstract {
@Override // (重写)实现所有接口的抽象方法
public void methodAbs1() {
System.out.println("这是第一个方法!");
}
@Override
public void methodAbs2() {
System.out.println("这是第二个方法!");
}
@Override
public void methodAbs3() {
System.out.println("这是第三个方法!");
}
@Override
public void methodAbs4() {
System.out.println("这是第四个方法!");
}
}
创建实现类对象,并使用:
public class Demo01Interface {
public static void main(String[] args) {
// 错误写法!不能直接new接口对象使用,必须有一个“实现类”来实现该接口
// MyInterfaceAbstract inter = new MyInterfaceAbstract();
// 创建实现类的对象使用
MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
impl.methodAbs1();
impl.methodAbs2();
}
}
4、接口的默认方法
回到目录
从Java 8开始,接口里允许定义默认方法。
4.1 接口默认方法的定义
接口默认方法的格式:(默认方法有方法体)
(public) default 返回值类型 方法名称(参数列表) {
// 方法体
}
接口里的默认方法,不是必须要被被实现类重写的,但是可以被重写。
【接口中的默认方法,不能省略default关键字】
4.2 接口默认方法的使用
- 接口的默认方法, 可以通过接口实现类对象直接调用;
- 接口的实现类, 可以对接口的默认方法进行重写(也可以不重写默认方法!).
备注:
- 接口当中的默认方法,可以解决接口升级的问题;
- Lambda表达式;
- 函数式编程, 接口的默认方法可以拼接函数模型.
接口MyInterfaceDefault:
public interface MyInterfaceDefault {
// 抽象方法1
public abstract void methodAbs1();
// 当想要增加一个抽象方法2来升级接口时,必须要在其实现类里面实现所有的抽象方法,不方便.
// 不如直接加上一个默认方法,还不用实现
// public abstract void methodAbs2();
// 默认方法
public default void methodDefault() {
System.out.println("这是新添加的默认方法");
}
}
实现类MyInterfaceDefaultA也还是一个抽象类
public class MyInterfaceDefaultA implements MyInterfaceDefault {
@Override
public void methodAbs1() {
System.out.println("实现了抽象方法,AAA");
}
}
public class MyInterfaceDefaultB implements MyInterfaceDefault {
@Override
public void methodAbs() {
System.out.println("实现了抽象方法,BBB");
}
@Override // 默认方法可以不用重写! 也可以重写
public void methodDefault() {
System.out.println("实现类B覆盖重写了接口的默认方法");
}
}
调用接口:
public class Demo02Interface {
public static void main(String[] args) {
// 创建了实现类对象
MyInterfaceDefaultA a = new MyInterfaceDefaultA();
a.methodAbs1(); // 调用抽象方法1,实际运行的是实现类A中重写抽象方法1后的方法。
// 调用默认方法,如果实现类当中没有,会向上找接口
a.methodDefault(); // 这是接口中新添加的默认方法
System.out.println("==========");
MyInterfaceDefaultB b = new MyInterfaceDefaultB();
b.methodAbs1();
b.methodDefault(); // 实现类B重写了接口的默认方法, 会调用实现类B中的重写的默认方法
}
}
5、接口的静态方法
回到目录
从Java8开始, 接口当中允许定义静态方法。
静态跟对象没有关系,静态只跟类有关系
5.1 接口中静态方法的定义
接口中静态方法定义的格式:
(public) static 返回值类型 方法名称(参数列表){
// 方法体
}
提示:就是将abstract或者default换成static关键字即可,带上方法体。
5.2 接口静态方法的使用
- 接口静态方法使用的格式
通过接口名称,直接调用其中的静态方法。
格式:
接口名称.静态方法名(参数);
- 注意:不能通过接口实现类的对象来调用接口中的静态方法
接口MyInterfaceStatic:
public interface MyInterfaceStatic {
// 接口的静态方法
public static void methodStatic() {
System.out.println("这是接口的静态方法!");
}
}
调用:
public class Demo03Interface {
public static void main(String[] args) {
// 不能通过创建接口的实现类对象来调用接口中的静态方法!
// 静态跟对象没有关系,静态只跟类有关系,没必要创建对象,直接就可以用类名称调用
// 直接通过接口名称调用静态方法
MyInterfaceStatic.methodStatic();
}
}
6、接口的私有方法
回到目录
从Java9开始,接口当中允许定义私有方法。
接口的私有方法只能被接口自己使用,不能被实现类或者别人使用
6.1 接口私有方法概述
为了解决接口中多个默认(或者静态)方法之间重复代码的问题,可以将重复的代码抽取成一个共有的方法,但这个方法不能让实现类使用,要私有化。这样抽取出来的私有的公共方法,就是接口的私有方法。
6.2 接口私有方法的定义
- 普通私有方法,解决多个【默认方法】之间重复代码问题
格式:
private 返回值类型 方法名称(参数列表){
方法体
}
- 静态私有方法,解决多个【静态方法】之间重复代码问题
格式:
private static 返回值类型 方法名称(参数列表){
方法体
}
6.3 接口私有方法的使用
示例如下:
接口A:
public interface MyInterfacePrivateA {
public default void methodDefault1() {
System.out.println("默认方法1");
methodCommon(); // 只有接口才能访问私有方法!
}
public default void methodDefault2() {
System.out.println("默认方法2");
methodCommon(); // 只有接口才能访问私有方法!
}
private void methodCommon() { // 将公共的默认方法,变为普通私有方法
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");
}
}
接口A的实现类:
public class MyInterfacePrivateAImpl implements MyInterfacePrivateA {
public void methodAnother() {
// 在接口中,没有将公共的默认方法私有化之前,可以直接访问到了接口中的默认方法,这样在逻辑上是错误的!
// methodCommon();
}
}
接口B:
public interface MyInterfacePrivateB {
public static void methodStatic1() {
System.out.println("静态方法1");
methodStaticCommon();
}
public static void methodStatic2() {
System.out.println("静态方法2");
methodStaticCommon();
}
private static void methodStaticCommon() { // 静态私有方法,解决多个静态方法之间重复代码问题
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");
}
}
接口B的实现类:
public class Demo04Interface {
public static void main(String[] args) {
MyInterfacePrivateB.methodStatic1(); // 静态方法不用new对象,直接用类名引用静态方法
MyInterfacePrivateB.methodStatic2();
// 错误写法!
// MyInterfacePrivateB.methodStaticCommon();
}
}
7、接口中的常量的定义与使用
回到目录
接口中可以定义“成员变量”,但必须使用public static final三个关键字进行修饰。从效果上看,这其实就是接口的常量。
7.1 接口中的常量的定义
接口中常量定义的格式:
(public) (static) (final) 数据类型 常量名称 = 数据值;
备注:
一旦使用final关键字进行修饰,说明不可改变。
注意事项:
- 接口当中的常量,可以省略public static final,注意:不写也照样是这三个;
- 接口当中的常量,必须要进行赋值;不能不赋值;
- 接口中常量的名称,使用完全大写的字母,用下划线进行分隔(推荐命名规则)。
7.2 接口中的常量的使用
- 直接用接口名引用接口的常量就行
定义一个接口:
public interface MyInterfaceConst {
// 这其实就是一个常量,一旦赋值,不可以修改
public static final int NUM_OF_MY_CLASS = 12;
}
使用接口中的常量:【直接用接口名引用接口中的常量就可以】
public class Demo05Interface {
public static void main(String[] args) {
// 访问接口当中的常量
System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS);
}
}
8、接口中可包含内容的小结
在Java 9+版本中,接口的内容可以有:
- 成员变量其实是常量
格式:
[public] [static] [final] 数据类型 常量名称 = 数据值;
注意:
常量必须进行赋值,而且一旦赋值不能改变。
常量名称完全大写,用下划线进行分隔。 - 接口中最重要的就是抽象方法
格式:
[public] [abstract] 返回值类型 方法名称(参数列表);
注意:
实现类必须覆盖重写接口所有的抽象方法,除非实现类是抽象类。 - 从Java 8开始,接口里允许定义默认方法
格式:
[public] default 返回值类型 方法名称(参数列表) { 方法体 }
注意:
默认方法也可以被覆盖重写 - 从Java 8开始,接口里允许定义静态方法
格式:
[public] static 返回值类型 方法名称(参数列表) { 方法体 }
注意:
应该通过接口名称进行调用,不能通过实现类对象调用接口静态方法 - 从Java 9开始,接口里允许定义私有方法
格式:
普通私有方法:private 返回值类型 方法名称(参数列表) { 方法体 }
静态私有方法:private static 返回值类型 方法名称(参数列表) { 方法体 }
注意:
private的方法只有接口自己才能调用,不能被实现类或别人使用。
9、接口的多实现
在继承中,一个子类只能继承一个父类。
在接口中,一个实现类是可以实现多个接口的,这叫做接口的多实现。并且,一个类能继承一个父类,同时实现多个接口。
接口多实现的格式——实现类实现多个接口,还可以继承一个父类:
public class MyInterfaceImpl /*extends Object*/ implements MyInterfaceA, MyInterfaceB {
// 要覆盖重写【所有的抽象方法】
}
使用接口的注意事项:
- 接口是没有静态代码块或者构造方法的(接口没有构造方法,所以不能创建对象);
- 如果实现类所实现的多个接口当中,存在重复的抽象方法,那么只需要覆盖重写一次即可;
- 如果实现类没有覆盖重写所有接口当中的所有抽象方法,那么实现类就必须是一个抽象类;
- 如果实现类所实现的多个接口中,存在重复的默认方法,那么实现类一定要对冲突的默认方法进行重写;
在Java中,继承关系是优先于接口实现关系的。
- 如果一个类的直接父类当中的方法,和接口当中的默认方法产生了冲突,则会优先使用父类当中的方法。
10、接口的多继承
一个接口能继承另一个或者多个接口,这就是接口的多继承。接口的继承使用 e x t e n d s 关 键 字 \color{blue}{extends 关键字} extends关键字,子接口会继承父接口的方法。
- 类与类之间是单继承的,一个子类的直接父类只有一个;
- 类与接口之间是多实现的,一个类可以实现多个接口;
- 接口与接口之间是多继承的。
注意事项:
- 多个父接口当中的【抽象方法】如果重复,没关系,因为抽象方法没有方法体;
- 多个父接口当中的【默认方法】如果重复,那么子接口必须进行默认方法的重写,而且【必须带着default关键字】!因为接口当中的default关键字是不能省略的。
- 要注意比较:继承中,子类(不是子接口)重写默认方法时,default关键字不可以保留;但子接口重写默认方法时,一定要写上default关键字!
示例:
接口A:
public interface MyInterfaceA {
public abstract void methodA(); // 抽象方法
public abstract void methodCommon(); // 接口B中也有的抽象方法
public default void methodDefault() { // 与接口B重复的默认方法
System.out.println("AAA");
}
}
接口B:
public interface MyInterfaceB {
public abstract void methodB();
public abstract void methodCommon();
public default void methodDefault() {
System.out.println("BBB");
}
}
多继承的子接口:
public interface MyInterface extends MyInterfaceA, MyInterfaceB {
public abstract void method();
@Override
public default void methodDefault() { // 子接口必须要重写重复的默认方法,还要带上default关键字
}
}
实现子接口的实现类:
public class MyInterfaceImpl implements MyInterface {
@Override
public void method() { // 子接口也是一个抽象的接口,重写抽象方法
}
@Override
public void methodA() {
}
@Override
public void methodB() {
}
@Override
public void methodCommon() {
}
}
二、多态
回到目录
多态的弊端:无法使用子类【特有】的内容(属性,方法)。
1、多态的格式与使用
代码当中体现多态性,其实就是一句话:父类引用指向子类对象。“左父右子就是多态”
多态的格式:
父类名称 对象名 = new 子类名称();
或者:
接口名称 对象名 = new 实现类名称();
示例
父类:
public class Fu {
public void method() {
System.out.println("父类方法");
}
public void methodFu() {
System.out.println("父类特有方法");
}
}
子类:
public class Zi extends Fu {
@Override
public void method() {
System.out.println("子类方法");
}
}
使用:
public class Demo01Multi {
public static void main(String[] args) {
// 使用多态的写法:左父右子
// 父类引用指向子类对象
Fu obj = new Zi(); // 右边的子类就被当作父类来看待
obj.method(); // 成员方法,看等号右边new的是谁,就是调用谁的成员方法 ——> 子类的method()
obj.methodFu(); // 子类没有,就往父类上找
}
}
2、多态中成员变量的使用
多态中成员变量访问的两种方式(与普通成员变量一样):
- 直接通过对象引用访问成员变量:看(创建对象时)等号左边new的是谁(哪个类),优先用谁的成员变量,没有则向上找;
- 间接通过成员方法访问成员变量:看该方法属于谁(哪个类),优先用谁(那个类)的成员变量,没有则向上找。
3、多态中成员方法的使用
在多态的代码当中,成员方法的访问规则是:看new的是谁(哪个类),就优先用谁(这个类的成员方法),没有则向上找。(与普通的成员方法一样)
口诀(只适用于成员方法,不适用于成员变量):编译看左边,运行看右边
对比一下:
- 成员变量:编译看左边,运行还看左边。
- 成员方法:编译看左边,运行看右边。
父类:
public class Fu /*extends Object*/ {
int num = 10;
public void showNum() {
System.out.println(num);
}
public void method() {
System.out.println("父类方法");
}
public void methodFu() {
System.out.println("父类特有方法");
}
}
子类:
public class Zi extends Fu {
int num = 20;
int age = 16;
@Override
public void showNum() {
System.out.println(num);
}
@Override
public void method() {
System.out.println("子类方法");
}
public void methodZi() {
System.out.println("子类特有方法");
}
}
使用:
public class Demo02MultiMethod {
public static void main(String[] args) {
Fu obj = new Zi(); // 左父右子,多态的写法。
obj.method(); // 父子都有,优先用子
obj.methodFu(); // 子类没有,父类有,向上找到父类
// 编译看左边,左边是Fu,但是Fu类中没有methodZi()方法,所以编译报错。
// obj.methodZi(); // 错误写法!
}
}
4、使用多态的好处
5、对象的转型
5.1 对象的向上转型
对象向上转型,就是多态的写法(父类引用指向子类对象)
- 对象向上转型一定是安全的,从小范围到大范围。但也有一个【弊端】:对象一旦向上转型为父类,那么就无法调用子类原本【特有】的内容。
(转型为父类,就不能调用子类【特有】的方法了。多态中成员变量和方法的“编译看左”就是这个理,左边是父类,编译时看父类有没有那个内容,没有就报错!) - 解决方案:使用对象的向下转型(还原成原本的样子)。
5.2 对象的向下转型
对象的向下转型,其实就是一个【还原】的动作。向下转型一定要进行instanceof判断,否则会有类转换异常。
格式:子类名称 对象名 = (子类名称)父类对象;
含义:将父类对象,【还原】成为本来的子类对象。类似于基本数据类型的强制类型转换,要保证没有“精度损失”,比如10.0可以转为int类型,而10.5不可以转为int类型,会有精度损失。
示例
父类Animal:
public abstract class Animal {
public abstract void eat();
}
子类Cat:
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
// 子类特有方法
public void catchMouse() {
System.out.println("猫抓老鼠");
}
}
子类Dog:
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃SHIT");
}
public void watchHouse() {
System.out.println("狗看家");
}
}
使用:
public class Demo01Main {
public static void main(String[] args) {
// 对象的向上转型,就是:父类引用指向之类对象。
Animal animal = new Cat(); // 本来创建的对象是一只猫Cat,向上转型为动物Animal
animal.eat(); // 猫吃鱼————父类,子类中有都有方法eat(),因为new的是子类,就使用子类重写的eat()方法
// 父类中没有抽象方法catchMouse();
// animal.catchMouse(); // 错误写法!
// 对象向上转型为父类之后,就不可以向下使用子类【特有】的内容了,共有的内容,还是可以用子类的。“编译看左有没有”
// 向下转型,进行“还原”动作,从动物还原回了猫
Cat cat = (Cat) animal; // 类似 int a = (int) 10.0; 由于不会有精度损失,可以直接转换
cat.catchMouse(); // 猫抓老鼠
// 下面是错误的向下转型
// 本来new的时候是一只猫,现在非要当做狗
// 错误写法!编译不会报错,但是运行会出现异常:
// java.lang.ClassCastException,类转换异常
Dog dog = (Dog) animal; // 错误的向下转换,ClassCastException。
}
}
但是,怎么得知父类引用的子类对象,原本是什么子类呢?
6、instanceof 关键字进行类型判断
如何才能知道一个父类引用的对象,本来是什么子类?
格式:
对象(或者对象引用) instanceof 类名称
这将会得到一个boolean值结果,也就是判断前面的对象能不能当做后面类型的实例。
承接上面的父类,子类
使用:
public class Demo02Instanceof {
public static void main(String[] args) {
Animal animal = new Dog(); // 本来是一只狗,向上转型为动物animal
animal.eat(); // 狗吃SHIT
// 如果希望掉用子类特有方法,需要向下转型
// 判断一下父类引用animal本来是不是Dog
if (new Dog() instanceof Dog) { // new Dog() 就是对象了,也可以写成对象引用animal
Dog dog = (Dog) animal;
dog.watchHouse();
}
// 判断一下animal本来是不是Cat
if (animal instanceof Cat) {
Cat cat = (Cat) animal;
cat.catchMouse();
}
giveMeAPet(new Dog());
}
public static void giveMeAPet(Animal animal) { // 不知道传入的具体动物是啥
if (animal instanceof Dog) { // 如果动物是狗
Dog dog = (Dog) animal; // 向下转型,得先判断一下,否则容易出现类转换异常
dog.watchHouse();
}
if (animal instanceof Cat) {
Cat cat = (Cat) animal;
cat.catchMouse();
}
}
}
三、接口多态的综合案例
1、分析
2、实现
USB接口:
public interface USB {
// 都是抽象方法
public abstract void open(); // 打开设备
public abstract void close(); // 关闭设备
}
Computer类:
public class Computer {
public void powerOn() {
System.out.println("笔记本电脑开机");
}
public void powerOff() {
System.out.println("笔记本电脑关机");
}
// 使用USB设备的方法,使用接口作为方法的参数列表
public void useDevice(USB usb) {
usb.open(); // 打开设备
if (usb instanceof Mouse) { // 向下转型,一定要先进行判断
Mouse mouse = (Mouse) usb; // 向下转型
mouse.click();
} else if (usb instanceof Keyboard) { // 先判断
Keyboard keyboard = (Keyboard) usb; // 向下转型
keyboard.type();
}
usb.close(); // 关闭设备
}
}
实现类键盘:
// 键盘是一个USB设备
public class Keyboard implements USB {
@Override
public void open() {
System.out.println("打开键盘");
}
@Override
public void close() {
System.out.println("关闭键盘");
}
public void type() {
System.out.println("键盘输入");
}
}
实现类鼠标:
// 鼠标也是一个USB设备
public class Mouse implements USB {
@Override
public void open() {
System.out.println("打开鼠标");
}
@Override
public void close() {
System.out.println("关闭鼠标");
}
public void click() {
System.out.println("鼠标点击");
}
}
使用:
public class DemoMain {
public static void main(String[] args) {
// 首先创建一个笔记本电脑对象
Computer computer = new Computer();
computer.powerOn();
// 准备一个鼠标,供电脑使用
// Mouse mouse = new Mouse();
// 首先进行向上转型,由原来的Mouse转型成USB
USB usbMouse = new Mouse(); // 左父右子,多态写法
// 参数是USB类型,我正好传递进去的就是USB鼠标
computer.useDevice(usbMouse);
// 创建一个USB键盘对象
Keyboard keyboard = new Keyboard(); // 没有使用多态写法
// 方法参数是USB类型,传递进去的是实现类对象,实现类可以向上转型为接口的类型! 类似于下面的基本数据类型的自动转换。
computer.useDevice(keyboard); // 正确写法!也自动发生了向上转型,相当于 USB usb = keyboard = new keyboard();
// 使用子类对象,匿名对象,也可以
// computer.useDevice(new Keyboard()); // 也是正确写法
computer.powerOff();
System.out.println("==================");
method(10.0); // 正确写法,double --> double
method(20); // 正确写法,int --> double
int a = 30;
method(a); // 正确写法,int --> double
}
public static void method(double num) {
System.out.println(num);
}
}