本文共 5091 字，大约阅读时间需要 16 分钟。

三大特性：封装、继承和多态

作为Java编程中的核心概念，封装、继承和多态是对象-oriented programming（OOP）的基石。本文将从这些概念的特性、语法应用以及实际案例入手，帮助读者更好地理解和掌握这些知识点。

一、封装

1.封装

封装是一种将类的内部实现细节隐藏起来的机制，防止外部程序直接访问对象的私有属性。通过提供get和set方法，外界只能通过特定的方法对属性进行读写操作。这不仅保护了对象的内部状态，也提高了代码的安全性和可维护性。

在Java中，get/set方法是外界获取和访问对象私有属性的唯一通道。例如，可以通过调用Student类的setAge方法来为age属性赋值，而不是直接修改私有字段。

注意事项：在构造方法中，super或this必须在第一行，确保能够正确调用父类或同类的构造方法。

2.代码演示

案例一：

public class Test {    public static void main(String[] args) {        Student s1 = new Student();        s1.name = "tom";    // name属性可见且可写        s1.setAge(20);     // 通过set方法赋值        s1.sex = "male";   // sex属性可见且可写        s1.score = 99.0;   // score属性可见且可写                System.out.println(s1.getAge()); // 调用get方法获取私有属性    }}class Student {    String name;           // 可见属性，外部可修改    private int age;       // 私有属性，必须通过set方法修改    String sex;          // 可见属性，外部可修改    double score;        // 可见属性，外部可修改    public Student() {}   // 空构造方法    public void setAge(int age) {        if (age >= 0 && age <= 153) {            this.age = age;        } else {            this.age = 18; // 默认设置为18        }    }    public int getAge() {        return this.age;    }}

案例二：

public class Test {    public static void main(String[] args) {        Teacher t1 = new Teacher();        t1.setName("jack");        t1.setAge(20);        t1.setSex("male");        t1.setSalary(2000.0);                System.out.println(t1.getName() + "\t" + t1.getAge() + "\t" + t1.getSex() + "\t" + t1.getSalary());    }}class Teacher {    private String name;    private int age;    private String sex;    private double salary;    public Teacher() {}    public void setName(String name) {        this.name = name;    }    public String getName() {        return this.name;    }    public void setAge(int age) {        this.age = age;    }    public int getAge() {        return this.age;    }    public void setSex(String sex) {        this.sex = sex;    }    public String getSex() {        return this.sex;    }    public void setSalary(double salary) {        this.salary = salary;    }    public double getSalary() {        return this.salary;    }}

二、继承

1.继承

继承是一种类与类之间特征和行为的传递关系，是OOP的核心概念之一。通过使用class子类extends父类的语法，可以表示子类继承父类的属性和方法。

2.语法

class 子类 extends 父类 {    // 子类独有的属性和方法    // 父类通过super关键字访问，子类通过this关键字访问}

3.应用

当一个子类继承父类后，子类可以在不修改父类代码的情况下，扩展父类的功能。例如，可以定义子类独有的属性和方法，同时可以通过调用父类的方法实现代码复用。

4.好处

• 复用性：子类可以重复利用父类的功能，减少代码编写。
• 可扩展性：新增功能时只需对子类进行扩展，不影响已有父类。

5.访问修饰符

private → default → protected → public             从严到宽

例如：

public class Animal {    private String name;    int age;         // 默认访问修饰符    protected String type;    public String sex;}

三、多态

1.多态

多态是指父类引用指向子类对象，从而使其呈现多种形态的现象。在Java中，多态主要体现在方法的多态和属性的多态。

2.多态的应用

场景一：方法多态

public class Animal {    public void eat() {        System.out.println("吃吃吃");    }}public class Cat extends Animal {    @Override    public void eat() {        System.out.println("吃老鼠");    }}public class Dog extends Animal {    public void eat() {        System.out.println("吃肉肉");    }}

场景二：属性多态

public class Animal {    String name;}public class SubClass extends Animal {    String name = "SubClass";}SubClass obj = new SubClass();System.out.println(obj.name); // 输出 "SubClass"

3.instanceof关键字

检验对象的类型关系：

public class Animal {}public class SubClass extends Animal {}SubClass obj = new SubClass();if (obj instanceof SubClass) {    // 可以进行SubClass特有的操作}

4.案例

public class Animal {    public void sayHi() {        System.out.println("我们已经说Hi了100遍");    }}public class Student extends Animal {    String name = "student";    public void test() {        String name = "test";        System.out.println(super.name);        System.out.println(this.name);        System.out.println(name);        super.sayHi();    }    public void sayHi() {        super.sayHi();        System.out.println("我来sayhi");    }}public class Test {    public static void main(String[] args) {        Student s = new Student();        s.test();        s.sayHi();    }}

四、super关键字

1.访问方法

使用super调父类的方法或属性：

super.方法(); // 调用父类的方法super.属性; // 调用父类的属性

案例

public class A {    public A() {        System.out.println("this is A");    }}public class B extends A {    public B() {        System.out.println("this is B");        super(); // 调用父类无参构造方法    }}public class C extends B {    public C() {        super(); // 默认调用父类无参构造        System.out.println("this is C");    }}

2.构造方法调用

• super()：调用父类无参构造方法
• super(参数)：调用父类有参构造方法
• 如果没有显示调用super(), 会默认调用父类的无参构造方法

案例

public class Person {    private String name = "person";    public Person() {        System.out.println("这是Person的无参构造");    }    public Person(String name) {        System.out.println("这是Person的有参构造");        this.name = name;    }}public class Student extends Person {    private String name = "student";    public Student(String name) {        this(name);        System.out.println("这是Student的有参构造");    }    public Student() {        this("名字");        System.out.println("这是Student的无参构造");    }}

五、总结

封装、继承和多态是Java编程中的核心概念，分别掌握这三大特性，是构建复杂应用程序的基础。通过合理使用封装，可以保护对象的主要状态不被外界随意修改；通过继承，可以在已有类的基础上开发出更高效、更功能完善的新类；而通过多态，可以让父类引用灵活地指向不同子类对象。在实际编程中，这三大特性必须结合使用，才能充分发挥Java的优势，为代码开发提供更高效的解决方案。

转载地址：http://qvdmz.baihongyu.com/