封装+继承+多态笔记及总结

编梦小匠

已于 2024-08-05 14:50:45 修改

阅读量1k

点赞数 16

CC 4.0 BY-SA版权

文章标签：笔记 java

于 2023-04-14 21:55:05 首次发布

本文链接：https://blog.csdn.net/weixin_74093287/article/details/130162443

本文详细解析了面向对象编程中的三大核心概念：封装、继承和多态。介绍了它们的基本定义、语法使用、实际应用场景及注意事项。

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

（四）super关键字（调用父类属性/方法）

注：所有的类，都默认直接或者间接继承object类

一，封装

（一）定义

封装就是隐藏对象的属性和实现细节，仅提供公共访问方式来让外界访问

（二）访问修饰符

public,protected,default,private

以下是访问修饰符的权限范围表：

其中，private修饰的成员变量只能在相应的类中使用，如果想要在外界访问它，只能提供公开访问的方法让外界可以去访问它，我们可以给私有属性提供get和set方法(alt+ins即可自动生成相关属性的get和set方法)，这样外界就可以通过调用get和set方法获取到私有属性的值和设置私有属性的值

例：

//类代码
public class Packaging {
    private int money;
    //有参构造，初始化money
    public Packaging(int money){
        this.money=money;
    }
    //getMoney获取私有属性money的值，setMoney设置私有属性的值
    public int getMoney() {
        return this.money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
}


//main代码
public class Application {
    public static void main(String[] args) {
        Packaging packaging = new Packaging(1000);
        packaging.setMoney(100);
        System.out.println(packaging.getMoney());
    }
}

（三）目的

为了不直接被外部使用

（四）口诀

属性私有，get/set

二，继承（单继承）

（一）定义

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为，子类拥有父类所有的方法，是类与类之间的一种关系

（二）语法

class 子类名 extends 父类名

（三）子类获取父类属性和方法

1，在主类中获取

（1）public，protected，default访问修饰符修饰的属性和方法：在主类使用可直接在主类new一个子类对象，然后通过子类名+父类属性/方法调用

例：

//父类
public class B {
    public String name;

    public B() {
        this.name = "张三";
    }
}


//子类
public class A extends B{
}


//主类
public class Application {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.name);
    }
}

（2）private属性和方法：子类无法继承，但可通过封装里的方法获取到private的值和设置private的值

例：

//子类
public class B {
    private String name;

    public B() {
        this.name = "张三";
    }

    public String getName() {
        return name;
    }

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


//父类
public class A extends B{

}



//主类
public class Application {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.getName());
        a.setName("李四");
        System.out.println(a.getName());
    }
}

2，在子类中获取

可通过super关键字直接获取，super+父类属性/方法名即可获取相应的父类属性/方法名

例：

//父类
public class B {
    private String name;

    public B() {
        this.name = "张三";
    }

    public String getName() {
        return name;
    }
}


//子类
public class A extends B{
    public void get(){
        System.out.println(super.getName());
    }
}


//主类
public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.get();
    }
}

（四）super关键字（调用父类属性/方法）

1，注意事项

（1）子类中super调用父类的构造方法，必须在子类构造方法的第一个

（2）super必须只能出现在子类的方法或者构造函数中

（3）super和this不能同时调用构造方法

2，对比（this）

（1）代表对象不同:

this：本身调用者这个对象

super：代表父类对象的引用

（2）前提不同：

this：没有继承也可以使用

super：只能在继承条件下才可以使用

（3）构造方法不同：

this：本类的构造

super：父类的构造

//子类
public class B {
    public String name;

    public B() {
        this.name = "张三";
    }
}


//父类
public class A extends B{
    public String name;

    public A() {
        this.name = "李四";
    }
    public void get(){
        System.out.println(this.name);
        System.out.println(super.name);
    }
}


//主类
public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.get();
    }
}

（五）重写（单指方法，和属性无关）

在主类中new两个相同的子类对象，并且子类和父类有相同的方法，但返回的类型设为一个父类型和一个子类型，静态方法和非静态方法展现出来的效果不同

1，静态方法

方法的调用只和左边定义的数据类型有关

//父类
public class B {
    public String name;
    public static void print(){
        System.out.println("BBB");
    }
}


//子类
public class A extends B{
    public String name;
    public static void print() {
        System.out.println("AAA");
    }
}


//主类
public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.print();
        B b = new A();
        b.print();
    }
}

2，非静态方法

子类型展现子类方法调用的相应结果
父类型重写为子类的方法

