OOP概念

面向对象编程（OOP，Object-Oriented Programming）是一种编程范式，旨在通过使用“对象”和“类”来组织代码。OOP 的核心概念包括以下几个方面
类 对象 封装 继承 多态 抽象

package com.flow.eda.lean;

public class Book {
//    名字
    private String name;
//    价格
    private double price;
    //    作者
    private String author;
    //    类目
    private String type;
    public Book(){

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    /**
     * Book类的有参构造
     * @param name 名字
     * @param price 价格
     * @param author 作者
     * @param type 类目
     */
    public Book(String name, double price, String author, String type) {
        this.name = name;
        this.price = price;
        this.author = author;
        this.type = type;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", price=" + price +
                ", author='" + author + '\'' +
                ", type='" + type + '\'' +
                '}';
    }
}

类

定义：

类是一个用户定义的数据类型，它封装了数据（属性）和对数据的操作（方法）。
类可以看作是现实世界中对象的抽象，描述了对象的特征和行为。

以下代码定义了一个简单的 Animal 类，包含两个属性：name（名字）和 age（年龄）。类提供了构造方法、getter 和 setter 方法用于访问和修改属性值，并且重写了 toString() 方法用于输出对象的字符串表示形式。整体设计比较合理，适用于表示一个动物的基本信息。

package com.flow.eda.lean;

public class Animal {

    private String name;

    private int age;

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

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

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
   public Animal(){}
    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

对象

1对象是类的实例。当你根据一个类创建一个对象时，该对象就具备了该类所定义的所有属性和方法。
2对象包含由类定义的属性，通常用变量表示。属性用于存储对象的状态或特征。
3对象可以将其状态（属性）和行为（方法）封装在一起，形成一个独立的实体。这种封装允许对象保护其内部状态，并通过公有方法来控制对其状态的访问
我们首先定义一个类，然后基于该类创建一个对象并调用它的方法。下面是一个简单的 Person 类的示例，代表一个人

public class Person {
    String name;
    int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 方法：介绍自己
    public void introduce() {
        System.out.println("你好我的名字事 " + name + " 我的年龄 " + age + " 岁");
    }
}

创建对象并调用方法：

public class Main {
    public static void main(String[] args) {
        // 创建 Person 对象
        Person person = new Person("宋", 20);

        // 调用对象的方法
        person.introduce();  // 输出
    }
}

对象 是类的实例，它拥有类定义的属性（name 和 age）和方法（introduce()）。
对象可以通过构造方法初始化属性，并通过调用方法来执行某些行为。

多态

多态是面向对象编程中的一个重要概念，它允许对象在不同情况下表现出不同的行为。多态通常通过方法重写和父类引用指向子类对象来实现。

父类 Animal：

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

子类 Dog：

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

使用多态的类：

public class Main {
    public static void main(String[] args) {
        // 创建 Animal 类型的引用，指向 Dog 和 Cat 对象
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        // 调用 sound 方法，表现出多态性
        myDog.sound();  // 输出: Dog barks
        myCat.sound();  // 输出: Cat meows
    }
}

通过父类 Animal 的引用指向子类 Dog 和 Cat 的对象，实现了多态性。
方法的调用根据对象的实际类型决定，而不是根据引用的类型，这种行为称为运行时多态（动态绑定）。
多态的优点在于代码的灵活性和可扩展性，允许我们在不修改现有代码的情况下扩展新类和新行为。

父类与子类与继承

在面向对象编程（OOP）中，父类（又称为基类或超类）和子类（又称为派生类）是继承机制的核心概念。继承允许一个类继承另一个类的属性和方法，从而实现代码的重用和扩展。

父类:

父类是一个通用的类，它定义了一些通用的属性和方法，供其他类（子类）继承和使用。父类可以包含：

属性：描述该类对象的一些共同特征（如name、age等）。
方法：描述该类对象的行为（如eat()、sleep()等）。

子类:

子类继承父类的属性和方法，同时可以扩展或修改这些功能。子类可以：

继承父类的所有非私有属性和方法。
定义自己特有的属性和方法。
重写（override）父类的方法，提供不同的实现。
子类通过继承父类，能够复用父类的代码，从而减少冗余并增强可扩展性

以下定义了一个 Son 类，它继承了父类 Animal，并且在其基础上添加了一个新的属性 isEyes，用于描述这个 Son 类的特定特征（如是否有眼睛）。这个类展示了如何通过继承（extends 关键字）来复用父类的代码，同时可以扩展子类的功能。

package com.flow.eda.lean;

public class Son extends Animal{
    private boolean isEyes;

    public void setEyes(boolean eyes) {
        isEyes = eyes;
    }

    public boolean isEyes() {
        return isEyes;
    }
    public Son(){

    }

    @Override
    public String toString() {
        return "Son{" +
                "isEyes=" + isEyes +
                '}';
    }

    public Son(String name, int age, boolean isEyes) {
        super(name, age);
        this.isEyes = isEyes;
    }
}

package com.flow.eda.lean;

public class Test1 {
    public static void main(String[] args) {
        Son bigson=new Son();
        bigson.setEyes(true);
        Animal son=new Animal();
        System.out.println(bigson.toString());
    }
}