《JavaSE》---16.＜抽象类接口Object类＞

目录

前言

一、抽象类

1.1什么是抽象类

1.2抽象类代码实现

1.3 抽象类特点

1.4抽象类的作用

二、接口

2.1什么是接口

2.2接口的代码书写

2.3 接口使用

2.4 接口特点

2.5 实现多个接口

快捷键（ctrl + i ）：

2.6接口的好处 

2.7 接口间的继承

 2.8 接口使用实例

实例一：

Comparable 接口（给对象排序）

2.9Clonable 接口和深拷贝

2.10 抽象类和接口的区别（常见面试题）

三、Object类

使用示范：

3.1Object类中toString()方法

3.2Object类中equals()方法

3.3Object类中hashcode()方法

---

前言

本篇博客主要讲解Java基础语法中的

抽象类和接口、抽象类和接口的概念、代码书写、特点、作用。实现多个接口快捷键（ctrl + i ）的使用、Comparable接口（给对象排序）、Clonable接口和深拷贝、抽象类和接口的区别、Object类、Object类中的toString()方法，equals()方法，hashcode()方法  

---

      大家好，本人是普通一本的在校大学生一枚，目前在学习java。之前也学了一段时间，但是没有发布博客。本人现在已经大二结束了，开学就大三了，时间过的真的很快。我会利用好这个暑假，来复习之前学过的内容，并整理好之前写过的博客进行发布。如果博客中有错误或者没有读懂的地方。热烈欢迎大家在评论区进行讨论！！！

      喜欢我文章的兄弟姐妹们可以点赞，收藏和评论我的文章。喜欢我的兄弟姐妹们以及也想复习一遍java知识的兄弟姐妹们可以关注我呦，我会持续更新滴，并且追求完整。
望支持！！！！！！一起加油呀！！！！

语言只是工具，不能决定你好不好找工作，决定你好不好找工作的是你的能力！！！！！

学历本科及以上就够用了！！！！！！！！！！！！！！！！！！！！！！！！！！！！

---

一、抽象类

1.1什么是抽象类

如果 一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 

我们知道，所有的对象都是通过一个类来描述的。

但是并不是所有类都是用来描述对象的。

比如之前我们在面向对象系列中所提到的矩形、圆、花。他们都是图形。因此他们可以继承Shape类。而在Shape类中我们有draw方法。但是由于Shape类不是具体的图形。因此不会用到draw方法。而是矩形、圆、花它们用draw方法。因此draw方法其实在Shape类中无法具体实现。所以我们可以将Shape类设计成一个“抽象类”。而把其中的draw方法我们设计成“抽象方法”。

1.2抽象类代码实现

如果一个类被abstract修饰，那么我们称之为这是一个抽象类。

如果一个方法被abstract修饰。那么我们称之为这是一个抽象方法。抽象方法不用给出具体实现。因为实际上它是要被子类重写。从而调用子类重写的方法。通过子类实现。

// 抽象类：被abstract修饰的类
public abstract class Shape {// 抽象方法：被abstract修饰的方法，没有方法体abstract public void draw();abstract void calcArea();// 抽象类也是类，也可以增加普通方法和属性public double getArea(){return area;}protected double area;    // 面积
}

如上代码。我们将Shape设计成抽象类。将draw设计成抽象方法。抽象类也可以有普通成员变量和普通成员方法。 甚至构造方法

1.3 抽象类特点

1. 抽象类不能直接实例化对象。

2. 抽象方法不能是 private 修饰的

3. 抽象方法不能被final和static修饰，因为抽象方法要被子类重写

4.抽象类必须被继承。并且继承后子类需要重写父类中的抽象方法。否则子类也是抽象类。必须用abstract修饰。

5.抽象类中不一定包含抽象方法。但是有抽象方法的类一定是抽象类。

6.抽象类中可以有构造方法。让子类创建对象时可以初始化父类成员变量。

1.4抽象类的作用

我们可以使用普通类被继承。但是使用普通类继承可以在编写代码时出现很多错误。比如我们不小心在子类中调用了父类需要被子类重写的方法。而使用抽象类。父类不能被实例化。因此也就无法调用其方法。因此使用抽象类可以"预防出错"。

---

二、接口