//子类
public class A extends B{
    public String name;
    public A() {
        //子类无参构造器隐藏代码：调用了父类的无参构造
        //调用父类的构造器只能在子类构造器的第一行
        super("hello");
        System.out.println("A无参构造");
    }

    @Override
    public void print() {
        System.out.println("AAA");
    }
}


//父类
public class B {
    public String name;
    public B(String name) {
        this.name=name;
        System.out.println("B无参构造");
    }

    public void print(){
        System.out.println("BBB");
    }
}


//主类
public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.print();
        B b = new A();
        b.print();
    }
}

3，父类型（向上转型）

可指向子类，但不可以调用子类独有的方法，若重写，则调用重写的方法，即为子类的该方法

4，子类型

可调用自己的方法（this）或者父类的方法（super）

5，动态绑定

所谓动态绑定就是使用父类引用子类对象然后（向上转型）调用父类和子类相同的方法在子类中重写了父类的方法

6，快捷键

alt+ins 点击override

7，条件

（1）方法名必须相同

（2）参数列表必须相同

（3）修饰符：范围可以扩大但不能缩小； public>protected>default>private

（4）抛出的异常：范围，可以被缩小，但不能扩大 ClassNotFoundException-->Expection(大)

8，意义

父类的功能，子类不一定需要，或者不一定满足！

注：对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！

9，目的

防止重复代码多次书写

三，多态（单指方法，和属性无）

（一）定义

同一方法可以根据发送对象的不同而采取多种不同的行为方式

（二）依据

一个对象的实际类型是确定的，但可以指向对象的引用的类型很多（父类，有关系的类）

（三）存在的条件

有继承关系
子类重写父类方法
父类引用指向子类对象

Father father = new Son();
//具体可参考继承-重写-非静态方法中的代码
B b = new A();

注：有些方法不可以重写，无法实现多态

static 方法，属于类，它不属于实例
final 常量
private 方法

（四）instanceof

1，语法

某类对象引用+instanceof+某个类

2，返回类型

boolean类型

3，作用

测试左边的对象是否是右边类或者该类的子类创建的实例对象

在强制转换前使用instanceof运算符判断是否可以成功转换

public class Test {
    public static void main(String[] args) {
        //Object->B->A
        Object object = new A();
        A a = new A();
        B b = new A();
        B c = new B();
        System.out.println(object instanceof A);
        System.out.println(object instanceof B);
        System.out.println(object instanceof Object);
        System.out.println(object instanceof String);
        System.out.println("------------------------------------------------------------------");
        System.out.println(a instanceof A);
        System.out.println(a instanceof B);
        System.out.println(a instanceof Object);
        System.out.println("-----------------------------------------------------------------");
        System.out.println(b instanceof A);
        System.out.println(b instanceof B);
        System.out.println(b instanceof Object);
        System.out.println("------------------------------------------------------------------");
        System.out.println(c instanceof A);
        System.out.println(c instanceof B);
        System.out.println(c instanceof Object);
    }
}

（五）抽象类

1，定义

被abstract修饰，包含抽象方法的类（也可以不含抽象方法，建议抽象类和抽象方法同时使用），不能直接实例化，只能被继承之后通过子类调用父类的构造方法使用

2，方法包括两种

普通方法

抽象方法：只有方法的声明，所以调用该抽象类，需重写所有抽象方法，若不重写，则需声明该类也为抽象类

3，目的

为了继承之后重写发生动态绑定，减少重复代码，提高开发效率

//抽象类
public abstract class Action {
    //抽象方法只要写方法的声明
    //抽象方法必须在抽象类中
    public abstract void get();
    //可以写普通函数
    public void set(){
        System.out.println("你好");
    }
}


//继承抽象类的类
public class A extends Action{
    public void get(){

    }
}

注：有抽象方法的类一定要声明为抽象类

抽象类不存在构造器

（六）接口（interface）

1，作用

（1）约束

（2）定义一些方法，让不同的人实现

2，默认方法

public abstract

3，所有常量

public static final

注：接口不能实例化，接口中没有构造方法

implements可以实现多个接口

必须要重写接口中的方法

//接口UserService
public interface UserService {
    void add(String name);
    void delete(String name);
    void updata(String name);
    void query(String name);
}


//接口TimeService
package com.quan.port;

public interface TimeService {
}


//实现接口
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {
        
    }

    @Override
    public void delete(String name) {
        
    }

    @Override
    public void updata(String name) {
        
    }

    @Override
    public void query(String name) {
        
    }
}