【java笔记总结】面向对象编程——封装，继承，多态

---

前言

参考教材：《java面向对象程序设计教程》
答案参考：chatgpt

一、封装

1.1、类修饰符

在 Java 中，类修饰符可以用来决定一个类的访问级别和其它一些属性。这些修饰符主要包括：

public: 类可以被任何其他类访问。

private: 类不能被其他类访问。这个修饰符不能直接应用于顶级类，但可以应用于内部类。

protected: 该修饰符不能直接应用于顶级类，但可以应用于内部类。被修饰的内部类可以被同一包内的类以及其他任何继承这个类的类访问。

default（无修饰符）: 如果一个类没有被声明为 public，private 或 protected，那么它默认是包私有的，即只能被同一个包的类访问。

final: 被 final 修饰的类不能被继承。

abstract: abstract 类不能被实例化，通常包含一个或多个抽象方法（也可以没有抽象方法）。

static: static 修饰符只能用于内部类，它表示这个类是静态的，不需要依赖外部类的实例。

public class MyClass { // 这是一个公有类
    // 类体
}

final class MyFinalClass { // 这是一个不能被继承的类
    // 类体
}

abstract class MyAbstractClass { // 这是一个抽象类
    // 类体
}

class OuterClass {
    static class MyStaticInnerClass { // 这是一个静态内部类
        // 类体
    }
}

在 C++ 中，没有类似 Java 中的类修饰符的概念：在 C++ 中，类的访问控制是通过在类体中使用 public，private 或 protected 关键字来实现的，这些关键字决定了类的成员的访问权限，而不是整个类的访问权限。除此之外，C++ 中还有 final 和 virtual 等关键字，但它们的含义和用途与 Java 中的并不完全一样。

1.2、访问权限——公有，私有，保护

在 Java 和 C++ 中，public、private、protected 这些修饰符都是用来控制对类成员的访问。这些成员可能包括变量（属性）、方法和内部类等。
在 Java 中：

public 成员可以在任何地方被访问。

private 成员只能在它们自己的类中被访问。

protected 成员可以在同一包的任何类中以及在不同包的子类中被访问。

默认访问级别（没有修饰符）是包级别的，这意味着这些成员可以在同一包的任何类中被访问。

在 C++ 中：

public 成员可以在任何地方被访问。

private 成员只能在它们自己的类中被访问。

protected 成员可以在它们自己的类中以及在任何派生类（即子类）中被访问。

所以，这些修饰符确实都是针对类的成员（即对象的属性和方法）。它们用来定义在什么情况下，这些成员可以被访问和修改。

1.3、成员变量

1.3.1、成员变量修饰符

在 Java 中，成员变量（字段）可以使用以下修饰符：

访问控制修饰符：用于确定其他类对此变量的访问级别。

public：该变量对所有类都可见。

protected：该变量只对同一个包内的类和所有子类可见。

private：该变量只在这个类内部可见。

无修饰符（默认）：该变量对同一包内的类可见。

---

static：用于指定该变量为静态变量，这意味着该变量属于类，而非类的实例。

final：该变量只能被赋值一次，一旦被赋值就不能改变。

transient：该变量不会被序列化。如果一个对象被 Java 的序列化机制序列化，所有的非 transient 变量都会被序列化，所有的 transient 变量都会被忽略。

volatile：告诉 JVM 该变量可能会被多个线程同时访问并修改，因此 JVM 不能对其进行缓存优化。这有助于保证多线程环境下的数据一致性，但可能会降低性能。

注意，和方法修饰符一样，这些修饰符并非所有都能同时使用，例如，final 和 volatile 不能同时修饰同一变量，因为 final 变量的值是不能改变的，而 volatile 则是用来处理变量值可能会改变的情况。

1.4、成员方法

1.4.1、成员方法修饰符

在 Java 中，成员方法（包括实例方法和类方法）可以使用以下修饰符：

访问控制修饰符：用于确定其他类对此方法的访问级别。

public：该方法对所有类都可见。

protected：该方法只对同一个包内的类和所有子类可见。

