使用this关键字

在一个实例方法或者是构造器中，this关键字指向当前对象**current object—被调用了方法或者构造器的对象。你可以通过this关键字在实例方法或者构造器中引用当前对象的任何成员。

this 与 Field

通常使用this关键字的原因是field被方法或构造器的参数遮蔽.例如, Point可以这样写

1
2
3
4
5
6
7
8
9
10

public class Point {
    public int x = 0;
    public int y = 0;
        
    //constructor
    public Point(int a, int b) {
        x = a;
        y = b;
    }
}

同样也可以这样写：

1
2
3
4
5
6
7
8
9
10

public class Point {
    public int x = 0;
    public int y = 0;
        
    //constructor
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

构造器的每一个参数遮蔽对象的一个filed字段/属性–方法内x 是构造器第一参数的一本局部副本.为了引用 Point 的 x字段, 构造器必须使用 this.x.

this 与构造器 Constructor

在一个构造器内，你同样可以使用this关键字来调用用一个类中的其他构造器。这样做叫作explicit constructor invocation**显示的构造函数调用.下面是一个 Rectangle 类,与对象一节中实现方法不同.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class Rectangle {
    private int x, y;
    private int width, height;
        
    public Rectangle() {
        this(0, 0, 1, 1);
    }
    public Rectangle(int width, int height) {
        this(0, 0, width, height);
    }
    public Rectangle(int x, int y, int width, int height) {
        this.x = x;
        this.y = y;
        this.width = width;
        this.height = height;
    }
    ...
}

这个类包含一系列的构造器.每一个构造器初始化初始化矩形的一些成员变量.构造器为没有提供初始化参数的成员变量设置一个默认值。例如。无参构造器在坐标(0,0)处创建一个1X1的矩形。这个两个参数的构造其调用了四个参数的构造器，传递里宽高参数并且使用了(0,0)坐标。就像之前一样，编译器决定去调用哪一个构造器，基于参数的数量以及类型。

如果存在这种调用，对其他构造器的调用必须出现在构造器中的第一行。

从方法返回值

当以下情况出现时方法会返回到调用他的代码处：

• 完成方法中的所有语句
• 执行到一个 return语句
• 或者抛出一个异常(稍后讨论)

哪一个先出现都会返回。

在方法声明时你会定义方法的返回类型。在方法体中，使用 return语句来返回值。

声明void返回类型的方法不会返回值，不一定要包含一个return语句,但是可以这么做。这种情况下，一个return语句可以用程序分支跳出一个控制流程块并且退出方法，使用方法如下:

1

return;

如果你你视图在声明了void的方法里返回一个值，将会出现编译错误。

任何没有声明void的方法都必须包含一个return语句和对应的返回值,如下：

1

return returnValue;

返回值的数据类型必须与方法声明的返回类型匹配;你不能在生命的boolean返回类型的方法里返回一个整形。

在对象一节中讨论的 Rectangle Rectangle 类的 getArea()方法返回一个integer:

1
2
3
4

// a method for computing the area of the rectangle
public int getArea() {
    return width * height;
}

方法返回的值为表达式 width*height的计算结果.

getArea 方法返回了一个基本数据类型. 方法同样可以返回引用类型的数据.例如 ，在一个操纵 Bicycle 对象的类里，我们可能会看到这样的方法:

1
2
3
4
5
6
7
8
9

public Bicycle seeWhosFastest(Bicycle myBike, Bicycle yourBike,
                              Environment env) {
    Bicycle fastest;
    // code to calculate which bike is 
    // faster, given each bike's gear 
    // and cadence and given the 
    // environment (terrain and wind)
    return fastest;
}

返回类型为一个类或者接口Returning a Class or Interface

如果你对本章节感到费解，可以先跳过，学习完接口与继承课程之后返回来学习。

当一个方法使用一个类名作为它的返回类型，例如 whosFastest这样,返回对象的类型必须使这个类或者这个类的子类。假设你有继承关系， ImaginaryNumber 是 java.lang.Number类的子类, java.lang.Number类是Object的子类, 如下图所示.

ImaginaryNumber类的继承关系

现在假设你有一个返回类型为Number的方法声明:

1
2
3

public Number returnANumber() {
    ...
}

returnANumber 方法可以返回 ImaginaryNumber 但是不能返回 Object. ImaginaryNumber 是一个 Number 因为他是 Number的子类. 但是Object并不一定是一个 Number — 它可能是一个 String 或者其他的类型.

你可以通过定义一个方法的返回类型为源方法返回类型的子类来覆盖一个方法，如下：

1
2
3

public ImaginaryNumber returnANumber() {
    ...
}

这种技术叫做 covariant return type协变返回类型,意味着返回类型允许用某一个类和其子类来区分。

注意:你同样可以声明接口为返回类型。这种情况下，你返回对象的类型必须是对应接口的实现类。

类-其他内容

该部分将覆盖类的更多方面。基于你之前学习的使用对象的引用以及.点操作符的关于对象的章节。:

• 通过方法返回值.
• this关键字.
• 类vs.实例 成员.
• 访问控制.

使用对象

一旦你创建了一个对象，你可能想要用它做一些事情。你可能需要使用这个对象的字段/成员变量中的一个，改变它，或者调用的方法来执行某些行为。

引用对象的字段/属性/成员变量

对象的字段通过它的名称来访问。你必须使用一个无歧义的名称。

你可能会在一个类中使用简单的名称。例如，我们可以在Rectangle类中加上一个语句。来打印它的 width 和 height:

1

System.out.println("Width and height are: " + width + ", " + height);

在这种情况下，width 和 height是简单的名称.在对象的类之外的代码中必须使用一个对象的引用或者表达式，紧接着一个点.操作符，紧接着字段的名称来引用，例如

1

objectReference.fieldName

例如， CreateObjectDemo 类中的代码是 Rectangle 类之外的代码.所以Rectangle 对象 rectOne的字段 origin, width, height的引用必须分别使用 rectOne.origin, rectOne.width, 以及 rectOne.height这样的名字.以下代码使用了两个这样的名称来展示rectOne的 width以及height字段:

1
2

System.out.println("Width of rectOne: "  + rectOne.width);
System.out.println("Height of rectOne: " + rectOne.height);

如果在以上代码中尝试使用简单的名字如 width ， height 并不会起作用，这两字段只存在于一个对象之中——并且会导致编译错误。

接着，程序使用相似的代码展示了rectTwo对象的信息。同类型的对象有他们自己的实例变量的副本。这样的话，每一个Rectangle对象都有名为 origin, width, 和 height等字段.当你通过一个引用变量访问其实例变量时，你引用的时那个特定的对象的字段。两个对象 rectOne 和 rectTwo ，在 CreateObjectDemo 有着不同的 origin, width, 和 height 字段.

为了方位一个实例变量，你可以使用命名的引用对象，就像之前的例子一样，或者你也可以使用任何返回该对象引用的表达式。重申一下，new操作符返回一个对象的引用。因此使用new的返回值来访问其实例变量:

1

int height = new Rectangle().height;

这个语句使用new创建 Rectangle 对象并且直接获取了他的高度。实质上，这个语句运算出一个Rectangle的默认高度。注意这个语句过后，程序中不在持有已经创建的Rectangle的对象引用，因为程序没有将这个引用存储在任何地方。这个对象没有别引用，并且它的资源时空间的将被Java虚拟机回收。

调用一个对象的方法

你也会用一个对象引用调用一个对象的方法。在对象应用的名称后面加上方法名，中间使用一个.操作符链接。同样，在闭合的()提供方法所需的参数，如果方法不需要参数，使用空的().

1

objectReference.methodName(argumentList);

或者:

1

objectReference.methodName();

Rectangle 类有两个方法: getArea()用来计算矩形的面积， move() 方法来盖面正方形的源点。下面是程序调用这两个方法的代码:

1
2
3

System.out.println("Area of rectOne: " + rectOne.getArea());
...
rectTwo.move(40, 72);

第一行语句，调用了 rectOne的 getArea() 方法并且显示了结果。第二行移动了 rectTwo 因为 move() 方法为对象的 origin.x 和 origin.y赋了新的值.

对于实例变量，对象引用必须时一个指向对象的引用。你可以使用一个变量名，同样可以使用一个返回对象引用的表达式。new操作符返回一个对象引用，因此你可以直接使用这个表达式的返回值来调用对象的方法:

1

new Rectangle(100, 50).getArea()

表达式 new Rectangle(100, 50)返回一个 Rectangle 对象的引用。正如展示的一样，可以使用.符号来调用这个新的Rectangle的getArea()方法。

有些方法，例如 getArea(),返回一个值。对于返回值的方法，你在在表达式中使用方法调用。你可以将返回值赋值给变量，可以用来做决定，或者控制循环语句。这段代码将 getArea() 的返回值赋值给变量 areaOfRectangle:

1

int areaOfRectangle = new Rectangle(100, 50).getArea();

记住，调用一个特定对象的方法就好像向这个对象发送信息。本例中，调用的getArea()方法构造器返回的rectangle对象的方法。

垃圾回收The Garbage Collector

有些面向对象的编程语言要求你持续跟踪你创建的所有对象，并且在不需要的时候明确的销毁它们。明确的管理内存是及其乏味并且容易出错的过程。Java编程语言允许你创建任意数量你想要的对象（当然受限与你的系统处理能力），并且无需担心何时销毁。Java 运行时环境确定对象不会再被使用的时候会删除对象。这个过程叫做垃圾回收garbage collection.

当一个对象没有引用指向它的时候，是符合垃圾回收条件的。或者，你可以通过将一个变量设置为特殊的值null，显式的清理一个对象引用。记住，一个程序可能对一个对象有非常多的引用;一个对象被垃圾回收前必须清理所有指向它的引用。

Java运行时环境有一个垃圾回收器，周期性的释放被没有引用指向的对象占用的内存。垃圾回收器确定时机正确时，会自动完成其工作。

创建对象

如你所知，类提供了对象的蓝图/模板；你可以通过类创建对象。下面的每一个语句取自 CreateObjectDemo ，都创建了一个对象并将它赋值给一个变量:

1
2
3

Point originOne = new Point(23, 94);
Rectangle rectOne = new Rectangle(originOne, 100, 200);
Rectangle rectTwo = new Rectangle(50, 100);

第一行创建了一个 Point 类的对象,第二行及第三行创建了 Rectangle 类的对象.

每一行语句都包含了三部分，详情如下：

1. 声明Declaration: 首先定义了变量对应的数据类型和变量名.
2. 实例化Instantiation: new 关键字时Java的创建（实例化）对象操作符.
3. 初始化Initialization: new 操作符接下来调用一个构造方法，构造方法初始化这个新的对象.

对象

一个特定的Java程序创建许多对象，就像你学过的，通过方法调用进行交出。通过对象的交互，一个程序可以处理各种各样的任务，诸如实现一个GUI（用户交互界面），运行一个动画，或者通过网路发送和接受信息。一旦一个对象完成了被创建的过程，它的资源可以被其他对象循环使用。

下面有一个小程序，叫做 CreateObjectDemo, 创建了三个对下给你，一个点对象 Point 和两个矩形 Rectangle 对象. 你会需要三个资源文件来完成这个程序.

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

public class CreateObjectDemo {
    public static void main(String[] args) {
		
        // Declare and create a point object and two rectangle objects.
        Point originOne = new Point(23, 94);
        Rectangle rectOne = new Rectangle(originOne, 100, 200);
        Rectangle rectTwo = new Rectangle(50, 100);
		
        // display rectOne's width, height, and area
        System.out.println("Width of rectOne: " + rectOne.width);
        System.out.println("Height of rectOne: " + rectOne.height);
        System.out.println("Area of rectOne: " + rectOne.getArea());
		
        // set rectTwo's position
        rectTwo.origin = originOne;
		
        // display rectTwo's position
        System.out.println("X Position of rectTwo: " + rectTwo.origin.x);
        System.out.println("Y Position of rectTwo: " + rectTwo.origin.y);
		
        // move rectTwo and display its new position
        rectTwo.move(40, 72);
        System.out.println("X Position of rectTwo: " + rectTwo.origin.x);
        System.out.println("Y Position of rectTwo: " + rectTwo.origin.y);
    }
}

这个程序创建，操作了三个不同的随想并显示了其信息，以下为输出情况:

1
2
3
4
5
6
7

Width of rectOne: 100
Height of rectOne: 200
Area of rectOne: 20000
X Position of rectTwo: 23
Y Position of rectTwo: 94
X Position of rectTwo: 40
Y Position of rectTwo: 72

接下来的三部分使用上面的例子描述了一个对象在程序中的生命周期。通过特们，你可以学习到如何在你的程序中创建和使用对象。同样可以学习到系统在对象的生命周期结束后如何清理它们。

向方法和构造函数传递信息

方法或者构造函数的声明，定义了它所需的参数的数量和类型。例如，下面的方法用来基于单款额度，利率，贷款期数，以及未来值来计算家庭贷款每月还款额:

1
2
3
4
5
6
7
8
9
10
11
12
13

public double computePayment(
                  double loanAmt,
                  double rate,
                  double futureValue,
                  int numPeriods) {
    double interest = rate / 100.0;
    double partial1 = Math.pow((1 + interest), 
                    - numPeriods);
    double denominator = (1 - partial1) / interest;
    double answer = (-loanAmt / denominator)
                    - ((futureValue * partial1) / denominator);
    return answer;
}

这个方法有四个参数：贷款金额，利率，未来值，以及带款期数。前三个参数双精度浮点数，第四个参数是一个整数，这些参数变量在方法体里使用，运行时将接纳传递进来的参数的值。

注意:参数变量Parameters 指的是方法定义使的变量列表. 参数Arguments是指方法被调用时传递进来的确切的值。当以调用一个方法，传递参数必须与定义的参数列表类型和顺序一致。

为你的类提供构造方法

类包含构造方法，可以被调用而根据类的蓝本创建对象。构造方法声明同普通的方法一样—只不过命名与类名相同且没有返回类型。例如，Bicycle类的构造方法：

1
2
3
4
5

public Bicycle(int startCadence, int startSpeed, int startGear) {
    gear = startGear;
    cadence = startCadence;
    speed = startSpeed;
}

如果要创建一个名为myBike的对象，适用new操作符调用构造方法：

1

Bicycle myBike = new Bicycle(30, 0, 8);

new Bicycle(30, 0, 8)为对象在内存中分配空间并初始化成员变量。

Bicycle 类只有一个构造方法，它也可以有其他更多构造方法，包括无参的构造方法:

1
2
3
4
5

public Bicycle() {
    gear = 1;
    cadence = 10;
    speed = 0;
}

Bicycle yourBike = new Bicycle(); 调用无惨构造方法创建一个名为yourBike的Bicycle类对象。

两个构造方法都可以在Bicycle类中定义因为它们有不同的参数列表。同方法一样，Java平台根据参数列表的数量以及类型区分不同的构造方法。不能定义有同样数量和类型参数列表的构造方法，因为平台无法区分它们。这么左会引起编译错误。

你可以不为类提供任何构造方法，当时这么左的时候必须小心。编译器为没有构造方法的类自动提供一个默认的无参构造函数。这个默认的构造方法会调用其父类的无参构造方法。这种情况下，如果父类没有无参构造方法编译器将会抱怨，因此你这么做之前必检查父类确实有无参构造器。如果你的类没有明确的父类，它有一个隐藏的父类Object,Object拥有无参构造方法。

你可自己调用父类的构造函数。本课开始的MountainBike类就这么做了，在接口与继承课程中还会详细讨论。

你可以使用限定修饰符来控制那些其他类可以访问构造方法。

注意:如果你不能调用Myclass的构造方法，就无法直接创建Myclass类的对象。

定义成员变量

变量由以下几种:

• 类的成员变量-叫做域/字段.
• 方法代码块中的变量-叫做局部变量。
• 方法定义中的变量-叫做参数。

Bicycle类使用以下几行定义了它的成员变量:

1
2
3

public int cadence;
public int gear;
public int speed;

成员变量的定义由三部分组成，按照顺序入下:

1. 零个或更多限定修饰符，例如public或者private.
2. 字段的类型.

3. 字段个名称.

