文章目录

• 🚀 一、抽象类
• • 🌟 1.1 抽象类的概念
  • 🌟 1.2 抽象类语法
  • 🌟 1.3 抽象类特性
  • 🌟 1.4 抽象类的作用
• 🚀 二、接口
• • 🌟 2.1 接口的概念
  • 🌟 2.2 语法规则
  • 🌟 2.3 接口使用
  • 🌟 2.4 接口特性
  • 🌟 2.5 实现多个接口
  • 🌟 2.6 接口之间的继承
  • 🌟 2.7 接口使用实例
  • • 2.7.1 Comparable 比较接口
    • 2.7.2 Comparator 比较器
    • 2.7.3 Clonable 接口和深拷贝
  • 🌟 2.8 抽象类和接口的区别
• 🚀 三、 Object 类
• • 🌟 3.2 获取对象信息
  • 🌟 3.3 对象比较 equals 方法
  • 🌟 3.4 hashcode 方法

🚀 一、抽象类

🌟 1.1 抽象类的概念

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

🌟 1.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; // 面积}

注：抽象类也是类，内部包含普通方法和属性，甚至构造方法。

🌟 1.3 抽象类特性

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

Shape shape = new Shape();// 编译出错Shape 是抽象的无法实例化。

2. 抽象方法不能是 private 的。

abstract class Shape{abstract private void draw();}// 编译出错private 和 abstract 非法的修饰符组合。

抽象方法没有限定符时，默认是 public 。
3. 抽象方法不能被 final 和 static 修饰，因为抽象方法要被子类重写。
4. 抽象类必须被继承，继承后要重写父类中所有抽象方法。否则子类也是抽象类，必须 abstract 修饰。
5. 抽象类不一定包含抽象方法，但是有抽象方法的类一定是抽象类。
6. 抽象类中可以有构造方法，供子类创建对象时，初始化父类成员变量。

🌟 1.4 抽象类的作用

抽象类本身不能被实例化，要想使用，只能创建该抽象类的子类，然后让子类重写抽象类中的抽象方法。

// 抽象类 Shapeabstract class Shape{    public abstract void Draw();}class Rect extends Shape{    @Override    public void Draw() { System.out.println("▢");    }}class Flower extends Shape{    @Override    public void Draw() { System.out.println("❀");    }}class Cycle extends Shape{    @Override    public void Draw() { System.out.println("⚪");    }}public class test2 {// 多态的一种表现    public static void drawMap(Shape shape){ shape.Draw();    }    public static void main(String[] args) { // 向上转型 Shape shape = new Rect(); drawMap(shape);    }}

🚀 二、接口

🌟 2.1 接口的概念

Java 中的接口是一种引用数据类型，可以作为多个类的使用规范。

🌟 2.2 语法规则

接口的定义格式与定义类的格式基本相同。

public interface 接口名称{// 抽象方法public abstract void method();public void method2();abstract method3();void method4();// 注意：在接口中上面的写法都是抽象方法，推荐方法4的写法，更加简洁。}

🌕提示：

1. 接口的名字一般以 大写 “ I ” 开头。
2. 接口命名一般是“形容词”词性的单词。
3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性，也就是上面方法四的写法。
4. 接口中的普通方法不能有具体实现，或者可以用 default 来修饰。并且可以有 static 方法。

🌟 2.3 接口使用

接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法。
类和接口之间的关系由 implements 实现。

// Ishape 接口public interface Ishape{// public abstract void    void draw();}// 对象和接口的关系是 implementsclass Rect implements Ishape{    @Override    public void draw() { System.out.println("□");    }}class Flower implements Ishape{    @Override    public void draw() { System.out.println("❀");    }}

🌟 2.4 接口特性

1. 接口是一种引用类型，不能直接被 new 实例化对象。
2. 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是public abstract，其他修饰符都会报错)。
3. 接口中的方法不能在接口中实现，只能由实现接口的类来重写。

public interface USB{void openDevice();// Error:(5, 23) java: 接口抽象方法不能带有主体void closeDevice(){System.out.println("关闭USB设备");}}

4. 重写接口中方法时，不能使用 default 访问权限修饰。因为子类重写方法的访问权限不能比父类原型低。（一般用 public）
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属性}}

6. 接口中不能有静态代码块和构造方法。
7. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class。
8. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类。

🌟 2.5 实现多个接口

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。

