JavaSE/封装、继承、多态

用户10788736

发布于 2023-10-16 08:30:54

1580

发布于 2023-10-16 08:30:54

文章被收录于专栏：CSDN搬移文章

前言

在学习面向对象编程语言时，封装、继承、多态则是我们必须学习和使用的三大特征。

本文通过举例，说明了该三大特征的基本权限特点。

一、访问限定符

范围	private	默认权限	protected	public
同一包中的同一类	√	√	√	√
同一包中的不同类		√	√	√
不同包中的子类			√	√
不同包中的非子类				√

注：访问权限用来控制方法或成员变量能否直接在类外使用。

二、封装

什么是封装

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

顾名思义，保护或防止类中的属性或方法被破坏，同时又提供一个接口，使对象可以使用该对象的封装属性或方法。

主要使用private关键字。

2.封装的案例

通过创建一个Stu类，在Main类创建Stu对象，访问该对象属性和方法举例说明。

class Stu{
    private String name;

    public String getName() {
        return name;
    }

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

    private void print(String name){
        System.out.println(name + "在学习");
    }

    public void getPrint(String name){
        print(name);
    }
}
public class Main {
    public static void main(String[] args) {
        Stu stu = new Stu();
        stu.setName("大佬");
        stu.getPrint( stu.getName() );
    }
}

输出结果为：

在该代码中，使用private修饰的属性和方法均属于私有成员，在该类外不能直接访问和使用。于是我们通过setName/getName()/getPrint间接访问和使用，这里的setName/getName()/getPrint就是对外公开的接口。

二、继承

什么是继承

继承：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。

例如下图关系：

父类具有的属性和方法，在子类当中都可以通过super关键字访问和使用。如果是创建了子类对象，也可以正常访问父类的内容，如果父类方法发生了重写，则需要通过super.方法（参数)访问和使用。

继承的使用，可以大大提高代码的简化，使同一段代码重复使用。

注意： 1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法。 2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。 3. 在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。 4. super(...)只能在子类构造方法中出现一次，并且不能和this同时出现。

2.继承的案例

通过创建一个Tree类，再创建一个OsmanthusTree类继承Tree类，访问该对象属性和方法举例说明。

class Tree{
    String name;
    public String age;
    public static String ascription;//归属
    public String function;//作用

    static{
        ascription = "中国持有";
    }

    public void springSprout(String name){
        System.out.println(this.name + "发芽");
    }
}

class OsmanthusTree extends Tree{
    private String disease;//该树患病

    public String getDisease() {
        return disease;
    }

    public void setDisease(String disease) {
        this.disease = disease;
    }
}

public class Inherit {
    public static void main(String[] args) {
        OsmanthusTree osmanthusTree = new OsmanthusTree();
        osmanthusTree.name = "小❀❀";
        osmanthusTree.setDisease("白蚁吞噬");
        System.out.println(osmanthusTree.name + osmanthusTree.getDisease());
        System.out.println(osmanthusTree.name + "治疗之后");
        osmanthusTree.springSprout( osmanthusTree.name );
    }
}

输出结果为：

在该代码中，使用 extends 连接Tree类和 OsmanthusTree类。 OsmanthusTree类为子类，Tree类为父类，在 OsmanthusTree中可以访问Tree的所有属性和方法。

也就是说，在子类中可以访问父类的所有属性和方法（私有权限除外）。

三、多态

什么是多态

多态：同一件事情，发生在不同对象身上，就会产生不同的结果。比如下图示意：

多态的案例

通过创建一个父类Creature，再创建Person类和Cat类继承Creature类，访问该对象属性和方法举例说明。

class Creature{
    String name;
    int age;

    public Creature(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println(this.name + "在吃午饭");
    }
}

class Person extends Creature{
    public Person(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(this.name + "在吃米饭");
    }
}

class Cat extends Creature{

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(this.name + "在吃猫粮");
    }
}

public class Polymorphism {

    public static void test(Creature creature){
        creature.eat();
    }

    public static void main(String[] args) {
        test(new Person("人类", 19));
        System.out.println("===========");

        test(new Cat("小猫", 2));
        System.out.println("===========");
    }
}

输出结果：