Java 精炼解读类和对象原理

什么是类和对象

在面向对象编程（Object-Oriented Programming，简称OOP）的思想中，类和对象是两个重要的概念。类是一种数据类型，它定义了一组属性和方法，而对象则是类的一个实例，具有这个类所定义的属性和方法。

类的定义和使用

在Java中，通过class关键字来定义一个类，格式如下所示：

public class ExampleClass {
    // 定义属性
    private int exampleInt;
    private String exampleStr;

    // 定义方法
    public int getExampleInt() {
        return exampleInt;
    }

    public void setExampleInt(int exampleInt) {
        this.exampleInt = exampleInt;
    }

    public String getExampleStr() {
        return exampleStr;
    }

    public void setExampleStr(String exampleStr) {
        this.exampleStr = exampleStr;
    }
}

上述例子中，我们定义了一个名为ExampleClass的类，它拥有两个属性：exampleInt和exampleStr，以及四个方法：getExampleInt()、setExampleInt()、getExampleStr()、setExampleStr()。

我们可以通过下面的代码来创建一个ExampleClass的对象，并为它的属性赋值：

ExampleClass exampleObject = new ExampleClass();
exampleObject.setExampleInt(42);
exampleObject.setExampleStr("Hello World");

通过上述代码我们成功实例化了一个ExampleClass对象，并为它的属性exampleInt和exampleStr赋值。

封装性

封装性指的是在一个对象内部封装了一些属性和方法，让外部无法随意的访问和修改内部的数据。

在Java中，我们可以通过修饰符来设置属性和方法的访问权限，常见的修饰符包括：

• public：表示该属性或方法可以被任何其他对象访问。
• private：表示该属性或方法只可以在当前类中被访问。
• protected：表示该属性或方法可以被当前类及其子类访问。

例如，我们可以将ExampleClass类的属性设置为私有的，并提供公共的getter和setter方法，来实现属性的封装：

public class ExampleClass {
    // 私有属性
    private int exampleInt;
    private String exampleStr;

    // 公共方法，用于访问私有属性
    public int getExampleInt() {
        return exampleInt;
    }

    public void setExampleInt(int exampleInt) {
        this.exampleInt = exampleInt;
    }

    public String getExampleStr() {
        return exampleStr;
    }

    public void setExampleStr(String exampleStr) {
        this.exampleStr = exampleStr;
    }
}

继承性

继承性指的是一个类可以从另一个类中继承属性和方法，并可以在自己的基础上进行修改或扩展。

在Java中，我们使用extends关键字来实现一个类的继承，例如：

public class ChildClass extends ParentClass {
    // 子类的属性和方法
}

上述代码中，ChildClass类继承了ParentClass类，可以直接使用ParentClass类中的属性和方法。同时，ChildClass类还可以根据需求添加新的属性和方法。

多态性

多态性指的是同一种类型的对象，在不同情况下的行为和表现方式可能会不同。在Java中，多态性可以通过以下两种方式来实现：

• 重载（Overloading）：同一个方法可以接受不同类型和数量的参数，在不同情况下会有不同的行为。
• 重写（Overriding）：子类可以通过重写父类的方法，来覆盖父类的方法实现，并且可以在子类中添加新的逻辑。

例如，我们可以通过以下代码来实现一个父类ParentClass和其子类ChildClass的多态性：

public class ParentClass {
    public void exampleMethod() {
        System.out.println("This is the parent class.");
    }
}

public class ChildClass extends ParentClass {
    // 重写父类的exampleMethod方法
    public void exampleMethod() {
        System.out.println("This is the child class.");
    }

    // 添加新的方法
    public void childMethod() {
        System.out.println("This is a method in the child class.");
    }
}

public class ExampleMain {
    public static void main(String[] args) {
        // 创建一个ParentClass对象
        ParentClass parentObject = new ParentClass();

        // 创建一个ChildClass对象
        ChildClass childObject = new ChildClass();

        // 调用父类的exampleMethod方法
        parentObject.exampleMethod(); // 输出 "This is the parent class."

        // 调用子类的exampleMethod方法
        childObject.exampleMethod(); // 输出 "This is the child class."

        // 调用子类中新增的方法
        childObject.childMethod(); // 输出 "This is a method in the child class."

        // 父类引用指向子类对象，多态性体现在这里
        ParentClass polyObject = new ChildClass();
        polyObject.exampleMethod(); // 输出 "This is the child class."
    }
}

总结

类和对象是OOP的核心概念，它们可以帮助我们实现封装性、继承性、多态性等特性。在编写Java程序时，我们应该尽可能地利用这些特性来提高代码的重用性、可读性和可维护性。