Java - 类

类定义了一种新的数据类型

一旦定义了一个类，就可以使用这种新的类型创建该类型的对象

• 类是对象的模板(template)，对象是类的实例(instance)

1. 类的基础知识

1.1 类的一般形式

class classname {
    type 实例变量1;
    type 实例变量2;
    // ...
    type 实例变量N;
    
    type methodname1(parameter-list) {
        // body of method
    }
    type methodname2(parameter-list) {
        // body of method
    }
    // ...
    type methodnameN(parameter-list) {
        // body of method
    }
}

类的代码包含在方法中，在类中定义的方法和变量都被称为类的成员。

大多数类中，实例变量由为该类定义的方法进行操作和访问。按照一般规则，方法决定了类中数据的使用方式。

1.2 一个简单的类

// BoxDemo.java
class Box {
    double width;
    double height;
    double depth;
}

class BoxDemo {
    public static void main(String[] args) {
        Box mybox = new Box();
        double vol;
        
        mybox.width = 10;
        mybox.height = 20;
        mybox.depth = 15;
        
        vol = mybox.width * mybox.height * mybox.depth;
        System.out.println("体积为" + vol);
    }
}

Java编译器自动将每个类放到各自的 .class 文件中。并非必须将 Box 类和 BoxDemo 类放入同一个源文件中，可将它们分别放置到各自的文件中，分别命名为 Box.java 和 BoxDemo.java

2. 声明对象

new 运算符在运行时为对象动态分配内存，并返回指向对象的引用。这个引用基本上是由 new 为该对象分配的内存地址，然后将这个引用存储在变量中。

在 Java 中，所有类对象都必须动态分配。

Box mybox = new Box(); 等价于：

Box mybox; // mybox 不指向实际的对象
mybox = new Box(); // 分配实际对象，并将该对象的引用赋给 mybox

---

new 运算符

new 运算符在运行时为对象分配内存。

可以创建在程序运行期间需要的任意数量的对象。但是，内存是有限的，new 运算符可能由于内存不足而不能为对象分配内存，就会发生运行时异常。

---

类是逻辑结构，对象是物理实体（对象占用内存中的空间）

3. 为对象引用变量赋值

Box b1 = new Box();
Box b2 = b1;

以上，b1 和 b2 会引用同一个对象。将 b1 赋值给 b2 时不会分配内存，也不会赋值原始对象的任何部分，只是简单地使 b2 引用 b1 所引用的同一个对象。因此，通过 b2 对对象所做的任何修改都将影响 b1 所引用的对象，它们本来就是同一个对象。

对 b1 的后续赋值，不会影响对象本身，也不会影响 b2

Box b1 = new Box();
Box b2 = b1;
// ...
b1 = null;
// b1 被设置成 null，但 b2 仍然指向原来的对象

将一个对象引用变量赋值给另一个对象引用变量时，不是创建对象的副本，而是创建引用的副本。

4. 方法

• Java 方法是语句的集合，它们在一起执行一个功能
  • 方法是解决一类问题的步骤的有序组合
  • 方法包含于类或对象中
  • 方法在程序中被创建，在其他地方被引用

修饰符 返回值类型 方法名(参数类型 参数名) {
    ...
    方法体
    ...
    return 返回值;
}

package method;

public class Demo01 {
    // main 方法
    public static void main(String[] args) {
        int sum = add(1, 2);
        System.out.println(sum);
    }

    // 加法
    public static int add(int a, int b) {
        return a+b;
    }
}

4.1 为 Box 类添加方法

class Box {
    double width;
    double height;
    double depth;
    
    void volume() {
        System.out.print("体积为：");
        System.out.println(width * height * depth);
    }
}

class BoxDemo {
    public static void main(String[] args) {
        Box mybox = new Box();
        
        mybox.width = 10;
        mybox.height = 20;
        mybox.depth = 15;
        
        mybox.volume();
    }
}

4.2 返回值

class Box {
    double width;
    double height;
    double depth;
    
    double volume() {
        return width * height * depth;
    }
}

class BoxDemo {
    public static void main(String[] args) {
        Box mybox = new Box();
        
        mybox.width = 10;
        mybox.height = 20;
        mybox.depth = 15;
        
        System.out.println("体积为: " + mybox.volume());
    }
}

4.3 添加带参的方法

class Box {
    double volume(double width, double height, double depth) {
        return width * height * depth;
    }
}

class BoxDemo {
    public static void main(String[] args) {
        Box mybox = new Box();
        
        System.out.println("体积为: " + mybox.volume(10, 20, 15));
    }
}

5. 构造函数

在创建对象时初始化对象自身。这种自动初始化通过构造函数实现。

class Box {
    double width;
    double height;
    double depth;
    
    Box() {
        System.out.println("初始化箱子尺寸");
        width = 10;
        height = 10;
        depth = 10;
    }
    
    double volume() {
        return width * height * depth;
    }
}

class BoxDemo {
    public static void main(String[] args) {
        Box mybox = new Box();
        
        System.out.println("体积为: " + mybox.volume());
    }
}

参数化的构造函数

class Box {
    double width;
    double height;
    double depth;
    
    Box(double w, double h, double d) {
        width = w;
        height = h;
        depth = d;
    }
    
    double volume() {
        return width * height * depth;
    }
}

class BoxDemo {
    public static void main(String[] args) {
        Box mybox = new Box(10, 20, 15);
        
        System.out.println("体积为: " + mybox.volume());
    }
}

6. this 关键字

有时，方法需要引用调用它的对象。为能执行这种操作，Java 定义了 this 关键字。可在任何方法中使用 this 关键字来引用当前对象。可以在允许使用当前类对象引用的任何地方使用 this。

Box (double w, double h, double d) {
    this.width = w;
    this.height = h;
    this.depth = d;
}

隐藏实例变量

Box (double width, double height, double depth) {
    this.width = width;
    this.height = height;
    this.depth = depth;
}

7. 堆栈类

class Stack {
    private int[] stck;
    private int tos;
    
    // 初始化栈
    Stack(int size) {
    	stck = new int[size];
        tos = -1;
    }
    
    // 入栈
    void push(int item) {
        if (tos==stck.length-1)
            System.out.println("栈满.");
        else
            stck[++tos] = item;
    }
    
    // 出栈
    int pop() {
        if (tos<0) {
            System.out.println("空栈.");
            return 0;
        }
        else
            return stck[tos--];
    }
}