Java 从入门到进阶之路(十八)

在之前的文章我们介绍了一下 Java 中的正则表达式,本章我们来看一下 Java 中的 Object。

在日常生活中,任何事物我们都可以看做是一个对象,在编程中是同样的道理,在 Java 编程中其实更突出,因为 Java 就是一门面向对象的编程语言。

我们先来看下面的代码:

 1 public class Main {
 2     public static void main(String[] args) {
 3         Person person = new Person();
 4 //        person.age = 1000; // 编译错误
 5 //        System.out.println(person.age); // 编译错误
 6         person.setAge(1000);
 7         System.out.println(person.getAge()); // 0
 8
 9         person.setAge(10);
10         System.out.println(person.getAge()); // 10
11
12         System.out.println(person.toString()); // [email protected]
13     }
14 }
15
16 class Person {
17     private int age;
18
19     public int getAge() {
20         return age;
21     }
22
23     public void setAge(int age) {
24         if (age < 0 || age > 100) {
25             return;
26         }
27         this.age = age;
28     }
29 }
30     }
31
32     public void setAge(int age) {
33         if (age < 0 || age > 100 ) {
34             return;
35         }
36         this.age = age;
37     }
38 }

在上面的代码中,我们定义了 get 和 set 方法来实现私有属性的获取和更改,起到了对私有属性的保护作用。

在上面的代码中,我们还写了一个 toString() 方法,但是我们并没有在 Person 类中定义该方法,这是因为当我们定义 Person 类的时候,系统会默认继承 Object 类,且 Object 类中有 toString() 方法,并且输出为一个 类名@地址,这个字符串没有什么实际意义。因此通常我们要使用一个类的 toString 方法时,就应当重写该方法,重写该方法后,返回的字符串没有严格的格式要求,将来可以根据需求而定,但是原则上该字符串应当包含当前对象的属性信息,只有当我们自定义的类需要重写该方法时,JAVA API 提供的类通常都已经重写了该方法。

下面我们将 toString() 方法进行重写:

 1 public class Main {
 2     public static void main(String[] args) {
 3         Point point = new Point(1, 2);
 4         String string = point.toString();
 5         System.out.println(string); // (1,2)
 6     }
 7 }
 8
 9 class Point {
10     private int x;
11     private int y;
12
13     public int getX() {
14         return x;
15     }
16
17     public void setX(int x) {
18         this.x = x;
19     }
20
21     public int getY() {
22         return y;
23     }
24
25     public void setY(int y) {
26         this.y = y;
27     }
28
29     public Point() {
30     }
31
32     public Point(int x, int y) {
33         this.x = x;
34         this.y = y;
35     }
36
37     public String toString() {
38         return "(" + x + "," + y + ‘)‘;
39     }
40 }

在上面的代码中,我们定义了一个 Point 类,相当于二维坐标系上的一个点,我们通过重写 toString 方法实现了一个坐标点的位置。

在 Object 类中还有定义好的 equals 方法,意思是比较两个对象,如下:

public class Main {
    public static void main(String[] args) {
        Point point1 = new Point(1, 2);
        Point point2 = new Point(1, 2);
        System.out.println(point1 == point2); // false
        System.out.println(point1.equals(point2)); // false
    }
}

在上面的代码中,point1 == point2 其实比较的是两个类的引用地址,所以为 false,我们看一下 equals 方法的源码:

1   public boolean equals(Object obj) {
2         return (this == obj);
3     }

在上面的代码中,Object 类的 equals 方法其实也是相当于 == 的方法来进行比较,所以当我们使用 equals 方法时同样需要进行重写,他的作用是比较两个对象(当前对象与给定对象)内容是否一样,如下:

 1 public class Main {
 2     public static void main(String[] args) {
 3         Point point1 = new Point(1, 2);
 4         Point point2 = new Point(1, 2);
 5         System.out.println(point1 == point2); // false
 6         System.out.println(point1.equals(point2)); // true
 7     }
 8 }
 9
10 class Point {
11     private int x;
12     private int y;
13
14     public int getX() {
15         return x;
16     }
17
18     public void setX(int x) {
19         this.x = x;
20     }
21
22     public int getY() {
23         return y;
24     }
25
26     public void setY(int y) {
27         this.y = y;
28     }
29
30     public Point() {
31     }
32
33     public Point(int x, int y) {
34         this.x = x;
35         this.y = y;
36     }
37
38     public String toString() {
39         return "(" + x + "," + y + ‘)‘;
40     }
41
42     public boolean equals(Object object) {
43         if (object == null) {
44             return false;
45         }
46         if (object == this) {
47             return true;
48         }
49         if (object instanceof Point) {
50             Point point = (Point) object; // 强转为point类型
51             return this.x == point.x && this.y == point.y;
52         }
53         return false;
54     }
55 }

当我们重写 equals 方法后,就可以获取我们想要的结果了,即上面代码第 6 行结果输出为 true。同样的,只有自己定义的类需要重写,JAVA API 提供的类基本都重写了 equals。

原文地址:https://www.cnblogs.com/weijiutao/p/11927146.html

时间: 2024-10-01 04:35:52

Java 从入门到进阶之路(十八)的相关文章

Java 从入门到进阶之路(八)

