目录

一、背景介绍

二、知识点构成

1、类与实例

2、构造方法

3、方法重载

4、属性与修饰符

5、封装

6、继承

7、多态

三、总结

1. 抽象层次不同：

2. 数据处理方式不同：

3. 代码组织不同：

4. 维护性和扩展性：

5. 适用场景不同：

6. 继承和多态：

---

一、背景介绍

本文将介绍面向对象基础相关的知识；

二、知识点构成

1、类与实例

一切事务皆为对象，即所有的东西都是对象，对象就是可以看到、感觉到、听到、触摸到、尝到或闻到的东西。准确说，对象是一个自包含的实体。用一组可识别的特性和行为来标识；面向对象其实就是针对对象类进行编程的意思。类就是具有相同的属性和功能对象的抽象集合，实例是类的具体实现，是可以在程序中创建、操作和使用的对象。实例化就是创建对象的过程，使用new关键字来创建，

// 示例：定义一个简单的类
class Car {
    String brand;
    int year;

    void start() {
        System.out.println("Car started!");
    }
}

// 创建示例
Car myCar = new Car();
myCar.brand = "Toyota";
myCar.year = 2023;
myCar.start();

2、构造方法

构造方法，又叫构造函数，其实就是对类的初始化，构造方法与类同名，无返回值，也不需要void，在new对象的时候调用，也就是说，在类创建时，调用的构造方法，所有类都有构造方法，如果编码的时候没有显式的声明构造方法，那么会默认生成空的构造方法，如果有显式的声明构造方法，那么默认的构造方法就会失效。

class Person {
    String name;

    // 构造方法
    Person(String n) {
        name = n;
    }
}

// 创建示例时调用构造方法
Person person = new Person("Alice");

3、方法重载

方法重载提供了创建同名的多个方法的能力，但这些方法需使用不同的参数类型。并不只有构造方法可以重载，普通方法也是可以重载的；方法重载时，两个方法必须要名字相同，但参数类型和参数个数必须要有所不同，否则重载就没有意义的。重载可在不改变原方法的基础上新增功能。

class MathUtils {
    int add(int a, int b) {
        return a + b;
    }

    double add(double a, double b) {
        return a + b;
    }
}

4、属性与修饰符

属性是一个方法或一对党法，但在调用它的代码看来，他是一个字段，即属性适合于以字段的方式使用方法调用的场合，public表示它所修饰的类成员可以允许其他任何类来访问，俗称共有的，private表示只允许同一个类中的成员访问，其他类包括它的子类无法访问，俗称私有的。

class Student {
    // 私有属性，只能在类内部访问
    private String name;

    // 公共属性，任何地方都可以访问
    public int age;
}

5、封装

封装指的是将数据和操作数据的方法（函数）封装在一个单元（类）内部，对外部隐藏内部的实现细节，只暴露必要的接口供外部访问。封装有助于维护代码的安全性、可维护性和可扩展性，同时也可以限制对数据的直接访问，确保数据的一致性和有效性。

封装的主要目的包括：

1. 隐藏实现细节：外部只需关注类的接口，不需要知道内部的具体实现。
2. 提供访问控制：通过定义不同访问修饰符（public、private、protected）来限制外部对类成员的访问。
3. 保护数据完整性：通过方法来控制数据的修改，避免非法操作导致数据不一致。

public class Car {
    // 私有属性，外部无法直接访问
    private String make;
    private String model;
    private int year;

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

    // 公有方法提供访问和修改私有属性的接口
    public String getMake() {
        return make;
    }

    public void setMake(String make) {
        this.make = make;
    }

    public String getModel() {
        return model;
    }

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

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        // 添加一些逻辑控制，确保年份在合法范围内
        if (year >= 1886 && year <= 2023) {
            this.year = year;
        } else {
            System.out.println("Invalid year!");
        }
    }

    // 其他方法
    public void start() {
        System.out.println("The car is starting.");
    }

    public void stop() {
        System.out.println("The car is stopping.");
    }
}

6、继承

继承是面向对象编程中的一个重要概念，它允许一个类（子类或派生类）继承另一个类（父类或基类）的属性和方法。通过继承，子类可以重用父类的代码，并在此基础上添加新的属性和方法，从而实现代码的重用和扩展。

继承的主要优势包括：

1. 代码重用：子类可以使用父类的属性和方法，减少了重复编写代码的工作。
2. 扩展性：子类可以添加新的属性和方法，以满足特定需求，从而扩展父类的功能。
3. 层次结构：通过继承，可以创建类之间的层次结构，更好地组织和管理代码。