// 先实现一个动物类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("猫猫正在跑");    }}class Fish extends Animal implements ISwimming{    public Fish(String name){ super(name);    }    @Override    public void swim() { System.out.println("鱼正在游");    }}// 一个类继承一个类，并且实现多个接口，接口间用 “ ， ” 隔开。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,IFlying,ISwimming{    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 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口.

🌟 2.6 接口之间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，但是接口与接口之间可以多继承。即：用接口可以达到多继承的目的。

🌕接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字。

interface IRunning {void run();} interface ISwimming {void swim();} // 接口之间的继承可以看作把多个接口合并到一起。interface IAmphibious extends IRunning, ISwimming {// ...}// 实现 IAmphibious 的类要重写三个接口中的所有抽象方法。class Frog implements IAmphibious {...void run(){// ...}void swim(){// ...}}

🌟 2.7 接口使用实例

2.7.1 Comparable 比较接口

实现对象数组的排序：

// 对象类要实现 Comparable 接口，并重写 compareTo 方法.class Student implements Comparable {    private String name;    private int age;    public Student(String name, int age) { this.name = name; this.age = age;    }    @Override    public String toString() { return "Student{" +  "name='" + name + '\'' +  ", age=" + age +  '}';    }// 重写的 compareTo 方法    @Override    public int compareTo(Object o) {    // 自定义比较器 Student s = (Student)o; if(s.age > this.age){     return -1; } else if(s.age < this.age){     return 1; } else{     return 0; } // return s.age - this.age;    }}public class demo1 {    public static void main(String[] args) {// 创建一个对象数组 Student[] students = new Student[]{  new Student("张三",23),  new Student("李四", 96),  new Student("王五", 97),  new Student("赵六", 92), }; // 调用排序方法 Arrays.sort(students); System.out.println(Arrays.toString(students));    }}

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

• 如果当前对象 小于 参数对象, 返回小于 0 的数字;
• 如果当前对象 大于 参数对象, 返回大于 0 的数字;
• 如果当前对象和参数对象 相等 , 返回 0;

2.7.2 Comparator 比较器

Comparator 比较器

class Student  {    String name;    int age;    public Student(String name, int age) { this.name = name; this.age = age;    }    @Override    public String toString() { return "Student{" +  "name='" + name + '\'' +  ", age=" + age +  '}';    }}// 年龄比较器class AgeComparator implements Comparator<Student>{    @Override    public int compare(Student o1, Student o2) { return o1.age - o2.age;    }}// 姓名比较器class NameComparator implements Comparator<Student>{    @Override    public int compare(Student o1, Student o2) { // 名字是字符串，不能直接加减，要用 compareTo 方法比较 return o1.name.compareTo(o2.name);    }}public class demo1 {    public static void main(String[] args) { Student[] students = new Student[]{  new Student("张三",23),  new Student("王五", 97),  new Student("李四", 96),  new Student("赵六", 92), }; System.out.println(Arrays.toString(students)); // 按名字比较 // 先创建一个比较器 nc NameComparator nc = new NameComparator(); // 在 sort 方法中使用比较器 Arrays.sort(students,nc); System.out.println(Arrays.toString(students)); // 按年龄比较 AgeComparator ac = new AgeComparator(); Arrays.sort(students,ac); System.out.println(Arrays.toString(students));    }}

自定义类型的比较一定要实现可比较接口才可以进行排序

⛅两种比较方法的区别：

1. Comparable: 对类的侵入性强，一旦写好，不能轻易改动。
2. Comparator : 更加灵活，对类的侵入性弱，更推荐使用。

2.7.3 Clonable 接口和深拷贝

Java 中内置了一些很有用的接口, Clonable 就是其中之一.Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 “拷贝”. 但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口。

Clonable 接口为什么是一个空接口？有什么作用？
空接口又叫做标志接口，表示实现它的类是可以被 clone 的。

