第一章 接口
1.1 概述
- 接口:是Java语言中一种引用类型,是方法的集合,如果说累的饿内部封装了成员变量,构造方法和成员变量,那么接口的内部主要就是封装了方法,包含抽象抽象方法(JDK7及以前),默认方法和静态方法(JDK 8),私有方法(JDK 9)。
- 接口的定义:它与定义类方式相似,但是使用interface关键字,他也会被编译成class文件,但一定要明确它并不是类,而是另外一种引用数据类型。
- 接口的使用:它不能创建对象,但是可以被实现(implements,类似于被继承)。一个实现接口的类(可以看做是接口的子类),需要实现接口中所有的抽象方法,创建该类的对象,就可以调用该方法了,狗则它必须是一个抽象类。
1.2 定义格式
public interface 接口名称 {
// 抽象方法
// 默认方法
// 静态方法
// 私有方法
}
- 含有抽象方法:
- 抽象方法使用abstract关键字修饰,可以省略,没有方法体。该方法供子类实现使用。
- 代码如下
public interface InterFaceName {
public abstract void method();
}
- 含有默认方法和静态方法
- 默认方法:使用default关键字修饰,不可省略,供子类调用或子类重写。
- 静态方法:使用static修饰,供接口直接调用。
- 代码如下:
public interface InterFaceName {
public default void method() {
// 执行语句
}
public static void method2() {
// 执行语句
}
}
- 含有私有方法和私有静态方法
- 私有方法:使用private修饰,供接口中的默认方法或者静态方法调用。
- 代码如下;
public interface InterFaceName {
private void method() {
// 执行语句
}
}
1.3 基本的实现
- 概述:类与接口的关系为实现关系,即类实现接口,该类可以成为接口的实现类,也可以成为接口的子类。实现的动作类似继承,格式相仿,只是关键字不同,实现使用implements关键字。
- 非抽象子类实现接口:
- 必须重写接口中的所有抽象方法。
- 继承了接口的默认方法,即可以直接调用,也可以重写。
- 实现格式:
class 类名 implements 接口名 {
// 重写接口中的抽象方法(必须)
// 重写接口中的默认方法(可选)
}
抽象方法的使用
必须全部实现,代码如下:
定义接口:
/*
* 在任何版本的java中,接口都能定义抽象方法:
* public abstract 返回值类型 方法名称(参数列表) {
*
* }
*
* 注意事项:
* 1、接口当中的抽象方法,修饰符必须是两个固定的关键字,public abstract
* 2、这两个关键字修饰符,可以选择性省略。
* 3、方法的三要素,可以随意定义。
*
* */
public interface MyInterfaceAbstract {
// 以下四种都是抽象方法
public abstract void methodAbs();
abstract void methodAbs1();
public void methodAbs2();
void methodAbs3();
}
定义实现类:
public class MyInterfaceAbstractImpl implements MyInterfaceAbstract {
@Override
public void methodAbs() {
System.out.println("第一个方法!");
}
@Override
public void methodAbs1() {
System.out.println("第二个方法!");
}
@Override
public void methodAbs2() {
System.out.println("第三个方法!");
}
@Override
public void methodAbs3() {
System.out.println("第四个方法!");
}
}
定义测试类:
/*
* 接口就是多个类的公共规范。
* 接口是一种引用数据类型,最重要的内容就是其中的抽象方法。
* 格式:
* public interface 接口名称 {
* // 接口内容
* }
*
* 备注:换成了关键字interface之后,编译生成的字节码文件仍然是,.java --> .class
*
* 如果是Java 7,那么接口中可以包含的内容有:
* 1、常量
* 2、抽象方法
*
* 如果是java 8,还可以额外包含有:
* 3、默认方法
* 4、静态方法
*
* 如果是java 9,还可以额外包含有:
* 5、私有方法
*
* 接口使用步骤:
* 1、接口不能直接使用,必须要有一个"实现类"来实现该接口。
* 格式:
* public class 实现类名称 implements 接口名称 {
* //...
* }
* 2、接口的实现类必须覆盖重写接口中所有的抽象方法。
* 3、创建实现类的对象来使用。
*
* 注意事项:
* 如果实现类并没有覆盖重写接口中所有的抽象方法,那么这个实现类自己就必须是抽象类。
* */
public class Demo01Interface {
public static void main(String[] args) {
// 错误写法,不能直接new接口对象使用
// MyInterfaceAbstract inter = new MyInterfaceAbstract();
// 创建实现类的对象使用
MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
impl.methodAbs();
}
}
默认方法的使用:
可以继承,可以重写,二选一,但是只能通过实现类的对象来调用。
继承默认方法,代码如下:
- 定义接口
/*
* 从Java 8开始,接口里允许定义默认方法。
* 格式:
* public default 返回值类型 方法名称() {
* // 方法体
* }
*
* 备注:接口当中的默认方法,可以解决接口升级的问题
* */
public interface MyInterfaceDefault {
// 抽象方法
public abstract void methodAbs();
// 新添加的方法改为默认方法就可以解决问题
public default void methodDefault() {
System.out.println("实现了一个默认方法");
}
}
- 定义实现类:
public class MyInterfaceDefaultA implements MyInterfaceDefault {
@Override
public void methodAbs() {
System.out.println("实现了抽象方法,AAA");
}
}
- 定义测试类
/*
* 1、接口的默认方法,可以通过接口实现类对象,直接调用。
* 2、接口的默认方法,也可以被接口实现类进行覆盖重写。
*
* */
public class Demo02Interface {
public static void main(String[] args) {
MyInterfaceDefaultA a = new MyInterfaceDefaultA();
a.methodAbs(); // 调用抽象方法,实际运行的是右侧实现类
// 调用默认方法,如果实现类当中没有,会向上找接口
a.methodDefault();
System.out.println("======================");
MyInterfaceDefaultB b = new MyInterfaceDefaultB();
b.methodAbs();
b.methodDefault();
}
}
重写默认方法,代码如下:
- 定义接口:
- 同上
- 定义实现类
public class MyInterfaceDefaultB implements MyInterfaceDefault {
@Override
public void methodAbs() {
System.out.println("实现了抽象方法,BBB");
}
@Override
public void methodDefault() {
System.out.println("B 覆盖重写了接口中的默认方法。");
}
}
- 定义测试类
- 同上
静态方法的使用
静态与.class文件相关,只能使用接口名调用,不可以通过实现类的类名或者实现类的对象调用,代码如下:
- 定义接口
public interface MyInterfaceStatic {
public static void methodStatic() {
System.out.println("这是接口的静态方法!");
}
}
- 定义实现类
public class MyInterfaceStaticImpl implements MyInterfaceStatic {
// 无法重写静态方法
}
- 定义测试类
/*
* 注意:不能通过接口实现类的对象去调用接口当中的静态方法。
* 正确用法:通过接口名称,直接调用其中的静态方法。
* 格式:
* 接口名称.静态方法名(参数);
*
* */
public class Demo03Interface {
public static void main(String[] args) {
// 创建了实现类对象
MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();
// 错误写法
// impl.methodStatic();
// 直接通过接口名称调用静态方法。
MyInterfaceStatic.methodStatic();
}
}
私有方法的使用
- 私有方法:只有默认方法可以调用。
- 私有静态方法:默认方法和静态方法都可以调用。
如果一个接口中有多个默认方法,并且方法中有重复的内容,呢么可以抽取出来,封装到私有方法中,供默认方法去调用,从设计的角度来说,私有的方法是对默认方法和静态方法的辅助。
- 定义接口:
/*
* 问题描述:
* 我们需要抽取一个共有方法,用来解决两个默认方法之间重复代码的问题。
* 但是这个共有方法不应该让实现类使用,应该是私有化的。
* 解决方法
* 从Java9开始,接口当中允许定义私有方法。
* 1、普通私有方法:解决多个默认方法之间重复代码问题。
* 格式:
* private 返回值类型 方法名称(参数列表) {
* 方法体
* }
* 2、静态私有方法:解决多个静态方法之间重复代码问题。
* 格式:
* private static 返回值类型 方法名称(参数列表) {
* 方法体
* }
*
* */
public interface MyInterfacePrivateA {
public default void methodDefaule1() {
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");
}
}
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");
}
}
1.4 接口的多实现
在前面的学习中,我们学到,一个类只能继承一个父类,而对于接口而言,一个类是可以实现多个接口的,这叫做接口的多实现。并且,一个类能继承一个父类,同时实现多个接口。
实现格式:
class 类名 [extends 父类名] implements 接口名1, 接口名2, ... {
// 重写接口中抽象方法[必须]
// 重写接口中的默认方法[不重名时可选]
}
抽象方法:
接口中,有多个抽象方法时,实现类必须重写所有抽象方法。如果抽象方法有重名的,只需要重写一次即可。代码如下;
- 定义多个接口:
public interface MyInterfaceA {
// 错误写法!接口不能有静态代码块
// static {
//
// }
// 错误写法!接口不能有构造方法
//public MyInterface(){}
public abstract void methodA();
public abstract void methodAbs();
public default void methodDefault() {
System.out.println("默认方法AAA");
}
}
public interface MyInterfaceB {
public abstract void methodB();
public abstract void methodAbs();
public default void methodDefault() {
System.out.println("默认方法BBB");
}
}
- 定义实现类:
public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {
@Override
public void methodA() {
System.out.println("覆盖重写了A方法!");
}
@Override
public void methodAbs() {
System.out.println("覆盖重写了AB接口都有的抽象方法。");
}
@Override
public void methodDefault() {
System.out.println("对多个接口中的重复的默认方法进行覆盖重写。");
}
@Override
public void methodB() {
System.out.println("覆盖重写了B方法!");
}
}
默认方法:
接口中,有多个默认方法时,实现类都可继承使用。如果默认方法有重名的,必须重写一次,代码如下:
- 定义多个接口:
public interface MyInterfaceA {
public abstract void methodA();
public abstract void methodComment();
public default void methodDefault() {
System.out.println("AAA");
}
}
public interface MyInterfaceB {
public abstract void methodB();
public abstract void methodComment();
public default void methodDefault() {
System.out.println("BBB");
}
}
- 定义实现类:
public class MyInterfaceImpl implements MyInterface {
@Override
public void method() {
}
@Override
public void methodA() {
}
@Override
public void methodB() {
}
@Override
public void methodComment() {
}
}
静态方法:
接口中,存在同名的静态方法并不会冲突,原因只能通过各自接口访问静态方法。
优先级问题
当一个类,即继承了一个父类,有实现了若干个接口时,父类中的成员方法与接口中的默认方法重名,子类就近选择执行父类的成员方法,代码如下:
- 定义接口
public interface MyInterface {
public default void method() {
System.out.println("接口的默认方法");
}
}
- 定义父类
public class Fu {
public void method() {
System.out.println("父类方法");
}
}
- 定义子类
public class Zi extends Fu implements MyInterface {
}
- 定义测试类
public class Demo01Interface {
public static void main(String[] args) {
Zi zi = new Zi();
zi.method();
}
}
1.5 接口的多继承
一个接口能继承另一个或者多个接口,这和类之间的继承比较相似,接口的继承使用extends关键字,自接口继承父接口的方法。如果父接口中的默认方法重名,那么子接口需要重写一次。代码如下:
- 定义父接口
interface A {
public default void method() {
System.out.println("AAAAAAAAAAAAAA");
}
}
interface B {
public default void method() {
System.out.println("BBBBBBBBBBBBBB");
}
}
- 定义子接口
interface D extends A, B {
@Override
public default void method() {
System.out.println("DDDDDDDDDDDDDD");
}
}
1.6 其他成员特点
- 接口中,无法定义成员变量,但是可以定义常量,其值不可以改变,默认使用public static final 修饰。
- 接口中,没有构造方法,不能创建对象。
- 接口中,没有静态代码块。
第二章 多态
2.1 概述
- 引入:多态是继封装、继承之后,面向对象对象的第三大特性。
- 定义
- 多态:是指同一行行为,具有多个不同的表现形式。
- 前提:
- 继承或者实现【二选一】
- 方法的重写【意义体现:不重写,无意义】
- 父类引用指向子类对象【格式体现】
2.2 多态的体现
多态体现的格式:
父类类型 变量名 = new 子类对象;
变量名.方法名();
- 注意:父类类型指子类对象继承父类类型,或者实现的父类接口类型。
代码如下:
Fu f = new Zi();
f.method();
- 注意:当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,执行的是子类重写后的方法。
代码如下:
- 定义父类:
public abstract class Animal {
public abstract void eat();
}
- 定义子类:
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
// 子类特有方法
public void catchMouse() {
System.out.println("猫抓老鼠");
}
}
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃骨头");
}
public void watchHouse() {
System.out.println("狗看家");
}
}
- 定义测试类:
/*
* 向上转型一定是安全的,没有问题的,正确的,但是也有一个弊端:
* 对象一旦向上转型为父类,那么就无法调用子类原本特有的内容
* 解决方法:用对象的向下转型。
*
* */
public class Demo01Main {
public static void main(String[] args) {
// 对象的向上转型,就是,父类引用指向子类对象
Animal animal = new Cat();
animal.eat();
// 向下转型,进行"还原"动作
Cat cat = (Cat) animal;
cat.catchMouse(); // 还原成功
// 下面是错误的向下转型
// 本来new的时候是一只猫,非要给他当作一只狗
// 错误写法,编译不会报错,但是运行会出现异常
Dog dog = (Dog) animal;
}
}
2.3 多态的好处
实际开发过程中,父类类型作为方法形式参数,传递子类对象给方法,进行方法的调用,更能体现出多态的扩展性与便利。代码如下:
- 定义父类:
public abstract class Animal {
public abstract void eat();
}
- 定义子类:
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃骨头");
}
}
- 定义测试类:
/*
* 如何才能知道一个父类引用的对象,本来是什么子类?
*
* 格式:
* 对象 instanceof 类型
* 这将得到一个boolean值结果,也就是判断前面的对象能不能当作后面类型的实例。
* */
public class Demo02Instanceof {
public static void main(String[] args) {
Animal animal = new Cat(); // 本来是一只猫
// 如果希望调用子类特有方法,需要向下转型
// 判断一下animal本来是不是Dog
if (animal instanceof Dog) {
Dog dog = (Dog) animal;
dog.watchHouse();
}
// 判断一下animal本来是不是Cat
if (animal instanceof Cat) {
Cat cat = (Cat) animal;
cat.catchMouse();
}
method(new Dog());
}
public static void method(Animal animal) {
// 如果希望调用子类特有方法,需要向下转型
// 判断一下animal本来是不是Dog
if (animal instanceof Dog) {
Dog dog = (Dog) animal;
dog.watchHouse();
}
// 判断一下animal本来是不是Cat
if (animal instanceof Cat) {
Cat cat = (Cat) animal;
cat.catchMouse();
}
}
}
- 注意:
- 由于多态特性的支持,method方法的Animal类型,是Cat和Dog的父类类型,父类类型接收子类对象,当然可以把Cat对象和Dog对象,传递给方法。
- 当eat方法执行时,多态规定,执行的是子类的重写的方法,那么效果自然与method方法一致。、
- 多态的好处体现在,可以使程序编写的更加简单,并有良好的扩展。
2.4 引用类型转换
多态的转型分为向上转型和向下转型两种:
向上转型
- 向上转型:多态本身是子类类型向父类类型向上转换的过程,这个过程是默认的。
- 当父类引用指向一个子类对象时,便是向上转型。
- 使用格式:
父类类型 变量名 = new 子类类型();
向下转型
- 向下转型:父类类型向子类类型向下转换的过程,这个过程是强制的。
- 一个已经向上转型的子类对象,将父类引用转为子类引用,可以使用强制类型转换的格式,便是向下转型。
- 使用格式:
子类类型 变量名 = (子类类型)父类变量名;
为什么要转型
当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误,也就是说,不能调用子类拥有,而父类没有的方法,编译都错误,更别说运行了。这也是多态给我们带来的麻烦。所以,想要调用子类特有的方法,必须做向下转型。
转型演示,代码如下:
定义类:
public abstract class Animal {
public abstract void eat();
}
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
// 子类特有方法
public void catchMouse() {
System.out.println("猫抓老鼠");
}
}
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃骨头");
}
public void watchHouse() {
System.out.println("狗看家");
}
}
定义测试类:
/*
* 向上转型一定是安全的,没有问题的,正确的,但是也有一个弊端:
* 对象一旦向上转型为父类,那么就无法调用子类原本特有的内容
* 解决方法:用对象的向下转型。
*
* */
public class Demo01Main {
public static void main(String[] args) {
// 对象的向上转型,就是,父类引用指向子类对象
Animal animal = new Cat();
animal.eat();
// 向下转型,进行"还原"动作
Cat cat = (Cat) animal;
cat.catchMouse(); // 还原成功
// 下面是错误的向下转型
// 本来new的时候是一只猫,非要给他当作一只狗
// 错误写法,编译不会报错,但是运行会出现异常
Dog dog = (Dog) animal;
}
}
注意:向下转型是危险的,必须保证对象本来就是该类型才能向下转型。例如:创建了Cat对象就不能向下转型成为Dog对象。所以:java提供了instanceof关键字,给引用变量的做类型校验,格式如下:
变量名 instanceof 数据类型
如果变量属于该数据类型,返回true
如果变量不属于该数据类型,返回false
- 代码演示:
/*
* 如何才能知道一个父类引用的对象,本来是什么子类?
*
* 格式:
* 对象 instanceof 类型
* 这将得到一个boolean值结果,也就是判断前面的对象能不能当作后面类型的实例。
* */
public class Demo02Instanceof {
public static void main(String[] args) {
Animal animal = new Cat(); // 本来是一只猫
// 如果希望调用子类特有方法,需要向下转型
// 判断一下animal本来是不是Dog
if (animal instanceof Dog) {
Dog dog = (Dog) animal;
dog.watchHouse();
}
// 判断一下animal本来是不是Cat
if (animal instanceof Cat) {
Cat cat = (Cat) animal;
cat.catchMouse();
}
method(new Dog());
}
public static void method(Animal animal) {
// 如果希望调用子类特有方法,需要向下转型
// 判断一下animal本来是不是Dog
if (animal instanceof Dog) {
Dog dog = (Dog) animal;
dog.watchHouse();
}
// 判断一下animal本来是不是Cat
if (animal instanceof Cat) {
Cat cat = (Cat) animal;
cat.catchMouse();
}
}
}
第三章 接口多态的综合案例
3.1 笔记本电脑
笔记本电脑通常具有使用USB设备的功能。在生产时,笔记本都预留了可以插入USB设备的USB接口,但具体是什么USB设备,笔记本厂商并不关心,只要符合USB规格的设备都可以。
3.2 案例分析
进行描述笔记本类,实现笔记本使用USB鼠标、USB键盘
- USB接口,包含开启功能,关闭功能
- 笔记本类,包含运行功能,关机功能,使用USB设备功能
- 鼠标类:要实现USB接口,并具备点击的方法
- 键盘类:实现USB接口,具备敲击的方法
3.3 案例实现
- 定义USB接口:
public interface USB {
public abstract void open();
public abstract void close();
}
- 定义鼠标类:
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 KeyBoard implements USB {
@Override
public void open() {
System.out.println("键盘开启");
}
@Override
public void close() {
System.out.println("键盘关闭");
}
public void type() {
System.out.println("键盘打字");
}
}
- 定义笔记本类
public class Laptop {
public void powerOn() {
System.out.println("笔记本电脑开机");
}
public void powerOff() {
System.out.println("笔记本电脑关机");
}
// 使用接口作为方法的参数
public void useDevice(USB usb) {
usb.open();
usb.close();
}
}
- 定义测试类:
public class DemoMain {
public static void main(String[] args) {
// 笔记本电脑
laptop laptop = new laptop();
laptop.powerOn();
// 创建一个鼠标
USB usb = new Mouse();
laptop.useDevice(usb);
// 创建一个鼠标
Mouse mouse = new Mouse();
// 方法参数是USB类型,传递进去的是实现类对象
laptop.useDevice(mouse); // 正确写法,向上转型
laptop.useDevice(new Mouse()); // 使用子类的匿名对象也是可以的
if (usb instanceof Mouse) {
Mouse mouse1 = (Mouse) usb; // 向下转型
mouse1.click();
}
laptop.powerOff();
}
}