Javase.抽象类和接口

抽象类和接口

  • 【本节目标】
  • 1.抽象类
    • 1.1抽象类的概念
    • 1.2 抽象类语法
    • 1.3 抽象类特性
    • 1.4 抽象类的作用
  • 2. 接口
    • 2.1 接口的概念
    • 2.2 语法规则
    • 2.3 接口使用
    • 2.4 接口特性
    • 2.5 实现多个接口
    • 2.6 接口间的继承
    • 2.7 接口使用实例
    • 2.8Clonable 接口和深拷贝
    • 2.9 抽象类和接口的区别
  • 3. Object类
    • 3.1使用Object接受所有累的对象
    • 2.2 获取对象信息
    • 2.3 对象比较equals方法
    • 2.4 hashcode方法

【本节目标】

  1. 抽象类
  2. 接口
  3. Object

1.抽象类

1.1抽象类的概念

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 比如：
在这里插入图片描述
在这里插入图片描述
在打印图形例子中, 我们发现, 父类 Shape 中的 draw 方法好像并没有什么实际工作, 主要的绘制图形都是由 Shape 的各种子类的 draw 方法来完成的. 像这种没有实际工作的方法, 我们可以把它设计成一个 抽象方法(abstract method), 包含抽象方法的类我们称为 抽象类(abstract class)。

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();
// 编译出错
java: Shape是抽象的; 无法实例化
  1. 抽象方法不能是 private 的
abstract class Shape {abstract private void draw();//error
}
// 编译出错
java: 非法的修饰符组合: abstract和private
  1. 抽象方法不能被final和static修饰，因为抽象方法要被子类重写
public abstract class Shape {abstract final void methodA();//errorabstract public static void methodB();//error
}/*
编译报错：
java: 非法的修饰符组合: abstract和final
java: 非法的修饰符组合: abstract和static*/
  1. 抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰
//矩形
public class Rect extends Shape {private double length;private double width;public Rect(double length, double width) {this.length = length;this.width = width;}@Overridepublic void draw() {System.out.println("矩形：length = " + this.length + " width = " + this.width);}@Overridevoid calcArea() {area = length * width;//super.area = this.length * this.width;}
}

//圆形
public class Circle extends Shape {private double r;final private static double Pl = 3.14;public Circle(double r) {this.r = r;}@Overridepublic void draw() {System.out.println("圆：r = " + r);}@Overridevoid calcArea() {area = Pl * r * r;//super.area = this.area * this.r * this.r;}
}

//三角形
public class Triangle extends Shape {private double a;private double b;private double c;@Overridepublic void draw() {System.out.println("三角形：a = " + this.a + " b = " + this.b + " c = " + this.c);}//三角形：直角三角形、等腰三角形等，还可以继续细化@Overridevoid calcArea() {//编译失败：要么实现该抽象方法，要么将三角形设计为抽象类}
}

//Shape.java
public abstract class Shape {abstract public void draw();abstract void calcArea();public double getArea() {return area;}protected double area;
}
  1. 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类
  2. 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

1.4 抽象类的作用

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

有些同学可能会说了, 普通的类也可以被继承呀, 普通的方法也可以被重写呀, 为啥非得用抽象类和抽象方法呢?

确实如此. 但是使用抽象类相当于多了一重编译器的校验。

使用抽象类的场景就如上面的代码, 实际工作不应该由父类完成, 而应由子类完成. 那么此时如果不小心误用成父类了, 使用普通类编译器是不会报错的. 但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题。

- 很多语法存在的意义都是为了 "预防出错", 例如我们曾经用过的 final 也是类似. 创建的变量用户不去修改, 不就相当于常量嘛? 但是加上 final 能够在不小心误修改的时候, 让编译器及时提醒我们。
- 充分利用编译器的校验, 在实际开发中是非常有意义的。

2. 接口

2.1 接口的概念

在现实生活中，接口的例子比比皆是，比如：笔记本上的USB口，电源插座等。
在这里插入图片描述
在这里插入图片描述
电脑的USB口上，可以插：U盘、鼠标、键盘…所有符合USB协议的设备
电源插座插孔上，可以插：电脑、电视机、电饭煲…所有符合规范的设备

