Java学习指南-第三天：面向对象编程（OOP）基础

　　1.面向对象编程简介

　　面向对象编程（OOP）是一种编程范式，它将程序组织为对象的集合，每个对象都是类的实例。OOP的四大核心概念是：

• 封装：隐藏对象的内部状态，通过公共方法访问。

• 继承：一个类可以继承另一个类的属性和方法。

• 多态：同一个方法在不同对象中有不同的实现。

• 抽象：简化复杂系统，只关注相关细节。

　　2.类与对象

• 类：类是对象的蓝图或模板，定义了对象的属性和方法。

• 对象：对象是类的实例，具有状态和行为。

　　2.1定义类

public class Dog {
    // 属性（字段）
    String name;
    int age;

    // 方法
    public void bark() {
        System.out.println(name + " is barking!");
    }

    public void eat(String food) {
        System.out.println(name + " is eating " + food);
    }
}

　　2.2创建对象

public class Main {
    public static void main(String[] args) {
        // 创建Dog类的对象
        Dog myDog = new Dog();

        // 设置属性
        myDog.name = "Buddy";
        myDog.age = 3;

        // 调用方法
        myDog.bark();
        myDog.eat("bone");
    }
}

　　3.构造方法

　　构造方法用于初始化对象。构造方法的名称必须与类名相同，且没有返回类型。

　　3.1默认构造方法

　　如果类中没有定义构造方法，Java会提供一个默认的无参构造方法。

　　3.2自定义构造方法

public class Dog {
    String name;
    int age;

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

    public void bark() {
        System.out.println(name + " is barking!");
    }
}

public class Main {
    public static void main(String[] args) {
        // 使用自定义构造方法创建对象
        Dog myDog = new Dog("Buddy", 3);
        myDog.bark();
    }
}

　　4.封装

　　封装是OOP的一个重要概念，通过访问修饰符控制对类的属性和方法的访问。

　　4.1访问修饰符

• private：只能在类内部访问。

• protected：可以在类内部、子类和同一包内访问。

• public：可以在任何地方访问。

• 默认（无修饰符）：可以在同一包内访问。

　　4.2 Getter和Setter方法

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

    // Getter方法
    public String getName() {
        return name;
    }

    // Setter方法
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.setName("Buddy");
        myDog.setAge(3);

        System.out.println("Name: " + myDog.getName());
        System.out.println("Age: " + myDog.getAge());
    }
}

　　5.今日任务

1. 定义一个Car类，包含属性brand、model、year和方法start、stop。

2. 创建Car类的对象，设置属性并调用方法。

3. 为Car类添加自定义构造方法和Getter/Setter方法。

　　6.示例代码

public class Car {
    private String brand;
    private String model;
    private int year;

    // 自定义构造方法
    public Car(String brand, String model, int year) {
        this.brand = brand;
        this.model = model;
        this.year = year;
    }

    // Getter和Setter方法
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getModel() {
        return model;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public void start() {
        System.out.println(brand + " " + model + " is starting.");
    }

    public void stop() {
        System.out.println(brand + " " + model + " is stopping.");
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car("Toyota", "Corolla", 2020);
        myCar.start();
        myCar.stop();

        System.out.println("Brand: " + myCar.getBrand());
        System.out.println("Model: " + myCar.getModel());
        System.out.println("Year: " + myCar.getYear());
    }
}

　　7.总结

　　今天的内容涵盖了面向对象编程的基础知识，包括类与对象、构造方法、封装和访问修饰符。这些是OOP的核心概念，务必熟练掌握。明天我们将深入学习继承和多态。

　　提示：多动手编写代码，尝试定义不同的类并创建对象，调用方法和访问属性。这将帮助你更好地理解面向对象编程的概念。

　　祝你学习愉快！