当前位置：首页 > article >正文

14天Java基础学习——第6天：面向对象编程（类与对象）

article 2024/11/16 11:16:22

第6天：面向对象编程（类与对象）

目标

本节的目标是深入理解面向对象编程中的类与对象概念，包括类的定义、对象的创建、构造方法、封装、访问修饰符、this关键字，以及静态与实例成员。通过理论与实践相结合的方式，帮助学生全面把握这些基础概念。

1. 类与对象的基础

1.1 类的定义

在Java中，类是对象的蓝图或模板。定义类时，首先需要指定类的名称，并可以包含属性（成员变量）和方法（成员函数）。

public class Dog {
    // 属性（成员变量）
    String name;
    int age;

    // 方法（成员函数）
    void bark() {
        System.out.println(name + " says Woof!");
    }
}

1.2 对象的创建

对象是类的实例。创建对象的过程称为实例化。Java使用new关键字来创建对象。

public class Main {
    public static void main(String[] args) {
        // 创建 Dog 类的对象
        Dog dog = new Dog();
        dog.name = "Buddy";
        dog.age = 3;
        dog.bark(); // 输出: Buddy says Woof!
    }
}

2. 构造方法与封装

2.1 构造方法

构造方法是一种特殊的方法，在创建对象时被调用。其名称与类相同，没有返回值。

public class Dog {
    String name;
    int age;

    // 构造方法
    public Dog(String name, int age) {
        this.name = name; // this关键字用于区分成员变量和参数
        this.age = age;
    }

    void bark() {
        System.out.println(name + " says Woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy", 3);
        dog.bark(); // 输出: Buddy says Woof!
    }
}

2.2 封装

封装是一种将数据和方法组合在一起的机制。通过访问修饰符，可以控制外部访问对象的属性，并通过公共方法对其进行操作。

public class Dog {
    // 私有成员变量
    private String name;
    private int age;

    // 构造方法
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 获取姓名
    public String getName() {
        return name;
    }

    // 设置姓名
    public void setName(String name) {
        this.name = name;
    }

    // 获取年龄
    public int getAge() {
        return age;
    }

    // 设置年龄
    public void setAge(int age) {
        this.age = age;
    }

    void bark() {
        System.out.println(name + " says Woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy", 3);
        dog.bark(); // 输出: Buddy says Woof!
        System.out.println("Name: " + dog.getName());
        System.out.println("Age: " + dog.getAge());
    }
}

3. 访问修饰符与 `this` 关键字

3.1 访问修饰符

Java中有四种访问修饰符：public、protected、default（包访问）和private。

修饰符	同包类	子类	其他类	说明
public	是	是	是	公开, 任何地方可访问
protected	是	是	否	受保护的, 仅限子类与同包类
default	是	否	否	包访问, 仅限同包类
private	否	否	否	私有, 仅限本类

3.2 `this` 关键字

this 关键字指的是当前对象的引用。它用于解决命名冲突，以及在构造方法中调用另一个构造方法。

示例：

public class Dog {
    private String name;
    private int age;

    // 构造方法
    public Dog(String name, int age) {
        this.name = name; // this关键字区分成员变量和参数
        this.age = age;
    }

    // 另一个构造方法
    public Dog(String name) {
        this(name, 0); // 通过 this 调用另一个构造方法
    }

    void bark() {
        System.out.println(name + " says Woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog1 = new Dog("Buddy", 3);
        dog1.bark(); // 输出: Buddy says Woof!

        Dog dog2 = new Dog("Max");
        dog2.bark(); // 输出: Max says Woof!
    }
}

4. 静态成员与实例成员

4.1 静态成员

静态成员属于类，而不是类的实例。可以直接通过类来访问静态变量或方法。

public class Dog {
    private static int dogCount = 0; // 静态变量

    public Dog() {
        dogCount++; // 每次创建对象，增加计数
    }

    public static int getDogCount() {
        return dogCount; // 返回当前狗的数量
    }

    void bark() {
        System.out.println("Woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog1 = new Dog();
        Dog dog2 = new Dog();
        System.out.println("Current dog count: " + Dog.getDogCount()); // 输出: Current dog count: 2
    }
}

4.2 实例成员

实例成员属于对象，每个对象都有其独立的实例变量和实例方法。

public class Dog {
    private String name;

    public Dog(String name) {
        this.name = name;
    }

    void bark() {
        System.out.println(name + " says Woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog1 = new Dog("Buddy");
        Dog dog2 = new Dog("Max");
        dog1.bark(); // 输出: Buddy says Woof!
        dog2.bark(); // 输出: Max says Woof!
    }
}