  • 通过上述例子可以看出：接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。

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

2.2 语法规则

接口的定义格式与定义类的格式基本相同，将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 接口使用

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

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 void openDevice() {System.out.println("打开鼠标");}@Overridepublic void closeDevice() {System.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 implements USB {@Overridepublic void openDevice() {System.out.println("打开笔记本电脑");}@Overridepublic void closeDevice() {System.out.println("关闭笔记本电脑");}//使用电脑：public void useDevice(USB usb) {usb.openDevice();if(usb instanceof Mouse) {Mouse mouse = new Mouse();mouse.click();} else if (usb instanceof KeyBoard) {KeyBoard keyBoard = new KeyBoard();keyBoard.input();}usb.closeDevice();}
}

//测试类
public class TestUSB {public static void main(String[] args) {Computer computer = new Computer();computer.openDevice();//打开电脑//使用鼠标设备computer.useDevice(new Mouse());//使用键盘设备computer.useDevice(new KeyBoard());computer.closeDevice();//关闭电脑}
}

2.4 接口特性

  1. 接口类型是一种引用类型，但是不能直接new接口的对象
public class TestUSB {public static void main(String[] args) {//USB usb = new USB();}
}//java: 接口.接口使用.USB是抽象的; 无法实例化
  1. 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是public abstract，其他修饰符都会报错)
public interface USB {//java: 此处不允许使用修饰符private//private void openDevice();void closeDevice();
}
  1. 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现
public interface USB {void openDevice();// 编译失败：因为接口中的方式默认为抽象方法//java: 接口抽象方法不能带有主体void closeDevice() {System.out.println("关闭设备");}
}
  1. 重写接口中方法时，不能使用默认的访问权限
public interface USB {void openDevice();//默认是public的void closeDevice();//默认是public的
}

public class Mouse implements USB {@Overridepublic void openDevice() {System.out.println("打开鼠标");}@Overridepublic void closeDevice() {System.out.println("关闭鼠标");}
}//编译报错，重写USB中openDevice方法时，不能使用默认修饰符
//正在尝试分配更低的访问权限; 以前为public

public class TestMouse {public static void main(String[] args) {Mouse mouse = new Mouse();mouse.openDevice();}
}
  1. 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量
//USB接口
public interface USB {double brand = 3.0;//默认void openDevice();void closeDevice();
}

public class USBTest {public static void main(String[] args) {System.out.println(USB.brand);//可以直接通过接口名访问，说明是静态的//编译报错：java: 无法为最终变量brand分配值//USB.brand = 2.0;//说明brand具有final属性}
}
  1. 接口中不能有静态代码块和构造方法
public interface USB {//编译失败public USB() {}{}//编译失败void openDevice();void closeDevice();
}
  1. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是 .class
  2. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类
  3. jdk8中：接口中还可以包含default方法。

2.5 实现多个接口

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。 下面通过类来表示一组动物：

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

另外我们再提供一组接口, 分别表示 “会飞的”, “会跑的”, “会游泳的”。

//IFlying.java
interface IFlying {void fly();
}//IRunning.java
interface IRunning {void run();
}//ISwimming.java
interface ISwimming {void swim();
}

接下来我们创建几个具体的动物：

  1. 猫, 是会跑的
public class Cat extends Animal implements IRunning {public Cat(String name) {super(name);}@Overridepublic void run() {System.out.println(this.name + "正在跑");}
}
  1. 鱼, 是会游的
public class Fish extends Animal implements ISwimming {public Fish(String name) {super(name);}@Overridepublic void swim() {System.out.println(this.name + "正在游泳");}
}
  1. 青蛙, 既能跑, 又能游(两栖动物)
public class Frog extends Animal implements IRunning, ISwimming {public Frog(String name) {super(name);}@Overridepublic void run() {System.out.println(this.name + "正在跑");}@Overridepublic void swim() {System.out.println(this.name + "正在游泳");}
}

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

提示：IDEA 中使用 Ctrl + i 快速实现接口
  1. 还有一种神奇的动物, 水陆空三栖, 叫做 “鸭子”
public 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 特性

      猫是一种动物，具有会跑的特性.青蛙也是一种动物，既能跑，也能游泳鸭子也是一种动物，既能跑，也能游，还能飞

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

例如, 现在实现一个方法, 叫 “散步”

public class TestAnimal {public static void walk(IRunning iRunning) {System.out.println("我去散步");iRunning.run();}//在这个walk方法内部，我们并不关注到底是哪种动物，只要参数是会跑就行public static void main1(String[] args) {Cat cat = new Cat("咪咪");walk(cat);Frog frog = new Frog("瓜瓜");walk(frog);}
}/*
执行结果：
我去散步
咪咪正在跑
我去散步
瓜瓜正在跑*/

甚至参数可以不是 “动物”, 只要会跑!

public class TestAnimal {public static void walk(IRunning iRunning) {//System.out.println("我去散步");iRunning.run();}//甚至参数可以不是 “动物”, 只要会跑!public static void main(String[] args) {Robot robot = new Robot("机器人");walk(robot);}
}/*
执行结果：
机器人正在用轮子跑*/

2.6 接口间的继承

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

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

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

通过接口继承创建一个新的接口 IAmphibious 表示 “两栖的”. 此时实现接口创建的 Frog 类, 就继续要实现 run 方法, 也需要实现 swim 方法。

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

2.7 接口使用实例

给学生对象数组排序

public class Student {private String name;private int score;public Student(String name, int score) {this.name = name;this.score = score;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", score=" + score +'}';}
}

再给定一个学生对象数组, 对这个对象数组中的元素进行排序(按分数降序)

Student[] students = new Student[]{new Student("张三", 15),new Student("李四", 16),new Student("王五", 17),new Student("赵六", 18)
};

按照我们之前的理解, 数组我们有一个现成的 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.java
public class Student {private String name;private int score;public Student(String name, int score) {this.name = name;this.score = score;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", score=" + score +'}';}
}

//Test.java
public class Test {public static void main(String[] args) {//再给定一个学生对象数组, 对这个对象数组中的元素进行排序(按分数降序)Student[] students = new Student[]{new Student("张三", 15),new Student("李四", 16),new Student("王五", 17),new Student("赵六", 18)};//按照我们之前的理解, 数组我们有一个现成的 sort 方法, 能否直接使用这个方法呢?Arrays.sort(students);System.out.println(Arrays.toString(students));}
}

仔细思考, 不难发现, 和普通的整数不一样, 两个整数是可以直接比较的, 大小关系明确。 而两个学生对象的大小关系怎么确定? 需要我们额外指定。

让我们的 Student 类实现 Comparable 接口, 并实现其中的 compareTo 方法

//Student1.java
public class Student1 implements Comparable <Student1> {private String name;private int score;public Student1(String name, int score) {this.name = name;this.score = score;}@Overridepublic String toString() {return "Student1{" +"name='" + name + '\'' +", score=" + score +'}';}@Overridepublic int compareTo(Object o) {//return this.score - o.age;Student1 student1 = (Student1)o;if(this.score > student1.score) {return -1;} else if (this.score < student1.score) {return 1;} else {return 0;}}
}

在 sort 方法中会自动调用 compareTo 方法。compareTo 的参数是 Object , 其实传入的就是 Student1 类型的对象。

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

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

//执行结果：
[Student1{name='赵六', score=18}, Student1{name='王五', score=17}, Student1{name='李四', score=16}, Student1{name='张三', score=15}]

问题： 假如我先要以姓名作为比较依据，就得把Test.java 中的 CompareTo 方法进行重写，十分的麻烦！

答案是使用另外一个接口：Comparator

Comparator接口是Java中用于定义对象比较的顺序的接口，它属于java.util包。这个接口允许我们自定义对象的排序规则，从而可以按照我们指定的方式对对象进行排序。

Comparator接口主要包含一个 compare(T o1, T o2) 方法：

public interface Comparator<T> {int compare(T o1, T o2);
}

该方法用于比较两个对象的大小。其返回值是整型，有三种可能的返回值：

  • 负数：表示第一个参数小于第二个参数。
  • 零：表示两个参数相等。
  • 正数：表示第一个参数大于第二个参数。

这个接口特别有用，当我们需要对自定义对象进行排序，而这些对象的自然顺序（即它们的Comparable实现）不满足我们的需求时，我们可以使用Comparator来定义新的排序规则。

用NameComparator和AgeComparator这两个类实现 Comparable 接口, 并实现其中的 compareTo 方法。

//AgeComparaTor.java
public class AgeComparator implements Comparator <Student> {@Overridepublic int compare(Student o1, Student o2) {return o1.age - o2.age;}
}

//NameComparator.java
public class NameComparator implements Comparator <Student> {@Overridepublic int compare(Student o1, Student o2) {return o1.name.compareTo(o2.name);}
}

//Test2.java
public class Test2 {public static void main(String[] args) {Student[] students = new Student[] {new Student("张三", 10),new Student("王五", 17),new Student("李四", 20)};System.out.println("排序前：" + Arrays.toString(students));//用姓名来比较：NameComparator nameComparator = new NameComparator();Arrays.sort(students, nameComparator);System.out.println("排序后：" + Arrays.toString(students));}
}

  • 用姓名来比较：

     //执行结果：排序前：[Student{name='张三', age=10}, Student{name='王五', age=17}, Student{name='李四', age=20}]排序后：[Student{name='张三', age=10}, Student{name='李四', age=20}, Student{name='王五', age=17}]

//Test2.java
public class Test2 {public static void main4(String[] args) {Student[] students = new Student[] {new Student("张三", 10),new Student("李四", 20),new Student("王五", 17),};System.out.println("排序前：" + Arrays.toString(students));//用年龄来比较：AgeComparator ageComparator = new AgeComparator();Arrays.sort(students, ageComparator);System.out.println("排序后：" + Arrays.toString(students));}
}

  • 用年龄来比较：

      //执行结果：排序前：[Student{name='张三', age=10}, Student{name='李四', age=20}, Student{name='王五', age=17}]排序后：[Student{name='张三', age=10}, Student{name='王五', age=17}, Student{name='李四', age=20}]

为了进一步加深对接口的理解, 我们可以尝试自己实现一个 sort 方法来完成刚才的排序过程(使用冒泡排序)

//Test.java
class Student implements Comparable <Student> {public String name;public int age;public Student(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}//用年龄来比较：@Overridepublic int compareTo(Student o) {return this.age - o.age;}
}

public class Test {//手动模拟实现一个Arrays.sort：public static void sort(Comparable[] comparables) {for (int i = 0; i < comparables.length - 1; i++) {for (int j = 0; j < comparables.length - 1 - i; j++) {if(comparables[j].compareTo(comparables[j + 1]) > 0) {Comparable tmp = comparables[j];comparables[j] = comparables[j + 1];comparables[j + 1] = tmp;}}}}public static void main2(String[] args) {Student[] students = new Student[] {new Student("张三", 10),new Student("李四", 20),new Student("王五", 17)};System.out.println("排序前：" + Arrays.toString(students));//Arrays.sort(students);sort(students);System.out.println("排序后：" + Arrays.toString(students));}
}

再次执行代码:

//执行结果：
排序前：[Student{name='张三', age=10}, Student{name='李四', age=20}, Student{name='王五', age=17}]
排序后：[Student{name='张三', age=10}, Student{name='王五', age=17}, Student{name='李四', age=20}]

2.8Clonable 接口和深拷贝

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

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

  • Clonable 接口
public interface Cloneable {
}
  • clone 方法
protected native Object clone() throws CloneNotSupportedException;

class Animal1 implements Cloneable {private String name;@Override/*protected Object clone() throws CloneNotSupportedException*/public Animal1 clone() {Animal1 o = null;try {o = (Animal1)super.clone();} catch (CloneNotSupportedException e) {e.printStackTrace();}return o;}
}public class Test {public static void main(String[] args) {Animal1 animal1 = new Animal1();Animal1 animal2 = animal1.clone();System.out.println(animal1 == animal2);}
}/*
输出结果
false
*/
  • 浅拷贝 VS 深拷贝

Cloneable 拷贝出的对象是一份 “浅拷贝”

观察以下代码:

//浅拷贝：
class Money {public double m = 99.9;
}class Person implements Cloneable {public Money money = new Money();@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}
public class TestDemo {public static void main(String[] args) throws CloneNotSupportedException {Person person1 = new Person();Person person2 = (Person)person1.clone();System.out.println("通过person2修改前的结果");System.out.println(person1.money.m);System.out.println(person2.money.m);person2.money.m = 100.1;System.out.println("通过person2修改后的结果");System.out.println(person1.money.m);System.out.println(person2.money.m);}
}/*
执行结果：
通过person2修改前的结果
99.9
99.9
通过person2修改后的结果
100.1
100.1*/

如上代码，我们可以看到，通过clone，我们只是拷贝了Person对象。但是Person对象中的Money对象，并没有拷贝。通过person2这个引用修改了m的值后，person1这个引用访问m的时候，值也发生了改变。这里就是发生了浅拷贝。

图文解析：

在这里插入图片描述

那么想一下如何实现深拷贝呢？

class Money1 implements Cloneable {public double m = 99.9;@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}class Person1 implements Cloneable {public Money1 money = new Money1();@Overrideprotected Object clone() throws CloneNotSupportedException {//return super.clone();Person1 tmp = (Person1) super.clone();tmp.money = (Money1) this.money.clone();return tmp;}
}
public class TestDemo1 {public static void main(String[] args) throws CloneNotSupportedException {Person1 person1 = new Person1();Person1 person2 = (Person1)person1.clone();System.out.println("通过person2修改前的结果");System.out.println(person1.money.m);System.out.println(person2.money.m);person2.money.m = 100.1;System.out.println("通过person2修改后的结果");System.out.println(person1.money.m);System.out.println(person2.money.m);}
}/*
执行结果：
通过person2修改前的结果
99.9
99.9
通过person2修改后的结果
99.9
100.1*/

如上代码，Money1和Person1两个类都实现了Cloneable接口，并重写了clone方法。Person1类中包含Money1对象。在Person1的clone方法中，首先调用super.clone()复制Person1对象，然后复制其内部的Money1对象，确保深拷贝。在TestDemo1的main方法中，创建了一个Person1对象person1，然后克隆得到person2。修改person2中的money对象的m值，发现person1中的对应值不变，说明实现了深拷贝，即person1和person2中的money对象是独立的。

图文解析：

在这里插入图片描述

2.9 抽象类和接口的区别

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

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

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

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

再次提醒:

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

在这里插入图片描述

3. Object类

3.1使用Object接受所有累的对象

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

  • 范例：使用Object接收所有类的对象
package Object类.使用Object接收所有类的对象;class Person {}class Student {}public class Test {public static void function(Object o) {System.out.println(o);}public static void main(String[] args) {function(new Person());function(new Student());}
}/*
执行结果：
Object类.使用Object接收所有类的对象.Person@1b6d3586
Object类.使用Object接收所有类的对象.Student@4554617c*/
  • 所以在开发之中，Object类是参数的最高统一类型。但是Object类也存在有定义好的一些方法。如下：

在这里插入图片描述
本小节当中，我们主要来熟悉这几个方法：toString()方法，equals()方法，hashcode()方法

2.2 获取对象信息

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

public class Test {// Object类中的toString()方法实现：public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());}public static void main(String[] args) {int[] array = {1, 3, 5, 7, 9};System.out.println(Arrays.toString(array));}
}/*
执行结果：
[1, 3, 5, 7, 9]
*/

2.3 对象比较equals方法

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

  • 如果==左右两侧是基本数据类型，比较的是变量中的值是否相同
  • 如果==左右两侧是引用类型变量，比较的是引用变量的地址是否相同
  • 如果要比较对象内容，必须重写Object中的equals方法，因为equals方法默认是按照地址进行比较的：
public boolean equals(Object obj) {return (this == obj);//使用引用中的地址直接来进行比较
}

class Person {private String name;private int age;public Person(String name, int age) {this.name = name;this.age = age;}
}public class Test {public static void main(String[] args) {Person person1 = new Person("张三", 15);Person person2 = new Person("张三", 15);int a = 10;int b = 10;System.out.println(a == b);//true//理论来讲，名字相同，年龄相同，可以看成是一个人，但是比较不出来：System.out.println(person1 == person2);//falseSystem.out.println(person1.equals(person2));//false}
}

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

class Person1 {private String name;private int age;public Person1(String name, int age) {this.name = name;this.age = age;}@Overridepublic boolean equals(Object obj) {if(obj == null) {return false;}//自己和自己比较if(this == obj) {return true;}//不是Person1对象if(!(obj instanceof Person1)) {return false;}//开始比较：Person1 person1 = (Person1) obj;//向下转型//理论来讲，名字相同，年龄相同，可以看成是一个人return this.name.equals(person1.name) && this.age == person1.age;}
}public class Test1 {public static void main(String[] args) {Person1 person1 = new Person1("张三", 19);Person1 person2 = new Person1("张三", 19);int a = 10;int b = 10;System.out.println(a == b);//trueSystem.out.println(person1 == person2);//falseSystem.out.println(person1.equals(person2));//true}
}

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

2.4 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 {private String name;private int age;public Person(String name, int age) {this.name = name;this.age = age;}
}public class TestDemo1 {public static void main(String[] args) {Person person1 = new Person("张三", 10);Person person2 = new Person("张三", 10);System.out.println(person1.hashCode());System.out.println(person2.hashCode());}
}/*
执行结果：
460141958
1163157884*/

注意事项：两个对象的hash值是不一样的。

像重写equals方法一样，我们也可以重写hashcode()方法。此时我们再来看看：

class Person2 {private String name;private int age;public Person2(String name, int age) {this.name = name;this.age = age;}@Overridepublic int hashCode() {return Objects.hash(name, age);}
}public class TestDemo2 {public static void main(String[] args) {Person2 person1 = new Person2("张三", 10);Person2 person2 = new Person2("张三", 10);System.out.println(person1.hashCode());System.out.println(person2.hashCode());}
}/*
执行结果：
24022530
24022530*/

注意事项：哈希值一样。

结论：

  1. hashcode 方法用来确定对象在内存中存储的位置是否相同
  2. 事实上 hashcode() 在散列表中才有用，在其他情况下没有，在散列表中 hashcode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/web/30464.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

GT_BERT文本分类

GT_BERT文本分类

目录 GT-BERT结束语代码实现整个项目源码&#xff08;数据集模型&#xff09; GT-BERT 在为了使 BERT 模型能够得到广泛的应用,在保证模型分类准确率不降低的情况下,减少模型参数规模并降低时间复杂度,提出一种基于半监督生成对抗网络与 BERT 的文本分类模型 GT-BERT。模型的整…
阅读更多...
【ajax基础04】form-serialize插件

【ajax基础04】form-serialize插件

目录 一&#xff1a;form-serialize插件 作用&#xff1a; 语法格式&#xff1a; 一&#xff1a;form-serialize插件 作用&#xff1a; 快速且大量的收集表单元素的值 例如上图对于多表单元素的情形&#xff0c;单靠通过”选择器获取节点.value”值的形式&#xff0c;获取…
阅读更多...
使用 GCD 实现属性的多读单写

使用 GCD 实现属性的多读单写

使用 Grand Central Dispatch (GCD) 实现多读单写的属性 首先需要确保在多线程环境下的线程安全性。可以使用 GCD 提供的读写锁机制 dispatch_rwlock_t 或者 dispatch_queue_t 来实现这个功能。 Swift版本的实现 怎样创建一个并发队列 &#xff1f;// 使用 Swift 来实现的首…
阅读更多...
.net 奇葩问题调试经历之1——在红外相机获取温度时异常

.net 奇葩问题调试经历之1——在红外相机获取温度时异常

📢欢迎点赞 ：👍 收藏 ⭐留言 📝 如有错误敬请指正，赐人玫瑰，手留余香！📢本文作者：由webmote 原创📢作者格言：新的征程，我们面对的不仅仅是技术还有人心，人心不可测，海水不可量，唯有技术，才是深沉黑夜中的一座闪烁的灯塔序言 我们在研发中，经常除了造产品…
阅读更多...
吉时利Keithley2602B数字源表

吉时利Keithley2602B数字源表

吉时利Keithley2602B数字源表 2601B、2602B、2604B 系统 Sourcemeter SMU 仪器 2601B、2602B 和 2604B 系统 Sourcemeter SMU 仪器为 40W DC / 200W 脉冲 SMU&#xff0c;支持 10A 脉冲&#xff0c;3A 至 100fA 和 40V 至 100nV DC。它们将精密电源、实际电流源、6 位数字万用…
阅读更多...
使用asyncua模块的call_method方法调用OPC UA的Server端方法报错：asyncio.exceptions.TimeoutError

使用asyncua模块的call_method方法调用OPC UA的Server端方法报错：asyncio.exceptions.TimeoutError

使用asyncua模块的call_method方法调用OPC UA的Server端方法报错&#xff1a;asyncio.exceptions.TimeoutError 报错信息如下&#xff1a; Traceback (most recent call last): asyncio.run(main()) File “D:\miniconda3\envs\py31013\lib\asyncio\runners.py”, line 44, in…
阅读更多...
反激开关电源整流桥选型及计算

反激开关电源整流桥选型及计算

整流桥的作用就是把输入交流电压整形成直流电压&#xff0c;把正弦波整成馒头波&#xff0c;由于整流管的单向导电 性&#xff0c;在输入电压瞬时值小于滤波电容上电压时整流桥&#xff0c;在这个时候是不导通的&#xff0c;使整流桥的电流变 成2-3ms左右的窄脉冲。为获得所需…
阅读更多...
【数据结构】选择题

【数据结构】选择题

在数据结构中&#xff0c;从逻辑上可以把数据结构分为&#xff08;线性结构和非线性结构&#xff09; 当输入规模为n时&#xff0c;下列算法渐进复杂性中最低的是&#xff08;&#xff09; 时间复杂度 某线性表采用顺序存储结构&#xff0c;每个元素占4个存储单元&#xf…
阅读更多...
13.3 Go 性能优化

13.3 Go 性能优化

&#x1f49d;&#x1f49d;&#x1f49d;欢迎莅临我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:「stormsha的主页」…
阅读更多...
【MAVEN学习 | 第1篇】Maven介绍与安装

【MAVEN学习 | 第1篇】Maven介绍与安装

文章目录 前言 一. Maven主要作用1.1 依赖管理1.2 项目构建 二. Maven安装和配置2.1 安装2.2 配置环境变量2.3 命令测试2.4 配置文件&#xff08;1&#xff09;依赖本地缓存位置&#xff08;本地仓库位置&#xff09;&#xff08;2&#xff09;配置国内阿里镜像&#xff08;3&a…
阅读更多...
WPS相同字体但是部分文字样式不一样解决办法

WPS相同字体但是部分文字样式不一样解决办法

如下图&#xff0c;在使用wps编辑文档的时候发现有些电脑的文字字体很奇怪&#xff0c;但是把鼠标移到这个文字的位置&#xff0c;发现它和其他正常文字的字体是一样的&#xff0c;都是仿宋_GB2312 正常电脑的文字如下图所示 打开C:\Windows找到Fonts这个文件夹 把仿宋_GB2312这…
阅读更多...
【启明智显产品介绍】工业级HMI芯片Model3芯片详解（二）图像显示

【启明智显产品介绍】工业级HMI芯片Model3芯片详解（二）图像显示

Model3芯片是一款集大容量存储、宽温操作范围及多功能接口于一身的MCU&#xff0c;配备了 2D 图像加速引擎和 PNG 解码/JPEG 编解码引擎&#xff0c;可以满足各类交互设计场景和多媒体互动需求&#xff0c;具有高可靠性、高安全性、高开放度的特点&#xff0c;可以面向于泛工业…
阅读更多...
Stable Diffusion 3 大模型文生图实践

Stable Diffusion 3 大模型文生图实践

windows教程2024年最新Stable Diffusion本地化部署详细攻略&#xff0c;手把手教程&#xff08;建议收藏!!)_stable diffusion 本地部署-CSDN博客 linux本地安装教程 1.前期准备工作 1&#xff09;创建conda环境 conda create --name stable3 python3.10 2&#xff09;下…
阅读更多...
【UBEMX安装和使用】

【UBEMX安装和使用】

UBEMX安装 1. UBEMX介绍2. 官网下载软件3. 安装步骤下载和关联的STM32Cube固件包 1. UBEMX介绍 STM32CubeMX是一种图形工具&#xff0c;通过分步过程可以非常轻松地配置STM32微控制器和微处理器&#xff0c;以及为Arm Cortex-M内核或面向Arm Cortex-A内核的特定Linux设备树生成…
阅读更多...
Flutter调用本地web

Flutter调用本地web

前言: 在目前Flutter 环境中&#xff0c;使用在线 webview 是一种很常见的行为 而在 app 环境中&#xff0c;离线使用则更有必要 1.环境准备 将依赖导入 2.引入前端代码 前端代码有两种情况 一种是使用打包工具 build 而来的前端代码 另一种情况是直接使用 HTML 文件 …
阅读更多...
YoloV8改进策略：Block篇|即插即用|StarNet，重写星操作，使用Block改进YoloV8（全网首发）

YoloV8改进策略：Block篇|即插即用|StarNet，重写星操作，使用Block改进YoloV8（全网首发）

摘要 本文主要集中在介绍和分析一种新兴的学习范式——星操作&#xff08;Star Operation&#xff09;&#xff0c;这是一种通过元素级乘法融合不同子空间特征的方法&#xff0c;通过元素级乘法&#xff08;类似于“星”形符号的乘法操作&#xff09;将不同子空间的特征进行融…
阅读更多...
java：动态代理和cglib代理的简单例子

java：动态代理和cglib代理的简单例子

# 项目代码资源&#xff1a; 可能还在审核中&#xff0c;请等待。。。 https://download.csdn.net/download/chenhz2284/89457803 # 项目代码 【pom.xml】 <dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version&…
阅读更多...
WGCLOUD的web ssh提示websocket服务连接已断开

WGCLOUD的web ssh提示websocket服务连接已断开

这个问题一般是server主机没有开放端口9998&#xff0c;因为9998是web ssh的端口&#xff0c;需要开放 我们只要在防火墙&#xff0c;或者安全软件&#xff0c;把这个端口开放了就可以了
阅读更多...
小白学-WEBGL

小白学-WEBGL

第一天&#xff1a; 1.canvas和webgl的区别 Canvas 和 WebGL 都是用于在网页上绘制图形的技术&#xff0c;它们通过浏览器提供的 API 使开发者能够创建丰富的视觉内容&#xff0c;但它们的工作原理和用途有所不同。 Canvas Canvas API 提供了一个通过 JavaScript 和 HTML <…
阅读更多...
Xtuner微调

Xtuner微调

环境安装 studio-conda xtuner0.1.17 conda activate xtuner0.1.17 进入家目录 &#xff08;~的意思是 “当前用户的home路径”&#xff09; cd ~ 创建版本文件夹并进入&#xff0c;以跟随本教程 mkdir -p /root/xtuner0117 && cd /root/xtuner0117 拉取 0.1.17 的版…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023