面向对象基础
定义class
在Java中，创建一个类，例如，给这个类命名为Person,就是定义一个class:
class Person {
public String name;
public int age;
}
创建实例
定义了class.只是定义了对象模板，而要根据对象模板创建出真正的对象实例，必须用new操作符。new操作符可以创建一个实例，然后，我们需要定义一个引用类型的变量来指向这个实例：
Person ming = new Person();
上述代码创建了一个Person类型的实例，并通过变量ming指向它
注意区分Person ming是定义Person类型的变量ming,而new Person()是创建Person实例。
有了指向这个实例的变量，我们就可以通过这个变量来操作实例。访问实例变量可以用变量.字段，例如：
ming.name = "Xiao Ming"; // 对字段name赋值
ming.age = 12; // 对字段age赋值
System.out.println(ming.name); // 访问字段name
Person hong = new Person();
hong.name = "Xiao Hong";
hong.age = 15;
两个instance拥有class定义的name和age字段，且各自都有一份独立的数据，互不干扰。
小结：
方法
一个class可以包含多个field,例如，我们给``类就定义了两个field:
class Person {
public String name;
public int age;
}
但是，直接把field用public暴露给外部可能会破坏封装性。比如，代码可以这样写：
Person ming = new Person();
ming.name = "Xiao Ming";
ming.age = -99; // age设置为负数
显然，直接操作field,容易造成逻辑混乱。为了避免外部代码直接去访问field,我们可以用private修饰field,拒绝外部访问：
class Person {
private String name;
private int age;
}
这时候需要使用方法（method）来让外部代码可以简洁修改field:
// private field
public class Main {
public static void main(String[] args) {
Person ming = new Person();
ming.setName("Xiao Ming"); // 设置name
ming.setAge(12); // 设置age
System.out.println(ming.getName() + ", " + ming.getAge());
}
}
class Person {
private String name;
private int age;
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return this.age;
}
public void setAge(int age) {
if (age < 0 || age > 100) {
throw new IllegalArgumentException("invalid age value");
}
this.age = age;
}
}
虽然外部代码不能直接修改private字段，但是，外部代码可以调用方法setName()和setAge()来间接修改private字段。在方法内部，我们就有机会检查参数对不对。比如，setAge()就会检查传入的参数，参数超出了范围，直接报错。这样，外部代码就没有任何机会把age设置成不合理的值。
对setName()方法同样可以做检查，例如 ，不允许传入null和空字符串:
public void setName(String name) {
if (name == null || name.isBlank()) {
throw new IllegalArgumentException("invalid name");
}
this.name = name.strip(); // 去掉首尾空格
}
同样，外部代码不能直接读取private字段，但可以通过getName()和getAge()间接获取private字段的值.
所以，一个类通过定义方法，就可以给外部代码暴露一些操作的接口，同时，内部自己保证逻辑一致性。调用方法的语法是实例变量.方法名（参数）；。一个方法调用就是一个语句，所以不要忘记在末尾加上;。例如:ming.setName("Xiao Ming")；
定义方法
从上面的代码可以看出，定义方法的语法是：
修饰符 方法返回类型 方法名(方法参数列表) {
若干方法语句;
return 方法返回值;
}
方法返回值通过return语句实现，如果没有返回值，返回类型设置为void，可以省略return
private 方法
有了public方法，自然就有private方法。和private字段一样，private方法不允许外部调用，那我们定义private是为了让内部方法调用private方法的。例如：
// private method
public class Main {
public static void main(String[] args) {
Person ming = new Person();
ming.setBirth(2008);
System.out.println(ming.getAge());
}
}
class Person {
private String name;
private int birth;
public void setBirth(int birth) {
this.birth = birth;
}
public int getAge() {
return calcAge(2019); // 调用private方法
}
// private方法:
private int calcAge(int currentYear) {
return currentYear - this.birth;
}
}
calcAge()是一个private方法，外部代码无法调用，但是，内部方法getAge()可以调用它.
此外，这个Person类只定义了birth字段，没有定义age字段，获取age时，通过方法getAge()返回的是一个实时计算的值，并非存储在某个字段的值，这说明方法可以封装一个类的对外接口。
this 变量
在方法内部，可以使用一个隐含的变量this，它始终指向当前实例。因此，通过this.field就可以访问当前实例的字段。
如果没有命名冲突，可以省略this。例如：
class Person {
private String name;
public String getName() {
return name; // 相当于this.name
}
}
但是，如果局部变量和字段重名，那么局部变量的优先级更高，就必须加上this:
class Person {
private String name;
public void setName(String name) {
this.name = name; // 前面的this不可少，少了就变成局部变量name了
}
}
方法参数
方法包含0个或任意个参数。方法参数用于接收传递给方法的变量值。调用方法时，必须严格按照参数的定义一一传递。例如：
class Person {
...
public void setNameAndAge(String name, int age) { // 多个参数之间用逗号隔开
...
}
}
可变参数
可变参数用类型...定义，可变参数相当于数组类型：
class Group {
private String[] names;
public void setNames(String... names) {
this.names = names;
}
}
上面的setNames()就定义了一个可变参数。调用时，可以 这么写：
Group g = new Group();
g.setNames("Xiao Ming", "Xiao Hong", "Xiao Jun"); // 传入3个String
g.setNames("Xiao Ming", "Xiao Hong"); // 传入2个String
g.setNames("Xiao Ming"); // 传入1个String
g.setNames(); // 传入0个String
参数绑定
调用方把参数传递给实例方法时，调用时传递的值会按参数位置一一绑定。
// 基本类型参数绑定
public class Main {
public static void main(String[] args) {
Person p = new Person();
int n = 15; // n的值为15
p.setAge(n); // 传入n的值
System.out.println(p.getAge()); // 15
n = 20; // n的值改为20
System.out.println(p.getAge()); // 15还是20? 答案是15
}
}
class Person {
private int age;
public int getAge() {
return this.age;
}
public void setAge(int age) {
this.age = age;
}
}
结论：基本类型参数的传递，是调用方值的复制，双方各自的后续修改，互不影响
传递引用参数的实例:
public class Main {
public static void main(String[] args) {
Person p = new Person();
String[] fullname = new String[] { "Homer", "Simpson" };
p.setName(fullname); // 传入fullname数组
System.out.println(p.getName()); // "Homer Simpson"
fullname[0] = "Bart"; // fullname数组的第一个元素修改为"Bart"
System.out.println(p.getName()); // "Homer Simpson"还是"Bart Simpson"?
}
}
class Person {
private String[] name;
public String getName() {
return this.name[0] + " " + this.name[1]; // 返回数组的各项值
}
public void setName(String[] name) {
this.name = name;
}
}
注意到setName()的参数现在是一个数组。一开始，把fullname数组传进去，然后，修改fullname数组内容，结果发现，实例p的字段p.name也被修改了！
结论：引用类型参数的传递，调用方的变量和接收方的参数变量，指向的是同一个对象。双方任意一方对这个对象的修改，都会影响双方（因为指向同一个对象嘛）
小结：
- 方法可以让外部代码安全地访问实例字段；
- 方法是一组执行语句，并且可以执行任意逻辑；
- 方法内部遇到return时返回，void表示不返回任何值（注意和返回null不同）
- 外部代码通过public方法操作实例，内部代码可以调用private方法
- 理解方法的参数绑定
构造方法
创建实例的时候，我们经常需要同时初始化这个实例的字段，例如：
Person ming = new Person();
ming.setName("小明");
ming.setAge(12);
初始化对象实例需要3行代码，而且，如果忘了调用setName()或者setAge()，这个实例内部的状态就是不正确的。
创建实例的时候，实际上是通过构造方法来初始化实例的。我们先来定义一个构造方法，能在创建Person实例的时候，一次性传入name和age,完成初始化：
// 构造方法
public class Main {
public static void main(String[] args) {
Person p = new Person("Xiao Ming", 15);
System.out.println(p.getName());
System.out.println(p.getAge());
}
}
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return this.name;
}
public int getAge() {
return this.age;
}
}
由于构造方法是很特殊的，所以构造方法的名称就是类名。构造方法的参数没有限制，在方法内部，也可以编写任意语句。但是，和普通方法相比，构造方法没有返回值（也没有void）,调用构造方法，必须用new操作符。
默认构造方法
任何class都有构造方法，前面虽然 没写Person类编写构造方法，为什么可以调用new Person()?原因是如果一个类没有定义构造方法，编译器会自动为我们生成一个默认构造方法，它没有参数，也没有执行语句，类似这样：
class Person {
public Person() {
}
}
要特别注意的是，如果我们自定义了一个构造方法，那么，编译器就不再自动创建默认构造方法：
public class Main {
public static void main(String[] args) {
Person p = new Person(); // 编译错误:找不到这个构造方法
}
}
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return this.name;
}
public int getAge() {
return this.age;
}
}
如果既要能使用带参数的构造方法，又想保留不带参数的构造方法，那么只能把两个构造方法都定义出来：
// 构造方法
public class Main {
public static void main(String[] args) {
Person p1 = new Person("Xiao Ming", 15); // 既可以调用带参数的构造方法
Person p2 = new Person(); // 也可以调用无参数构造方法
}
}
class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return this.name;
}
public int getAge() {
return this.age;
}
}
没有在构造方法中初始化字段时，引用类型的字段默认是null,数值类型的字段用默认值，int类型默认值是0,布尔类型默认值是false:
class Person {
private String name; // 默认初始化为null
private int age; // 默认初始化为0
public Person() {
}
}
也可以对字段直接进行初始化：
class Person {
private String name = "Unamed";
private int age = 10;
}
那么问题来了：既对字段进行初始化，又在构造方法中对字段进行初始化：
class Person {
private String name = "Unamed";
private int age = 10;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
多构造方法
可以定义多个构造方法，在通过new操作符调用的时候，编译器通过构造方法的参数数量、位置和类型自动区分：
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person(String name) {
this.name = name;
this.age = 12;
}
public Person() {
}
}
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person(String name) {
this(name, 18); // 调用另一个构造方法Person(String, int)
}
public Person() {
this("Unnamed"); // 调用另一个构造方法Person(String)
}
}
总结：
- 实例在创建时通过
new操作符会调用其对应的构造方法，构造方法用于初始化实例； - 没有定义构造方法时，编译器会自动创建一个默认的无参数构造方法
- 可以定义多个构造方法，编译器根据参数自动判断
- 可以在一个构造方法内部调用另一个构造方法，用于代码复用。
方法重载
在一个类中，我们可以定义多个方法，如果有一系列方法，它们的功能都是类似的，只有参数有所不同，那么，可以把这一组方法名做成同名方法。例如，在Hello类中，定义多个hello()方法：
class Hello {
public void hello() {
System.out.println("Hello, world!");
}
public void hello(String name) {
System.out.println("Hello, " + name + "!");
}
public void hello(String name, int age) {
if (age < 18) {
System.out.println("Hi, " + name + "!");
} else {
System.out.println("Hello, " + name + "!");
}
}
}
这种方法名相同，但各自的参数不同，称为方法重载（Overload）.
注意：方法重载的返回值类型通常都是相同的。
方法重载的返回值类型通常都是相同的。
方法重载的目的是，功能类似的方法使用同一名字，更容易记住，因此，调用起来更简单
举个例子，String类提供了多个重载方法indexOf()，可以查找子串：
-
int indexOf():根据字符的Unicode码查找； -
int indexOf(String str):根据字符串查找； -
int indexOf(int ch, int formIndex)：根据字符查找，但指定起始位置； -
int indexOf(String str, int formIndex):根据字符串查找，但指定起始位置。
// String.indexOf()
public class Main {
public static void main(String[] args) {
String s = "Test string";
int n1 = s.indexOf('t');
int n2 = s.indexOf("st");
int n3 = s.indexOf("st", 4);
System.out.println(n1); // 3
System.out.println(n2);// 2
System.out.println(n3); // 5
}
}
小结：
- 方法重载是指多个方法的方法名相同，但各自的参数不同；
- 重载方法应该完成类似的功能，参考
String的indexOf(); - 重载方法返回值类型应该相同
