面向对象--封装

Su sir～

已于 2023-10-13 08:46:02 修改

阅读量32

点赞数

文章标签： java 开发语言

于 2023-10-12 19:51:56 首次发布

本文链接：https://blog.csdn.net/Susir001/article/details/133797977

版权

一、封装

面向对象编程的3大特点：封装、继承、多态
封装：

就是快递打包封装，装起来，方便使用
把一些东西藏起来不让别人看见

作用：

将代码封装到方法，方便使用，复用
将代码功能增强

类的封装如何实现：

属性私有化
提供对外可以访问的方法来对属性进行设值和取值（即get set 方法）

总结：

属性私有：private
对属性提供set，get方法
set方法一定是有参无返回值
get方法一定是无参有返回值
且set，get方法固定命名，一定是setXXX，getXXX。即后面一定是属性首字母大写

二、继承（extends）

2.1 继承

继承：子类继承父类，子类就可以使用父类中的东西（属性和方法）

为什么要继承？

有些类中定义的属性，方法有重复 --> 继承就可以减少重复
为多态做准备

如何写？
public class A extends B{

}
以上代码就是继承，A类继承B类，A类是子类，B类是父类。

如何定义父类：

将一些类中共同有的属性和方法向上抽取形成父类 – 即父类更抽象，子类更具体

2.2 继承的特点：

子类继承父类，子类对象可以使用父类中非私有的属性和方法
Java支持继承，但是只能单继承

2.3 继承中的属性

父类中有的属性，子类中没有的属性：子类可以直接用父类中的

父类中没有的属性，子类中有的属性：子类用自己的

父类中有的属性，子类中有与之同名的属性：子类使用自己的属性（就近引用）

2.4 继承中的方法

父类中有的方法，子类中没有的方法：子类可以直接用父类中的

父类中没有的方法，子类中有的方法：子类用自己的

父类中有的方法，子类中有与之同名的方法：子类使用自己的方法–>重写

2.5 继承中的构造方法

构造方法只能被new来调用

会先调用父类的构造方法
初始化父类中的属性
执行父类的构造方法中的内容
再初始化子类的属性
再执行子类构造方法中的内容
将引用赋值给对象

为什么在调用子类构造方法创建子类对象时先调用父类构造方法呢？？？

是因为每个构造方法的第一行都隐藏一个super()调用父类无参构造方法

三、重写（Override）

重写：也叫覆写或者覆盖

发生在子父类之间的方法的关系
要求子父类的方法访问修饰符返回值类型，方法名，参数列表完全一致，方法体不一样
父类修饰符可以比子类大一些

注意：Override注解 - 是重写，需与父类所定义方法的完全一致（目前学习）

为什么要重写：父类有方法，但是这个方法子类不适用

ps：重写也是多态的前提

四、super & this

默认的：

super() ：在每个类的每个构造方法第一行都隐藏了一个super()来调用父类无参构造

super代表当前对象的父类对象

在每个构造方法中第一行隐式存在有super()调用父类无参构造

也可以使用super(实参)来主动调用父类的有参构造

super:代表父类对象，就可以调用父类属性和方法

super.属性；调用父类属性

super.方法();调用父类方法

this & super 对比：

this super
代表代表当前对象代表父类对象
构造方法 this() 调用自己的 super() 调用父类的
this(参数) 调用自己的有参构造 super(参数) 调用父类的有参构造
属性 this.属性他自己的属性，自己没有该属性也会调用父类属性 super.属性调用父类属性
方法 this.方法() 调用自己的方法，自己没有调用父类方法 super.方法() 调用父类方法

	this	super
代表	代表当前对象	代表父类对象
构造方法	this() 调用自己的	super() 调用父类的
	this(参数) 调用自己的有参构造	super(参数) 调用父类的有参构造
属性	this.属性他自己的属性，自己没有该属性也会调用父类属性	super.属性调用父类属性
方法	this.方法() 调用自己的方法，自己没有调用父类方法	super.方法() 调用父类方法

五、访问修饰符

访问修饰符

修饰符，就是一些符号
public、protected 受保护的、default 默认/不写、private

访问修饰符又叫访问控制符或者权限符，即通过以上这些修饰可以改变访问的权限

当前类内同包不同类不同包子类内不同包不同类
public √ √ √ √
protected（保护儿子） √ √ 子类对象可以访问 ×
default 缺省 √ √ × ×
private √ × × ×

	当前类内	同包不同类	不同包子类内	不同包不同类
public	√	√	√	√
protected（保护儿子）	√	√	子类对象可以访问	×
default 缺省	√	√	×	×
private	√	×	×	×

访问权限修饰符：public>protected>package>private

六、创建对象的过程

如果有继承，先创建父类，再创建子类
对本类，先属性初始化再执行构造方法内代码

七、final（最终）

final修饰类，则此类不能被继承（无子类）
final修饰属性（变量），该变量为常量，不能再重新赋值
final修饰方法，该方法子类不能被重写，但子类可以使用父类方法 --> super（）

八、static（静态修饰符）

static,静态修饰符，可以修饰类（是内部类）、属性、方法

类里面的类 – 内部类

8.1 特点

机制：凡是被static修饰的属性/方法/代码块会随着类加载而初始化，内存只有一个

static修饰的属性和方法，则被该类的所有对象共享

static修饰的属性和方法都可以通过类名调用

8.2 售票案例：

8.2.1 售票案例代码

public class HuangNiu {
    /**
     * 不加static，ticket属性会随着创建对象，每个对象都有100张票
     * 不加static的属性，叫做对象属性（属于对象，归对象特有）
     * 加了static修饰，该属性会被类该的所有对象共享
     * 加了static的属性，叫做类属性（属于类，不属于某个对象）
     */
    static int ticket = 100;
    String name;

    void sell(int num) {
        ticket -= num;
        System.out.println(name + "卖出" + num + "张票");
    }
}

8.2.2 测试案例代码

public class Test {
    public static void main(String[] args) {
        //黄牛1
        HuangNiu huangNiu = new HuangNiu();
        huangNiu.name = "牛1";
        huangNiu.sell(1);
        System.out.println("还剩"+huangNiu.ticket+"张票");

        System.out.println("-------------------");
        //黄牛2
        HuangNiu huangNiu2 = new HuangNiu();
        huangNiu2.name = "牛2";
        huangNiu2.sell(10);
        System.out.println("还剩"+huangNiu2.ticket+"张票");
    }
}