   Bicycle类的成员变量名字为 cadence, gear, 以及speed 并且都是int 类型的。public关键字表明了这些时公有，然和可以访问该类的对象都可以访问这些成员变量。

限定修饰符

第一个（最左边的）限定修饰符使你控制其他类可以访问成员变量的权限。现在，仅仅关注public和private。其他的限定修饰符后面会讨论.

• public 修饰符—本字段可以被所有类访问.
• private 修饰符—本字段只可以在本类中访问.

为了体现封装特性，通常设置成员变量为私有private。意味着它们只能在Bicycle类中被直接访问。然而，我们仍然需要访问这些值。这可以通过添加获取字段值的公有方法间接实现:

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

public class Bicycle {
        
    private int cadence;
    private int gear;
    private int speed;
        
    public Bicycle(int startCadence, int startSpeed, int startGear) {
        gear = startGear;
        cadence = startCadence;
        speed = startSpeed;
    }
        
    public int getCadence() {
        return cadence;
    }
        
    public void setCadence(int newValue) {
        cadence = newValue;
    }
        
    public int getGear() {
        return gear;
    }
        
    public void setGear(int newValue) {
        gear = newValue;
    }
        
    public int getSpeed() {
        return speed;
    }
        
    public void applyBrake(int decrement) {
        speed -= decrement;
    }
        