private：该方法只在这个类内部可见。

无修饰符（默认）：该方法对同一包内的类可见。

---

static：用于指定该方法为静态方法，这意味着该方法属于类，而非类的实例。

final：该方法不能在子类中被重写。

abstract：该方法在本类中没有具体实现，必须在子类中实现。如果一个类包含抽象方法，那么这个类必须被声明为抽象类。

synchronized：该方法在同一时间只能被一个线程访问。

native：该方法的实现由非 Java 代码（如 C 或 C++ 代码）提供。

strictfp：用于指定该方法必须遵循 IEEE 754 标准，以保证在所有平台上都有精确的浮点计算。

请注意，这些修饰符并非所有都能同时使用，例如，abstract 和 final 不能同时修饰同一方法，因为 abstract 方法必须在子类中被重写，而 final 方法不能被重写。

1.4.2、构造方法

在Java中，构造方法是一种特殊的方法，它用于初始化对象的状态。构造方法与类名相同，不返回任何值（包括void）。每次使用关键字new创建对象时，构造方法都会被调用。
以下是一个简单的例子：

public class Student {
    String name;
    int age;

    // 这是一个构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

在这个例子中，Student 类有一个构造方法，该方法接收两个参数：name 和 age。当我们创建Student类的新对象时，就可以使用这个构造方法，像这样：
Student student = new Student(“张三”, 20);

在这行代码中，new Student(“张三”, 20); 就是调用了构造方法，创建了一个新的 Student 对象。

1.4.3、类方法与实例方法

类方法和实例方法是 Java（以及其他面向对象编程语言）中的两种主要方法类型。

实例方法：实例方法是类的实例（对象）可以调用的方法。这些方法可以访问和修改实例变量的值，也可以访问其他实例方法和类方法。实例方法定义在类中，但不使用 static 关键字。这些方法通常用来执行与特定对象实例有关的任务。
例子：

public class Dog {
    private String name;

    // 这是一个实例方法
    public void bark() {
        System.out.println(name + " is barking!");
    }
}

类方法：类方法，也被称为静态方法，是使用 static 关键字声明的方法。这些方法不依赖于类的实例，而是直接与类本身相关。它们不能访问类的实例变量或实例方法，因为它们在没有类的实例的情况下就可以被调用。类方法通常用来执行与类本身（而不是类的特定实例）相关的任务。
例子：

public class MathUtil {
    // 这是一个类方法
    public static int add(int a, int b) {
        return a + b;
    }
}

在调用时，实例方法需要一个类的实例，然后调用实例的方法，例如 dog.bark()。而类方法则直接在类上调用，例如 MathUtil.add(5, 10)。
注意：虽然实例方法可以访问类方法，但是在类方法中访问实例方法或实例变量是不允许的，因为实例方法和实例变量需要一个具体的实例来引用，而类方法在没有实例的情况下就可以被调用。

---

C++静态方法和java静态方法区别：
是的，Java 中的类方法（静态方法）和 C++ 中的静态方法在许多方面都很相似。在这两种语言中，静态方法都与类相关，而不是类的实例。这意味着你可以在没有创建类的实例的情况下调用静态方法。
静态方法在 Java 和 C++ 中都不能访问类的非静态字段或调用非静态方法，因为这些都是依赖于特定实例的。它们通常用于实现不直接依赖于类实例的功能。
这里有一个简单的 C++ 静态方法的例子：

class MyClass {
public:
    static void myStaticMethod() {
        cout << "This is a static method.";
    }
};

int main() {
    MyClass::myStaticMethod();  // 调用静态方法
    return 0;
}

在这个例子中，myStaticMethod 是 MyClass 的一个静态方法，我们可以直接通过类名来调用它，而不需要创建 MyClass 的实例。

1.5 包

在Java中，包（Package）是用于组织类和接口的一种机制。它们实质上是命名空间，允许我们对类和接口进行组织。使用包可以避免类名冲突，提供访问控制，并且可以有效地管理大型的应用程序。
以下是一个如何使用包的例子：

package com.mycompany.myapp;

public class MyClass {
    //...
}

在这个例子中，MyClass类被放置在了包com.mycompany.myapp中。我们可以使用完整的包名和类名（也被称为全限定名）来访问这个类，例如com.mycompany.myapp.MyClass。
除此之外，包也用于导入其他的类和包。例如：

import java.util.List;

这里，java.util 是一个包，List 是这个包中的一个接口。使用 import 关键字，我们可以在代码中直接使用 List，而不用写全限定名 java.util.List。

---

继续来几个例子：

1. 创建和使用包
   假设我们创建了一个名为com.myapp.shapes的包，并在其中定义了一个Circle类。

// 文件路径: com/myapp/shapes/Circle.java

package com.myapp.shapes;

public class Circle {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    public double getArea() {
        return Math.PI * radius * radius;
    }
}

现在，我们可以在另一个类中使用这个Circle类。假设这个类在com.myapp.main包下。

// 文件路径: com/myapp/main/Main.java

package com.myapp.main;

import com.myapp.shapes.Circle;

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle(5.0);
        System.out.println("The area of the circle is " + circle.getArea());
    }
}

