Java语言ch04 面向对象基础

字数统计: 5.8k字   |   阅读时长: 24分

本文主要内容为面向对象基础内容，包括方法、构造方法、重载、继承、多态等。

方法

把field从public改成private，外部代码不能访问这些field，所以我们需要使用方法（method）来让外部代码可以间接修改field：

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
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设置成不合理的值。

一个类通过定义方法，就可以给外部代码暴露一些操作的接口，同时，内部自己保证逻辑一致性。

定义方法

定义方法的语法是：

1
2
3
4
修饰符 方法返回类型 方法名(方法参数列表) {
    若干方法语句;
    return 方法返回值;
}

this

在方法内部，可以使用一个隐含的变量this，它始终指向当前实例。因此，通过this.field就可以访问当前实例的字段。

如果没有命名冲突，可以省略this。例如：

1
2
3
4
5
6
7
class Person {
    private String name;

    public String getName() {
        return name; // 相当于this.name
    }
}

但是，如果有局部变量和字段重名，那么局部变量优先级更高，就必须加上this说明指向当前实例：

1
2
3
4
5
6
7
class Person {
    private String name;

    public void setName(String name) {
        this.name = name; // 前面的this不可少，少了就变成局部变量name了
    }
}

可变参数

可变参数用类型...定义，可变参数相当于数组类型：

1
2
3
4
5
6
7
class Group {
    private String[] names;

    public void setNames(String... names) {
        this.names = names;
    }
}

setNames()就定义了一个可变参数。调用时，可以这么写：

1
2
3
4
5
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

参数绑定

调用方把参数传递给实例方法时，调用时传递的值会按参数位置一一绑定。

基本参数类型绑定

class Main {
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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
    }
}

class Person {
    private int age;

    public int getAge() {
        return this.age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

结论：基本类型参数的传递，是调用方值（上面代码传递的为15）的复制。双方各自的后续修改，互不影响。

引用参数类型绑定

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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()); // 变为"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;
    }
}

结论：引用类型参数的传递，调用方的变量和接收方的参数变量，指向的是同一个对象。双方任意一方对这个对象的修改，都会影响对方。

构造方法

在创建对象实例时就把内部字段全部初始化为合适的，我们就需要构造方法。

创建实例的时候，实际上是通过构造方法来初始化实例的。

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
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操作符。

默认构造方法

如果一个类没有定义构造方法，编译器会自动为我们生成一个默认构造方法，它没有参数，也没有执行语句，类似这样：

1
2
3
4
class Person {
    public Person() {
    }
}

如果我们自定义了一个构造方法，那么，编译器就不再自动创建默认构造方法。

如果既要能使用带参数的构造方法，又想保留不带参数的构造方法，那么只能把两个构造方法都定义出来。

没有在构造方法中初始化字段时，引用类型的字段默认是null，数值类型的字段用默认值，int类型默认值是0，布尔类型默认值是false。

在Java中，创建对象实例的时候，按照如下顺序进行初始化：

  1. 先初始化字段，例如，int age = 10;表示字段初始化为10，double salary;表示字段默认初始化为0，String name;表示引用类型字段默认初始化为null；
  2. 执行构造方法的代码进行初始化。

多构造方法

可以定义多个构造方法，在通过new操作符调用的时候，编译器通过构造方法的参数数量、位置和类型自动区分：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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() {
    }
}

一个构造方法可以调用其他构造方法，这样做的目的是便于代码复用。调用其他构造方法的语法是this(…)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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操作符会调用其对应的构造方法，构造方法用于初始化实例；

  • 没有定义构造方法时，编译器会自动创建一个默认的无参数构造方法；

  • 可以定义多个构造方法，编译器根据参数自动判断；

  • 可以在一个构造方法内部调用另一个构造方法，便于代码复用。

方法重载

方法名相同，但各自的参数不同，称为方法重载（Overload）

注意：方法重载的返回值类型通常都是相同的。