2.1什么是接口

在现实生活中，接口的例子比比皆是，比如：笔记本上的USB口，电源插座等。

接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。

在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

2.2接口的代码书写

我们使用 interface 关键字，来定义了一个接口。它与类的定义相似。我们把class关键字换成interface。那么它就从一个类，变成一个接口了。

public interface 接口名称{// 抽象方法public abstract void method1();   // public abstract 是固定搭配，可以不写public void method2();abstract void method3();void method4();// 注意：在接口中上述写法都是抽象方法，跟推荐方式4，代码更简洁
}

注：

1.创建接口时，接口命名一般以大写字母 I 开头。

2.接口命名一般使用形容词的单词。

3.在规范中，接口中的方法和属性不加任何修饰符。保证代码的简洁。

2.3 接口使用

接口不能被直接使用。而是需要一个“实现类”来实现接口中的所有抽象方法。

如 extends 关键字一样。我们使用 implements 关键字来实现接口

public  class 类名称 implements 接口名称{// ...
} 

注意：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。 

代码示例：

请实现笔记本电脑使用USB鼠标、USB键盘的例子

1. USB接口：包含打开设备、关闭设备功能

2. 笔记本类：包含开机功能、关机功能、使用USB设备功能

3. 鼠标类：实现USB接口，并具备点击功能

4. 键盘类：实现USB接口，并具备输入功能

//USB接口
public interface USB{void openDevice();void closeDevice();
}//鼠标类，实现USB接口。
public class Mouse implements USB{@Overridepublic openDevice(){Ststem.out.println("打开鼠标！");}@Overridepublic closeDevice(){Ststem.out.println("关闭鼠标！");}public void click(){System.out.println("鼠标点击");}
}// 键盘类，实现USB接口
public class KeyBoard implements USB {@Overridepublic void openDevice() {System.out.println("打开键盘");}@Overridepublic 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();}
}

2.4 接口特点

1. 接口类型是一种引用类型，但是不能直接new接口的对象

2.接口中的方法都是public abstract修饰的（被隐式的指定）。其他修饰符都会报错

3. 接口中的方法不能在接口中实现，只能由实现接口的类来实现。

4. 重写接口中方法时，不能使用默认的访问权限。

5. 接口中的变量会被隐式的指定为 public static final 变量。可以直接通过接口名访问

6. 接口中不能有静态代码块和构造方法

7. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class

8. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类

9. jdk8中：接口中还可以包含default方法。

2.5 实现多个接口

一个类是可以实现多个接口。

区别于

Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承

注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。

快捷键（ctrl + i ）：

IDEA 中使用 ctrl + i 快速实现接口。

2.6接口的好处 

class Duck extends Animal implements IRunning, ISwimming, IFlying {public Duck(String name) {super(name);}@Overridepublic void fly() {System.out.println(this.name + "正在用翅膀飞");}@Overridepublic void run() {System.out.println(this.name + "正在用两条腿跑");}@Overridepublic void swim() {System.out.println(this.name + "正在漂在水上");}
}

 上面的代码展示了 Java 面向对象编程中最常见的用法:

• 一个类继承一个父类, 同时实现多种接口. 继承表达的含义是 is - a 语义,
• 接口表达的含义是 具有 xxx 特性 .

 猫是一种动物, 具有会跑的特性.

青蛙也是一种动物, 既能跑, 也能游泳

鸭子也是一种动物, 既能跑, 也能游, 还能飞

这样的设计。时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型, 而只关注某个类是否具备某种能力.

2.7 接口间的继承

类和类之间是单继承的，一个类可以实现多个接口，

接口与接口之间可以多继承。即：用接口可以达到 多继承的目的

使用 extends 关键字.

interface IRunning {void run();
}interface ISwimming {void swim();
}// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {}class Frog implements IAmphibious {...
}

通过接口继承创建一个新的接口 IAmphibious 表示 "两栖的".

此时实现接口创建的 Frog 类, 就继续要实现 run 方 法, 也需要实现 swim 方法.

接口间的继承相当于把多个接口合并在一起. 

 2.8 接口使用实例

实例一：

给对象数组排序

