构造器和this关键字
构造器
Java类中自带构造器，实际是一个类同名的方法，默认参数为空，想指定参数需要重写。
Java构造器类似Python的构造函数，都是在初始化类时调用，不同的是Java可以同时存在有参和无参两个构造器。
指定参数后想再次使用无参构造器，需要声明一个无参的。
this关键字
this关键字代表当前对象本身的地址，类似于Python的self：
- Java：this.name
- Python：self.name
示例
Person类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| public class Person {
String name;
double age;
public Person(){
System.out.println("！无参构造器");
}
public Person(String name, double age){
this.name = name;
this.age = age;
System.out.println("！有参构造器");
}
}
|
Test类
1
2
3
4
5
6
7
8
9
10
11
| public class Test {
public static void main(String[] args) {
Person user1 = new Person();
System.out.println("姓名：" + user1.name);
System.out.println("年龄：" + user1.age);
Person user2 = new Person("张三", 18);
System.out.println("姓名：" + user2.name);
System.out.println("年龄：" + user2.age);
}
}
|
输出
封装
封装概念
面向对象的三大特征：封装、继承、多态。
为了防止类成员变量被直接外部调用操作，一般将成员变量设定为private私有类型，不暴漏在外，定义对外的setter和getter方法来对其操作，在setter和getter方法中写入相关合法判断，用户在进行存取数据时，只需要调用setter和getter方法即可。
好处：增强代码的安全性、提高开发效率。
示例
Person类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| public class Person {
private double age;
public void setAge(double age){
if (age >= 0 && age <= 150){
this.age = age;
System.out.println("年龄合法");
}else {
System.out.println("年龄不合法");
}
}
public double getAge(){
return this.age;
}
}
|
Main类
1
2
3
4
5
6
7
8
9
10
11
12
13
| public class Main {
public static void main(String[] args) {
Person user1 = new Person();
user1.setAge(20);
System.out.println("年龄：" + user1.getAge());
System.out.println("-----");
Person user2 = new Person();
user2.setAge(200);
System.out.println("年龄：" + user2.getAge());
}
}
|
JavaBean
概念
JavaBean可以理解为实体类，可用于存取数据、封装数据，一个实体类必须包含以下三要素：
- 必须提供一个无参构造器（有参看需求）
- 成员变量私有（private修饰）
- 每个成员变量都有对应的setXxx()和getXxx()方法来供外部操作
IDEA中可快捷生成相关代码。
示例
标准实体类：Person类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| public class Person {
private String name;
private Double age;
public Person() {
}
public Person(String name, Double age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Double getAge() {
return age;
}
public void setAge(Double age) {
this.age = age;
}
}
|
String类
常见几种对象创建方式
String s1 = " "
String s2 = new String(" ")
字符数组自动合并为字符串
1
2
| char[] c1 = {'a', 'b', 'c'};
String s5 = new String(c1);
|
byte字节型自动转为字符，再合并为字符串
1
2
| byte[] byte1 = {97, 98, 99};
String s6 = new String(byte1);
|
String类型变量对比
“ “创建的String变量之间的对比
“ ”创建的变量，变量存储的是常量在堆内存中的地址，同样的常量，常量池中只存在一个，因此两个变量地址相同
new String创建的String变量之间的对比
两个new String创建两个字符串对象，地址不同
“ “和new String创建的String变量之间的对比
“ ”创建的变量存的常量地址，new String创建字符串对象，变量存的字符串对象地址，两个地址不同
equals()
equals()方法只对比变量内容
示例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
public class StringDemo {
public static void main(String[] args) {
String s1 = "示例";
String s2 = "示例";
System.out.println(s1 == s2);
String s3 = new String("示例");
System.out.println(s1 == s3);
String s4 = new String("示例");
System.out.println(s3 == s4);
char[] c1 = {'a', 'b', 'c'};
String s5 = new String(c1);
System.out.println("s5: " + s5);
byte[] byte1 = {97, 98, 99};
String s6 = new String(byte1);
System.out.println("s6: " + s6);
System.out.println(s3.equals(s4));
}
}
|