class Animal implements Cloneable{    private String name;    public Animal(String name){ this.name = name;    }    public String getName() { return name;    }    public void setName(String name) { this.name = name;    }    @Override    protected Object clone() throws CloneNotSupportedException { // 返回的是 Object 类型 return super.clone();    }}public class demo1 {    public static void main(String[] args) throws CloneNotSupportedException { Animal a1 = new Animal("123"); // 返回的是 Object 类型，要进行强制类型转换 Animal a2 = (Animal) a1.clone(); System.out.println(a2.getName());    }}// 输出 ： 123

• 浅拷贝和深拷贝

class Money {    public int m;}// 实现 Clonable 接口class Person implements Cloneable {    public int age;    Money money = new Money();    @Override    public String toString() { return "Person{" +  ", age=" + age +  '}';    }    // 虽然Cloneable是一个空接口，但是必须在类中重写 clone 方法    //throws CloneNotSupportedException 抛出异常    @Override    protected Object clone() throws CloneNotSupportedException { return super.clone();    }}public class t1 {    public static void main(String[] args) throws CloneNotSupportedException { // 这样的写法不能 clone 引用变量，是浅拷贝。更改拷贝值时会影响原型 Person p1 = new Person(); p1.money.m = 12; Person p2 = (Person) p1.clone(); System.out.println(p1.money.m); System.out.println(p2.money.m); System.out.println("---------------------------------------"); p2.money.m = 9955; System.out.println(p1.money.m); System.out.println(p2.money.m);    }}/*输出：*12  12*9955 9955*/

如上代码，我们可以看到，通过 Clone ，只是拷贝了 Person 对象，但是 Person 中的 Money 对象，并没有被拷贝。通过 person2 这个引用修改了 m 的值后， person1 中的值也发生了改变。这就是发生了浅拷贝。那么如何才能实现深拷贝呢？

// 让 money 类也可以被被克隆class Money implements Cloneable{    public int m;    @Override    protected Object clone() throws CloneNotSupportedException { return super.clone();    }}// 实现 Clonable 接口class Person implements Cloneable{    int age;    Money money = new Money();    @Override    protected Object clone() throws CloneNotSupportedException { Person tmp = (Person) super.clone(); // 拷贝 money 的引用 tmp.money = (Money) this.money.clone(); return tmp;    }}public class t2 {    public static void main(String[] args) throws CloneNotSupportedException { Person p1 = new Person(); p1.money.m = 12; Person p2 = (Person) p1.clone(); System.out.println(p1.money.m); System.out.println(p2.money.m); System.out.println("---------------------------------------"); p2.money.m = 9999; System.out.println(p1.money.m); System.out.println(p2.money.m);    }}/*12*12*---------------------------------------*12*9999*/

⛅ 上面的代码便是深拷贝的写法，深拷贝和浅拷贝，不在于方法，而在于具体代码的实现。

🌟 2.8 抽象类和接口的区别

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

核心区别：
抽象类中可以包含普通方法和普通字段，这样的普通方法和字段可以被子类直接使用，不必重写，而接口中不能包含普通方法，子类必须重写所有抽象方法。

public Animal{protected String name;public Animal(String name){this.name = name;}}// 这里的 Animal 只能作为抽象类，不能作为接口

抽象类的存在是为了让编译器更好的校验，Animal 这样的类一般不会直接使用，而是使用它的子类。

🚀 三、 Object 类

Object 类是 Java 默认提供的一个类。Java 中除了 Object 类，所有的类都是存在继承关系的，默认会继承 Object 类。
所有类的对象都可以使用 Object 类的引用进行接收。

class Person{}class Student{}public class Test {public static void main(String[] args) {function(new Person());function(new Student());}// Object 类的引用可以接受任何类的对象public static void function(Object obj) {System.out.println(obj);}} // 执行结果：// Person@1b6d3586// Student@4554617c

Object 类也有一些自己的方法：

下面来熟悉几个方法：

🌟 3.2 获取对象信息

如果要打印对象中的内容，可以直接重写 Object 类中的 toString() 方法。

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

🌟 3.3 对象比较 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("zhangsan", 20) ;Person p2 = new Person("zhangsan", 20) ;int a = 10;int b = 10;System.out.println(a == b); // 输出trueSystem.out.println(p1 == p2); // 输出falseSystem.out.println(p1.equals(p2)); // 输出false}}

Student 类重写 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.4 hashcode 方法

hashcode 方法可以用来比较两个对象在内存中存储的位置是否相同。

我们认为两个相同的对象，应该存储在同一个位置，如果不重写 hashcode() 方法：

class Person{    public String name;    public int age;    public Person(String name, int age) { this.name = name; this.age = age;    }}public class demo1 {    public static void main(String[] args) { Person p1 = new Person("zhangsan",18); Person p2 = new Person("zhangsan",18); System.out.println(p1.hashCode()); System.out.println(p2.hashCode());    }}// 460141958// 1163157884

我们看到，两个对象的 hash 值不一样。
接下来我们重写 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 demo1 {    public static void main(String[] args) { Person p1 = new Person("adcz",18); Person p2 = new Person("adcz",18); System.out.println(p1.hashCode()); System.out.println(p2.hashCode());    }}// 92660537// 92660537

hash 值一样。

🌕总结：

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

虫部落快搜