Java编程的逻辑 (13) - 类

本系列文章经补充和完善，已修订整理成书《Java编程的逻辑》，由机械工业出版社华章分社出版，于2018年1月上市热销，读者好评如潮！各大网店和书店有售，欢迎购买，京东自营链接：http://item.jd.com/12299018.html

---

类

上节我们介绍了函数调用的基本原理，本节和接下来几节，我们探索类的世界。

程序主要就是数据以及对数据的操作，为方便理解和操作，高级语言使用数据类型这个概念，不同的数据类型有不同的特征和操作，Java定义了八种基本数据类型，其中，四种整形byte/short/int/long，两种浮点类型float/double，一种真假类型boolean，一种字符类型char，其他类型的数据都用类这个概念表达。

前两节我们暂时将类看做函数的容器，在某些情况下，类也确实基本上只是函数的容器，但类更多表示的是自定义数据类型，我们先从容器的角度，然后从自定义数据类型的角度谈谈类。

函数容器

我们看个例子，Java API中的类Math，它里面主要就包含了若干数学函数，下表列出了其中一些：

Math函数	功能
int round(float a)	四舍五入
double sqrt(double a)	平方根
double ceil(double a)	向上取整
double floor(double a)	向下取整
double pow(double a, double b)	a的b次方
int abs(int a)	绝对值
int max(int a, int b)	最大值
double log(double a)	自然对数
double random()	产生一个大于等于0小于1的随机数

使用这些函数，直接在前面加Math.即可，例如Math.abs(-1)返回1。

这些函数都有相同的修饰符，public static。

static表示类方法，也叫静态方法，与类方法相对的是实例方法。实例方法没有static修饰符，必须通过实例或者叫对象（待会介绍）调用，而类方法可以直接通过类名进行调用的，不需要创建实例。

public表示这些函数是公开的，可以在任何地方被外部调用。与public相对的有private，
如果是private，表示私有，这个函数只能在同一个类内被别的函数调用，而不能被外部的类调用。在Math类中，有一个函数 Random
initRNG()就是private的，这个函数被public的方法random()调用以生成随机数，但不能在Math类以外的地方被调用。

将函数声明为private可以避免该函数被外部类误用，调用者可以清楚的知道哪些函数是可以调用的，哪些是不可以调用的。类实现者通过private函数封装和隐藏内部实现细节，而调用者只需要关心public的就可以了。可以说，通过private封装和隐藏内部实现细节，避免被误操作，是计算机程序的一种基本思维方式。

除了Math类，我们再来看一个例子Arrays，Arrays里面包含很多与数组操作相关的函数，下表列出了其中一些：

Arrays函数	功能
void sort(int[] a)	排序，按升序排，整数数组
void sort(double[] a)	排序，按升序排，浮点数数组
int binarySearch(long[] a, long key)	二分查找，数组已按升序排列
void fill(int[] a, int val)	给所有数组元素赋相同的值
int[] copyOf(int[] original, int newLength)	数组拷贝
boolean equals(char[] a, char[] a2)	判断两个数组是否相同

这里将类看做函数的容器，更多的是从语言实现的角度看，从概念的角度看，Math和Arrays也可以看做是自定义数据类型，分别表示数学和数组类型，其中的public static函数可以看做是类型能进行的操作。接下来让我们更为详细的讨论自定义数据类型。

自定义数据类型

我们将类看做自定义数据类型，所谓自定义数据类型就是除了八种基本类型以外的其他类型，用于表示和处理基本类型以外的其他数据。

一个数据类型由其包含的属性以及该类型可以进行的操作组成，属性又可以分为是类型本身具有的属性，还是一个具体数据具有的属性，同样，操作也可以分为是类型本身可以进行的操作，还是一个具体数据可以进行的操作。

这样，一个数据类型就主要由四部分组成：

• 类型本身具有的属性，通过类变量体现
• 类型本身可以进行的操作，通过类方法体现
• 类型实例具有的属性，通过实例变量体现
• 类型实例可以进行的操作，通过实例方法体现