// 父类
class Animal {
    String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void eat() {
        System.out.println(name + " is eating.");
    }
    
    public void sleep() {
        System.out.println(name + " is sleeping.");
    }
}

// 子类继承父类
class Dog extends Animal {
    public Dog(String name) {
        super(name); // 调用父类的构造方法
    }
    
    public void bark() {
        System.out.println(name + " is barking.");
    }
}

class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }
    
    public void meow() {
        System.out.println(name + " is meowing.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        Cat cat = new Cat("Whiskers");
        
        dog.eat();
        dog.bark();
        
        cat.eat();
        cat.meow();
    }
}

上面的示例中，有一个基类 Animal 和两个派生类 Dog 和 Cat。Animal 类具有通用的属性和方法，而 Dog 和 Cat 类继承了 Animal 类，因此它们拥有了 name、eat() 和 sleep() 方法。

通过继承，Dog 类和 Cat 类可以添加自己特有的方法（例如 bark() 和 meow()）。在 Main 类中，我们实例化了 Dog 和 Cat 对象，并调用了它们的方法。

7、多态

多态是面向对象编程中的一个重要概念，它允许不同的类通过共同的接口来表现不同的行为。多态性使得可以在运行时动态地确定要执行的具体方法，而不需要在编译时确定。这为代码的灵活性和可扩展性提供了基础。

多态性的主要特征是：

1. 方法重写：子类可以重写（覆盖）父类的方法，以实现特定的行为。
2. 向上转型：可以将子类的实例赋值给父类的引用变量，实现了多态性。
3. 运行时绑定：在运行时根据实际对象的类型来调用方法，而不是根据引用变量的类型

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound.");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks.");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat meows.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        
        animal1.makeSound();
        animal2.makeSound();
    }
}

Animal 是基类，而 Dog 和 Cat 是派生类。它们都重写了基类的 makeSound() 方法。

在 Main 类中，我们创建了一个指向 Dog 实例的 Animal 引用变量 animal1，以及一个指向 Cat 实例的 Animal 引用变量 animal2。尽管这两个引用变量的类型都是 Animal，但由于多态性的存在，它们实际上可以指向不同的子类实例。

当调用 makeSound() 方法时，实际执行的方法取决于引用变量所指向的实际对象类型。在运行时，Java 会根据对象的实际类型来动态地选择要调用的方法。这就是多态性的体现。

三、总结

面向对象和面向过程是两种不同的编程范式，它们在代码组织、设计思想和解决问题的方式上有很大的区别。以下是它们之间的主要区别：

1. 抽象层次不同：

• 面向过程： 面向过程编程以过程或函数为中心，强调程序的执行顺序和步骤。代码主要是一系列的过程（函数）调用，以完成特定的任务。
• 面向对象： 面向对象编程以对象为中心，强调事物之间的关系和交互。代码主要是由对象组成，每个对象包含数据和操作数据的方法。

2. 数据处理方式不同：

• 面向过程： 数据和函数（过程）是分开的，数据通过函数进行处理和操作。
• 面向对象： 数据和操作数据的方法被封装在一起，通过对象进行处理和操作。

3. 代码组织不同：

• 面向过程： 程序由一系列的函数组成，每个函数都有特定的任务。
• 面向对象： 程序由一组对象组成，每个对象包含数据和方法，它们协同工作来实现功能。

4. 维护性和扩展性：

• 面向过程： 面向过程的代码可能较难维护和扩展，因为修改一个过程可能会影响到其他调用它的地方。
• 面向对象： 面向对象的代码更易于维护和扩展，因为每个对象的内部实现是封装的，修改一个对象不会影响其他对象。

5. 适用场景不同：

• 面向过程： 面向过程适用于相对简单的问题，如数据处理、算法等。
• 面向对象： 面向对象适用于较为复杂的问题，需要处理多个实体之间的交互和关系。

6. 继承和多态：

• 面向过程： 面向过程编程通常不涉及继承和多态的概念。
• 面向对象： 面向对象编程强调继承和多态，允许代码的重用和扩展。

总的来说，面向对象编程更加强调数据的组织和交互，使得代码更加模块化、灵活和易于维护。面向过程编程更侧重于步骤和流程，适用于简单的问题。不同的编程范式适用于不同的场景和问题复杂度。