JAVA——第四章——类与对象

4.1 类
之前我大概提到一个自行车类的实例，以及其子类山地车。这里给出一种实现Bicycle类的实例以概述类的声明。

class Bicycle {
    public int gear;
    public int speed;

    void changeGear(int newValue){
        this.gear = newValue;
    }

    void speedUp(int increment){
        this.speed += increment;
    }

    void printStates(){
        System.out.println("The Bike has " + gear
            + "'s gear and it's speed is " + speed);
    }
}

MountainBike 类继承了Bicycle类的所有字段和方法，并添加字段seatHeight 和 设置其方法 changeHeight（int newValue）。

class MountainBike extends Bicycle {
    public int seatHeight;

    void changeHeight(int newValue){
        seatHeight = newValue;
    }

    //注意子类的构造器写法
    public MountainBike(int startGear,int startspeed,int startHeight){
        super(startGear,startspeed);
        seatHeight = startHeight;
    }

    void printStates(){
        System.out.println("gear: " + gear +
                           " speed: " + speed +
                           " seatHeight: " + seatHeight);
    }
}

下面是 BicycleDemo 类，实例化两个对象：

class BicycleDemo{
    public static void main(String[] args) {
        Bicycle bike1 = new Bicycle();
        bike1.changeGear(2);
        bike1.speedUp(10);
        bike1.printStates();

        MountainBike bike2 = new MountainBike();
        bike2.changeGear(5);
        bike2.speedUp(30);
        bike2.changeHeight(20);
        bike2.printStates();
    }
}

//打印结果为:
//The Bike has 2's gear and it's speed is 10
//gear: 5 speed: 30 seatHeight: 20

---

一. 类的声明

class MyClass{
    //filed,constructor
    //method declarations
}

• 类体（花括弧之间的区域）包含对象自创建起生命周期内的所有代码：初始化新对象的构造器、类及对象状态的字段声明、实现类及其对象行为的方法.

上述类声明是最小的一个。它只包括声明必须的组件。在类声明中可以添加更多的关于类声明的信息，如超类的名字，是否实现接口等，如下 :

class MyClass extends MySuperClass inplements YourInterface{
    //field ,constructor
    //method declarations
}

通常，类声明包含下列组件：

1. 修饰符——public、private 等
2. 类名 ——符合规则的任意类名称
3. 如果有超类，要在超类前添加 extends 关键字（一个类只能继承一个超类）
4. 如果实现一系列接口（用逗号分隔），要在接口前面添加 implements 关键字（一个类可以实现多个接口）
5. 类体——花括弧 {} 之间的部分

（1）访问修饰符
基于封装的精髓，通常将类内部的字段声明为 private ，这就意味着只有类内部的成员可以直接访问这些字段。但要是在类的外部还想访问这些字段，可以通过公共方法获取字段值

class Bicycle{
    private int gear;
    private int speed;

    public int getGear(){
        return gear;
    }

    public int setGear(int newValue){
        gear = newValue;
    }

    public int getSpeed(){
        return Speed;
    }

    public int speedUp(int increment){
        Speed += increment;
    }
}

（2）类型
所有变量都必须有类型。变量的类型可以是int、float、boolean 等主类型，也可以是字符串、数组、对象等引用类型。

---

二. 定义方法
方法声明中必须有方法的返回类型和名称一对花括弧和花括弧之间的方法体。更普遍一点，方法声明包括六个组件

1. 修饰符
2. 返回值类型。如果方法不返回值，其类型是void
3. 方法名
4. 圆括号内的参数列表。参数用逗号隔开，而且要放在数据类型之后，如果没有参数，也必须使用空圆括号。
5. 异常列表
6. 花括弧里面的方法体

方法的重载
Java语言也支持重载方法，Java可以用不同的 方法签名 （方法声明中的方法名和参数类型构成方法签名）来区分方法。也就是说，如果方法的参数列表不同，则可以使用同一个方法名。

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

重载方法通过传递参数的参数数目和类型来区分。区分方法时，编译器不会考虑返回类型，因此不能声明两个方法，他们具有相同的方法签名，即使他们具有不同的返回类型。

三. 构建构造器

每个类都包含构造器，调用这些构造器可以从类创建对象。构造器的生命与方法的声明有点像，只是构造器名称与类名一样，且没有返回值类型。

类不一定要提供构造器，但是提供构造器，就要特别小心。编译器会为没有构造器的任意类自动创建一个无参数的默认构造器。该默认构造器会调用父类的无参数构造器，在这种情况下，如果父类没有无参数构造器，编译器就会报错，所以必须验证父类是否包含无参数构造器。

---

在上述的Bicycle 类中，我使用了重载构造器，使得不同的构造方法公用一个名称：

//两个构造器
public Bicycle(){}
public Bicycle(int startGear,int startspeed){
    gear = startGear;
    speed = startspeed;
}

//两个构造器
public MountainBike(){}
public MountainBike(int startGear,int startspeed,int startHeight){
    super(startGear,startspeed);
    seatHeight = startHeight;
}

这样，实例化Bicycle类的时候还可以这么写：

Bicycle bike3 = new Bicycle(2,10);
bike3.printStates();

MountainBike bike4 = new MountainBike(5,30,20);
bike4.printStates();