在Main类中，我们导入了com.myapp.shapes.Circle类，然后在main方法中创建了一个Circle对象，并调用了它的getArea方法。
2. 使用包级别的访问控制
在Java中，你可以使用public, private, protected, 和默认（无修饰符）这四种访问级别。如果你没有明确地在类或成员上指定修饰符，那么它们将有包级别的访问权限，也就是说，只有在同一个包中的其他类才能访问它们。
例如，如果我们有一个在com.myapp.shapes包中的Rectangle类，它有一个默认访问级别的width成员：

// 文件路径: com/myapp/shapes/Rectangle.java

package com.myapp.shapes;

class Rectangle {
    double width;
    double height;

    Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    double getArea() {
        return width * height;
    }
}

然后我们在同一个包中的另一个类Square中访问Rectangle的width成员：

// 文件路径: com/myapp/shapes/Square.java

package com.myapp.shapes;

public class Square {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle(5.0, 5.0);
        System.out.println("The width of the rectangle is " + rectangle.width);
    }
}

在这个例子中，Square类可以访问Rectangle的width成员，因为它们都在com.myapp.shapes这个包中。但是，如果你试图在com.myapp.main包中的类访问Rectangle的width成员，将会出现编译错误，因为width成员只对同一包内的类可见。

二、继承与多态

2.1 概念

在 Java 中，类的继承是 Java 面向对象编程的一个重要特性。它允许你基于已存在的类创建新的类。新创建的类继承了基类（也称为父类或超类）的属性和方法，并可以添加新的属性和方法，或者覆盖继承的方法。这种机制能够提高代码的重用性和可维护性。

基本语法：在 Java 中，我们使用 “extends” 关键字来声明一个类继承另一个类。例如，如果我们有一个 “Animal” 类，我们可以创建一个新的 “Dog” 类，让 “Dog” 继承 “Animal”：

public class Animal {
    public void eat() {
        System.out.println("Animal eats");
    }
}

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

在这个例子中，“Dog” 类就继承了 “Animal” 类的 “eat()” 方法，并添加了自己的 “bark()” 方法。

方法覆盖：子类可以覆盖（override）父类的方法，即在子类中定义一个和父类中同名、参数列表相同的方法。覆盖后，子类对象调用的是子类中定义的方法。例如：

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

    public void bark() {
        System.out.println("Dog barks");
    }
}

在这个例子中，“Dog” 类覆盖了父类 “Animal” 的 “eat()” 方法，所以一个 “Dog” 对象调用 “eat()” 方法时，会打印 “Dog eats”。

继承的限制：在 Java 中，一个类只能直接继承一个父类（称为单继承）。但是，一个类可以间接继承多个父类，例如，如果有一个类 B 继承了类 A，然后类 C 继承了类 B，那么类 C 间接地继承了类 A 的属性和方法。

