Java系列之类与对象以及封装继承多态详解

废话不多说，我将根据我的理解来整理这一部分的内容。

目录

1.类

2.对象

3.封装

4.继承

5.多态

6.总结

---

 

1.类

在Java中，类描述了一个对象的属性和方法。类定义了一组变量和方法，这些变量和方法可以被该类的所有对象共享。通常我们将变量称为“属性”或“字段”，将方法称为“函数”或“方法”。我们可以使用关键字class来定义一个类，以及使用public、private等关键字来控制类的访问级别。下面是一个简单的示例：

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void sayHello() {
        System.out.println("Hello, my name is " + name + ", and I'm " + age + " years old.");
    }
}

在上面的代码中，我们定义了一个名为Person的类，它包含两个私有的成员变量name和age，还有一个公共的构造函数Person(String name, int age)和一个公共的方法sayHello()。其中，this.name和this.age用来引用当前对象的属性。下面是如何创建Person类的一个对象：

Person person = new Person("Tom", 20);

上面的代码创建了一个名为person的对象，使用new关键字调用了Person的构造函数，并传递了两个参数"Tom"和20。现在我们可以调用person对象的sayHello()方法：

person.sayHello();

这将输出以下内容：

Hello, my name is Tom, and I'm 20 years old.

2.对象

对象是类的实例，具有特定的状态和行为。在Java中，可以使用new关键字来创建对象。例如：

Person person = new Person("Tom", 20);

上面的代码创建了一个Person类的对象person。通过new关键字调用Person类的构造函数，并将参数"Tom"和20传递给它。现在，person对象拥有了该类定义的属性和方法。

对象的状态由其属性值决定。例如，在上面的代码中，person对象的name属性设置为"Tom"，age属性设置为20。对象的行为由其方法决定。例如，在上面的代码中，我们可以调用person对象的sayHello()方法来打印出它的介绍。

对象和类之间的关系是：类描述了一组对象的共同特征和行为，而对象则代表了该类中的一个具体实例。通常我们可以将类看作是制造汽车的工厂，而对象则是该工厂生产出的汽车。每个汽车都有自己的状态（例如颜色、型号等）和行为（例如加速、刹车等），但它们都共享相同的属性和方法。

3.封装

在Java中，封装是一种将数据和方法组合在一起以保护其安全性和隐藏复杂性的机制。通过使用访问修饰符（如public、private、protected等），可以控制类中成员的访问级别。通常情况下，我们应该尽可能地将类的成员设为私有（即private）或受保护的（即protected），以防止外部代码直接修改类的内部状态。

例如，在上面的Person类中，我们将name和age属性声明为私有的

这样就不能从类的外部访问它们，只能通过类的公共方法来读取和修改属性。这种做法可以避免对象被不当地修改，保证程序的正确性和稳定性。

另外，Java还提供了setter和getter方法，用于对私有属性进行设置和获取。例如，在Person类中，我们可以添加以下代码：

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

public String getName() {
    return name;
}

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

public int getAge() {
    return age;
}

上面的代码定义了四个公共的方法，分别是setName()、getName()、setAge()和getAge()。这些方法用于设置或获取对象的私有属性。例如，我们可以使用以下代码将person对象的name属性修改为"Jerry"：

person.setName("Jerry");

同样，我们也可以使用getName()方法获取person对象的name属性：

String name = person.getName();

4.继承

继承是一种面向对象编程的重要特性，它允许我们构建一个已存在类的子类，以便在子类中添加或修改功能。在Java中，我们可以使用关键字extends来实现继承。例如，下面是一个描述学生（Student）类的例子：

public class Student extends Person {
    private String major;

    public Student(String name, int age, String major) {
        super(name, age);
        this.major = major;
    }

    public void sayMajor() {
        System.out.println("My major is " + major);
    }
}

在上面的代码中，Student类继承自Person类，它具有该类的所有属性和方法，并添加了一个额外的属性major和一个名为sayMajor()的方法。构造函数使用super关键字调用了Person类的构造函数来初始化父类的属性。现在，我们可以创建一个Student对象，并调用其sayHello()方法和sayMajor()方法：

Student student = new Student("Tom", 20, "Computer Science");
student.sayHello();
student.sayMajor();

这将输出以下内容：

Hello, my name is Tom, and I'm 20 years old.
My major is Computer Science

5.多态

多态是一种允许不同对象对同一消息做出不同响应的特性。在Java中，多态有两种实现方式：重载和重写。重载指在同一个类中定义多个方法，它们具有相同的名称但参数列表不同。重写指在子类中重新定义父类的方法，以改变方法的行为。

例如，在Person类中，我们可以添加一个名为walk()的方法：

public void walk() {
    System.out.println("I'm walking.");
}

在Student类中，我们可以重写该方法：

@Override
public void walk() {
    System.out.println("I'm walking to the classroom.");
}

现在，我们可以通过Person类型的引用来调用Person对象的walk()方法，也可以通过Student类型的引用来调用Student对象的walk()方法。这就是多态的体现。

6.总结

在Java中，类和对象是面向对象编程的基本概念。类描述了一组对象的共同特征和行为，而对象则代表了该类中的一个具体实例。封装、继承和多态是面向对象编程的三个基本特性，它们可以使程序具有更好的可读性、可维护性和可扩展性。

需要注意的是，在设计类的时候，我们应该遵循单一职责原则（SRP）和开放-封闭原则（OCP），即每个类应该只负责一个

明确的职责，而且应该对修改关闭、对扩展开放。这将有助于避免代码的耦合和复杂性，提高程序的可维护性和可扩展性。

下面是一个更完整的例子，它演示了如何设计一个简单的图形计算器程序：

public abstract class Shape {
    private String name;

    public Shape(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public abstract double getArea();
}

public class Circle extends Shape {
    private double radius;

    public Circle(String name, double radius) {
        super(name);
        this.radius = radius;
    }

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

public class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(String name, double width, double height) {
        super(name);
        this.width = width;
        this.height = height;
    }

    @Override
    public double getArea() {
        return width * height;
    }
}

public class Calculator {
    public static void main(String[] args) {
        Circle circle = new Circle("Circle", 5.0);
        Rectangle rectangle = new Rectangle("Rectangle", 3.0, 4.0);

        Shape[] shapes = { circle, rectangle };

        for (Shape shape : shapes) {
            System.out.println(shape.getName() + "'s area is " + shape.getArea());
        }
    }
}

上述代码定义了一个抽象类Shape，它包含一个名为name的属性和一个抽象方法getArea()。该类还包含一个构造函数Shape(String name)和一个公共方法getName()，用于获取该图形的名称。

然后，我们定义了两个具体的子类：Circle和Rectangle。这些子类继承自Shape类，并实现了它们自己的计算面积的方法getArea()。

最后，我们定义了一个名为Calculator的主类，它包含一个名为main()的静态方法。在该方法中，我们创建了一个Circle对象和一个Rectangle对象，并将它们存储在一个Shape数组中。然后，我们遍历该数组，调用每个元素的getName()方法和getArea()方法，并输出结果。

这个例子演示了如何使用类和对象来设计一个简单但有用的程序。通过封装、继承和多态这三个特性，我们可以实现代码的重用、扩展和维护，提高程序的可读性和可维护性。