class Student {private String name;private int score;public Student(String name, int score) {this.name = name;this.score = score;}@Overridepublic 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;}@Overridepublic String toString() {return "[" + this.name + ":" + this.score + "]";}@Overridepublic 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;}}
}

class Main{public static void main(String[] args) {Student[] students = new Student[] {new Student("张三", 95),new Student("李四", 96),new Student("王五", 97),new Student("赵六", 92),};Arrays.sort(students);System.out.println(Arrays.toString(students));}
}

执行结果 

// 执行结果
[[王五:97], [李四:96], [张三:95], [赵六:92]]

在 sort 方法中会自动调用 compareTo 方法. compareTo 的参数是 Object , 其实传入的就是 Student 类型的对象. 然后比较当前对象和参数对象的大小关系(按分数来算).

• 如果当前对象应排在参数对象之前, 返回小于 0 的数字;
• 如果当前对象应排在参数对象之后, 返回大于 0 的数字;
• 如果当前对象和参数对象不分先后, 返回 0;

再次执行程序, 结果就符合预期了.

注意事项:

对于 sort 方法来说, 需要传入的数组的每个对象都是 "可比较" 的, 需要具备 compareTo 这样的能力. 通过重写 compareTo 方法的方式, 就可以定义比较规则.

我们可以尝试自己实现一个 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]]

2.9Clonable 接口和深拷贝

Java 中内置了一些很有用的接口, Clonable 就是其中之一.

Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 "拷贝". 但是要想合法调用 clone 方法, 必须要 先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常.  

我们点进去Clonable接口会发现

这是一个空接口，这也叫做标记接口：证明当前类是可以被克隆的！

class Animal implements Cloneable {private String name;@Overridepublic 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

浅拷贝 VS 深拷贝

Cloneable 拷贝出的对象是一份 "浅拷贝" 观察以下代码:  

class Money {public double m = 99.99;
}class Person implements Cloneable{public Money money = new Money();@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}public class TestDemo3 {public static void main(String[] args) throws CloneNotSupportedException {Person person1 = new Person();Person person2 = (Person) person.clone();System.out.println("通过person2修改前的结果");System.out.println(person1.money.m);System.out.println(person2.money.m);person2.money.m = 13.6;System.out.println("通过person2修改后的结果");System.out.println(person1.money.m);System.out.println(person2.money.m);}
}

// 执行结果
通过person2修改前的结果
99.99
99.99
通过person2修改后的结果
13.6
13.6

如上图，我们克隆的只是person这个对象。并没有克隆对象里面的对象。克隆之后。Money m中的引用还是指向0x65。

因此我们修改person2中的money数值为13.6后person1中的money数值也发生了改变。 

这个就叫做浅拷贝。

而深拷贝就是还会克隆对象里面的对象。修改person2中的money数值为13.6后person1中的money数值不变改变。

 通过clone，我们只是拷贝了Person对象。

但是Person对象中的Money对象，并 没有拷贝。

通过person2这个引用修改了m的值后，person1这个引用访问m的时候，值也发生了改变。

这里就是发生了浅拷贝。那么想一下如何实现深拷贝呢？

实现深拷贝。需要我们自己重写clone方法。如下

class Money {public double m = 99.99;
}class Person implements Cloneable{public Money money = new Money();@Overrideprotected Object clone() throws CloneNotSupportedException {Person temp =(person)super.clone();tem.m = (Money)this.m.clonereturn temp;}
}public class TestDemo3 {public static void main(String[] args) throws CloneNotSupportedException {Person person1 = new Person();Person person2 = (Person) person.clone();System.out.println("通过person2修改前的结果");System.out.println(person1.money.m);System.out.println(person2.money.m);person2.money.m = 13.6;System.out.println("通过person2修改后的结果");System.out.println(person1.money.m);System.out.println(person2.money.m);}
}

// 执行结果
通过person2修改前的结果
99.99
99.99
通过person2修改后的结果
99.99
13.6

