java类与对象

java类

一、类和对象

类(class)可以看成对具体事物的抽象特征提取。比如：人这个类，拥有器官的属性、拥有走路、劳动、吃喝玩乐的行为等。

类不能使用private、protected修饰。

对象(Object, instance)可以看成具体的事物，就是类的实例。比如：小明这个人，就是人类的一个实例。

二、类

1. 类的定义

[修饰符1 修饰符2...] class 类名 {
    ...
}

举个粒子：

public class Student {
    // 属性：成员变量
    int id;
    String name;
    String sex;
    int age;
    // 行为：方法
    void selfIntroduce() {
        System.out.printf("大家好，我是一名学生。我叫%s，今年%d岁，是一名%s生，我的学号是%d，请大家多多关照。
", name, age, sex, id);
    }
    void study() {
        System.out.println("我正在学习...");
    }
    void speak(String s) {
        // s为局部变量
        System.out.println(s);
    }
}

2. 类的成员

（1）属性：变量(field)

成员变量：在类中，有初始值
局部变量：在方法中

（2）行为：方法(method)

方法想必都很熟悉了，这里就不多介绍。

（3）构造器：构造方法

构造方法与普通方法不同，构造方法无返回值类型，但有返回值，返回值是新建对象（new）时的引用地址；当然也有相同之处，都有参数列表，也都可以进行重载。

每一个类都有构造方法，当没有显示定义构造方法时，系统默认会给类一个无参的构造方法。

构造方法定义：

类名(参数列表) {
    ...
}

举个李子：

public class Point {
    String name = null;
    float x; // x坐标
    float y; // y坐标
    Point() {                   // 默认构造方法
    }
    Point(float a, float b) {   // 构造方法重载
        x = a;
        y = b;
    }
    Point(float a, float b, String s) {   // 构造方法重载
        x = a;
        y = b;
        name = s;
    }
    void showPoint() { // 显示点的信息
        if(name != null)
            System.out.printf("%s(%.2f, %.2f)
", name, x, y);
        else
            System.out.printf("p(%.2f, %.2f)
", x, y);
    }
    double distance(Point p) { //计算两点距离
        return Math.sqrt(Math.pow((p.x - x), 2) + Math.pow((p.y - y), 2));
    }
}

三、对象

1. 声明对象

类名  对象名;

2. 创建对象

对象名 = new 类名(参数列表);

3. 参数传值

基本数据类型：传值，是指具体数字或字符串，所以变量的内容不会被修改。

引用数据类型：传值，是指引用值，也就是地址，所以变量的内容可能被修改。

举个栗子：

class E {
    public static void main(String args[]) {
        Point o = new Point();  // 新建对象，使用无参构造方法
        o.x = 0;
        o.y = 0;
        o.name = "O";
        Point a = new Point(3, 4, "A"); // 新建对象，使用重构的构造方法
        o.showPoint();
        a.showPoint();
        System.out.printf("d(OA) = %.2f
", a.distance(o));
    }
}

四、组合类型

——A类中声明B类的对象b作为自己的成员变量

1. 类组合对象

当在类中声明其他类的对象作为自己成员变量时，要么不使用new关键字新建对象；要么声明和新建放在同个语句中。

再举个栗子：

class Circle {
    Point o;                        // Right
    // o = new Point(0, 0, "O");       // Error
    // Point oo = new Point(0, 0, "O");// Right

    float r;        // Right
    // r = 5;          // Error
    // float rr = 5;   // Right

    Circle() {              // 默认构造方法
    }
    Circle(Point O, float R) {// 重载构造方法
        o = O;
        r = R;
    }
    void getCenterPoint() { // 获取圆心信息
        o.showPoint();
    }
    double area() {         // 计算圆面积
        return Math.PI*Math.pow(r, 2);
    }
}

class E {
    public static void main(String args[]) {
        Point o = new Point(0, 0, "O"); // 新建Point对象，使用重构的构造方法
        Circle c = new Circle(o, 8);    // 新建Circle对象，使用重载的构造方法
        c.getCenterPoint();             // 获取圆心信息
        System.out.printf("Area: %.2f", c.area());  // 计算圆o的面积
    }
}

2. 组合类型的一些规则

类方法只能操作类变量
实例方法可以操作类变量、实例变量
类只能调用类方法、类变量
对象可以调用类方法、实例方法、类变量、实例变量