方法重载的目的是，功能类似的方法使用同一名字，更容易记住，因此，调用起来更简单。

重载方法indexOf()

String类提供了多个重载方法indexOf()，可以查找子串：

  • int indexOf(int ch)：根据字符的Unicode码查找；
  • int indexOf(String str)：根据字符串查找；
  • int indexOf(int ch, int fromIndex)：根据字符查找，但指定起始位置；
  • int indexOf(String str, int fromIndex)根据字符串查找，但指定起始位置。

小结

  • 方法重载是指多个方法的方法名相同，但各自的参数不同；

  • 重载方法应该完成类似的功能，参考String的indexOf()；

  • 重载方法返回值类型应该相同。

继承

定义

Java使用extends关键字来实现继承：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Person {
    private String name;
    private int age;

    public String getName() {...}
    public void setName(String name) {...}
    public int getAge() {...}
    public void setAge(int age) {...}
}

class Student extends Person {
    // 不要重复name和age字段/方法,
    // 只需要定义新增score字段/方法:
    private int score;

    public int getScore() { … }
    public void setScore(int score) { … }
}

在OOP的术语中，我们把Person称为超类（super class），父类（parent class），基类（base class），把Student称为子类（subclass），扩展类（extended class）。

Java只允许一个class继承自一个类，因此，一个类有且仅有一个父类。只有Object特殊，它没有父类。

protected

为了让子类可以访问父类的字段，我们需要把private改为protected。用protected修饰的字段可以被子类访问。

protected关键字可以把字段和方法的访问权限控制在继承树内部，一个protected字段和方法可以被其子类，以及子类的子类所访问。

super

super关键字表示父类（超类）。子类引用父类的字段时，可以用super.fieldName。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Main {
    public static void main(String[] args) {
        Student s = new Student("Xiao Ming", 12, 89);
    }
}

class Person {
    protected String name;
    protected int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

class Student extends Person {
    protected int score;

    public Student(String name, int age, int score) {
        this.score = score;
    }
}

编译错误，原因是在Student的构造方法中，无法调用父类Person的构造方法。

在Java中，任何class的构造方法，第一行语句必须是调用父类的构造方法。如果没有显式调用父类的构造方法，编译器会帮我们自动加一句super();

Student类的构造方法实际上是这样：

1
2
3
4
5
6
7
8
class Student extends Person {
    protected int score;

    public Student(String name, int age, int score) {
        super(); // 自动调用父类的构造方法
        this.score = score;
    }
}

但是，Person类并没有无参数的构造方法，因此，编译失败。

解决方法是调用Person类存在的某个构造方法。例如：

1
2
3
4
5
6
7
8
class Student extends Person {
    protected int score;

    public Student(String name, int age, int score) {
        super(name, age); // 调用父类的构造方法Person(String, int)
        this.score = score;
    }
}

向上转型

把一个子类类型安全地变为父类类型的赋值，被称为向上转型（upcasting）。

继承树是Student > Person > Object，所以，可以把Student类型转型为Person，或者更高层次的Object。

向上转型实际上是把一个子类型安全地变为更加抽象的父类型：

1
2
3
4
Student s = new Student();
Person p = s; // upcasting, ok
Object o1 = p; // upcasting, ok
Object o2 = s; // upcasting, ok

向下转型

把一个父类类型强制转型为子类类型，就是向下转型（downcasting）

不能把父类变为子类，因为子类功能比父类多，向下转型很可能会失败。失败的时候，Java虚拟机会报ClassCastException。

利用instanceof，在向下转型前可以先判断：

1
2
3
4
5
Person p = new Student();
if (p instanceof Student) {
    // 只有判断成功才会向下转型:
    Student s = (Student) p; // 一定会成功
}

区分继承和组合

继承是is关系，组合是has关系。

Student是Person的一种，它们是is关系，而Student并不是Book，Student和Book的关系是has关系。

具有has关系不应该使用继承，而是使用组合，即Student可以持有一个Book实例：

1
2
3
4
class Student extends Person {
    protected Book book;
    protected int score;
}

小结

