[豪の学习笔记] JavaReStudy#07

面向对象编程-进阶部分

1 - IDEA常用快捷键

1.删除当前行 ctrl+Y

2.查看一个类的层级关系 ctrl+H

3.定位方法 ctrl+B

4.自动分配变量名，在后面加 .var

5.导入该行需要的类，先配置auto import，然后使用 Alt+Enter 即可

6.快速格式化代码 ctrl + alt + L

7.快速运行程序 Alt + R

8.生成构造器 alt + insert

2 - 包

包的三大作用

①区分相同名字的类

②当类很多时，可以很好地管理类

③控制访问范围

包的基本语法

package 关键字，表示打包

com.magicshushu 表示包名

包的本质

包的本质实际上就是创建不同的文件夹/目录来保存类文件

包的命名规则

只能包含数字、字母、下划线、小圆点，不能用数字开头，不能是关键字或保留字

demo.class.exec1  // 错误，class为关键字
demo.12a  // 错误，12a是数字开头
demo.ab12.oa  // 正确

包的命名规范

一般是小写字母 + 小圆点

com.公司名.项目名.业务模块名

com.sina.crm.user  // 用户模块
com.sina.crm.order  // 订单模块
com.sina.crm.utils  // 工具类

Java中常用的包

java.lang.*    lang包是基本包，默认引入，不需要再引入

java.util.*    util包，系统提供的工具包，工具类，使用Scanner

java.net.*    网络包，网络开发

java.awt.*    java界面开发，GUI

如何引入包

语法：import 包;

引入一个包的主要目的是要使用该包下的类，比如 import java.util.Scanner; 就只是引入一个类Scanner，对应的，import java.util.*; 表示将java.util 包所有都引入

注意事项和使用细节

package的作用是声明当前类所在的包，需要放在类的最上面，一个类中最多只有一句package

import指令，位置放在package的下面，在类定义前面，可以有多句且无顺序要求

3 - 访问修饰符

java提供四种访问控制修饰符号，用于控制方法和属性（成员变量）的访问权限（范围）

public 公开级别，对外公开

protected 受保护级别，对子类和同一个包中的类公开

无修饰符，默认级别，向同一个包的类公开

private 私有级别，只有类本身可以访问，不对外公开

访问级别	同类	同包	子类	不同包
公开	√	√	√	√
受保护	√	√	√
默认	√	√
私有	√

使用注意事项

修饰符可以用来修饰类中的属性，成员方法和类

只有默认的和public才能修饰类，且遵循上述访问权限特点

成员方法的访问规则和属性完全一样

4 - 面向对象编程 - 封装

封装介绍

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

隐藏实现细节：方法<-- 调用（传入参数..）

可以对数据进行验证，确保安全合理

封装实现步骤

将属性进行私有化 private，防止外部直接修改属性

提供一个公共的set方法，用于对属性判断并赋值

提供一个公共的get方法，用于获取属性的值

将构造器和setXxx融合

5 - 面向对象编程 - 继承

继承基本介绍

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

继承的基本语法

class 子类 extends 父类{

}

子类就会自动拥有父类定义的属性和方法

父类又叫超类、基类

子类又叫派生类

继承的深入讨论细节

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

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

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

如果希望指定去调用父类的某个构造器，需要显式地调用super(参数列表)

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

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

java所有类都是Object类的子类，Object是所有类的基类

父类构造器的调用不限于直接父类，将一直往上追溯直到Object类（顶级父类）

子类最多只能继承一个父类（指直接继承）

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

继承的本质分析

public class ExtendsTheory{
    public static void main(String[] args){
        Son son = new Son(); //内存的布局
    }
}
class GrandPa{
    String name = "yeye";
    String hobby = "Arknights"
}
class Father extends GrandPa{
    String name = "papa";
    int age = 45;
}
class Son extends Father{
    String name = "ererer"
}

先在方法区加载Object类，再加载Grandpa，然后是Father，最后是Son

然后在堆中分配Grandpa、Father、Son

6 - super关键字

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

基本语法

1.访问父类的属性，但不能访问父类的private属性

super.属性名

2.访问父类的方法，但不能访问父类的private方法

super.方法名(参数列表)

3.访问父类的构造器，只能放在构造器的第一句，只能出现一句

super(参数列表)

super编程带来的便利/细节

分工明确，父类属性由父类初始化，子类属性由子类初始化

当子类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过super；如果没有重名，使用super、this、直接访问是一样的效果

super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；如果让多个基类中都有同名的成员，使用super访问遵循就近原则，同时也遵循访问权限的原则

super和this的比较

区别点	this	super
访问属性	访问本类中的属性 如果本类没有此属性则从父类中继续查找	从父类开始查找属性
调用方法	访问本类中的方法 如果本类中没有此方法则从父类继续查找	从父类开始查找方法
调用构造器	调用本类构造器 必须放在构造器首行	调用父类构造器 必须放在子类构造器首行
特殊	表示当前对象	子类中访问父类对象

7- 方法重写/覆盖(override)

基本介绍

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

注意事项和使用细节

子类方法的形参列表、方法名称要和父类方法的形参列表、方法名称完全一样

子类方法的返回类型和父类方法的返回类型一样，或是父类返回类型的子类（比如父类返回类型是Object，子类方法返回类型是String）

子类方法不能缩小父类方法的访问权限 public > protected > 默认 > private

8 - 面向对象编程 - 多态

方法或对象具有多种形态，是面向对象的第三大特征，多态是建立在封装和继承基础之上的

多态的具体体现

1.方法的多态

方法的重载体现多态

方法的重写体现多态

2.对象的多态（重点内容）

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

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

运行类型是可以变化的

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

Animal animal = new Dog(); //animal编译类型是Animal，但运行类型是Dog
animal = new Cat(); // animal的运行类型变成了Cat，编译类型仍然是Animal