构造函数和继承：构造函数是不能被继承的，但是在创建子类的对象时，会首先调用父类的构造函数（如果没有显式调用父类的构造函数，会自动调用父类的无参构造函数）。如果父类没有无参构造函数，那么在子类的构造函数中必须显式调用父类的其他构造函数，使用 “super” 关键字。

super关键字：在子类方法中，我们可以使用 “super” 关键字调用父类的方法或属性，包括被子类覆盖的方法。这个特性在处理一些需要引用父类方法的场合非常有用。

2.2 成员变量的隐藏和方法重写

成员变量的隐藏：当子类和父类定义了同名的成员变量时，子类中的变量会隐藏父类中的变量。这称为成员变量的隐藏，或者叫做变量遮蔽。它们的值可以独立设置，互不影响。在子类中如果需要访问父类的成员变量，可以通过 super 关键字进行访问。
例如：

public class Parent {
    public int value = 1;
}

public class Child extends Parent {
    public int value = 2;
}

Child child = new Child();
System.out.println(child.value); // 输出2
System.out.println(((Parent)child).value); // 输出1

在这个例子中，Child 类中的 value 变量隐藏了 Parent 类中的 value 变量。
这段代码主要演示了变量的隐藏和类型转换。在这个例子中，Child 类继承了 Parent 类，并且它们都定义了一个 value 变量。当我们创建一个 Child 对象时，它实际上有两个 value 变量，一个是 Child 自己的，另一个是从 Parent 继承的。Child 类的 value 变量隐藏了 Parent 类的 value 变量。
System.out.println(child.value); 这句代码会打印 Child 类的 value 变量的值，也就是 2。
System.out.println(((Parent)child).value); 这句代码首先将 child 对象向上转型为 Parent 类型，然后访问 value 变量。由于变量没有动态绑定的特性，所以这会访问 Parent 类的 value 变量，也就是打印 1。
所以，尽管 child 对象实际上是一个 Child 类的实例，但是当你把它看作一个 Parent 类的实例时，你会看到 Parent 类的 value 变量的值，这就是类型转换的效果。

方法的重写（Override）：当子类定义了一个与父类签名相同的方法时，子类中的方法会覆盖父类中的方法。这称为方法的重写或者方法的覆盖。在调用这个方法时，会调用子类中的版本，而不是父类中的版本。这是一种多态的表现形式。
例如：

public class Parent {
    public void print() {
        System.out.println("Parent");
    }
}

public class Child extends Parent {
    @Override
    public void print() {
        System.out.println("Child");
    }
}

Child child = new Child();
child.print(); // 输出"Child"
((Parent)child).print(); // 也输出"Child"

在这个例子中，Child 类中的 print() 方法重写了 Parent 类中的 print() 方法。

java的方法重写和C++ 中虚函数的区别：
Java 中的方法重写和 C++ 中的虚函数机制有相似之处，都是面向对象编程中多态的一种体现。下面是一些关键点：

C++ 虚函数：在 C++ 中，如果你希望子类能够重写父类的方法，你需要在父类中将这个方法声明为虚函数（使用 virtual 关键字）。然后在子类中可以重写这个方法。如果你通过父类指针或引用调用这个方法，C++ 会动态地决定调用哪个版本的方法，这就是动态绑定。

Java 方法重写：在 Java 中，所有的非静态方法默认都是虚方法，子类可以自由地重写父类的方法（除非父类方法被声明为 final，此时子类无法重写该方法）。如果你通过父类引用调用这个方法，Java 会动态地决定调用哪个版本的方法，这也是动态绑定。

所以，虽然 C++ 需要明确指定虚函数，而 Java 则假定所有非静态方法都可以被重写，但这两种机制的基本原理是一样的。都是通过让子类可以重写父类方法，从而实现多态性。

2.3 super关键字

在 Java 中，super 关键字有以下主要用途：

访问父类的成员变量：如果子类和父类有同名的成员变量，我们可以使用 super 关键字来访问父类的成员变量。
例如：

public class Parent {
    protected int value = 1;
}

public class Child extends Parent {
    private int value = 2;

    public void printValue() {
        System.out.println(value); // 输出2
        System.out.println(super.value); // 输出1
    }
}

