Java轻松掌握面向对象的三大特性封装与继承和多态

Java是一门面向对象编程语言，而面向对象编程的三大特性为封装、继承和多态。下面将为大家介绍如何轻松掌握这三大特性。

封装

封装是指将类的属性和方法包装在一起，隐藏了类的实现细节，使得类的使用者只需关注类的功能而不必关心其内部实现。Java中可以通过public、private、protected、default等访问修饰符来实现封装。

以下是一个示例代码，演示了如何实现类的封装：

public class Student {

    private String name;
    private int age;

    // 构造函数
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getter和setter方法
    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;
    }
}

在这个示例中，定义了一个名为Student的类，其中包含了两个私有属性name和age。通过设置getter和setter方法，外部可以通过这些方法来访问和修改这些属性。这就是封装的效果。

继承

继承是指一个类可以从另一个类继承属性和方法，并且还可以在继承的基础上增加新的属性和方法。在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, I'm " + name);
    }
}

public class Student extends Person {

    private String school;

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

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    // 重写父类的方法
    @Override
    public void sayHello() {
        System.out.println("Hello, I'm " + getName() + ", a student of " + school);
    }
}

在这个示例中，定义了一个名为Person的父类，其中包含了两个私有属性name和age以及一个公共方法sayHello。然后定义了一个名为Student的子类，继承了Person类并增加了一个新的私有属性school，同时重写了父类的公共方法sayHello。从而实现了类的继承。

多态

多态是指对象在不同的情况下具有不同的行为，即同一个方法可以被不同的对象调用时表现出不同的形态。在Java中，可以通过继承和方法重写来实现多态。

以下是一个示例代码，演示了如何实现类的多态：

public class Animal {

    public void eat() {
        System.out.println("Animal is eating...");
    }
}

public class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("Dog is eating...");
    }
}

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("Cat is eating...");
    }
}

public class Test {

    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();

        animal1.eat();
        animal2.eat();
    }
}

在这个示例中，定义了一个名为Animal的父类，其中包含了一个公共方法eat。然后定义了两个子类Dog和Cat，分别重写了eat方法。在最后的Test类中，定义了两个Animal类型的对象，一个是Dog类型的对象，一个是Cat类型的对象。由于它们都是Animal的子类，所以可以通过父类类型的变量进行引用和调用。最终输出的结果就是：

Dog is eating...
Cat is eating...

即表现出了多态的效果。

综上所述，Java的封装、继承和多态是面向对象编程的三大特性，使用它们可以实现对象的高内聚、低耦合以及更好的代码重用性等优点。通过以上Case教程，您已经可以轻松掌握这三大特性了。