不过，对于一个具体类型，每一个部分不一定都有，Arrays类就只有类方法。

类变量和实例变量都叫成员变量，也就是类的成员，类变量也叫静态变量或静态成员变量。类方法和实例方法都叫成员方法，也都是类的成员，类方法也叫静态方法。

类方法我们上面已经看过了，Math和Arrays类中定义的方法就是类方法，这些方法的修饰符必须有static。下面解释下类变量，实例变量和实例方法。

类变量

类型本身具有的属性通过类变量体现，经常用于表示一个类型中的常量，比如Math类，定义了两个数学中常用的常量，如下所示：

public static final double E = 2.7182818284590452354;
public static final double PI = 3.14159265358979323846;

E表示数学中自然对数的底数，自然对数在很多学科中有重要的意义，PI表示数学中的圆周率π。与类方法一样，类变量可以直接通过类名访问，如Math.PI。

这两个变量的修饰符也都有public static，public表示外部可以访问，static表示是类变量。与public相对的主要也是private，表示变量只能在类内被访问。与static相对的是实例变量，没有static修饰符。

这里多了一个修饰符final，final 在修饰变量的时候表示常量，即变量赋值后就不能再修改了。使用final可以避免误操作，比如说，如果有人不小心将Math.PI的值改了，那么很多相关的计算就会出错。另外，Java编译器可以对final变量进行一些特别的优化。所以，如果数据赋值后就不应该再变了，就加final修饰符吧。

表示类变量的时候，static修饰符是必需的，但public和final都不是必需的。

实例变量和实例方法

实例字面意思就是一个实际的例子，实例变量表示具体的实例所具有的属性，实例方法表示具体的实例可以进行的操作。如果将微信订阅号看做一个类型，那"老马说
编程"订阅号就是一个实例，订阅号的头像、功能介绍、发布的文章可以看做实例变量，而修改头像、修改功能介绍、发布新文章可以看做实例方法。与基本类型对
比，int a;这个语句，int就是类型，而a就是实例。

接下来，我们通过定义和使用类，来进一步理解自定义数据类型。

定义第一个类
我们定义一个简单的类，表示在平面坐标轴中的一个点，代码如下：

class Point {
    public int x;
    public int y;

    public double distance(){
        return Math.sqrt(x*x+y*y);
    }
}

我们来解释一下：

public class Point

表示类型的名字是Point，是可以被外部公开访问的。这个public修饰似乎是多余的，不能被外部访问还能有什么用？在这里，确实不能用private 修饰Point。但修饰符可以没有（即留空），表示一种包级别的可见性，我们后续章节介绍，另外，类可以定义在一个类的内部，这时可以使用private 修饰符，我们也在后续章节介绍。

public int x;
public int y;

定义了两个实例变量，x和y，分别表示x坐标和y坐标，与类变量类似，修饰符也有public或private修饰符，表示含义类似，public表示可被外部访问，而private表示私有，不能直接被外部访问，实例变量不能有static修饰符。

public double distance(){
    return Math.sqrt(x*x+y*y);
}

定义了实例方法distance，表示该点到坐标原点的距离。该方法可以直接访问实例变量x和y，这是实例方法和类方法的最大区别。实例方法直接访问实例变量，到底是什么意思呢？其实，在实例方法中，有一个隐含的参数，这个参数就是当前操作的实例自己，直接操作实例变量，实际也需要通过参数进行。实例方法和类方法更多的区别如下所示：

• 类方法只能访问类变量，但不能访问实例变量，可以调用其他的类方法，但不能调用实例方法。
• 实例方法既能访问实例变量，也可以访问类变量，既可以调用实例方法，也可以调用类方法。

关于实例方法和类方法更多的细节，后续会进一步介绍。

使用第一个类