调用父类的方法：如果子类重写了父类的方法，我们可以使用 super 关键字调用父类的方法。
例如：

public class Parent {
    public void print() {
        System.out.println("Parent");
    }
}

public class Child extends Parent {
    @Override
    public void print() {
        super.print();
        System.out.println("Child");
    }
}

调用父类的构造函数：在子类的构造函数中，我们可以使用 super 关键字调用父类的构造函数。需要注意的是，这个 super 调用必须是子类构造函数的第一条语句。
例如：

public class Parent {
    public Parent() {
        System.out.println("Parent constructor");
    }
}

public class Child extends Parent {
    public Child() {
        super();
        System.out.println("Child constructor");
    }
}

在这个例子中，创建一个 Child 对象会首先调用 Parent 的构造函数，然后再调用 Child 的构造函数。

2.4 对象的上转型对象

在 Java 中，向上转型（Upcasting）是一种将子类对象视为父类对象的操作。这是多态性的一个重要特点。当你向上转型时，你可以将一个特定的类的引用视为其父类的引用。在向上转型过程中，可能会丢失一些从子类获取的信息。
假设我们有两个类：Animal（动物）类和 Dog（狗）类，其中 Dog 类是 Animal 类的子类。我们可以创建一个 Dog 对象并将它向上转型为 Animal，如下所示：

Dog myDog = new Dog();
Animal myAnimal = myDog; // 这就是向上转型

在这个例子中，myDog 是一个 Dog 类的实例，我们将它向上转型为 Animal 类型并将其存储在 myAnimal 变量中。现在，虽然 myAnimal 实际上是一个 Dog 实例，但我们只能访问它作为 Animal 对象的那部分属性和方法。
值得注意的是，即使进行了向上转型，Java 仍然记得实际的对象类型。因此，如果 Dog 类重写了 Animal 类的某个方法，那么即使引用类型是 Animal，调用该方法时也会调用 Dog 类的版本，因为 Java 的方法调用是动态绑定的。例如：

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

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

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        Animal myAnimal = myDog;
        myAnimal.makeSound(); // 输出 "The dog barks"
    }
}

在这个例子中，即使 myAnimal 是 Animal 类型的，但 makeSound() 方法依然会输出 “The dog barks”，因为实际的对象类型是 Dog。

如何理解动态绑定？
Java 的方法调用是动态绑定的"这句话的意思是，在 Java 中，哪个版本的方法会被调用（即，是父类的方法还是子类的方法）是在运行时才确定的，而不是在编译时。这是多态的一个关键特性。
例如，假设我们有一个 Animal 父类和一个 Dog 子类，它们都有一个 makeSound() 方法。在 Dog 类中，makeSound() 方法重写了 Animal 类的 makeSound() 方法。

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

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

然后我们创建一个 Dog 对象，并将其类型转换为 Animal：

Animal myAnimal = new Dog();

当我们调用 myAnimal.makeSound() 时，虽然 myAnimal 的静态类型（编译时类型）是 Animal，但实际调用的是 Dog 类的 makeSound() 方法，因为 myAnimal 的动态类型（运行时类型）是 Dog：

myAnimal.makeSound(); // 输出 "The dog barks"

这就是动态绑定的一个例子。虽然在编译时，编译器只知道 myAnimal 是一个 Animal，但在运行时，Java 虚拟机（JVM）会查看实际的对象类型（即 Dog），并调用相应的方法。这种在运行时确定对象方法调用的机制就称为动态绑定。

与之相对的有静态绑定吗？
是的，Java也有静态绑定。与动态绑定相对，静态绑定是在编译时期确定的，这个过程也叫早期绑定。
静态绑定在Java中主要用于以下情况：

静态方法：静态方法在编译时就被解析。这是因为静态方法不依赖于实例，而是依赖于类本身。

final方法：final方法不能被子类重写，因此在编译时期就能确定它们的行为。

private方法：private方法只能在类本身中被调用，因此，编译器可以在编译时就确定它们的行为。

