JavaSE/封装继承多态

Posted 2023-04-03 Y君的进化史

博客制作不易，欢迎各位点赞👍+收藏⭐+关注

---

前言

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

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

---

一、访问限定符

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

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

---

二、封装

1. 什么是封装

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

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

主要使用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就是对外公开的接口。

---

二、继承

1. 什么是继承

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

例如下图关系：

父类具有的属性和方法，在子类当中都可以通过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的所有属性和方法。

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

---

三、多态

1. 什么是多态

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

2. 多态的案例

通过创建一个父类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("===========");
    

输出结果：

由输出结果可知，不同的子类继承父类，在该类中重写了某个方法之后，又使用该被重写的方法，会得到不同的结果。这就是多态带来的便利，同时我们也可以得知多态实现的几个必要条件：

1. 必须在继承关系下；

2. 必须在子类中发生父类方法的重写；

3. 通过子类的引用调用重写的方法。

---

总结

上述代码展示和图文说明就是封装、继承、多态的全部啦。

这篇博客如果对你有帮助，给博主一个免费的点赞以示鼓励，欢迎各位🔎点赞👍评论收藏⭐，谢谢！！！

如果有什么疑问或不同的见解，欢迎评论区留言哦。

JavaSE基础知识—面向对象（5.4面向对象三大特征：封装继承多态）

面向对象编程具有三大特征：

封装

继承

多态

一、封装

1、好处

狭义的封装：也就是属性的封装，避免了任意赋值的危险，提高了数据的安全性！
　　①隐藏一个类中不需要对外提供的实现细节
　　②使用者只能通过实现定制好的方法来访问数据，可以方便的加入控制逻辑，限制对属性的不合理操作
　　③便于修改，增强代码的可维护性

2、具体实现步骤 ★

①属性私有化(private)
②提供公共的(public)方法：set方法和get方法

示例：
class Person{
　　private String name;
　　public void setName(String name){
　　　　this.name = name;
　　}
　　public String getName(){
　　　　return name;
　　}
}

3、注意

一般来讲，建议所有属性进行封装。当然如果希望将属性设置成只读的，则可以仅仅提供get方法，如果是只写的，则可以仅仅提供set方法

二、继承

1、概念

一个类没有定义成员，则具备了另一个类的成员，这种现象称为继承
被继承的类称为父类或超类或基类
继承其他类的类称为子类或派生类

2、好处

①提高代码的重用性
②提高代码的维护性和扩展性

3、语法

class 类名 extends 父类类名{}

4、特点★

①子类继承了父类的所有属性和方法，包含私有的，只是访问时先遵循成员的访问权限，当然也可以通过公共的方法去访问
②子类没有继承父类的构造器
③java支持的是单继承，也就是extends后面只能有一个类名
④不能滥用继承。子类和父类必须满足 is-a的关系
⑤java中所有类都直接或间接继承了Object类
⑥类的成员的继承不限于直接父类

5、子类调用父类构造器 ★

①子类不能继承父类的构造器
②子类必须调用父类的构造器，目的是为了初始化父类的信息
③如果子类没有显式调用父类的构造器，则系统将默认调用父类的无参构造器
④如果父类没有无参构造器，则子类必须显式调用父类的有参构造器，否则报错！
　　语法：super(参数列表)
⑤构造器的调用，不限于直接父类，将一直往上追溯直到Object类

三、多态

1、理解

概念：一种事物有多种表现形态，前面的封装和继承都是为多态打基础的
好处：
　　①提高代码的重用性和扩展性
　　②不需要关心每个元素的实际类型，只需要知道它的通用类型，调用比较方便，扩展性更高

2、体现 ★

①方法的重载和重写 √
②对象的多态性（对象的向上转型） ★
　　注意：对于一个对象来讲，编译类型和运行类型出现了不一致，这种现象称为：多态
　　编译类型=左边的类型，由编译器检测的类型
　　运行类型=右边的类型，由解释器检测的类型
相关概念：
本态调用：Person p = new Person();
多态调用：Person p = new Student();
正常方法调用：Student s = new Student(); s.say();
虚拟方法调用：Person p = new Student();p.say();

3、对象转型 ★

（1）向上转型

语法：父类类型 引用名 = new 子类类型();
理解：父类的引用指向了子类对象
特点：
　　①编译看左边，运行看右边
　　　　能调用哪些成员，要看编译类型中定义了哪些成员
　　　　运行效果，要看运行类型中的方法执行
　　②属性没有重写或多态之说

（2）向下转型

语法：子类类型 引用名 = （子类类型）父类 的引用;
特点：
　　①不能强转父类的对象，只能强转父类的引用
　　②强转的父类的引用，必须指向的是该目标子类的对象
　　③可以调用从父类继承来的以及子类本身定义的所有成员

4、多态的应用

（1）多态数组

理解：数组的定义类型为父类类型，元素可以为子类类型

（2）多态参数

理解：方法的形参类型为父类类型，实参可以为子类类型
instanceof：用于判断某对象的运行类型是否是右边的类型XX或XX的子类型
　　写法：a instanceOf XX
　　结果：true|false
应用场景：一般放在if条件中用作判断