    public void speedUp(int increment) {
        speed += increment;
    }
}

类型

所有的变量都必须由一个类型。你可以使用基本数据类型例如int,float,boolean,等等。或者你可以使用引用类型，例如字符串，数组，对象。

变量名

所有的变量，无论时成员变量，局部变量或者参数，都遵循同样的命名规则与约定，这在之前的语言基础课程变量命名中讲过。Variables—Naming.

在本课中，注意这些命名规则同样适用与方法名和类名，除了以下两点：

• 类名的首字母需要大写the first letter of a class name should be capitalized, and
• 方法名的首个单词应该为动词the first (or only) word in a method name should be a verb.

定义方法

下面时一个典型的定义方法的例子:

1
2
3
4

public double calculateAnswer(double wingSpan, int numberOfEngines,
                              double length, double grossTons) {
    //do the calculation here
}

定义方法必须的元素只有方法返回类型，方法名，已对小括号()以及{}包围的方法体。

更加常见的方法定义包含六个部分，按照顺序依次是:

1. 限定修饰符—例如public,private以及后面会学到的其他修饰符。
2. 返回类型—定义方法返回的数据类型，如果方法不返回值标记为void.
3. 方法名—定义字段名的规则同样适用用方法名，约定稍有不同，方法名的第一个词一般动词等。
4. 在小括号内的参数列表—由小括号包围，逗号分割，参数前标明其数据类型，如果没有参数必须适用一个空的小括号。
5. 异常列表—之后的课程会讲到。
6. 方法体，由花括号{}包围—方法的代码，局部变量声明都包含在内。

限定修饰符，返回类型，参数在本节的后续内容中学习。异常将在之后的课程学习。

定义:方法定义的两部分内容定义为方法签名 method signature—方法名以及参数类型.

上面声明的方法签名如下:

1

calculateAnswer(double, int, double, double)

方法命名

尽管方法名可以是任何的合法标识符，但是按照惯例约定方法命名很严格。按照惯例，方法名应该是一个小写的动词或者以小写的动词开头的多个单词，后续单词可以是形容词名词等。在多个单词的方法命名时，第二个单词及之后的单词首字母需要大写（首字母小写驼峰命名）.以下为一些例子:

1
2
3
4
5
6
7

run
runFast
getBackground
getFinalData
compareTo
setX
isEmpty

通常，在同一类中的方法命名是位移的。不过，因为方法重载，方法名可以重复。

方法重载

Java编程语言支持方法重载，Java可以本剧方法的不同方法签名method signatures辨别同名的不同方法。以为这同一个类中可以有不同参数列表（接口与继承课程中将会介绍一些限定条件）的同名方法。

假设你的类可以适用书写不同类型的数据(字符串，整数等等)并且包含了一个可以画出不同数据类型的方法。为每一种数据画法起一个新的方法名将会非常麻烦—例如drawString,drawInteger,drawFloat等等。在Java编程语言中，你可以对这些方法适用同样的名称，只需要为每个方法传入不同的参数别表。这样，画出数据类可以定义四个名为draw的类，每一个都有不同的参数列表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class DataArtist {
    ...
    public void draw(String s) {
        ...
    }
    public void draw(int i) {
        ...
    }
    public void draw(double f) {
        ...
    }
    public void draw(int i, double f) {
        ...
    }
}

重载的方法因传入参数的数量及数据类型而不同。在上面的示例代码中 draw(String s) 与 draw(int i) 是有区别且位移的方法因为他们需要不同的参数类型。你不能在同一个类中定义名字相同参数数量与类型都相同的方法，因为编译器无法分辨。

编译器在区分方法是并不考虑返回类型，所以不能定义两个方法签名相同但是返回类型不同的方法。

注意: 方法重载不应该滥用，因为它们会使代码的可读性变差。