Java面向对象、封装继承多态、重写和重载、枚举讲解_多态 继承 重载

Java是一种面向对象的编程语言，它支持面向对象的特性，如封装、继承、多态、重写和重载，以及枚举。通过理解和熟练掌握这些概念和语法，可以编写出更灵活、可扩展的Java程序。

一、面向对象编程

面向对象编程（OOP）是一种编程范式，以对象作为程序的基本单元，将数据和操作封装在一起。Java是一种面向对象的语言，核心思想是通过创建对象来解决问题。

二、封装

封装是面向对象编程中的一个重要概念，将数据和操作封装在一个类中，通过访问修饰符控制对数据的访问。封装可以隐藏数据的实现细节，提供公共的接口来访问和操作数据。

代码：

class Person {
    private String name;
    private int age;

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

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

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

        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Person类封装了私有的name和age属性，并提供了公共的setter和getter方法来访问和设置属性的值。

三、继承

继承是面向对象编程中的一种机制，它允许一个类继承另一个类的属性和方法。子类继承了父类的特性，并可以在此基础上添加新的属性和方法。

代码：

class Animal {
    protected String name;

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

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

class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("Buddy");
        dog.eat(); // 输出：Animal is eating
        dog.bark(); // 输出：Dog is barking
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

Animal类是父类，Dog类是其子类。子类继承了父类的属性和方法，并可以在此基础上添加新的功能。

四、多态

多态是面向对象编程的一个重要特性，它允许同一类型的对象在不同的情况下表现出不同的行为。多态通过继承和方法重写实现。

代码：

class Animal {
    public void makeSound() {
        System.out.println("Animal makes sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat meows");
    }
}

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

        animal1.makeSound(); // 输出：Dog barks
        animal2.makeSound(); // 输出：Cat meows
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

Animal类是父类，Dog和Cat类是其子类。通过将子类对象赋值给父类引用，可以实现多态性。在调用makeSound()方法时，根据实际对象的类型，会调用相应子类的方法。

五、重写和重载

重写是指在子类中重新定义父类的方法，使其具有不同的实现。重写的方法必须具有相同的名称、参数列表和返回类型。重载是指在一个类中定义多个同名方法，但参数列表不同。

代码：

class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }
}

public class OverridingOverloadingExample {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        int result1 = calculator.add(5, 3); // 输出：8
        double result2 = calculator.add(2.5, 3.5); // 输出：6.0
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Calculator类中定义了两个同名的add()方法，一个是接受两个整数参数的方法，另一个是接受两个浮点数参数的方法。根据调用时传入的参数类型和个数，会自动匹配调用对应的重载方法。

六、枚举

枚举是一种特殊的数据类型，它限制变量只能取特定的预定义值。在Java中，使用enum关键字定义枚举类型。

代码：

enum Day {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

public class EnumExample {
    public static void main(String[] args) {
        Day day = Day.MONDAY;

        switch (day) {
            case MONDAY:
                System.out.println("Today is Monday");
                break;
            case TUESDAY:
                System.out.println("Today is Tuesday");
                break;
            // ...
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

定义一个Day枚举类型，包含一周的每一天。通过使用枚举类型的变量，可以方便地表示和操作特定的值。