  • 继承是面向对象编程的一种强大的代码复用方式；
  • Java只允许单继承，所有类最终的根类是Object；
  • protected允许子类访问父类的字段和方法；
  • 子类的构造方法可以通过super()调用父类的构造方法；
  • 可以安全地向上转型为更抽象的类型；
  • 可以强制向下转型，最好借助instanceof判断；
  • 子类和父类的关系是is，has关系不能用继承。

多态

覆写

在继承关系中，子类如果定义了一个与父类方法签名完全相同的方法，被称为覆写（Override）。

在Person类中，我们定义了run()方法：

1
2
3
4
5
class Person {
    public void run() {
        System.out.println("Person.run");
    }
}

在子类Student中，覆写这个run()方法：

1
2
3
4
5
6
class Student extends Person {
    @Override
    public void run() {
        System.out.println("Student.run");
    }
}

Java的实例方法调用是基于运行时的实际类型的动态调用，而非变量的声明类型。

多态Polymorphic

针对某个类型的方法调用，其真正执行的方法取决于运行时期实际类型的方法。对某个类型调用某个方法，执行的实际方法可能是某个子类的覆写方法。

多态具有一个非常强大的功能，就是允许添加更多类型的子类实现功能扩展，却不需要修改基于父类的代码。

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
public class Main {
    public static void main(String[] args) {
        // 给一个有普通收入、工资收入和享受国务院特殊津贴的小伙伴算税
        Income[] incomes = new Income[] {
            new Income(3000),
            new Salary(7500),
            new StateCouncilSpecialAllowance(15000)
        };
        System.out.println(totalTax(incomes));
    }

    public static double totalTax(Income... incomes) {
        double total = 0;
        for (Income income: incomes) {
            total = total + income.getTax();
        }
        return total;
    }
}

class Income {
    protected double income;

    public Income(double income) {
        this.income = income;
    }

    public double getTax() {
        return income * 0.1; // 税率10%
    }
}

class Salary extends Income {
    public Salary(double income) {
        super(income);
    }

    @Override
    public double getTax() {
        if (income <= 5000) {
            return 0;
        }
        return (income - 5000) * 0.2;
    }
}

class StateCouncilSpecialAllowance extends Income {
    public StateCouncilSpecialAllowance(double income) {
        super(income);
    }

    @Override
    public double getTax() {
        return 0;
    }
}

覆写Object方法

Object定义了几个重要的方法：

  • toString()：把instance输出为String；
  • equals()：判断两个instance是否逻辑相等；
  • hashCode()：计算一个instance的哈希值。

在必要的情况下，我们可以覆写Object的这几个方法。

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
class Person {
    ...
    // 显示更有意义的字符串:
    @Override
    public String toString() {
        return "Person:name=" + name;
    }

    // 比较是否相等:
    @Override
    public boolean equals(Object o) {
        // 当且仅当o为Person类型:
        if (o instanceof Person) {
            Person p = (Person) o;
            // 并且name字段相同时，返回true:
            return this.name.equals(p.name);
        }
        return false;
    }

    // 计算hash:
    @Override
    public int hashCode() {
        return this.name.hashCode();
    }
}

调用父类的被覆写的方法

通过super来调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Person {
    protected String name;
    public String hello() {
        return "Hello, " + name;
    }
}

Student extends Person {
    @Override
    public String hello() {
        // 调用父类的hello()方法:
        return super.hello() + "!";
    }
}

final

因为继承可以使得子类覆写父类的方法，则

  1. 如果一个父类不允许子类对父类的某个方法进行覆写，可以把该方法标记为final，用final修饰的方法不能被Override：

  2. 如果一个类不希望被其他类继承，那么可以把这个类本身标记为final，用final修饰的类不能被继承