 此时就实现了深拷贝

2.10 抽象类和接口的区别（常见面试题）

抽象类和接口都是 Java 中多态的常见使用方式. 都需要重点掌握. 同时又要认清两者的区别

核心区别:

抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而

接口中 不能包含普通方法,和普通变量。 子类必须重写所有的抽象方法.

如之前写的 Animal 例子. 此处的 Animal 中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此此 处的 Animal 只能作为一个抽象类, 而不应该成为一个接口.

class Animal {protected String name;public Animal(String name) {this.name = name;}
}

再次提醒:

抽象类存在的意义是为了让编译器更好的校验, 像 Animal 这样的类我们并不会直接使用, 而是使用它的子类. 万一不小心创建了 Animal 的实例, 编译器会及时提醒我们.  

---

三、Object类

Object是Java默认提供的一个类。

Java里面除了Object类，所有的类都是存在继承关系的。

java中所有类默认会继承Object父类。

因此所有类的对象都可以使用Object的引用进行接收。

使用示范：

class Person{}
class Student{}
public class Test {public static void main(String[] args) {function(new Person());function(new Student());}public static void function(Object obj) {System.out.println(obj);}
}
//执行结果：
Person@1b6d3586
Student@4554617c

在开发之中，

Object类是参数的最高统一类型。但是Object类也存在有定义好的一些方法。如下：  

对于整个Object类中的方法需要实现全部掌握。

下面我们主要来熟悉这几个方法：toString()方法，equals()方法，hashcode()方法  

3.1Object类中toString()方法

获取对象信息

如果要打印对象中的内容，可以直接重写Object类中的toString()方法，之前已经讲过了

// Object类中的toString()方法实现：
public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

3.2Object类中equals()方法

在Java中，==进行比较时：

a.如果==左右两侧是基本类型变量，比较的是变量中值是否相同

b.如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同

c.如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的：

// Object类中的equals方法
public boolean equals(Object obj) {return (this == obj);   // 使用引用中的地址直接来进行比较
}
class Person{private String name ; private int age ; public Person(String name, int age) {this.age = age ; this.name = name ;}
}
public class Test {public static void main(String[] args) {Person p1 = new Person("gaobo", 20) ; Person p2 = new Person("gaobo", 20) ; int a = 10;int b = 10;System.out.println(a == b);             // 输出trueSystem.out.println(p1 == p2);           // 输出falseSystem.out.println(p1.equals(p2));      // 输出false}
}

Person类重写equals方法后，然后比较：

class Person{...@Overridepublic boolean equals(Object obj) {if (obj == null) {return false ; }if(this == obj) {return true ; }// 不是Person类对象if (!(obj instanceof Person)) {return false ; }Person person = (Person) obj ; // 向下转型，比较属性值return this.name.equals(person.name) && this.age==person.age ; }
}

结论：比较对象中内容是否相同的时候，一定要重写equals方法。  

3.3Object类中hashcode()方法

回忆刚刚的toString方法的源码：

public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

hashCode()这个方法，他帮我算了一个具体的对象位置，我们只能说它是个内存地址（但不是真的地址）。然后调用Integer.toHexString()方法，将这个地址以16进制输出。  

hashcode方法源码：

public native int hashCode();

该方法是一个native方法，底层是由C/C++代码写的。我们看不到。

我们认为两个名字相同，年龄相同的对象，将存储在同一个位置，如果不重写hashcode()方法，我们可以来看

示例 代码：  

class Person {public String name;public int age;public Person(String name, int age) {this.name = name;this.age = age;}
}
public class TestDemo4 {public static void main(String[] args) {Person per1 = new Person("gaobo", 20) ;Person per2 = new Person("gaobo", 20) ;System.out.println(per1.hashCode());System.out.println(per2.hashCode());}
}
//执行结果
460141958
1163157884

注意事项：

两个对象的hash值不一样。 像重写equals方法一样，我们也可以重写hashcode()方法。此时我们再来看看。 

class Person {public String name;public int age;public Person(String name, int age) {this.name = name;this.age = age;}@Overridepublic int hashCode() {return Objects.hash(name, age);}
}
public class TestDemo4 {public static void main(String[] args) {Person per1 = new Person("gaobo", 20) ;Person per2 = new Person("gaobo", 20) ;System.out.println(per1.hashCode());System.out.println(per2.hashCode());}
}
//执行结果
460141958
460141958

注意事项：哈希值一样。 

结论：

1、hashcode方法用来确定对象在内存中存储的位置是否相同

2、事实上hashCode() 在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的 散列码，进而确定该对象在散列表中的位置。