07-面向对象中级-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_45768501/article/details/132612070

本文详细介绍了Java中的封装、继承、方法重写和多态等面向对象编程的关键概念，包括访问修饰符的作用、封装的实现步骤、继承的原理与细节、方法重写的要求以及多态的体现和机制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、访问修饰符

2、封装

封装就是把抽象出的数据【属性】和对数据的操作【方法】封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作【方法】，才能对数据进行操作

2.1、封装实现步骤

第一步：属性私有化

将属性进行私有化 private 修饰【让外部不能直接访问】

第二步：提供一个公共(public)的set方法，用于对属性判断并赋值

第三步：提供一个公共的(public)get方法,用于获取属性的值

3、继承

继承可以解决代码复用,让我们的编程更加靠近人类思维.当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类,在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过 extends 来 声明继承父类即可。画出继承的示意图

3.1、继承细节-私有访问

子类继承了所有的属性和方法，非私有属性和方法可以直接访问，但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问

3.2、继承细节2

子类必须调用父类的构造器，完成父类的初始化

3.3、继承细节-3

当创建子类对象时，不管使用子类的哪个构造器,默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则,编译不会通过[举例说明]

如果父类没有提供无参构造器，则必须在子类的构造器中用super 去指定使用父类的哪个构造器完成对父类的初始化工作

3.4、继承细节-4

如果希望指定去调用父类的某个构造器，则显式的调用一下 : super( 参数列表 )

super 在使用时，必须放在构造器第一行 (super 只能在构造器中使用 )

super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器

3.5、继承细节-5

java 所有类都是 Object 类的子类 , Object 是所有类的基类 .

父类构造器的调用不限于直接父类！将一直往上追溯直到 Object 类 ( 顶级父类 )

3.6、继承细节-6

子类最多只能继承一个父类 ( 指直接继承 ) ，即 java 中是单继承机制。

思考：如何让 A 类继承 B 类和 C 类？【 A 继承 B ， B 继承 C 】

不能滥用继承，子类和父类之间必须满足 is-a 的逻辑关系

3.7、继承本质（重要）

3.8、super

super代表父类的引用，用于访问父类的属性、方法、构造器

super可以访问父类的属性(方法)，但是不能访问父类的私有属性(方法)

访问父类的构造器(这点前面用过):
super(参数列表);只能放在构造器的第一句，只能出现一句!

super是专门来访问父类的，在查找时会直接跳过本类！

package super_;

/**
 * @Author: lihaojie
 * @Description:
 * @DateTime: 2023/9/5 13:57
 **/
public class B extends A {

    // super可以访问父类的属性(方法)，但是不能访问父类的私有属性(方法)
    public void hi() {
        System.out.println(super.n1);
        System.out.println(super.n2);
        System.out.println(super.n3);
        // System.out.println(super.n4); // 编译报错
    }

    // super可以访问父类的属性(方法)，但是不能访问父类的私有属性(方法)
    public void ok() {
        super.test100();
        super.test200();
        super.test300();
        // super.test400(); // 编译报错
    }

    public B() {
        super();
    }

}

super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员;如果多个基类(上级类)中都有同名的成员,使用super访问遵循就近原则。A->B->C，当然也需要遵守访问权限的相关规则（如果访问到B的时候找到了，但是是private修饰，将直接报错，不继续往上找）

3.9、super与this的区别

4、方法重写（Override）

简单的说，方法重写就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的那个方法

4.1、方法重写的细节

方法重写要满足下面的条件：

①子类的方法参数、方法名称，要和父类的方法参数，方法名称保持一致

②子类方法不能缩小父类方法的访问权限，比如父类方法是public，子类方法就不能是protected/default/private

③子类方法返回类型必须和父类方法返回类型一致，或者子类方法返回类型是父类方法返回类型的子类，例如父类返回Object，子类返回String

4.2、重写和重载的比较

5、多态

多态是指方法与对象有多重形态，是面向对象的第三大特征，多态是建立在封装与集成基础之上的

