新手初学Java继承、封装与多态

下面是“新手初学Java继承、封装与多态”的完整攻略。

什么是继承？

在 Java 中，继承是一种面向对象的重要特性，它允许一个类（称为子类或派生类）继承另外一个类（称为父类或基类）的属性和方法。通过继承，子类可以重用父类的方法和属性，并且可以加入新的方法和属性来满足自己的特殊需求。

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 + ", I'm " + age + " years old.");
    }
}

public class Student extends Person {
    private String school;

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

    public void study() {
        System.out.println(name + " is studying at " + school);
    }
}

在上面的示例中，Student 类继承了 Person 类，从而拥有了 Person 类中的 name 和 age 属性以及 sayHello() 方法。同时，Student 类还新增了一个 school 属性和 study() 方法以便满足自身的需求。

什么是封装？

封装是面向对象程序设计中的一个重要特性，它允许将数据和方法包装到一个单独的单元中，并对外部隐藏具体实现细节，从而提高了代码的可维护性和安全性。

在 Java 中，封装通常借助访问控制修饰符来实现：

• private：封装级别最高，只有自身类的成员可以访问；
• protected：允许子类和同一个包中的类访问；
• public：所有类都可以访问。

public class Account {
    private String name;
    private double balance;

    public Account(String name, double balance) {
        this.name = name;
        this.balance = balance;
    }

    public void deposit(double amount) {
        balance += amount;
    }

    public void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
        } else {
            System.out.println("Insufficient funds.");
        }
    }

    public double getBalance() {
        return balance;
    }

    // 封装 name 属性，提供 getter 和 setter 方法
    public String getName() {
        return name;
    }

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

在上面的示例中，Account 类封装了 name 和 balance 属性，并且提供了公有方法 deposit()、withdraw() 和 getBalance() 来访问这些属性，同时还提供了公有方法 getName() 和 setName() 来访问和修改 name 属性。

什么是多态？

多态是面向对象编程中最重要的特性之一，它允许将同一种操作应用于不同的对象上，从而实现不同的结果。在 Java 中，多态通常通过接口、抽象类和方法重写实现。

public interface Shape {
    double area();
}

public class Circle implements Shape {
    private double radius;

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

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

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

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

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

public class Main {
    public static void main(String[] args) {
        Shape[] shapes = new Shape[2];
        shapes[0] = new Circle(2.5);
        shapes[1] = new Rectangle(3.0, 4.0);

        for (Shape shape : shapes) {
            System.out.println("The area of the shape is " + shape.area());
        }
    }
}

在上面的示例中，Shape 接口定义了 area() 抽象方法，Circle 和 Rectangle 类继承了 Shape 接口并实现了 area() 方法。在 Main 类中，我们创建了一个 Shape 数组，并且将 Circle 和 Rectangle 类的实例赋值给数组中的元素，最后使用增强型循环遍历数组，依次调用不同对象的 area() 方法输出面积。

这就是“新手初学Java继承、封装与多态”的完整攻略，希望对你有所帮助！