java类与对象

java类

一、类和对象

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

对象(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，请大家多多关照。\n", 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)\n", name, x, y);
        else
            system.out.printf("p(%.2f, %.2f)\n", 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\n", 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. 组合类型的一些规则

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