7.跟着狂神学JAVA（面向对象）

什么是面向对象

• 面向过程
  • 步骤清晰简单
  • 适合处理一些较为简单的问题
  • 线性思维
• 面向对象
  • 先分类、然后对分类后的细节进行面向过程的思考
  • 适合处理复杂、多人协作的问题
  • 分类思维

面向对象编程的本质是：以类的方式组织代码，以对象的组织（封装）数据

• 抽象
  • 从认识论的角度考虑是先有对象后有类，对象是具体的事物，类是对对象的抽象
  • 从代码运行的角度考虑是现有类后有对象，类是对象的模板
• 三大特性
  • 封装
  • 继承
  • 多态

关于方法

• 方法的定义
  • 修饰符 返回值类型 方法名(参数类型，参数名){
    方法体;
    return 返回值;
    }
  • 如果没有返回值，仍需添加return；语句
  • return关键字语句后添加的代码无效
• 异常处理
  • 抛出异常
  • 关键字throws
• 方法的调用
  • 静态方法（添加了static修饰符的方法）
    • 可以直接通过类名加方法名调用
  • 非静态方法（未添加static修饰符的方法）
    • 无法直接通过类名加方法名直接调用
    • 必须将类实例化后，通过对象名加方法名才可以调用
  • 关于方法间的互相调用
    • 静态方法是在程序加载类时就已经存在
    • 非静态方法在类实例化后才存在
• 关于形参和实参
  • 形参和实参的类型必须要一致
• 关于值传递和引用传递
  • Java是值传递
  • 即只是把实参的值传递给形参
  • 方法内形参值的变化不会直接影响到实参
  • 特殊情况，当传递的实参和形参是一个类时，实参的属性会受到影响，因为传入的值是类的内存地址

类与对象的关系

• 类是一种抽象的数据类型

• 对象是抽象概念的具体实例

类的创建

一个程序中只允许一个main方法，因此通常将main方法单独放在比如Application的类中，其它定义的类中不再加入main方法

• 类中只有属性和方法两个内容

类的实例化

• 使用new关键字
• 如有一个Student类，实例化时就使用语句

Student stu = new Student();

• 使用new关键字创建对象时，分配内存空间并进行默认的初始化，然后对类中的构造器进行调用改变对象的状态

构造器（构造方法）

• 类中的构造器也称为构造方法，是在进行实例化对象时必须要调用的，构造器有2个特点
  • 一个类中即使什么都不写，也会自己隐式创建一个构造器
  • 必须和类的名字相同
  • 必须没有返回类型，也不能写void
  • 构造器区分有参构造器和无参构造器，如果类中同时有有参构造和显式的无参构造，程序可以自己根据有无参数传入决定所使用的构造器

IDEA中使用 alt+insert可以自动添加构造器

创建对象内存分析

• 在Java中，当使用new关键字创建一个新对象时，会经历以下4个步骤：
  • 分配内存空间：首先，JVM会在堆上为新的对象分配足够的内存空间。这个空间的大小取决于对象实例化的类中声明的所有实例变量所需的总空间。
  • 初始化对象：接下来，对象会被默认初始化。这意味着所有字段都会被设置为它们的默认值。（基本类型默认值为：int, byte, short, long 为 0；float 为 0.0f；double 为 0.0d；boolean 为 false；char 为 \u0000。对于引用类型（即对象类型的变量），默认值为 null）
  • 执行构造器：一旦内存被分配并且对象被默认初始化之后，就会调用类的构造器。构造器负责执行任何必要的初始化任务，比如为类中的成员变量赋值。这是开发者定义对象状态的地方。构造器可能会改变默认初始化的值。
  • 返回引用：最后，构造器执行完毕后，新创建的对象的引用会被返回给创建它的代码，这样就可以通过这个引用访问和操作对象。

如果类中没有显式地定义构造器，Java编译器会自动提供一个无参的默认构造器。如果定义了构造器，那么默认构造器就不会存在，除非显式地定义它。如果需要调用其他构造器或者父类的构造器，可以使用this或者其他形式的构造器链来实现。

封装

