【大话设计模式】面向对象基础

旧城等待， 2023-10-11 15:56 29阅读 0赞

**目录**

一、背景介绍

二、知识点构成

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表示只允许同一个类中的成员访问，其他类包括它的子类无法访问，俗称私有的。

![5fed6b2e809f40e692b9ae6756062058.png][]

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、继承和多态 ###

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

![64298f35752e4828b4417957060cce8c.png][]

[5fed6b2e809f40e692b9ae6756062058.png]: https://img-blog.csdnimg.cn/5fed6b2e809f40e692b9ae6756062058.png
[64298f35752e4828b4417957060cce8c.png]: https://img-blog.csdnimg.cn/64298f35752e4828b4417957060cce8c.png