Java杂谈：解锁面向对象编程（OOP）魔法

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

Java的核心理念是面向对象编程。实际上，所有Java程序都遵循这一原则，你没有其他选择。这与C++有所不同，因为在C++中，你可以决定是否采用面向对象的方式。在Java中，面向对象编程是不可分割的，因此在编写任何简单的Java程序之前，理解其基本原则是非常重要的。我希望可以通过下面的讲解帮助你更好的理解。

---

一、对象（object）与类（class）：一切的基础

一个类可以看作是一个蓝图，用来定义一组对象的共同特点和行为。想象一下，类就像是制造相同玩具的模具，而每一个由这个模具生产出来的玩具就是一个对象。
定义类的代码如下：

// 定义一个类
class Dog {
    // 对象属性：名字
    String name;

    // 构造方法，创建对象时会调用
    public Dog(String name) {
        this.name = name; // 初始化名字
    }

}

每个对象都有自己的属性和功能，它们遵循这个类的定义。因为它们都是由同一个蓝图“铸造”出来的，所以我们说这些对象是这个类的实例。简单来说，类是一个抽象的概念，而对象则是实际存在的实体。
下面的代码就是这个类的实例化，即对象：

// 主类
public class ceshi {
    public static void main(String[] args) {
        // 创建对象（实例化）
        Dog dog1 = new Dog("Puppy");
    }
}

---

二、封装（Encapsulation）：将秘密装进盒子

就像把珍贵的秘密安全地放入一个锁住的盒子，封装保护了对象的内部状态，只有通过特定的方法才能访问。

封装的优势在于，用户可以轻松地使用功能，而不需要了解其内部的具体实现。这样的设计确保了用户不用担心错误使用可能引发的问题，从而可以更加安心和高效地利用这些功能。
代码如下（示例）：

class Dog {
    private String name = "Puppy"; // 私有属性，即封装起来了

    public String getName() {
        return name; // 提供一个获取名字的方法
    }
}

---

三、继承（Inheritance）：继承父母的基因

通过继承，我们可以创建一个新类（子类），它可以重用父类（基类）的方法和属性。这就像你的外貌从父母那里继承来的基因。

举个例子，如果我们有一个“动物”类，它包含基本的特征，比如“Eating”。然后我们可以创建一个“狗”类，这个类都可以继承“动物”类。这意味着“狗”默认拥有“Eating”的能力，但它们也可以添加自己的特征，比如“狗”可以有“Wang”这个特性。
代码如下：

// 父类：动物
class Animal {
    void eat() {
        System.out.println("Eating~~~~~");
    }
}
// 子类：狗
class Dog extends Animal {
    private String name = "Puppy"; // 私有属性

    // 提供一个获取名字的方法
    public String getName() {
        return name;
    }
    // 狗类特有的方法
    public void bark() {
        System.out.println(name + "Wang~~wang~");
    }
}

public class ceshi {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        // 使用继承的方法
        myDog.eat();   // 输出：动物在吃东西
   
        // 使用子类特有的方法
        myDog.bark();  // 输出：小狗在叫
    }
}

---

四、多态（polymorphism）：同一接口，不同实现

多个对象可以通过同一个接口（方法）进行操作，但具体的实现会因为对象的不同而有所差异。

举个例子：还是有一个“动物”类，它包含基本的特征，还是“能叫”。然后我们可以创建一个“狗”类和一个“猫”类，这两个类都可以重写父类的方法。即同一方法或操作在不同对象上可以表现出不同的行为。
代码如下：

// 父类：动物
class Animal {
    public void makeSound() {
        System.out.println("动物在叫");
    }
}

// 子类：狗、猫
class Dog extends Animal {
    // 进行重载，体现其多态性
    @Override
    public void makeSound() {
        System.out.println("Wang~~wang~");
    }  
}
class Cat extends Animal {
    //进行重载，体现多态性
    @Override
    public void makeSound() {
        System.out.println("Miao~~~miao~");
    }
}

public class ceshi {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.makeSound(); // 输出：小狗
        myCat.makeSound(); // 输出：小猫
    }
}

---

五、抽象（abstraction）：隐藏复杂，暴露细节

抽象提供了一个框架，让我们能够在不同的子类中实现具体的方法。就像抽象画——每个人都有自己的解释。

抽象是面向对象编程的一种重要特性，主要用来定义一种简单的接口或基础类，而不直接实现具体行为。抽象可以通过抽象类（abstract class）和接口（interface）来实现。
举个例子：还是小狗的例子，先定义一个抽象类和抽象方法：

// 抽象类
abstract class Animal {
    // 抽象方法，没有实现
    abstract void bark();
    // 具体方法
    void eat() {
        System.out.println("Eating~~~");
    }
}

第一种，由子类继承这个抽象类：

// 具体子类
class Dog extends Animal {
    // 实现抽象方法
    @Override
    void bark() {
        System.out.println("Wang~~~~wang~");
    }
}

第二种，可以用接口实现。
接口是实现抽象的重要手段之一。在Java中，接口定义了一组可以由类实现的抽象行为。

class Cat implements Animal {
    @Override
    public void bark() {
        System.out.println("Miao~~miao~~");
    }

    @Override
    public void eat() {
        System.out.println("Cat is eating.");
    }
}

---

总结

以上就是我要讲的内容，本文仅仅简单介绍了Java面向对象编程的简单例子，希望可以帮到大家。