定义了类本身和定义了一个函数类似，本身不会做什么事情，不会分配内存，也不会执行代码。方法要执行需要被调用，而实例方法被调用，首先需要一个实例，实例也称为对象，我们可能会交替使用。下面的代码演示了如何使用：

public static void main(String[] args) {
    Point p = new Point();
    p.x = 2;
    p.y = 3;
    System.out.println(p.distance());
}

我们解释一下：

Point p = new Point();

这个语句包含了Point类型的变量声明和赋值，它可以分为两部分：

 Point p;
 p = new Point()；

Point p声明了一个变量，这个变量叫p，是Point类型的。这个变量和数组变量是类似的，都有两块内存，一块存放实际内容，一块存放实际内容的位置。声明变量本身只会分配存放位置的内存空间，这块空间还没有指向任何实际内容。因为这种变量和数组变量本身不存储数据，而只是存储实际内容的位置，它们也都称为引用类型的变量。

p = new Point();创建了一个实例或对象，然后赋值给了Point类型的变量p，它至少做了两件事：

1. 分配内存，以存储新对象的数据，对象数据包括这个对象的属性，具体包括其实例变量x和y。
2. 给实例变量设置默认值，int类型默认值为0。

与方法内定义的局部变量不同，在创建对象的时候，所有的实例变量都会分配一个默认值，这与在创建数组的时候是类似的，数值类型变量的默认值是 0，boolean是false, char是'\u0000'，引用类型变量都是null，null是一个特殊的值，表示不指向任何对象。这些默认值可以修改，我们待会介绍。

p.x = 2;
p.y = 3;

给对象的变量赋值，语法形式是：对象变量名.成员名。

System.out.println(p.distance());

调用实例方法distance，并输出结果，语法形式是：对象变量名.方法名。实例方法内对实例变量的操作，实际操作的就是p这个对象的数据。

我们在介绍基本类型的时候，是先定义数据，然后赋值，最后是操作，自定义类型与此类似：

• Point p = new Point(); 是定义数据并设置默认值
• p.x = 2; p.y = 3; 是赋值
• p.distance() 是数据的操作

可以看出，对实例变量和实例方法的访问都通过对象进行，通过对象来访问和操作其内部的数据是一种基本的面向对象思维。本例中，我们通过对象直接操作了其内部数据x和y，这是一个不好的习惯，一般而言，不应该将实例变量声明为public，而只应该通过对象的方法对实例变量进行操作，原因也是为了减少误操作，直接访问变量没有办法进行参数检查和控制，而通过方法修改，可以在方法中进行检查。

修改变量默认值

之前我们说，实例变量都有一个默认值，如果希望修改这个默认值，可以在定义变量的同时就赋值，或者将代码放入初始化代码块中，代码块用{}包围，如下面代码所示：

int x = 1;
int y;
{
    y = 2;
}

x的默认值设为了1，y的默认值设为了2。在新建一个对象的时候，会先调用这个初始化，然后才会执行构造方法中的代码。

静态变量也可以这样初始化：

static int STATIC_ONE = 1;
static int STATIC_TWO;
static
{
    STATIC_TWO = 2;
}

STATIC_TWO=2;语句外面包了一个 static {}，这叫静态初始化代码块。静态初始化代码块在类加载的时候执行，这是在任何对象创建之前，且只执行一次。

修改类 - 实例变量改为private

上面我们说一般不应该将实例变量声明为public，下面我们修改一下类的定义，将实例变量定义为private，通过实例方法来操作变量，代码如下：

class Point {
    private int x;
    private int y;

    public void setX(int x) {
        this.x = x;
    }