  3. 一个类的实例字段，用final修饰的字段在初始化后不能被修改。

在构造方法中初始化final字段：

1
2
3
4
5
6
class Person {
    public final String name;
    public Person(String name) {
        this.name = name;
    }
}

常用，因为可以保证实例一旦创建，其final字段就不可修改。

小结

  • 子类可以覆写父类的方法（Override），覆写在子类中改变了父类方法的行为；
  • Java的方法调用总是作用于运行期对象的实际类型，这种行为称为多态；
  • final修饰符有多种作用：
    • final修饰的方法可以阻止被覆写；
    • final修饰的class可以阻止被继承；
    • final修饰的field必须在创建对象时初始化，随后不可修改。

抽象类

如果父类的方法本身不需要实现任何功能，仅仅是为了定义方法签名，目的是让子类去覆写它，那么，可以把父类的方法声明为抽象方法：

1
2
3
class Person {
    public abstract void run();
}

把一个方法声明为abstract，表示它是一个抽象方法，本身没有实现任何方法语句。因为这个抽象方法本身是无法执行的，所以，Person类也无法被实例化。编译器会告诉我们，无法编译Person类，因为它包含抽象方法。

必须把Person类本身也声明为abstract，才能正确编译它：

1
2
3
abstract class Person {
    public abstract void run();
}

抽象类

如果一个class定义了方法，但没有具体执行代码，这个方法就是抽象方法，抽象方法用abstract修饰。

因为无法执行抽象方法，因此这个类也必须申明为抽象类（abstract class）。

因为抽象类本身被设计成只能用于被继承，因此，抽象类可以强迫子类实现其定义的抽象方法，否则编译会报错。

例如，Person类定义了抽象方法run()，那么，在实现子类Student的时候，就必须覆写run()方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Main {
    public static void main(String[] args) {
        Person p = new Student();
        p.run();
    }
}

abstract class Person {
    public abstract void run();
}

class Student extends Person {
    @Override
    public void run() {
        System.out.println("Student.run");
    }
}

面向抽象编程

引用高层类型，避免引用实际子类型的方式，称之为面向抽象编程。

面向抽象编程的本质就是：

  • 上层代码只定义规范（例如：abstract class Person）；
  • 不需要子类就可以实现业务逻辑（正常编译）；
  • 具体的业务逻辑由不同的子类实现，调用者并不关心。

小结

  • 通过abstract定义的方法是抽象方法，抽象方法只有定义，没有实现。抽象方法定义了子类必须实现的接口规范；
  • 定义了抽象方法的class必须被定义为抽象类，从抽象类继承的子类必须实现抽象方法；
  • 如果不实现抽象方法，则该子类仍是一个抽象类；
  • 面向抽象编程使得调用者只关心抽象方法的定义，不关心子类的具体实现。

接口

在抽象类中，抽象方法本质上是定义接口规范：即规定高层类的接口，从而保证所有子类都有相同的接口实现

如果一个抽象类没有字段，所有方法全部都是抽象方法：

1
2
3
4
abstract class Person {
    public abstract void run();
    public abstract String getName();
}

应该把该抽象类改写为接口：interface。

使用interface可以声明一个接口：

1
2
3
4
interface Person {
    void run();
    String getName();
}

因为接口定义的所有方法默认都是public abstract的，所以这两个修饰符不需要写出来。

当一个具体的class去实现一个interface时，需要使用implements关键字。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Student implements Person {
    private String name;

    public Student(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(this.name + " run");
    }

    @Override
    public String getName() {
        return this.name;
    }
}

在Java中，一个类只能继承自另一个类，不能从多个类继承。但是，一个类可以实现多个interface，例如：

1
2
3
class Student implements Person, Hello { // 实现了两个interface
    ...
}

抽象类和接口的对比

abstract class interface
继承 只能extends一个class 可以implements多个interface
字段 可以定义实例字段 不能定义实例字段
抽象方法 可以定义抽象方法 可以定义抽象方法
非抽象方法 可以定义非抽象方法 可以定义default方法

接口继承

一个interface可以继承自另一个interface。interface继承自interface使用extends，它相当于扩展了接口的方法。例如：

1
2
3
4
5
6
7
8
interface Hello {
    void hello();
}

interface Person extends Hello {
    void run();
    String getName();
}

此时，Person接口继承自Hello接口，因此，Person接口现在实际上有3个抽象方法签名，其中一个来自继承的Hello接口。

default方法

在接口中，可以定义default方法。

default方法的目的是，当我们需要给接口新增一个方法时，会涉及到修改全部子类。如果新增的是default方法，那么子类就不必全部修改，只需要在需要覆写的地方去覆写新增方法。

静态字段和方法

实例字段：class中定义的字段

静态字段static field：用static修饰的字段

实例字段在每个实例中都有自己的一个独立“空间”，但是静态字段只有一个共享“空间”，所有实例都会共享该字段。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Main {
	public static void main(String[] args) {
		Person ming = new Person("Xiao Ming", 12);
		Person hong = new Person("Xiao Hong", 15);
		ming.number = 88;
		System.out.println(hong.number);
		hong.number = 99;
		System.out.println(ming.number);
	}
}

class Person {
	public String name;
	public int age;
	
