目录
一、抽象类
1. 抽象类概念
抽象类的产生背景
1.多态的实现需要依赖继承与方法重写,但是前面的方式我们无法对子类是否重写方法做出要求,子类到底重写方法与否,重写哪些方法,全凭自愿,若需要对子类重写方法做出一些强制性的要求,就会用到抽象类
2.很多父类其实本身就是抽象的,只有在具体子类中方法才有具体含义,这些类也应当被定义为抽象类
在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的, 如果 一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。
在打印图形例子中 , 我们发现 , 父类 Shape 中的 draw 方法好像并没有什么实际工作 , 主要的绘制图形都是由 Shape的各种子类的 draw 方法来完成的 . 像这种没有实际工作的方法 , 我们可以把它设计成一个 抽象方法 (abstract method) , 包含抽象方法的类我们称为 抽象类(abstract class)。
2. 抽象类语法
在 Java 中,一个类如果被 abstract 修饰称为抽象类,抽象类中被 abstract 修饰的方法称为抽象方法,抽象方法不用给出具体的实现体。
// 抽象类:被abstract修饰的类
public abstract class Shape {
// 抽象方法:被abstract修饰的方法,没有方法体
abstract public void draw();
abstract void calcArea();
// 抽象类也是类,也可以增加普通方法和属性
public double getArea(){
return area;
}
protected double area; // 面积
}
注意:抽象类也是类,内部可以包含普通方法和属性,甚至构造方法。
3. 抽象类特性
3.1 抽象类不能直接实例化对象,抽象类必须有子类,抽象类不能自己实例化对象,要通过子类对象向上转型为其实例化
Shape shape = new Shape();
// 编译出错
Error:(30, 23) java: Shape是抽象的; 无法实例化
3.2 抽象方法不能是 private 的
abstract class Shape {
abstract private void draw();
}
// 编译出错
Error:(4, 27) java: 非法的修饰符组合: abstract和private
3.3 抽象方法不能被fifinal和static修饰,因为抽象方法要被子类重写
public abstract class Shape {
abstract final void methodA();
abstract public static void methodB();
}
// 编译报错:
// Error:(20, 25) java: 非法的修饰符组合: abstract和final
// Error:(21, 33) java: 非法的修饰符组合: abstract和static
3.4 抽象类必须被继承,并且继承后子类要重写父类中的抽象方法,否则子类也是抽象类,必须要使用 abstract 修饰
// 矩形类
public class Rect extends Shape {
private double length;
private double width;
Rect(double length, double width){
this.length = length;
this.width = width;
}
public void draw(){
System.out.println("矩形: length= "+length+" width= " + width);
}
public void calcArea(){
area = length * width;
}
}
//圆类
public class Circle extends Shape{
private double r;
final private static double PI = 3.14;
public Circle(double r){
this.r = r;
}
public void draw(){
System.out.println("圆:r = "+r);
}
public void calcArea(){
area = PI * r * r;
}
}
// 三角形类:
public abstract class Triangle extends Shape {
private double a;
private double b;
private double c;
@Override
public void draw() {
System.out.println("三角形:a = "+a + " b = "+b+" c = "+c);
}
// 三角形:直角三角形、等腰三角形等,还可以继续细化
//@Override
//double calcArea(); // 编译失败:要么实现该抽象方法,要么将三角形设计为抽象类
}
3.5 抽象类中不一定包含抽象方法,但是有抽象方法的类一定是抽象类3.6 抽象类中可以有构造方法,供子类创建对象时,初始化父类的成员变量3.7子类也是抽象类,可以选择性的重写抽象方法,即子类可以一个抽象方法都不重写
二、接口
1. 接口的概念
在现实生活中,接口的例子比比皆是,比如:笔记本上的 USB 口,电源插座等。电脑的 USB 口上,可以插: U 盘、鼠标、键盘 ... 所有符合 USB 协议的设备电源插座插孔上,可以插:电脑、电视机、电饭煲 ... 所有符合规范的设备通过上述例子可以看出: 接口就是公共的行为规范标准,大家在实现时,只要符合规范标准,就可以通用 。 在 Java 中,接口可以看成是:多个类的公共规范,是一种引用数据类型。
2. 语法规则
接口的定义格式与定义类的格式基本相同,将class关键字换成 interface 关键字,就定义了一个接口。
public interface 接口名称{
// 抽象方法
public abstract void method1(); // public abstract 是固定搭配,可以不写
public void method2();
abstract void method3();
void method4();
}
提示 :1. 创建接口时 , 接口的命名一般以大写字母 I 开头 .2. 接口的命名一般使用 " 形容词" 词性的单词 .3. 阿里编码规范中约定 , 接口中的方法和属性不要加任何修饰符号 , 保持代码的简洁性
3. 接口使用
接口不能直接使用,必须要有一个 " 实现类 " 来 " 实现 "该接口,实现接口中的所有抽象方法。子类要实现接口,使用implements关键字来表示子类实现接口,子类必须覆写接口中的所有抽象方法(前提 : 子类是普通类)
public class 类名称 implements 接口名称{
// ...
}
注意:子类和父类之间是extends 继承关系,类与接口之间是 implements 实现关系。子类的命名 : 以父类接口名称开头,以impl结尾
Messagelmpl => 一眼看上去就知道是IMessage接口的子类
实现一个笔记本电脑使用 USB 鼠标、 USB 键盘的例子:1. USB 接口:包含打开设备、关闭设备功能2. 笔记本类:包含开机功能、关机功能、使用 USB 设备功能3. 鼠标类:实现 USB 接口,并具备点击功能4. 键盘类:实现 USB 接口,并具备输入功能
// USB接口
public interface USB {
void openDevice();
void closeDevice();
}
// 鼠标类,实现USB接口
public class Mouse implements USB {
@Override
public void openDevice() {
System.out.println("打开鼠标");
}
@Override
public void closeDevice() {
System.out.println("关闭鼠标");
}
public void click(){
System.out.println("鼠标点击");
}
}
// 键盘类,实现USB接口
public class KeyBoard implements USB {
@Override
public void openDevice() {
System.out.println("打开键盘");
}
@Override
public void closeDevice() {
System.out.println("关闭键盘");
}
public void inPut(){
System.out.println("键盘输入");
}
}
// 笔记本类:使用USB设备
public class Computer {
public void powerOn(){
System.out.println("打开笔记本电脑");
}
public void powerOff(){
System.out.println("关闭笔记本电脑");
}
public void useDevice(USB usb){
usb.openDevice();
if(usb instanceof Mouse){
Mouse mouse = (Mouse)usb;
mouse.click();
}else if(usb instanceof KeyBoard){
KeyBoard keyBoard = (KeyBoard)usb;
keyBoard.inPut();
}
usb.closeDevice();
}
}
// 测试类:
public class TestUSB {
public static void main(String[] args) {
Computer computer = new Computer();
computer.powerOn();
// 使用鼠标设备
computer.useDevice(new Mouse());
// 使用键盘设备
computer.useDevice(new KeyBoard());
computer.powerOff();
}
}
4. 接口特性
4.1 接口类型是一种引用类型,但是不能直接new接口的对象
public class TestUSB {
public static void main(String[] args) {
USB usb = new USB();
}
}
// Error:(10, 19) java: day20210915.USB是抽象的; 无法实例化
4.2 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract(只能是 public abstract,其他修饰符都会报错)
public interface USB {
// Error:(4, 18) java: 此处不允许使用修饰符private
private void openDevice();
void closeDevice();
}
4.3 接口中的方法是不能在接口中实现的,只能由实现接口的类来实现
public interface USB {
void openDevice();
// 编译失败:因为接口中的方式默认为抽象方法
// Error:(5, 23) java: 接口抽象方法不能带有主体
void closeDevice(){
System.out.println("关闭USB设备");
}
}
4.4 重写接口中方法时,不能使用默认的访问权限
public interface USB{
void openDevice(); // 默认是public的
void closeDevice(); // 默认是public的
}
public class Mouse implements USB {
@Override
void openDevice() {
System.out.println("打开鼠标");
}
// ...
}
// 编译报错,重写USB中openDevice方法时,不能使用默认修饰符
// 正在尝试分配更低的访问权限; 以前为public
4.5 接口中可以含有变量,但是接口中的变量会被隐式的指定为 public static final 变量
public interface USB {
double brand = 3.0; // 默认被:final public static修饰
void openDevice();
void closeDevice();
}
public class TestUSB {
public static void main(String[] args) {
System.out.println(USB.brand); // 可以直接通过接口名访问,说明是静态的
// 编译报错:Error:(12, 12) java: 无法为最终变量brand分配值
USB.brand = 2.0; // 说明brand具有final属性
}
}
4.6 接口中不能有静态代码块和构造方法
public interface USB {
// 编译失败
public USB(){
}
{ } // 编译失败
void openDevice();
void closeDevice();
}
4.7 接口虽然不是类,但是接口编译完成后字节码文件的后缀格式也是.class4.8 如果类没有实现接口中的所有的抽象方法,则类必须设置为抽象类4.9 jdk8中:接口中还可以包含default方法。
5. 实现多个接口
在 Java 中,类和类之间是单继承的,一个类只能有一个父类,即 Java 中不支持多继承 ,但是 一个类可以实现多个接 口 。下面通过类来表示一组动物 .
【提示】IDEA 中使用 ctrl + i 快速实现接口
class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
}
另外我们再提供一组接口
,
分别表示
"
会飞的
", "
会跑的
", "
会游泳的
"
interface IFlying {
void fly();
}
interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
接下来我们创建几个具体的动物:
猫
,
是会跑的
class Cat extends Animal implements IRunning {
public Cat(String name) {
super(name);
}
@Override
public void run() {
System.out.println(this.name + "正在用四条腿跑");
}
}
鱼
,
是会游的
class Fish extends Animal implements ISwimming {
public Fish(String name) {
super(name);
}
@Override
public void swim() {
System.out.println(this.name + "正在用尾巴游泳");
}
}
青蛙
,
既能跑
,
又能游
(
两栖动物
)
class Frog extends Animal implements IRunning, ISwimming {
public Frog(String name) {
super(name);
}
@Override
public void run() {
System.out.println(this.name + "正在往前跳");
}
@Override
public void swim() {
System.out.println(this.name + "正在蹬腿游泳");
}
}
注意:一个类实现多个接口时,每个接口中的抽象方法都要实现,否则类必须设置为抽象类 。
还有一种神奇的动物
,
水陆空三栖
,
叫做
"
鸭子
"
class Duck extends Animal implements IRunning, ISwimming, IFlying {
public Duck(String name) {
super(name);
}
@Override
public void fly() {
System.out.println(this.name + "正在用翅膀飞");
}
@Override
public void run() {
System.out.println(this.name + "正在用两条腿跑");
}
@Override
public void swim() {
System.out.println(this.name + "正在漂在水上");
}
}
上面的代码展示了 Java 面向对象编程中最常见的用法 : 一个类继承一个父类 , 同时实现多种接口 .继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性 .猫是一种动物, 具有会跑的特性.青蛙也是一种动物, 既能跑, 也能游泳鸭子也是一种动物, 既能跑, 也能游, 还能飞
这样设计有什么好处呢 ? 时刻牢记多态的好处 , 让程序猿 忘记类型 . 有了接口之后 , 类的使用者就不必关注具体类型 , 而只关注某个类是否具备某种能力
例如
,
现在实现一个方法
,
叫
"
散步
"
public static void walk(IRunning running) {
System.out.println("我带着伙伴去散步");
running.run();
}
在这个
walk
方法内部
,
我们并不关注到底是哪种动物
,
只要参数是会跑的
, 就行。甚至参数可以不是
"
动物
",
只要会跑
!
class Robot implements IRunning {
private String name;
public Robot(String name) {
this.name = name;
}
@Override
public void run() {
System.out.println(this.name + "正在用轮子跑");
}
}
Robot robot = new Robot("机器人");
walk(robot);
// 执行结果
机器人正在用轮子跑
6. 接口间的继承
在 Java 中,类和类之间是单继承的,一个类可以实现多个接口,接口与接口之间可以多继承。即:用接口可以达到多继承的目的。接口可以继承一个接口 , 达到复用的效果 . 使用 extends 关键字.( 接口间的继承相当于把多个接口合并在一起 . )
通过接口继承创建一个新的接口 IAmphibious 表示 " 两栖的 ". 此时实现接口创建的 Frog 类 , 就继续要实现 run 方法, 也需要实现 swim 方法 .
interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
}
class Frog implements IAmphibious {
...
}
7. 接口使用实例
给对象数组排序
class Student {
private String name;
private int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
@Override
public String toString() {
return "[" + this.name + ":" + this.score + "]";
}
}
再给定一个学生对象数组
,
对这个对象数组中的元素进行排序
(
按分数降序
)
Student[] students = new Student[] {
new Student("张三", 95),
new Student("李四", 96),
new Student("王五", 97),
new Student("赵六", 92),
};
数组我们有一个现成的
sort
方法
,
能否直接使用这个方法呢
?
Arrays.sort(students);
System.out.println(Arrays.toString(students));
// 运行出错, 抛出异常.
Exception in thread "main" java.lang.ClassCastException: Student cannot be cast to java.lang.Comparable
仔细思考 , 不难发现 , 和普通的整数不一样 , 两个整数是可以直接比较的 , 大小关系明确 。 而两个学生对象的大小关系怎么确定? 需要我们额外指定。让我们的 Student 类实现 Comparable 接口, 并实现其中的 compareTo 方法
class Student implements Comparable {
private String name;
private int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
@Override
public String toString() {
return "[" + this.name + ":" + this.score + "]";
}
@Override
public int compareTo(Object o) {
Student s = (Student)o;
if (this.score > s.score) {
return -1;
} else if (this.score < s.score) {
return 1;
} else {
return 0;
}
}
}
在 sort 方法中会自动调用 compareTo 方法 . compareTo 的参数是 Object , 其实传入的就是 Student 类型的对象 . 然后比较当前对象和参数对象的大小关系( 按分数来算 )如果当前对象应排在参数对象之前, 返回小于 0 的数字;如果当前对象应排在参数对象之后, 返回大于 0 的数字;如果当前对象和参数对象不分先后, 返回 0;再次执行程序 , 结果就符合预期了
// 执行结果
[[王五:97], [李四:96], [张三:95], [赵六:92]]
注意事项 : 对于 sort 方法来说 , 需要传入的数组的每个对象都是 " 可比较 " 的 , 需要具备 compareTo 这样的能力 。 通过重写 compareTo 方法的方式 , 就可以定义比较规则。JDK就是根据compareTo方法的返回值进行不同
Student对象的大小比较 ~
为了进一步加深对接口的理解
,
我们可以尝试自己实现一个
sort
方法来完成刚才的排序过程
(
使用冒泡排序
)
public static void sort(Comparable[] array) {
for (int bound = 0; bound < array.length; bound++) {
for (int cur = array.length - 1; cur > bound; cur--) {
if (array[cur - 1].compareTo(array[cur]) > 0) {
// 说明顺序不符合要求, 交换两个变量的位置
Comparable tmp = array[cur - 1];
array[cur - 1] = array[cur];
array[cur] = tmp;
}
}
}
}
sort(students);
System.out.println(Arrays.toString(students));
// 执行结果
[[王五:97], [李四:96], [张三:95], [赵六:92]]
8. 对比一下抽象类与接口
大家以后若发现某些需求场景,既可以使用抽象类又可以使用接口.
接口优先原则: 开发之中优先考虑使用接口
9. Clonable 接口和深拷贝
9.1 自定义实现Clonable接口
什么是克隆?
现实生活中的”克隆:
被克隆的羊和克隆羊多利,实实在在存在的两个独立的羊对象 ~
克隆羊多利的所有属性值都是复制被克隆的那只羊
Animal a1 = new Animal0):
Animal a2 = a1;
a1和a2之间是不是克隆的关系?不是,只是两个引用(俩名字而已)
克隆必须要产生新的对象
Java 中内置了一些很有用的接口 , Clonable 就是其中之一 。Object 类中存在一个 clone 方法 , 调用这个方法可以创建一个对象的 " 拷贝 ". 但是要想合法调用 clone 方法 , 必须要先实现 Clonable 接口 , 否则就会抛出 CloneNotSupportedException 异常 .
在Java中一个类要实现克隆的能力,需要两步走
1.在类的定义之上实现Colonable接口 :打标记,JVM只会将带Cloneable接口的子类赋予其可以拷贝的能力
2.在类中重写obiect类的clone方法: 具体实现的克隆方法。因为Object类是Java的万物之母,所有类默认都继承自Object父类,object类中的所有方法所有类都具备。
class Animal implements Cloneable {
private String name;
@Override
public Animal clone() {
Animal o = null;
try {
o = (Animal)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return o;
}
}
public class Test {
public static void main(String[] args) {
Animal animal = new Animal();
Animal animal2 = animal.clone();
// 证明克隆对象确实是新产生的对象
System.out.println(animal == animal2);
}
}
// 输出结果
// false
9.2 深拷贝和浅拷贝
浅拷贝的概念:
浅拷贝: 当前类中若包含了其他类的引用,克隆后的新对象不会产生新的内部对象,浅拷贝只是将原对象中的所有属性值,复制一份儿而已
若原对象中包含引用类型,拷贝对象只是复制引用的地址而已,并不会产生引用对象本身的
新对象!
深拷贝: 产生的拷贝对象内部,包含的其他类对象也会复制一个新的对象产生
实现深拷贝:
1.递归的clone方法调用 =》 陈年老代码
2.通过序列化的方式 =》 现代所谓的json序列化与反序列化就在进行深浅拷贝(暂不实现)
class Money implements Cloneable{
double sal = 10.5;
@Override
protected Money clone() throws CloneNotSupportedException {
return (Money) super.clone();
}
}
public class Person implements Cloneable{
// 包含了其他类型的对象
Money money = new Money();
int age;
@Override
public Person clone() throws CloneNotSupportedException {
Person per = (Person) super.clone();
per.money = this.money.clone();
return per;
}
}
三、抽象类和接口的区别
抽象类和接口都是 Java 中多态的常见使用方式, 都需要重点掌握 。 同时又要认清两者的区别 ( 重要 !!! 常见面试题 )。核心区别 : 抽象类中可以包含普通方法和普通字段 , 这样的普通方法和字段可以被子类直接使用 ( 不必重写 ), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法。如之前写的 Animal 例子, 此处的 Animal 中包含一个 name 这样的属性 , 这个属性在任何子类中都是存在的 。因此此处的 Animal 只能作为一个抽象类, 而不应该成为一个接口。
class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
}
提醒:抽象类存在的意义是为了让编译器更好的校验, 像 Animal 这样的类我们并不会直接使用, 而是使用它的子类. 万一不小心创建了 Animal 的实例, 编译器会及时提醒我们.