在之前的文章我们介绍了一下 Java 中的重载,接下来我们看一下 Java 中的构造方法. 我们之前说过,我们在定义一个变量的时候,java 会为我们提供一个默认的值,字符串为 null,数字为 0.如下: 1 public class HelloWorld { 2 public static void main(String[] args) { 3 User e = new User(); // 创建一个 User 对象 4 e.print(); // 姓名:null 年龄:0 性别:null

Java 从入门到进阶之路(十四)

在之前的文章我们介绍了一下 Java 中的抽象类和抽象方法,本章我们来看一下 Java 中的接口. 在日常生活中,我们会接触到很多类似接口的问题,比如 USB 接口,我们在电脑上插鼠标,键盘,U盘的时候不用去考虑它到底能不能插进去,只要型号对了就肯定能插进去,接口就相当于一个标准,你要想把鼠标插到我的电脑上,在出厂时就必须遵守该电脑定义的接口标准. 在 Java 中同样有接口的概念,当然也会有接口的定义标准. 1.有 interface 定义: 2.只能包含常量和抽象方法: 3.接口不能被实例化

Java 从入门到进阶之路(十五)

在之前的文章我们介绍了一下 Java 中的接口,本章我们来看一下 Java 中类的多态. 在日常生活中,很多意思并不是我们想要的意思,如下: 1.领导:“你这是什么意思?” 小明:“没什么意思,意思意思.” 领导:“你这就不够意思了.” 小明:“小意思,小意思.” 领导:“你这人真有意思.” 小明:“其实也没有别的意思.” 领导:“那我就不好意思了.” 小明:“是我不好意思.” 2.电视剧<快把我哥带走> 妹:“你根本就不懂我.” 哥:“你不说我怎么懂你啊,” 妹:“真的懂不需要说出来,” 哥

Java 从入门到进阶之路(十九)

在之前的文章我们介绍了一下 Java 中的Object,本章我们来看一下 Java 中的包装类. 在 Java 中有八个基本类型:byte,short,int,long,float,double,char,boolean,是以值的形式存在的,所以他们并没有面向对象的特征,自然也不继承自 Object,所以不能使用多台,用 Object 的角度去接受基本类型. 假设现在我们有一个计算 1+1 的值,代码如下: 1 public class Main { 2 public static void m

Java 从入门到进阶之路(三)

之前的文章我们介绍了 Java 中的变量和基本数据类型,本章我们来看一下 Java 的运算符和表达式. 计算机的最基本用途之一就是执行数学运算,作为一门计算机语言,Java也提供了一套丰富的运算符来操纵变量.我们可以把运算符分成以下几组: 算术运算符 关系运算符 位运算符 逻辑运算符 赋值运算符 其他运算符 算术运算符 算术运算符用在数学表达式中,它们的作用和在数学中的作用一样.下表列出了所有的算术运算符. 表格中的实例假设整数变量A的值为10,变量B的值为20: 操作符 描述 例子 + 加法

Java 从入门到进阶之路(四)

之前的文章我们介绍了 Java 的运算符和表达式,本章我们来看一下 Java 的循环结构. 循环是程序设计语言中反复执行某些代码的一种计算机处理过程,是一组相同或相似语句被有规律的重复性进行. 循环的要素: - 循环变量的初始化 - 循环条件(以循环变量为基础) - 循环变量的改变(向着循环的结束进行改变) Java中有三种主要的循环结构: while 循环 do…while 循环 for 循环 while 循环 while是最基本的循环,它的结构为: while(布尔表达式){ //循环内容

Java 从入门到进阶之路(十一)

之前的文章我们介绍了一下 Java 中的继承,接下来我们继续看一下 Java 中的继承. 在有些时候,我们通过类继承的方式可以获取父类的方法,但是有些时候父类为我们提供的方法并不完全符合我们的需求,这时候我们就要对类方法进行重写,如下: 1 public class HelloWorld { 2 public static void main(String[] args) { 3 Student student = new Student(); 4 student.name = "张三"

Redis进阶实践之十八 使用管道模式提高Redis查询的速度

原文:Redis进阶实践之十八 使用管道模式提高Redis查询的速度 一.引言 学习redis 也有一段时间了,该接触的也差不多了.后来有一天,以为同事问我,如何向redis中批量的增加数据,肯定是大批量的,为了这主题,我从新找起了解决方案.目前的解决方案大都是从官网上查找和翻译的,每个实例也都调试了,正确无误.把结果告诉我同事的时候,我也跟清楚这个主题如何操作了,里面的细节也更清楚了.大然也有人说可以通过脚本来做这个操作,没错,但是我对脚本语言还没有研究很透,就不来班门弄斧了. 二.管道的由来

Python 爬虫从入门到进阶之路(十四)

之前的文章我们已经可以根据 re 模块,Xpath 模块和 BeautifulSoup4 模块来爬取网站上我们想要的数据并且存储在本地,但是我们并没有对存储数据的格式有要求,本章我们就来看数据的存储格式 JSON 及 Python 中的 json 模块. JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式,它使得人们很容易的进行阅读和编写.同时也方便了机器进行解析和生成.适用于进行数据交互的场景,比如网站前台与后台之间的数据交互. JSON和XML的比较