Java 面向对象 -- Java 语言的封装、继承、多态、内部类和 Object 类

Java 是一种广泛使用的面向对象编程语言，其核心思想包括封装、继承和多态这三大特性。此外，Java 还支持内部类和 Object 类的使用，这些特性使得 Java 具有强大的代码复用性和可维护性。以下是对这些特性的详细介绍以及相应的代码示例。

封装

封装是指将对象的属性和行为封装在一起，并通过访问修饰符控制对外部访问。它可以保护对象的内部状态，避免外部直接修改。在 Java 中，通过 private 关键字来限制成员变量的访问，通过 getter 和 setter 方法来访问和修改这些私有变量。

class Person {
    private String name;
    private int age;

    // Getter 方法
    public String getName() {
        return name;
    }

    // Setter 方法
    public void setName(String name) {
        this.name = name;
    }

    // Getter 方法
    public int getAge() {
        return age;
    }

    // Setter 方法
    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        }
    }
}

public class TestEncapsulation {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("张三");
        person.setAge(25);

        System.out.println("姓名: " + person.getName() + ", 年龄: " + person.getAge());
    }
}

继承

继承是指一个类可以从另一个类派生出自己的子类，从而继承父类的属性和方法。通过继承，可以实现代码的复用。Java 中使用 extends 关键字来定义继承关系。

class Animal {
    public void eat() {
        System.out.println("动物在吃东西");
    }
}

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

public class TestInheritance {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // 继承自 Animal
        dog.bark(); // Dog 本身的方法
    }
}

多态

多态允许对象以不同的方式表现。具体来说，它使得同一个方法在不同对象上有不同的表现形式。多态有两种主要实现方式：方法重载（编译时多态）和方法重写（运行时多态）。

class Animal {
    public void sound() {
        System.out.println("动物发出声音");
    }
}

class Cat extends Animal {
    public void sound() {
        System.out.println("猫叫：喵");
    }
}

class Dog extends Animal {
    public void sound() {
        System.out.println("狗叫：汪");
    }
}

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

        myCat.sound(); // 输出：猫叫：喵
        myDog.sound(); // 输出：狗叫：汪
    }
}

内部类

内部类是定义在另一个类内部的类。它可以访问其外部类的所有成员，包括私有成员。内部类可以用于逻辑上的分组，便于组织代码。

class OuterClass {
    private String outerField = "外部类字段";

    class InnerClass {
        public void display() {
            System.out.println("访问：" + outerField);
        }
    }
}

public class TestInnerClass {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.display(); // 输出：访问：外部类字段
    }
}

Object 类

在 Java 中，所有的类都直接或间接地继承自 Object 类。Object 类提供了一些基本的方法，如 toString()、equals() 和 hashCode()。这些方法可以被子类重写，以实现自定义的行为。

class Person extends Object {
    private String name;

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

    @Override
    public String toString() {
        return "Person{name='" + name + '\'' + '}';
    }
}

public class TestObjectClass {
    public static void main(String[] args) {
        Person person = new Person("李四");
        System.out.println(person.toString()); // 输出：Person{name='李四'}
    }
}

总结

通过封装、继承和多态，Java 提供了强大的面向对象编程能力，使得代码更加灵活和易于维护。而内部类和 Object 类的使用进一步丰富了 Java 的特性，使得开发者能够编写出更高效和结构化的代码。这些特性在实际的开发中发挥着重要作用，帮助程序员构建更复杂的系统。