目录
前言
本篇博客主要讲解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{
@Override
public openDevice(){
Ststem.out.println("打开鼠标！");
}
@Override
public closeDevice(){
Ststem.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();
}
}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);
}
@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 特性 .
猫是一种动物, 具有会跑的特性.
青蛙也是一种动物, 既能跑, 也能游泳
鸭子也是一种动物, 既能跑, 也能游, 还能飞
这样的设计。时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型, 而只关注某个类是否具备某种能力.
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;
}
@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;
}
}
}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;
@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
浅拷贝 VS 深拷贝
Cloneable 拷贝出的对象是一份 "浅拷贝" 观察以下代码:
class Money {
public double m = 99.99;
}
class Person implements Cloneable{
public Money money = new Money();
@Override
protected 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();
@Override
protected Object clone() throws CloneNotSupportedException {
Person temp =(person)super.clone();
tem.m = (Money)this.m.clone
return 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); // 输出true
System.out.println(p1 == p2); // 输出false
System.out.println(p1.equals(p2)); // 输出false
}
}Person类重写equals方法后，然后比较：
class Person{
...
@Override
public 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;
}
@Override
public 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() 的作用是获取对象的 散列码，进而确定该对象在散列表中的位置。
343
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
