12. 定义类 【连载 12】







Java 是面向对象的编程语言，我们可以使用 Java 来模拟现实世界的任何事物，其中 `类` 有非常重要的作用。在【面向对象的初步理解】中已经做过其基本的讲解，这次内容，主要来告诉你如何在 Java 中定义类。






## 成员变量


现在使用 Java 语言来模拟汽车，其属性，其行为。汽车对应到 `Java` 世界中是一个类：


```java
public class Car {
  
}
```


汽车的制造商、里程表、最高时速我们可以用类的**成员变量**来表示：


```java
public class Car {
String make;//制造商
  double odometer;//里程
  int maxSpeed;//最高时速
}
```


在一个类中，除了基本类型变量之外，还可以使用引用类型变量，作为成员变量。比如给汽车增加一个引擎的属性。


定义引擎：


```java
public class Engine {
  double power = 5.5;//动力
}
```


`Car` 增加引擎属性：


```java
public class Car {
  String make;//制造商
  double odometer;//里程
  int maxSpeed;//最高时速
  Engine engine;//引擎
}
```


## 成员方法


汽车除了有其属性之外，当然还有它自己的行为，在类中用方法来模拟汽车的行为。汽车启动、汽车行驶用两个成员方法来表示：


```java
public class Car {
  String make;//制造商
  double odometer;//里程
  int maxSpeed;//最高时速
  Engine engine;//引擎
  
  //汽车启动
  public void starup() {
    System.out.println(make + "， 启动了");
  }


  //汽车行驶
  public void run() {
    System.out.println("80, 行驶");
  }


}
```






## 构造方法


在一个类中还有一种重要的方法，就是构造方法，被称为构造器，它的作用是用来创建对象的。当我们使用一个类去创建一个对象的时候，会调用其相应的构造方法，来创建一个对象实例。构造方法有自己的一些规则，有别于普通的成员方法。


构造方法需要满足以下条件：


1. 方法的名字必须和类的名字保持一致。
2. 构造方法是没有返回值的。


给汽车类增加构造函数：


```java
public class Car {
  String make;//制造商
  double odometer;//里程
  int maxSpeed;//最高时速
  Engine engine;//引擎
  
  //空构造，也是默认构造。
  public Car() {
    System.out.println("调用了空构造方法");
  }
  
  //汽车启动
  public void starup() {
    System.out.println(make + "， 启动了");
  }


  //汽车行驶
  public void run() {
    System.out.println("80, 行驶");
  }


}
```


> 定义了一个空的构造，方法中没有任何的代码逻辑。这也是一个类的默认构造方法。意思是说：如果一个类没有像上面显示的什么任何构造方法的时候，当我们创建对象的时候，会自动调用一个空的构造方法。


```java
public static void main(String[] args) {
  Car myCar = new Car();
}
```


> - `Car myCar`：声明了一个`Car`类型的变量。
> - `new` ： 一个创建对象的关键字。
> - `Car()` ：调用构造方法






除了空构造方法之外，可以自一个类中定义多个构造方法，但是这些个构造方法之间参数不能一样。我们再定义两个构造方法：


```java
public class Car {
  String make;//制造商
  double odometer;//里程
  int maxSpeed;//最高时速
  Engine engine;//引擎
  
  //空构造，也是默认构造。
  public Car() {
    System.out.println("调用了空构造方法");
  }
  //一个参数的构造方法，可以传递make值，创建一个对象
  public Car(String make) {
    this.make = make;
  }
  
  //多个参数的构造
  public Car(String make, double odometer, int maxSpeed, Engine engine) {
        this.make = make;
        this.odometer = odometer;
        this.maxSpeed = maxSpeed;
        this.engine = engine;
  } 
  
  //汽车启动
  public void starup() {
    System.out.println(make + "， 启动了");
  }


  //汽车行驶
  public void run() {
    System.out.println("80, 行驶");
  }


}
```


使用不同的构造方法来创建对象：


```java
public static void main(String[] args) {
  Car myCar  = new Car();
  Car poloCar = new Car("polo");
  Engine engine = new Engine();
  Car miniCar = new Car("mini", 50.5, 200, engine);
}
```






## 方法重载


汽车的类中，存在三个参数不一样的构造方法。这种情况其实是一种方法重载的现象。


**方法重载：**在一个类中方法名相同，方法的参数不一样的现象叫做方法重载。


> 方法参数不一样包括情况：
>
> - 方法的参数的类型相同，个数不相同
> - 方法的个数相同，类型不相同
>
> 原则是只要方法的参数不一样，在调用的时候，能够正确的区分是调用哪个方法，就 OK






构造方法可以重载，当然其他的成员方法也是可以重载的。比如 `Car` 中的`run`方法：


```java
//汽车行驶
  public void run() {
    System.out.println("80, 行驶");
  }


//指定某个速度行驶
public void run(int speed) {
  System.out.println("以"+ speed +"的速度行驶");
}
```


两个 run 方法的参数不一样，构成了方法重载。方法重载主要是为了适应不同的场景。像你买一份凉皮，有人喜欢加辣，有人不要辣。


调用两个方法：


```java
public static void main(String[] args) {
  Car myCar  = new Car();
  myCar.run();
  myCar.run(200);
}
```






现在已经了解一个类的基本结构，我们可以根据实际的情况去定义其属性和方法。下面要介绍的是变量和方法的可见性。






## 可见性


所谓可见性，就是说针对一个变量和方法，谁可以方法调用。主要的针对两类情况，类的内部和类的外部。


控制变量和方法可见性的是修饰词：






- `private`  私有的，不公开。修饰的变量和方法只有在其类的内部 可以被调用，对类的外部不可见。
- `protected`  保护的，有权限的公开。修饰的变量和方法只有同一个包下的其他类可以调用，对其他的类不可见。变量和方法没有任何修饰词的时候，默认效果和 protected 修饰一样。
- `public`  完全公共的，修饰的变量和方法对其他的类完全公开，可以被访问和调用。


对于变量，如果使用 private 修饰的话，起到一个保护作用，这种做法叫封装。只有通过调用其对应对象的公开的方法才可以访问被封装的变量属性。


对于方法，一般都会使用 `public` 修饰，方法公开被调用。如果该方法只是本类的内部使用，我们可以使用 `private` 修饰。


对于构造方法，如果用`private` 修饰的话，在该类的外部将不能创建实例对象。这种做法可以用来实现`单例模式`，后面有内容会讲的。






OK，对于类的定义，我们基本用到的一些规则给你做了介绍。下次内容着重来说一说类的使用。