• 程序设计追求”高内聚、低耦合“，高内聚是指高内聚指的是模块内部的各个元素之间联系紧密，功能单一明确；低耦合是指低耦合意味着模块之间的依赖关系较弱，相互之间的影响较小。
• 数据的隐藏，禁止直接访问一个对象中数据的实际表示，而通过操作接口来访问
• 属性私有（private），get/set（提供了可以操作这些属性的方法）

IDEA中使用 alt+insert可以自动添加get/set方法

• 封装的作用
  • 提高程序的安全性，保护数据
  • 隐藏代码的实现细节
  • 统一接口
  • 提高系统的可维护性

继承

• 继承的本质是对某一批类的抽象化
• 关键字 extends（扩展） ，子类是父类的扩展
• Java中类只有单继承，没有多继承
• 继承是类和类的一种关系，此外类和类之间的关系还有依赖、组合、聚合等
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类
• 子类和父类从意义上讲应该具有”is a“的关系
• 所有的类，都默认直接或间接继承Object类
• 私有的东西无法被继承
• 调用父类的关键字是super
• 隐藏代码默认调用父类的无参构造，显示调用时子类构造器和父类构造器只能存在一种，且都必须位于子类构造器的第一行

在IDEA中ctrl +H用于打开 “Type Hierarchy”（类型层次结构）窗口，会展示该类的继承层次结构

关于super和this

• this：
  • 本身调用者这个对象
  • 没有继承也可以使用
  • this()是本类的构造方法
• super：
  • 代表父类对象的应用
  • 只有在继承条件下才可以使用
  • super()是父类的构造方法

关于方法的重写

• 重写都是方法的重写，与属性无关
• 重写必须要有继承关系，子类重写父类的方法，且方法名必须相同，参数列表必须相同，修饰符范围可以扩大但不能缩小（public>Protected>Default>private）
• 抛出异常的范围可以缩小但不能扩大
• 关键字Override
• 静态方法和非静态方法区别很大
• 静态方法调用之和方法左边定义的类型有关，父类的引用指向子类
• 使用非静态方法时，子类可以重写父类的方法
  为什么需要重写：父类的功能子类不一定需要或不一定满足

多态

• 同一方法可以根据发送对象的不同而采取多种不同的行为方式可以实现动态编译
• 多态使用的条件
  • 继承
  • 方法重写（静态方法static因为独属于类不属于实例所以不能重写，常量方法final不能重写，private方法不能重写）
  • 父类引用指向子类对象（例：Father son = new Son() ）
• 一个对象的实际类型是确定的，但可以指向的引用类型有很多（父类、有关系的类）
• 子类能调用本身或者继承父类的方法，父类可以指向子类但不能调用子类独有的方法
• 注意事项：多态是方法的多态，没有属性的多态
• 关键字instance of：用来判断引用对象的类型 （类型转换）引用类型
• 类型转换

关于父类引用指向子类对象

• 是指使用父类的引用类型来引用子类的实际对象。这种做法利用了Java中的多态性。
• 继承关系：首先，必须存在一个类继承关系，即一个类（子类）继承另一个类（父类）。
• 向上转型（Upcasting）：当使用父类的引用指向子类的对象时，实际上是将子类的对象进行了向上转型。这是Java自动完成的，不需要显式地使用new ParentClass(new ChildClass())这样的形式。
• 多态性：通过父类引用访问子类对象时，可以调用所有在父类中声明过的方法（包括子类重写的和未重写的方法），这就是多态性的体现。如果子类中添加了新的方法或者属性，则这些新特性不能通过父类引用直接访问。
• 安全性与类型检查：Java在运行时会检查实际对象的类型，确保调用的方法是安全的。如果试图通过父类引用调用子类特有的方法，将会得到一个编译错误，因为编译器仅知道父类的信息。

举例说明

// 父类
class Animal {
    void eat() {
        System.out.println("吃东西");
    }
}

// 子类
class Dog extends Animal {
    void bark() {
        System.out.println("汪汪叫");
    }
}

public class Main {
    public static void main(String[] args) {
        // 父类引用指向子类对象
        Animal myDog = new Dog();
        
        // 可以调用eat方法
        myDog.eat(); // 输出: 吃东西
        
        // 但是不能直接调用bark方法，因为myDog是Animal类型的引用
        // myDog.bark(); // 这样做会导致编译错误
    }
}