    public void setY(int y) {
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public double distance() {
        return Math.sqrt(x * x + y * y);
    }
}

这个定义中，我们加了四个方法，setX/setY用于设置实例变量的值，getX/getY用于获取实例变量的值。

这里面需要介绍的是this这个关键字，this表示当前实例， 在语句this.x=x;中，this.x表示实例变量x，而右边的x表示方法参数中的x。前面我们提到，在实例方法中，有一个隐含的参数，这个参数就是this，没有歧义的情况下，可以直接访问实例变量，在这个例子中，两个变量名都叫x，则需要通过加上this来消除歧义。

这四个方法看上去是非常多余的，直接访问变量不是更简洁吗？而且上节我们也说过，函数调用是有成本的。在这个例子中，意义确实不太大，实际上，Java编译器一般也会将对这几个方法的调用转换为直接访问实例变量，而避免函数调用的开销。但在很多情况下，通过函数调用可以封装内部数据，避免误操作，我们一般还是不将成员变量定义为public。

使用这个类的代码如下：

public static void main(String[] args) {
    Point p = new Point();
    p.setX(2);
    p.setY(3);
    System.out.println(p.distance());
}

将对实例变量的直接访问改为了方法调用。

修改类 - 引入构造方法

在初始化对象的时候，前面我们都是直接对每个变量赋值，有一个更简单的方式对实例变量赋初值，就是构造方法，我们先看下代码，在Point类定义中增加如下代码：

public Point(){
    this(0,0);
}

public Point(int x, int y){
    this.x = x;
    this.y = y;
}

这两个就是构造方法，构造方法可以有多个。不同于一般方法，构造方法有一些特殊的地方：

• 名称是固定的，与类名相同。这也容易理解，靠这个用户和Java系统就都能容易的知道哪些是构造方法。
• 没有返回值，也不能有返回值。这个规定大概是因为返回值没用吧。

与普通方法一样，构造方法也可以重载。第二个构造方法是比较容易理解的，使用this对实例变量赋值。

我们解释下第一个构造方法，this(0,0)的意思是调用第二个构造方法，并传递参数0,0，我们前面解释说this表示当前实例，可以通过this访问实例变量，这是this的第二个用法，用于在构造方法中调用其他构造方法。

这个this调用必须放在第一行，这个规定应该也是为了避免误操作，构造方法是用于初始化对象的，如果要调用别的构造方法，先调别的，然后根据情况自己再做调整，而如果自己先初始化了一部分，再调别的，自己的修改可能就被覆盖了。

这个例子中，不带参数的构造方法通过this(0,0)又调用了第二个构造方法，这个调用是多余的，因为x和y的默认值就是0，不需要再单独赋值，我们这里主要是演示其语法。

我们来看下如何使用构造方法，代码如下：

Point p = new Point(2,3);

这个调用就可以将实例变量x和y的值设为2和3。前面我们介绍 new Point()的时候说，它至少做了两件事，一个是分配内存，另一个是给实例变量设置默认值，这里我们需要加上一件事，就是调用构造方法。调用构造方法是new操作的一部分。

通过构造方法，可以更为简洁的对实例变量进行赋值。

默认构造方法

每个类都至少要有一个构造方法，在通过new创建对象的过程中会被调用。但构造方法如果没什么操作要做，可以省略。Java编译器会自动生成一个默认构造方
法，也没有具体操作。但一旦定义了构造方法，Java就不会再自动生成默认的，具体什么意思呢？在这个例子中，如果我们只定义了第二个构造方法（带参数的），则下面语句：

Point p = new Point();

就会报错，因为找不到不带参数的构造方法。

为什么Java有时候帮助自动生成，有时候不生成呢？你在没有定义任何构造方法的时候，Java认为你不需要，所以就生成一个空的以被new过程调用，你定义了构造方法的时候，Java认为你知道自己在干什么，认为你是有意不想要不带参数的构造方法的，所以不会帮你生成。

私有构造方法

构造方法可以是私有方法，即修饰符可以为private， 为什么需要私有构造方法呢？大概可能有这么几种场景：

• 不能创建类的实例，类只能被静态访问，如Math和Arrays类，它们的构造方法就是私有的。
• 能创建类的实例，但只能被类的的静态方法调用。有一种常用的场景，即类的对象有但是只能有一个，即单例模式（后续文章介绍），在这个场景中，对象是通过静态方法获取的，而静态方法调用私有构造方法创建一个对象，如果对象已经创建过了，就重用这个对象。
• 只是用来被其他多个构造方法调用，用于减少重复代码。

关键字小结

本节我们提到了多个关键字，这里汇总一下：

• public:可以修饰类、类方法、类变量、实例变量、实例方法、构造方法，表示可被外部访问。
• private:可以修饰类、类方法、类变量、实例变量、实例方法、构造方法，表示不可以被外部访问，只能在类内被使用。
• static: 修饰类变量和类方法，它也可以修饰内部类（后续章节介绍）。
• this：表示当前实例，可以用于调用其他构造方法，访问实例变量，访问实例方法。
• final: 修饰类变量、实例变量，表示只能被赋值一次，final也可以修饰实例方法和局部变量（后续章节介绍）。
  

类和对象的生命周期

类

在程序运行的时候，当第一次通过new创建一个类的对象的时候，或者直接通过类名访问类变量和类方法的时候，Java会将类加载进内存，为这个类型分配一块空间，这个空间会包括类的定义，它有哪些变量，哪些方法等，同时还有类的静态变量，并对静态变量赋初始值。后续文章会进一步介绍有关细节。

类加载进内存后，一般不会释放，直到程序结束。一般情况下，类只会加载一次，所以静态变量在内存中只有一份。

对象

当通过new创建一个对象的时候，对象产生，在内存中，会存储这个对象的实例变量值，每new一次，对象就会产生一个，就会有一份独立的实例变量。

每个对象除了保存实例变量的值外，可以理解还保存着对应类型即类的地址，这样，通过对象能知道它的类，访问到类的变量和方法代码。

实例方法可以理解为一个静态方法，只是多了一个参数this，通过对象调用方法，可以理解为就是调用这个静态方法，并将对象作为参数传给this。

对象的释放是被Java用垃圾回收机制管理的，大部分情况下，我们不用太操心，当对象不再被使用的时候会被自动释放。

具体来说，对象和数组一样，有两块内存，保存地址的部分分配在栈中，而保存实际内容的部分分配在堆中。栈中的内存是自动管理的，函数调用入栈就会分配，而出栈就会释放。

堆中的内存是被垃圾回收机制管理的，当没有活跃变量指向对象的时候，对应的堆空间就可能被释放，具体释放时间是Java虚拟机自己决定的。活跃变量，具体的说，就是已加载的类的类变量，和栈中所有的变量。

小结

本
节我们主要从自定义数据类型的角度介绍了类，谈了如何定义类，以及如何创建对象，如何使用类。自定义类型由类变量、类方法、实例变量和实例方法组成，为方
便对实例变量赋值，介绍了构造方法。本节引入了多个关键字，我们介绍了这些关键字的含义。最后我们介绍了类和对象的生命周期。

通过类实现自定义数据类型，封装该类型的数据所具有的属性和操作，隐藏实现细节，从而在更高的层次上（类和对象的层次，而非基本数据类型和函数的层次）考虑和操作数据，是计算机程序解决复杂问题的一种重要的思维方式。

本节介绍的Point类，其属性只有基本数据类型，下节我们介绍类的组合，以表达更为复杂的概念。

----------------

未完待续，查看最新文章，敬请关注微信公众号“老马说编程”(扫描下方二维码)，从入门到高级，深入浅出，老马和你一起探索Java编程及计算机技术的本质。原创文章，保留所有版权。

-----------

更多相关原创文章

计算机程序的思维逻辑 (14) - 类的组合

计算机程序的思维逻辑 (15) - 初识继承和多态

计算机程序的思维逻辑 (16) - 继承的细节

计算机程序的思维逻辑 (17) - 继承实现的基本原理

计算机程序的思维逻辑 (18) - 为什么说继承是把双刃剑

计算机程序的思维逻辑 (19) - 接口的本质

计算机程序的思维逻辑 (20) - 为什么要有抽象类？

计算机程序的思维逻辑 (21) - 内部类的本质