面向过程和面向对象

面向过程和面向对象的概念及区别

面向过程：

1. 概念：

   • 面向过程是一种以事件为中心的编程范式。
   • 它按照功能将程序结构划分为若干个基本模块，形成树状结构。
   • 每个模块内部一般由顺序、选择和循环三种基本结构组成。

2. 特点：

   • 程序流程在编写时已经确定。
   • 侧重于具体步骤和操作流程。

面向对象：

1. 概念：

   • 面向对象是一种将数据和对这些数据的操作封装在一起的编程范式。
   • 它把同类对象抽象出其共性，形成类，类中的大多数数据只能被本类的方法处理。

2. 特点：

   • 对象与对象之间通过消息进行通信。
   • 程序流程由用户在使用中决定，更加灵活。

区别：

1. 组织结构：

   • 面向过程：程序由功能模块组成，各模块关系简单，功能上相对独立。
   • 面向对象：程序由相互依存的对象组成，对象间通过消息通信。

2. 数据与方法的关系：

   • 面向过程：数据与方法分离，更注重功能的实现过程。
   • 面向对象：数据与方法绑定在一起，形成对象。

3. 扩展性与重用性：

   • 面向对象通常比面向过程具有更高的代码重用性和扩展性。

面向对象的三大特性详解

1. 多态

• 概念：多态是指允许一个接口被多种数据类型所实现，或一个接口在不同情境中具有多种实现方式。
• 举例：在Java中，所有的类都继承自Object类，Object类中有一个toString()方法。不同的类可以重写这个方法以提供自己的实现，当调用不同对象的toString()方法时，会表现出不同的行为，这就是多态的体现。

2. 封装

• 概念：封装是把数据和操作数据的方法绑定在一起，作为对象。它隐藏对象的内部状态和实现细节，只对外提供公共的接口来访问和操作对象。
• 举例：在Java中，一个类可以将其属性设为private，这样外部就无法直接访问这些属性。然后，类可以提供public的getter和setter方法来允许外部获取或修改这些私有属性。这就是封装的典型应用。

3. 继承

• 概念：继承是面向对象编程中实现代码重用的重要手段。通过继承，子类可以获得父类的所有属性和方法，并且可以添加或重写自己的属性和方法。
  以下是一些具体的实例（Java实现），用于说明面向对象编程中的多态、封装和继承概念。

实例：动物叫声

假设我们有一个基类Animal，它有一个方法makeSound。然后，我们有两个从Animal派生的子类：Dog和Cat。每个子类都重写了makeSound方法以实现不同的叫声。

public class Animal {
    public void makeSound() {
        System.out.println("Some generic animal sound");
    }
}

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

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

// 在某处调用
Animal animal1 = new Dog();
Animal animal2 = new Cat();
animal1.makeSound(); // 输出 "Woof!"
animal2.makeSound(); // 输出 "Meow!"

在这个例子中，animal1和animal2都是Animal类型的引用，但实际上它们分别引用了Dog和Cat对象。当我们调用makeSound方法时，会表现出多态性，即同一个接口（makeSound方法）在不同的对象上有不同的实现。

封装

实例：一个简单的银行账户类

public class BankAccount {
    private double balance; // 私有属性，对外界隐藏

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    // 公共的访问方法（getter）
    public double getBalance() {
        return balance;
    }

    // 公共的修改方法（setter）
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        } else {
            System.out.println("Insufficient funds!");
        }
    }
}

在这个例子中，balance是一个私有属性，对外界是隐藏的。我们只能通过公共的getter和setter方法来访问和修改它。这样就确保了账户余额的安全性和数据的完整性。

继承

实例：交通工具类及其子类

public class Vehicle {
    protected String brand;
    
    public Vehicle(String brand) {
        this.brand = brand;
    }
    
    public void startEngine() {
        System.out.println(brand + " vehicle engine started.");
    }
}

public class Car extends Vehicle {
    private int numberOfSeats;
    
    public Car(String brand, int numberOfSeats) {
        super(brand); // 调用父类的构造函数
        this.numberOfSeats = numberOfSeats;
    }
    
    public void honk() {
        System.out.println(brand + " car is honking!");
    }
}

public class Motorcycle extends Vehicle {
    public Motorcycle(String brand) {
        super(brand); // 调用父类的构造函数
    }
    
    public void revEngine() {
        System.out.println(brand + " motorcycle is revving its engine!");
    }
}

在这个例子中，Car和Motorcycle都是Vehicle的子类。它们继承了Vehicle类的属性和方法，并且各自添加了特有的属性和方法。通过继承，我们能够实现代码的重用和扩展。例如，Car和Motorcycle都继承了Vehicle的startEngine方法，但Car类添加了honk方法，而Motorcycle类添加了revEngine方法。