多态性的优势

1. 统一规范接口
   多态性通过父类提供了一个统一的接口规范，使得不同子类虽然具有不同的行为，但可以共享同一个接口，而不必为每个子类单独定义一个接口，使得代码更加简洁和统一。
2. 节省代码编写的工作量
   多态性使得可以在后续扩展时节省代码编写的工作量，特别是在处理数组或集合时，通过父类或接口类型的引用，可以遍历数组或集合中的不同子类对象，而不需要修改现有的调用方法。
3. 提高代码的可读性和可维护性
   通过多态性，代码变得更加清晰和一致。由于所有子类共享相同的接口，因此阅读代码的人更容易理解和维护代码。
4. 增强代码的灵活性
   多态性使得代码更加灵活，可以在运行时根据实际对象的类型动态地调整其行为，而不需要预先知道所有可能的情况。
5. 支持更好的测试
   多态性支持更好的单元测试。由于接口或父类定义了公共的行为，可以为这些公共行为编写测试用例，独立地测试每个子类的行为，同时也确保所有子类都遵循相同的契约。
6. 更好的解耦
   多态性有助于实现更好的解耦。当你的代码依赖于接口或抽象类时，它就不依赖于具体的实现细节。这意味着你可以更容易地更换或扩展系统的一部分，而不会影响到其他部分。
7. 支持框架和库的使用
   很多现代的框架和库都利用了多态性来提供高度可配置和可扩展的功能。例如，Spring 框架使用依赖注入（DI）和面向接口编程来实现高度灵活的组件模型。通过多态性，可以轻松地替换或扩展框架中的组件，而不需要修改框架本身的代码。
8. 改善代码的可扩展性
   多态性使得系统更容易扩展。当需要添加新功能或新类型时，只需要添加新的子类或实现，而不需要修改现有的代码。这使得系统的维护成本降低，并且更容易适应未来的需求变化。
9. 方便的异常处理
   在处理异常时，可以定义一个通用的异常处理方法来处理所有类型的异常，而不需要为每种异常类型编写单独的处理逻辑。
10. 设计模式的支持
    许多设计模式都依赖于多态性，例如工厂模式、策略模式、观察者模式等。这些模式通常涉及到创建和使用具有相同接口的不同对象，而多态性是实现这些模式的关键。

Static修饰符

• 静态属性：可以被类的所有实例共用
• 静态方法：类中的非静态方法可以直接调用类中的静态方法
• 静态代码块：首先执行静态代码块（只执行一次），然后执行匿名代码块，而后执行构造方法
• 静态导入包：可以简化需要多次调用的方法的调用方式

final修饰的类无法被继承

抽象类

• 关键字：abstract
• 抽象类
  • 抽象类是一种不能被实例化的类，它主要用于被其他类继承
  • 抽象类可以包含抽象方法和具体实现的方法
  • 包含抽象方法的类必须声明为抽象类
  • 抽象类可以有构造器、成员变量等
• 抽象方法
  • 抽象方法是没有实现体的方法，即只有方法签名而没有方法体
  • 抽象方法必须在抽象类中声明
  • 子类要么也声明为抽象类，要么必须实现所有未实现的抽象方法
  • 抽象方法可以带有default修饰符来提供默认实现

java本身只有单继承，接口例外，接口可以多继承

接口

• 接口就是规范，本质是契约，定义的是一组规则，通过接口可以实现约束和实现分离，接口中只有方法的定义
• 关键字：interface
• 接口中默认所有定义方法其实都是抽象的（public abstract），所有定义的属性都是常量（public static final）
• 接口都需要有一个实现类（类名规范：接口名+Impl）
• 类实现接口的关键字：implements
• 实现接口的类必须要重写接口的方法

内部类

• 成员内部类
  • 内部类可以获得外部类的私有属性和私有方法
• 静态内部类无法获得非静态属性
• 局部内部类，写在类的方法当中
• 匿名内部类，不需要类名的类

一个类文件中可以有多个class，但只能有一个public class