1.3 构造方法
它也被称为构造函数、构造器。类创建对象是通过调用构造方法来实现的。构造方法是一种特殊的方法，方法名必须和类名一致，不需要定义返回值类型。
public ClassName(Params) {
// 方法体
}
示例代码如下：
（1）在 Student 类中编写构造器：
public class Student {
public Student() { }
}
（2）在主函数中调用该构造器：
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
Student student = new Student();
}
}
【注意：对于在别处调用构造器，如果我们要去查看这个构造器，只需要按住 Ctrl 键，用鼠标点击构造方法名即可】
【注意：该部分为新创建的构造方法，它存储在堆内存中；它为新创建的对象，它存储的是前面新创建的构造器的地址，并且存储在栈内存中，当我们使用新创建的对象时，会发现一个内存地址，根据这个内存地址从而找到了构造器】
构造方法主要分为两种：（1）无参构造；（2）有参构造。每个类默认都有一个无参构造，定义类的时候不需要专门声明无参构造方法，如果手动定义一个有参构造，则会覆盖默认的无参构造。
1.4 创建对象
创建对象只需要调用对应类的构造器即可，构造器分为无参构造和有参构造，区别在于调用无参构造创建的对象，不会给属性赋值，需要手动对属性进行赋值，先创建再赋值。调用有参构造，则不需要在构造函数外部进行属性赋值，构造函数本身就会为创建好的对象赋值，只需要在调用的时候将属性值传入即可，边创建边赋值。
【注意：（1）int 的默认值为 0，String 的默认值为 null；（2）在 Java 中，int 类型的数如果以 0 开头，则会认为是八进制数；（3）若是 double 类型的数据，传参 01.23，则会输出 1.23，因为 Java 中（Java7 以后）只支持十进制和十六进制，不支持八进制，所以会输出实际值】
（1）构造器为无参构造时
创建构造器代码如下：
public class User {
public int id;
public String name;
public int age;
public User() { }
}
调用该构造器代码如下：
public class Test {
public static void main(String[] args) {
User user = new User();
user.id = 1;
user.name = "02";
user.age = 3;
System.out.println(user.id);
System.out.println(user.name);
System.out.println(user.age);
}
}
输出结果如下：
1 02 3
（2）构造器为有参构造时
创建构造器代码如下：
public class User {
public int id;
public String name;
public int age;
public User() { }
public User(int id, String name, int age) { }
}
调用构造器：
public class Test {
public static void main(String[] args) {
User user = new User(1, "02", 3);
System.out.println(user.id);
System.out.println(user.name);
System.out.println(user.age);
}
}
输出结果：
0 null 0
错误原因：输出这样的结果是因为我们传入的参数名和构造器中的属性名是一样的，其本质代码如下所示，程序不知道我们在构造器中定义的 id 到底是类中的属性还是传入的参数，根据就近原则，程序会默认把定义的 id 当成我们传入的参数，也就是把传入的参数又给赋值成属性名 (或者说是参数名)，此时就会输出默认值。
public class User {
public int id;
public String name;
public int age;
public User() { }
public User(int id, String name, int age) {
id = id;
name = name;
age = age;
}
}
解决方法：
（1）修改传入的参数的参数名，如下代码：
public class User {
public int id;
public String name;
public int age;
public User() { }
public User(int id1, String name1, int age1) {
id = id1;
name = name1;
age = age1;
}
}
（2）使用 this 关键字，使用此种方式比较常见。【使用 this 关键字则是指定其为属性名】如下代码：
public class User {
public int id;
public String name;
public int age;
public User() { }
public User(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
}
修改后最终结果如下：
1 02 3
1.5 使用对象
对象的使用包括获取和修改属性，调用方法。访问属性通过 对象名。属性名 来完成，调用方法通过 对象名。方法名 来完成。
在 User 类中新定义一个 test 方法，代码如下：
public int test() {
return 0;
}
对属性的获取、修改以及方法调用的代码：
public class Test {
public static void main(String[] args) {
User user = new User(1, "02", 3);
user.id = 2; // 属性的修改
System.out.println(user.name); // 属性的获取
user.test(); // 方法的调用
}
}
1.6 this 关键字
在类定义的时候通常会使用 this 关键字，this 用来指代当前类的实例化对象，通过 this 可以调用当前类的属性和方法，例如在有参构造函数中，通过 this 关键字将外部传入的值赋给当前类的实例化对象。this 关键字除了可以在类中访问属性也可以在类中调用方法。类中方法分为两种：（1）构造方法；（2）普通方法。
1.6.1 方法的调用
（1）调用构造方法：this(参数列表)，【注意：不能在普通方法中使用 this 关键字来调用构造方法】。代码示例如下：
public User(int id, String name, int age) {
this(); // 在构造方法中调用无参构造方法
}
public User() {
this(1, "02", 3); // 在构造方法中调用有参构造方法
}
【注意：两者不能同时互相调用，否则会报错。原因是我们不能无限的去调用创建对象，最终会导致内存溢出，所以代码会报错】。如下代码所示：
public User() {
this(1, "02", 3);
}
public User(int id, String name, int age) {
this(); // 在方法中调用无参构造方法
}
（2）调用普通方法：this.方法名 (参数列表)。无论是在构造器中还是普通方法中都可以调用普通方法。【注意：在自己的方法中调用自己，即为递归】具体代码如下：
public User() {
this.test(); // 在无参构造器中调用普通方法
}
public User(int id, String name, int age) {
this.test(); // 在有参构造器中调用普通方法
}
public int test() {
this.test(); // 在自己的普通方法中调用普通方法（递归）
return 0;
}
public int test2() {
this.test(); // 在另一个普通方法调用普通方法
return 1;
}
1.7 方法重载
方法重载是体现 Java 代码复用的一种重要方式，指的是两个方法之间的一种关系。
1.7.1 方法之间可以构成重载所要具备的条件
（1）方法在同一个类中；（2）方法名相同；（3）参数列表不同（个数或类型不同）；（4）与返回值和访问权限修饰符无关。
方法重载具体代码如下：
public class Test {
public static void main(String[] args) {
Test test = new Test();
test.method();
test.method(1);
}
public void method() {
System.out.println("无参");
}
public void method(int num) {
System.out.println("有参");
}
}
结果如下：
无参 有参
1.8 成员变量和局部变量
变量之间除了数据类型、变量名、变量值不同之外，变量的作用域范围也是不同的。变量的作用域是指在程序中可以通过变量名来访问该变量的范围，变量的作用域是由变量被声明时所在的位置决定的。
Java 中根据不同的作用域可以将变量分为成员变量和局部变量。（1）如果一个变量在方法中声明，则该变量为局部变量；（2）如果一个变量在方法外，类中声明，则该变量为成员变量。
具体代码如下：
public class Test {
int id = 1; // 成员变量
public void method() {
int id1 = 1; // 局部变量
}
}
1.8.1 成员变量和局部变量的作用域的区别
成员变量的作用域在整个类中，类中的每个方法都可以访问该变量。局部变量的作用域只在定义该变量的方法中，出了该方法就无法访问。
示例代码如下【由于变量的作用域不同，最后一行代码会报错】：
public class Test {
int num = 1;
public void a1() {
int num1 = 2;
System.out.println(num);
}
public void a2() {
System.out.println(num1);
}
}
1.8.2 不同作用域的变量的优先级
当成员变量和局部变量重名的时候，局部变量优先级更高。
具体代码如下：
public class Test {
int num = 1;
public void a1() {
int num = 2;
System.out.println(num);
}
public static void main(String[] args) {
Test test = new Test();
test.a1();
}
}
输出结果如下：
2
之前讲到 this 关键字会把变量定义到类中定义的属性名，【this 是指当前类的意思】于是有以下结果：
public class Test {
int num = 1;
public void a1() {
int num = 2;
System.out.println(this.num);
}
public static void main(String[] args) {
Test test = new Test();
test.a1();
}
}
此时结果如下：
1
1.8.3 不同作用域的变量的初始值
成员变量和局部变量除了作用域不同之外，初始值也不同，Java 会给成员变量赋初始值，局部变量则不会赋初始值，不同数据类型的成员变量的初始值也不同。具体如下：
（1）整数类型的初始值是 0；（2）浮点型的初始值是 0.0；（3）char 类型的初始值是 ' '；（4）boolean 类型的初始值是 false；（5）引用类型的初始值是 null
【注意：null 是指内存已经开辟出来了，但里面没有任何东西】
示例代码如下：
public class Test {
String a1;
Object object;
byte a2;
int a3;
short a4;
long a5;
double a6;
float a7;
char a8;
boolean a9;
public void method() {
System.out.println(a1);
System.out.println(object);
System.out.println(a2);
System.out.println(a3);
System.out.println(a4);
System.out.println(a5);
System.out.println(a6);
System.out.println(a7);
System.out.println(a8);
System.out.println(a9);
}
public static void main(String[] args) {
Test test = new Test();
test.method();
}
}
输出结果如下：
null null 0 0 0 0 0.0 0.0 false