构造方法：构造方法在编译时就被解析。

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

    static void staticMethod() {
        System.out.println("This is a static method in Animal class");
    }
}

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

    static void staticMethod() {
        System.out.println("This is a static method in Dog class");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();
        myAnimal.makeSound(); // 输出 "The dog barks"
        myAnimal.staticMethod(); // 输出 "This is a static method in Animal class"
    }
}

在这段代码中，虽然 myAnimal 是 Dog 类的实例，但当我们调用 myAnimal.staticMethod() 时，输出的是 “This is a static method in Animal class”。这是因为静态方法不是动态绑定的，它们在编译时就被解析。因此，即使 myAnimal 是 Dog 类的实例，它仍然调用了 Animal 类中的静态方法。这就是静态绑定的一个例子。

---

2.5 抽象类

抽象类是一种特殊的类，它不能被实例化。抽象类的主要目的是为它的子类定义一个公共的、可继承的类型。抽象类可以包含一个或多个抽象方法。这些方法被声明，但没有具体实现。具体的实现由抽象类的子类提供。
下面是一个简单的抽象类的例子：

// 定义抽象类 Animal
public abstract class Animal {
    // 抽象方法 makeSound
    abstract void makeSound();

    // 非抽象方法
    public void eat() {
        System.out.println("The animal eats");
    }
}

// Dog 类继承 Animal 类
public class Dog extends Animal {
    // 实现 makeSound 方法
    public void makeSound() {
        System.out.println("The dog barks");
    }
}

// Cat 类继承 Animal 类
public class Cat extends Animal {
    // 实现 makeSound 方法
    public void makeSound() {
        System.out.println("The cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建 Dog 对象
        Dog myDog = new Dog();
        myDog.makeSound(); // 输出 "The dog barks"
        myDog.eat(); // 输出 "The animal eats"

        // 创建 Cat 对象
        Cat myCat = new Cat();
        myCat.makeSound(); // 输出 "The cat meows"
        myCat.eat(); // 输出 "The animal eats"
    }
}

2.6 接口

抽象类是一种特殊的类，它不能被实例化。抽象类的主要目的是为它的子类定义一个公共的、可继承的类型。抽象类可以包含一个或多个抽象方法。这些方法被声明，但没有具体实现。具体的实现由抽象类的子类提供。
下面是一个简单的抽象类的例子：

// 定义接口 Animal
public interface Animal {
    // 抽象方法 makeSound
    void makeSound();
}

// Dog 类实现 Animal 接口
public class Dog implements Animal {
    // 实现 makeSound 方法
    public void makeSound() {
        System.out.println("The dog barks");
    }
}

// Cat 类实现 Animal 接口
public class Cat implements Animal {
    // 实现 makeSound 方法
    public void makeSound() {
        System.out.println("The cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建 Dog 对象
        Dog myDog = new Dog();
        myDog.makeSound(); // 输出 "The dog barks"

        // 创建 Cat 对象
        Cat myCat = new Cat();
        myCat.makeSound(); // 输出 "The cat meows"
    }
}

接口和抽象类的区别：
接口和抽象类在 Java 中都可以用于定义抽象类型，但是它们之间有一些主要的区别：

实例化：抽象类和接口都不能直接被实例化，它们需要通过其子类或实现类来实例化。

方法定义：抽象类可以有非抽象的方法（具有具体实现的方法），而在 Java 8 之前，接口只能有抽象方法。从 Java 8 开始，接口可以有默认方法和静态方法。

成员变量：抽象类可以有非 final 和非 static 的变量，而接口只能有 static 和 final 的变量。

继承与实现：一个类可以实现多个接口，但只能继承一个抽象类。

构造函数：抽象类可以有构造函数，而接口不能有构造函数。

访问修饰符：接口中的方法默认是 public 的，抽象类则可以有 public、protected 和 private 的方法（private 方法不能是抽象的）。

总的来说，如果你需要创建一种对象的“模板”，并且预计会有很多共享代码，那么抽象类是一个很好的选择。如果你需要定义一种行为协议，或者你的类需要实现多个不相关的属性，那么接口可能是更好的选择。

三、多态

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。