面向对象

封装

封装：利用抽象将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体。

数据被保护在类的内部，尽可能地隐藏内部的实现细节，只保留一些对外接口使之与外部发生联系。

使用封装有 4 大好处：

1、良好的封装能够减少耦合。
2、类内部的结构可以自由修改。==封装可以使我们更容易地修改类的内部实现，而无需修改使用了该类的代码
3、可以对成员进行更精确的控制。==对setter或getter中写入条件判断可以防止调用时的错误
4、隐藏信息，实现细节。

继承

继承：子类继承父类的属性和方法，使得子类对象（实例）具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的方法。

优点：使得代码结构更加清晰可见。

继承的分类

继承分为单继承和多继承，Java 语言只支持类的单继承，但可以通过实现接口的方式达到多继承的目的。

Java是一个面向对象的语言，一个对象肯定有身份和行为，那么继承则是一个类表明自己身份，接口则提供了行为，一个身份可以有多个行为。所以说，大多数时候你并不需要多个继承，你只是需要继承类中的某个方法。

构造方法

参考链接： https://javabetter.cn/oo/construct.html

构造方法必须符合以下规则：

构造方法的名字必须和类名一样；
构造方法没有返回类型，包括 void；
构造方法不能是抽象的（abstract）、静态的（static）、最终的（final）、同步的（synchronized）。

简单解析一下最后一条规则。

由于构造方法不能被子类继承，所以用 final 和 abstract 关键字修饰没有意义；
构造方法用于初始化一个对象，所以用 static 关键字修饰没有意义；
多个线程不会同时创建内存地址相同的同一个对象，所以用 synchronized 关键字修饰没有必要。

默认构造方法的目的主要是为对象的字段提供默认值

构造函数可以被重载

复制一个对象可以通过下面三种方式完成：

通过构造方法
通过对象的值
通过 Object 类的 clone() 方法

构造方法虽然没有返回值，但返回的是类的对象。

父类的构造方法不能被继承，因为构造方法语法是与类同名，而继承则不更改方法名。

子类的构造过程必须调用其父类的构造方法：

Java 虚拟机**构造子类对象前会先构造父类对象，父类对象构造完成之后再来构造子类特有的属性，**这被称为**内存叠加**。而 Java 虚拟机构造父类对象会执行父类的构造方法，所以子类构造方法必须调用 super()即父类的构造方法。

如果子类的构造方法中没有显示地调用父类构造方法，则系统默认调用父类无参数的构造方法。

继承与修饰符

Java 子类重写继承的方法时，不可以降低方法的访问权限，子类继承父类的访问修饰符作用域不能比父类小，继承当中子类抛出的异常必须是父类抛出的异常或父类抛出异常的子异常

非访问修饰符：

本质上是对类常量的说明。

final 变量：

final 表示”最后的、最终的”含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值(即不能只声明)。final 修饰符通常和 static 修饰符一起使用来创建类常量。

final 方法：

父类中的 final 方法可以被子类继承，但是不能被子类重写。声明 final 方法的主要目的是防止该方法的内容被修改。

final 类：

final 类不能被继承，没有类能够继承 final 类的任何特性。

所以无论是变量、方法还是类被 final 修饰之后，都有代表最终、最后的意思。内容无法被修改。

Object类和转型

首先声明，要实例化（赋值）的对象都放在等号左侧。

向上转型 : 通过子类对象(小范围)实例化父类对象(大范围)，这种属于自动转换。

向下转型 : 通过父类对象(大范围)实例化子类对象(小范围)，在书写上父类对象需要加括号()强制转换为子类类型。但父类引用变量实际引用必须是子类对象才能成功转型。

例子：

Object object=new Integer(666);//向上转型

Integer i=(Integer)object;//向下转型Object->Integer，object的实质还是指向Integer

String str=(String)object;//错误的向下转型，虽然编译器不会报错但是运行会报错

这里的object的引用类型是Object，但是实际类型已经变成Integer

object变量指向的是Integer对象，而不是String对象.

虽然编译时不报错（因为String确实是Object的子类），但运行时会抛出ClassCastException. 此时可以用instanceof作条件判断确保程序正常运行。

子父类初始化顺序

在 Java 继承中，父子类初始化先后顺序为：

父类中静态成员变量和静态代码块
子类中静态成员变量和静态代码块
父类中普通成员变量和代码块，父类的构造方法
子类中普通成员变量和代码块，子类的构造方法

总的来说，就是静态>非静态，父类>子类，非构造方法>构造方法。同一类别（例如普通变量和普通代码块）成员变量和代码块执行从前到后，需要注意逻辑。调用构造方法的时候，是对成员变量进行一些初始化操作，所以普通成员变量和代码块优于构造方法执行。

多态

Java 的多态是指在面向对象编程中，同一个类的对象在不同情况下表现出来的不同行为和状态。

子类可以继承父类的字段和方法，子类对象可以直接使用父类中的方法和字段（私有的不行）。
子类可以重写从父类继承来的方法，使得子类对象调用这个方法时表现出不同的行为。
可以将子类对象赋给父类类型的引用，这样就可以通过父类类型的引用调用子类中重写的方法，实现多态。

多态的目的是为了提高代码的灵活性和可扩展性，使得代码更容易维护和扩展。比如说，通过允许子类继承父类的方法并重写，增强了代码的复用性。

再比如说多态可以实现动态绑定，这意味着程序在运行时再确定对象的方法调用也不迟。

多态的前提条件有三个：

子类继承父类
子类重写父类的方法
父类引用指向子类的对象

举例：

//子类继承父类
public class Wangxiaoer extends Wanger {
    public void write() { // 子类重写父类方法
        System.out.println("记住仇恨，表明我们要奋发图强的心智");
    }

    public static void main(String[] args) {
        // 父类引用指向子类对象
        Wanger[] wangers = { new Wanger(), new Wangxiaoer() };

        for (Wanger wanger : wangers) {
            // 对象是王二的时候输出：勿忘国耻
            // 对象是王小二的时候输出：记住仇恨，表明我们要奋发图强的心智
            wanger.write();
        }
    }
}

class Wanger {
    public void write() {
        System.out.println("勿忘国耻");
    }
}

多态与向下转型

（其实向下转型就是你不能强迫把父类转换为子类，这样理解最佳）

举例：

public class Wangxiaosi extends Wangsi {
    public void write() {
        System.out.println("记住仇恨，表明我们要奋发图强的心智");
    }

    public void eat() {
        System.out.println("我不喜欢读书，我就喜欢吃");
    }

    public static void main(String[] args) {
        Wangsi[] wangsis = { new Wangsi(), new Wangxiaosi() };

        // wangsis[1]能够向下转型
        ((Wangxiaosi) wangsis[1]).write();
        // wangsis[0]不能向下转型
        ((Wangxiaosi)wangsis[0]).write();
    }
}

class Wangsi {
    public void write() {
        System.out.println("勿忘国耻");
    }

    public void read() {
        System.out.println("每周读一本好书");
    }
}