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 String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void sayHello() {
        System.out.println("Hello, my name is " + name);
    }
}
public class Main {
    public static void main(String[] args) {
        Person person = new Person("John", 25);
        System.out.println(person.getName());  // 输出：John
        person.sayHello();  // 输出：Hello, my name is John
        person.setName("Mike");
        person.sayHello();  // 输出：Hello, my name is Mike
    }
}

继承是指一个类可以继承另一个类的属性和方法，通过继承可以实现代码的重用和扩展。子类可以继承父类的非私有字段和方法，并可以重写父类的方法。

示例代码如下：

public class Student extends Person {
    private String major;
    public Student(String name, int age, String major) {
        super(name, age);
        this.major = major;
    }
    public String getMajor() {
        return major;
    }
    public void setMajor(String major) {
        this.major = major;
    }
    @Override
    public void sayHello() {
        System.out.println("Hello, my name is " + getName() + ", and I'm a student majoring in " + major);
    }
}
public class Main {
    public static void main(String[] args) {
        Student student = new Student("Tom", 20, "Computer Science");
        System.out.println(student.getName());  // 输出：Tom
        student.sayHello();  // 输出：Hello, my name is Tom, and I'm a student majoring in Computer Science
        student.setMajor("Mathematics");
        student.sayHello();  // 输出：Hello, my name is Tom, and I'm a student majoring in Mathematics
    }
}

多态是指同一类型的对象在不同情况下表现出不同的行为。通过多态，可以实现基于父类的统一接口，对不同子类对象进行统一处理。

示例代码如下：

public class Animal {
    public void makeSound() {
        System.out.println("The animal makes a sound");
    }
}
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("The dog barks");
    }
}
public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("The cat meows");
    }
}
public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        animal1.makeSound();  // 输出：The dog barks
        animal2.makeSound();  // 输出：The cat meows
    }
}

抽象是指将类的共同特征提取出来形成抽象类或接口，用于定义一组规范，子类可以根据需要进行实现或继承。

示例代码如下：

public abstract class Shape {
    public abstract double getArea();
    public abstract double getPerimeter();
}
public class Circle extends Shape {
    private double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
    @Override
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}
public class Rectangle extends Shape {
    private double width;
    private double height;
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    @Override
    public double getArea() {
        return width * height;
    }
    @Override
    public double getPerimeter() {
        return 2 * (width + height);
    }
}
public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(3, 4);
        System.out.println(circle.getArea());  // 输出：78.53981633974483
        System.out.println(circle.getPerimeter());  // 输出：31.41592653589793
        System.out.println(rectangle.getArea());  // 输出：12.0
        System.out.println(rectangle.getPerimeter());  // 输出：14.0
    }
}