package com.magicshushu.poly_.objectpoly_;

public class Animal{
    public void cry(){
        System.out.println("动物叫");
    }
}

package com.magicshushu.poly_.objectpoly_;

public class Cat extends Animal{
    @Override
    public void cry(){
        System.out.println("Cat叫");
    }
}

package com.magicshushu.poly_.objectpoly_;

public class Dog extends Animal{
    @Override
    public void cry(){
        System.out.println("Dog叫");
    }
}

package com.magicshushu.poly_.objectpoly_;

public class PolyObject{
    public static void main(String[] args){
        //体验对象多态特点
        Animal animal = new Dog();
        //因为执行到该行时，这个animal的运行类型为Dog，所以这个cry是Dog的cry
        animal.cry(); //输出“Dog叫”
        
        animal = new Cat();
        animal.cry(); //输出“Cat叫”
    }
}

注意事项和使用细节

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

属性无重写之说，属性的值看编译类型

instanceof 比较操作符，用于判断对象的运行类型是否为XX类型或XX类型的子类型

------多态的向上转型------

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

语法：父类类型 引用名 = new 子类类型();

特点：编译类型看左边，运行类型看右边

可以调用父类中的所有成员（遵守访问权限）

不能调用子类中的特有成员

最终运行效果看子类的具体实现，即调用方法时按照从子类开始查找方法

------多态向下转型------

语法：子类类型 引用名 = (子类类型) 父类引用;

只能强转父类的引用，不能强转父类的对象

要求父类的引用必须指向的是当前目标类型的对象

当向下转型后，可以调用子类类型中的所有成员

Animal animal = new Cat();
Cat cat = (Cat) animal; //此时cat的编译类型是Cat，运行类型是Cat
cat.catchMouse();

Java的动态绑定机制

1.当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定

2.当调用对象属性的时候，没有动态绑定机制，哪里声明哪里使用

public class Main{
    public static void main(String[] args){
        A a = new B(); //向上转型，
        System.out.println(a.sum()); //调用的是B类中的sum()，结果为40
        System.out.println(a.sum1()); //调用的是B类中的sum1()，结果为30
    }
}
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;
    }
}
若把B类中的sum()函数注释掉，则main中System.out.println(a.sum());调用的是A类中的sum()函数，其中又会调用子类的geti()函数
若把B类中的sum1()函数注释掉，则main中System.out.println(a.sum1());调用的是A类中的sum1()函数，其中的i则是A的i

多态的应用

1.多态数组：数组的定义类型为父类类型，里面保存的实际元素类型为子类类型

2.多态参数：方法定义的形参类型为父类类型，实参类型允许为子类类型

9 - Object类详解

Object类是类层次结构的根类，每个类都使用Object类作为超类，所有对象（包括数组）都实现这个类的方法

equals方法

----- ==与equals的对比 -----

==是一个比较运算符，可以判断基本类型，也可以判断引用类型。判断基本类型时，判断的是值是否相等；判断引用类型时，判断的是地址是否相等，即判定是不是同一个对象

equals是Object类中的方法，只能判断引用类型，默认判断的是地址是否相等，子类中往往会重写该方法，用于判断内容是否相等，比如Integer、String

如何重写equals方法

public class Main{
    public static void main(String[] args){
        Person p1 = new Person("Jackey", 20, '男');
        Person p2 = new Person("Jackey", 50, '男');
        System.out.println(p1.equals(p2)); // false
    }
}
class Person{
    private String name;
    private int age;
    private char gender;

    public Person(String name, int age, char gender){
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    // 重写Object类的equals方法
    public boolean equals(Object obj){
        if(this == obj){
            return true; // 如果比较的两个对象是同一对象，则返回true
        }
        // 类型判断
        if(obj instanceof Person){
            // 因为要得到obj的各个属性，所以需进行向下转型
            Person p = (Person)obj;
            return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;
        }
        return false; // 如果不是Person，直接返回false
    }
}

hashCode方法

xx.hashCode()返回对象xx的哈希码值

提高具有哈希结构的容器的效率

两个引用，如果指向的是同一个对象则哈希值一样，如果指向的是不同对象则哈希值不一样

哈希值主要根据地址号得来，但不能完全将哈希值等价于地址

toString方法

默认返回：全类名（包名+类名）+ @ + 哈希值的十六进制

子类往往重写toString方法，用于返回对象的属性信息

重写toString方法，打印或拼接对象时，都会自动调用该对象的toString形式

@Override
public String toString(){
    return "Monster{" +
            "name=" + name + '\' +
            ", job='" + job + '\' +
            ", sal=" + sal +
            '}';
}

当直接输出一个对象时，toString方法会被默认地调用，比如System.out.println(monster);就会默认调用monster.toString()

finalize方法

当对象被回收时，系统自动调用该对象的finalize方法，子类可以重写该方法，做一些释放资源的操作

当某个对象没有任何引用时，JVM就会认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象。在销毁该对象前，会先调用finalize方法

垃圾回收机制的调用，是由系统来决定（即有自己的GC算法），也可以通过System.gc()主动触发垃圾回收机制

在实际开发中，几乎不会运用finalize，更多是为了面试

断点调试（debug）

在开发中可以用断点调试一步一步地看源码执行的过程，从而发现错误所在

在断点调试过程中是运行状态，是以对象的运行类型来执行的

断点调试是指在程序的某一行设置一个断点，调试时程序运行到这一行就会停住，然后可以一步一步往下调试，调试过程中可以看各个变量当前的值，出错的话调试到出错的代码行即显示错误

断点调试快捷键

F7 跳入方法内

F8 逐行执行代码

shift+F8 跳出方法

F9 resume，执行到下一个断点