package poly;

/**
 * @Author: lihaojie
 * @Description:
 * @DateTime: 2023/9/5 14:56
 **/
public class Master {

    private String name;

    public Master(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    // 主人给 狗 喂 骨头
    public void feed(Dog dog, Bone bone) {
        System.out.println("主人" + name + "给" + dog.getName() + "吃" + bone.getName());
    }

    // 主人给 猫 喂 黄花鱼
    public void feed(Cat cat, Fish fish) {
        System.out.println("主人" + name + "给" + cat.getName() + "吃" + fish.getName());
    }

    // 如果动物很多 食物也很多 那么最后feed这个方法也要重载很多，代码复用性太低，不利于管理和维护

}

5.1、多态的具体体现-方法多态

重写重载就是

package com.hspedu.poly_;
public class PloyMethod {
public static void main(String[] args) {
//方法重载体现多态
A a = new A();
//这里我们传入不同的参数，就会调用不同 sum 方法，就体现多态
System.out.println(a.sum(10, 20));
System.out.println(a.sum(10, 20, 30));
//方法重写体现多态
B b = new B();
a.say();
b.say();
第 322页
韩顺平循序渐进学 Java 零基础
}
}
class B { //父类
public void say() {
System.out.println("B say() 方法被调用...");
}
}
class A extends B {//子类
public int sum(int n1, int n2){//和下面 sum 构成重载
return n1 + n2;
}
public int sum(int n1, int n2, int n3){
return n1 + n2 + n3;
}
public void say() {
System.out.println("A say() 方法被调用...");
}
}

5.2、多态的具体体现-对象多态

重要：

①一个对象的编译类型和运行类型可以不一致

②编译类型是在定义对象时就确定了，不能改变

③运行类型是可以变化的

④编译类型看定义时=号的左边，运行类型看=号的右边

举例：

Animal animal = new Dog(); 【animal编译类型是Animal，运行类型是Dog】
animal = new Cat(); 【animal编译类型是Animal，运行类型是Cat】

多态入门案例：

public class Animal {
    public void cry() {
        System.out.println("动物在叫...");
    }
}
public class Cat extends Animal {
    public void cry() {
        System.out.println("Cat cry() 小猫喵喵叫");
    }
}
public class Dog extends Animal {
    public void cry() {
        System.out.println("Dog cry() 小狗汪汪叫");
    }
}
public class PolyObject {
    public static void main(String[] args) {
        // 体验一下对象多态的特点
        // 编译类型 Animal 运行类型是 Dog
        Animal animal = new Dog();
        animal.cry(); // 执行到该行时，Animal的运行类型是Dog 所以cry就是Dog的cry
        animal = new Cat();
        animal.cry(); // 执行到该行时，Animal的运行类型是Cat 所以cry就是Cat的cry
    }
}

5.3、多态解决方案与传统解决方案的区别

5.4、多态之向上转型

①多态的前提是：两个对象（类）存在继承关系

②多态的向上转型

1）本质：父类引用指向了子类对象

2）父类类型引用名 = new 子类类型();

3) 编译类型看左边，运行类型看右边，可以调用父类的所有成员（遵循访问权限），不能调用子类的特有成员，最终运行效果要看子类的具体实现！

5.5、多态之向下转型

5.6、多态的动态绑定机制

package poly.dynameic;
public class DynamicBinding {
    public static void main(String[] args) {
        //a 的编译类型 A, 运行类型 B
        A a = new B();
        System.out.println(a.sum());
        System.out.println(a.sum1());
    }
}
class A {//父类
    public int i = 10;
    //动态绑定机制:
    public int sum() {
        return getI() + 10;
    }
    public int sum1() {
        return i + 10;
    }
    public int getI() {
        return i;
    }
}
class B extends A {
    public int i = 20;
    /*public int sum() {
        return i + 20;
    }*/
    public int getI() {
        return i;
    }
    /*public int sum1() {
        return i + 10;
    }*/
}