	public static int number;
	
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
}

输出：

1
2
88
99

因为在Java程序中，实例对象并没有静态字段，不推荐用实例变量.静态字段去访问静态字段。

类名.静态字段来访问静态对象。

上述访问静态字段的代码应该为：

1
2
Person.number = 99;
System.out.println(Person.number);

静态方法

静态方法：用static修饰的方法

调用实例方法必须通过一个实例变量，调用静态方法则不需要实例变量，通过类名就可以调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Main {
    public static void main(String[] args) {
        Person.setNumber(99);
        System.out.println(Person.number);
    }
}

class Person {
    public static int number;

    public static void setNumber(int value) {
        number = value;
    }
}

因为静态方法属于class而不属于实例，因此，静态方法内部，无法访问this变量，也无法访问实例字段，它只能访问静态字段。

Person.setNumber(99); 不需实例化，通过类名调用

接口的静态字段

interface是可以有静态字段的，并且静态字段必须为final类型。

interface的字段只能是public static final类型。

1
2
3
4
5
6
7
8
public interface Person {
    int MALE = 1;
    int FEMALE = 2;
    // 编译器会自动加上public statc final:
    
    //public static final int MALE = 1;
    //public static final int FEMALE = 2;
}

包

Java定义了一种名字空间，称之为包：package。一个类总是属于某个包，类名（比如Person）只是一个简写，真正的完整类名是包名.类名。

1
2
3
4
package pk; // 申明包名pk

public class Person {
}

包没有父子关系，java.util和java.util.zip是不同的包，两者没有任何继承关系。

小结

Java内建的package机制是为了避免class命名冲突；

JDK的核心类使用java.lang包，编译器会自动导入；

JDK的其它常用类定义在java.util.*，java.math.*，java.text.*，……；

包名推荐使用倒置的域名，例如org.apache。

作用域

public

定义为public的class、interface可以被其他任何类访问

private

private访问权限被限定在class的内部，而且与方法声明顺序无关。推荐把private方法放到后面，因为public方法定义了类对外提供的功能。

protected

protected作用于继承关系。定义为protected的字段和方法可以被子类访问，以及子类的子类。

final

Java还提供了一个final修饰符。**final与访问权限不冲突**，它有很多作用。

用final修饰class可以阻止被继承，用final修饰method可以阻止被子类覆写，用final修饰field可以阻止被重新赋值，用final修饰局部变量可以阻止被重新赋值。

小结

  1. 一个.java文件只能包含一个public类，但可以包含多个非public类。如果有public类，文件名必须和public类的名字相同。

  2. final修饰符不是访问权限，它可以修饰class、field和method。

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码
-->

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

日日行，不怕千万里； <br><br> 常常做，不怕千万事。 <br><br> INTJ <br><br> 天真认生，请多指教。