【零基础 快速学Java】韩顺平 零基础30天学会Java--- 面向对象编程(中级部分)(2024JavaReview)

IDEA 常用快捷键

• 添加注释和取消注释 ctrl + / 【第一次是添加注释，第二次是取消注释】
• 导入该行需要的类 先配置 auto import , 然后使用 alt+enter 即可
• 快速格式化代码 ctrl + alt + L
• 生成构造器等 alt + insert [提高开发效率]
• 查看一个类的层级关系 ctrl + H [学习继承后，非常有用]
• 自动的分配变量名 , 通过在后面加 .var （或者用Ctrl+Alt+V）

包

包的三天作用（区分相同名字的类）（控制访问范围）

1. 区分相同名字的类
2. 当类很多时,可以很好的管理类
3. 控制访问范围

包(package )基本语法（包的本质实际上就是创建不同的文件夹/目录来保存类文件）（需要放在类(或者文件)的最上面）

package com.hspedu;
说明:

1. package 关键字,表示打包,
2. com.hspedu: 表示包名

包的命名

常用的包和引入（import）（import指令 位置放在package的下面，在类定义前面,可以有多句且没有顺序要求）

一个包下,包含很多的类,java 中常用的包有:

1. java.lang.* //lang 包是基本包，默认引入，不需要再引入.
2. java.util.* //util 包，系统提供的工具包, 工具类，使用 Scanner
3. java.net.* //网络包，网络开发
4. java.awt.* //是做 java 的界面开发，GUI

访问修饰符

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

使用的注意事项（只有默认的和public才能修饰类!）

1. 修饰符可以用来修饰类中的属性，成员方法以及类
2. 只有默认的和public才能修饰类!，并且遵循上述访问权限的特点。
3. 因为没有学习继承，因此关于在子类中的访问权限，我们讲完子类后，在回头讲解
4. 成员方法的访问规则和属性完全一样.

面向对象编程三大特征—封装

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

封装的理解和好处

1)隐藏实现细节:方法(连接数据库)<–调用(传入参数…)
2)可以对数据进行验证，保证安全合理

封装的实现步骤 (三步)

1. 将属性进行私有化private 【不能直接修改属性)
2. 提供一个公共的(public)set方法，用于对属性判断并赋值

public void setXxx(类型 参数名){//Xxx 表示某个属性
		//加入数据验证的业务逻辑
		属性 = 参数名:
}

3. 提供一个公共的(public)get方法，用于获取属性的值

public 数据类型 getXxx(){ //权限判断,Xxx 某个属性
return xx;
}

将构造器和 setXxx 结合

//有三个属性的构造器
	public Person(String name, int age, double salary) {
		//	this.name = name;
		//	this.age = age;
		//	this.salary = salary;
		//我们可以将 set 方法写在构造器中，这样仍然可以验证
		setName(name); setAge(age); setSalary(salary);
	}

面向对象编程三大特性—继承

提出代码复用的问题

继承的基本语法（父类又叫 超类，基类）（子类又叫派生类）

class 子类 extends 父类{
}
1)子类就会自动拥有父类定义的属性和方法
2)父类又叫 超类，基类。
3)子类又叫派生类。

继承的深入讨论/细节问题（默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪个构造器完成对父类的初始化工作）(super() 和 this()，这两个都是构造器 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器)（父类构造器的调用不限于直接父类！将一直往上追溯直到 Object 类(顶级父类)）（子类最多只能继承一个父类(指直接继承)，即 java 中是单继承机制。思考：如何让 A 类继承 B 类和 C 类？ 【A 继承 B， B 继承 C】）

1. 子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问, 但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问
2. 子类必须调用父类的构造器， 完成父类的初始化
3. 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过
4. 如果希望指定去调用父类的某个构造器，则显式的调用一下 : super(参数列表)
5. super 在使用时，必须放在构造器第一行(super 只能在构造器中使用)
6. super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
7. java 所有类都是 Object 类的子类, Object 是所有类的基类.
8. 父类构造器的调用不限于直接父类！将一直往上追溯直到 Object 类(顶级父类)
9. 子类最多只能继承一个父类(指直接继承)，即 java 中是单继承机制。 思考：如何让 A 类继承 B 类和 C 类？ 【A 继承 B， B 继承 C】
10. 不能滥用继承，子类和父类之间必须满足 is-a 的逻辑关系

继承的本质分析(重要)

(1) 首先看子类是否有该属性

(2) 如果子类有这个属性，并且可以访问，则返回信息

(3) 如果子类没有这个属性，就看父类有没有这个属性(如果父类有该属性，并且可以访问，就返回信息…)

(4) 如果父类没有就按照(3)的规则，继续找上级父类，直到 Object…

课堂练习

案例1

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

基本语法

super 给编程带来的便利/细节（当子类中有和父类中的成员(属性和方法)重名时，为了访问父类的成员，必须通过super。如果没有重名使用super、this、直接访问是一样的效果!）（ super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员;如果多个基类(上级类)中都有同名的成员，使用super访问遵循就近原则。A->B->C，当然也需要遵守访问权限的相关规则）

1. 调用父类的构造器的好处(分工明确,父类属性由父类初始化，子类的属性由子类初始化)
2. 当子类中有和父类中的成员(属性和方法)重名时，为了访问父类的成员，必须通过super。如果没有重名使用super、this、直接访问是一样的效果!
3. super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员;如果多个基类(上级类)中都有同名的成员，使用super访问遵循就近原则。A->B->C，当然也需要遵守访问权限的相关规则

super 和 this 的比较（访问方法和属性时，this访问本类中的属性，如果本类没有此属性则从父类中继续查找，super从父类开始查找属性）

方法重写/覆盖(override)（简单的说:就是子类有一个方法,和父类的某个方法的名称、返回类型（重点）、参数一样）

注意事项和使用细节（形参列表,方法名称完全一样）（父类方法返回类型一样，或者是父类返回类型的子类）（子类方法不能缩小父类方法的访问权限）

重载VS重写

面向对象编程三大特性—多态

多[多种]态[状态]基本介绍（方法或对象具有多种形态，多态是建立在封装和继承基础之上的）

多态的具体体现

方法的多态 （重写和重载就体现多态 ）

对象的多态 （编译类型（不可改变）看定义时 =号 的左边，运行类型（可以改变）看=号的 右边）(核心，困难，重点)

1. 一个对象的编译类型和运行类型可以不一致
2. 编译类型在定义对象时，就确定了，不能改变3. 运行类型是可以变化的.
3. 编译类型看定义时 =号 的左边，运行类型看=号的 右边

多态注意事项和细节讨论

多态的前提是：两个对象(类)存在继承关系

多态的向上转型（可以调用父类中的所有成员(需遵守访问权限)，不能调用子类中特有成员（因为在编译阶段，能调用哪些成员,是由编译类型来决定的））（最终运行效果看子类(运行类型)的具体实现, 即调用方法时，按照从子类(运行类型)开始查找方法，然后调用）

多态向下转型（相当于原来的子类,要求父类的引用必须指向的是当前目标类型的对象）

属性没有重写之说！（属性的值看编译类型）（见练习题2）

/**
 * @创建人 wdl
 * @创建时间 2024/9/1
 * @描述
 */
public class PolyDetail02 {
    public static void main(String[] args) {
        //属性没有重写之说！属性的值看编译类型
        Base base = new Sub();//向上转型
        System.out.println(base.count);// ？ 看编译类型 10
        Sub sub = new Sub();
        System.out.println(sub.count);//?	20
    }
}


class Base { //父类
    int count = 10;//属性
}

class Sub extends Base {//子类
     int count = 20;//属性
}

instanceOf 比较操作符（用于判断对象的运行类型（重点）是否为 XX 类型或 XX 类型的子类型）

课堂练习

2.

java 的动态绑定机制(非常非常重要)

1. 当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定
2. 当调用对象属性时，没有动态绑定机制，哪里声明，那里使用

/**
 * @创建人 wdl
 * @创建时间 2024/9/1
 * @描述
 */
public class DynamicBinding {
    public static void main(String[] args) {
        //a 的编译类型 A, 运行类型 B
        A a = new B();//向上转型
        System.out.println(a.sum());//?40 -> 30
        System.out.println(a.sum1());//?30-> 20
    }
}


class A {//父类
    public int i = 10;
    //动态绑定机制:

    public int sum() {//父类 sum()
         return getI() + 10;//20 + 10
    }

    public int sum1() {//父类 sum1()
         return i + 10;//10 + 10
    }


    public int getI() {//父类 getI
         return i;
    }
}


class B extends A {//子类
     public int i = 20;

//	public int sum() {
//	return i + 20;
//	}


    public int getI() {//子类 getI()
         return i;
    }


//	public int sum1() {
//	return i + 10;
//	}
}

多态的应用

1) 多态数组

数组的定义类型为父类类型，里面保存的实际元素类型为子类类型应用实例:现有一个继承结构如下：要求创建 1 个 Person 对象、2 个 Student 对象和 2 个 Teacher 对象, 统一放在数组中，并调用每个对象
say 方法.

应用实例升级：如何调用子类特有的方法，比如Teacher 有一个 teach , Student 有一个 study

怎么调用？

2) 多态参数

方法定义的形参类型为父类类型，实参类型允许为子类类型

Object 类详解

equals 方法（ ==和 equals 的对比）

==是一个比较运算符（既可以判断基本类型，又可以判断引用类型）

如果判断基本类型，判断的是值是否相等。示例:inti=10;double d=10.0:
如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象

equals: 是Object类中的方法（只能判断引用类型）（默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。）

默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。比如Integer,String 【看看string 和 Integer的 equals 源代码 】

/**
 * @创建人 wdl
 * @创建时间 2024/9/1
 * @描述
 */
public class Equals01 {


    public static void main(String[] args) {
        A a = new A();
        A b = a;
        A c = b;
        System.out.println(a == c);//true
        System.out.println(b == c);//true
        B bObj = a;
        System.out.println(bObj == c);//true
        int num1 = 10;
        double num2 = 10.0;
        System.out.println(num1 == num2);//基本数据类型，判断值是否相等


        //equals 方法，源码怎么查看.
        //把光标放在 equals 方法，直接输入 ctrl+b
        //如果你使用不了. 自己配置. 即可使用.


        /*
        //带大家看看 Jdk 的源码 String 类的 equals 方法
        //把 Object 的 equals 方法重写了,变成了比较两个字符串值是否相同
        public boolean equals(Object anObject) {
            if (this == anObject) {//如果是同一个对象
            return true;//返回 true
        }
        if (anObject instanceof String) {//判断类型
            String anotherString = (String)anObject;//向下转型
            int n = value.length;
            if (n == anotherString.value.length) {//如果长度相同
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {//然后一个一个的比较字符
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;//如果两个字符串的所有字符都相等，则返回 true
            }
        }
        return false;//如果比较的不是字符串，则直接返回 false
    }
        */


        "hello".equals("abc");


        //看看 Object 类的 equals 是
        /*
        //即 Object 的 equals 方法默认就是比较对象地址是否相同
        //也就是判断两个对象是不是同一个对象.
        public boolean equals(Object obj) {
            return (this == obj);
        }
        */




        /*
        //从源码可以看到 Integer 也重写了 Object 的 equals 方法,
        //变成了判断两个值是否相同
        public boolean equals(Object obj) {
            if (obj instanceof Integer) {
                return value == ((Integer)obj).intValue();
            }
            return false;
        }
        */
        Integer integer1=new Integer(1000);
        Integer integer2=new Integer(1000);
        System.out.println(integer1==integer2);//false
        System.out.println(integer1.equals(integer2));//true

        String str1=new String("hspedu");
        String str2=new String("hspedu");
        System.out.println(str1==str2);//false
        System.out.println(str1.equals(str2));//true


        }
}


class B {
}

class A extends B {
}

重写

应用实例: 判断两个 Person 对象的内容是否相等，如果两个 Person 对象的各个属性值都一样，则返回 true，反之 false。

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

hashCode 方法（返回该对象的哈希码值。支持此方法是为了提高哈希表(例如 java.uti1.Hashtable 提供的哈希表)的性能）

1. 提高具有哈希结构的容器的效率！
2. 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的！
3. 两个引用，如果指向的是不同对象，则哈希值是不一样的
4. 哈希值主要根据地址号来的！， 不能完全将哈希值等价于地址。
5. 后面在集合，中 hashCode 如果需要的话，也会重写, 在讲解集合时，在说如何重写 hashCode()

toString 方法（默认返回：全类名+@+哈希值的十六进制）（当直接输出一个对象时，toString 方法会被默认的调用）

1. 基本介绍
   默认返回：全类名+@+哈希值的十六进制，【查看 Object 的 toString 方法】
   子类往往重写 toString 方法，用于返回对象的属性信息
2. 重写 toString 方法，打印对象或拼接对象时，都会自动调用该对象的 toString 形式
3. 当直接输出一个对象时，toString 方法会被默认的调用, 比如 System.out.println(monster)； 就会默认调用monster.toString()

/**
 * @创建人 wdl
 * @创建时间 2024/9/1
 * @描述
 */


public class ToString_ {
    public static void main(String[] args) {


        /*
        Object 的 toString() 源码
        (1)getClass().getName() 类的全类名(包名+类名 ) (2)Integer.toHexString(hashCode()) 将对象的 hashCode 值转成 16 进制字符串 public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }
        */


        Monster monster = new Monster("小妖怪", "巡山的", 1000);
        System.out.println(monster.toString() + " hashcode=" + monster.hashCode());

        System.out.println("==当直接输出一个对象时，toString 方法会被默认的调用==");
        System.out.println(monster); //等价 monster.toString()
    }
}


class Monster {
    private String name;
    private String job;
    private double sal;

    public Monster(String name, String job, double sal) {
        this.name = name;
        this.job = job;
        this.sal = sal;
    }


    //重写 toString 方法, 输出对象的属性
    //使用快捷键即可 alt+insert -> toString
    @Override
    public String toString() { //重写后，一般是把对象的属性值输出，当然程序员也可以自己定制
        return "Monster{" +
                "name='" + name + '\'' +
                ", job='" + job + '\'' + ", sal=" + sal +
                '}';
    }


//    @Override
//    protected void finalize() throws Throwable {
//        System.out.println("fin..");
//    }
}

finalize 方法

1. 当对象被回收时，系统自动调用该对象的 finalize 方法。子类可以重写该方法，做一些释放资源的操作
2. 什么时候被回收：当某个对象没有任何引用时，则 jvm 就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用 finalize 方法。
3. 垃圾回收机制的调用，是由系统来决定(即有自己的 GC 算法), 也可以通过 System.gc() 主动触发垃圾回收机制

提示： 我们在实际开发中，几乎不会运用 finalize , 所以更多就是为了应付面试

/**
 * @创建人 wdl
 * @创建时间 2024/9/1
 * @描述
 */
//演示 Finalize 的用法
public class Finalize_ {
    public static void main(String[] args) {


        Car bmw = new Car("宝马");
        //这时 car 对象就是一个垃圾,垃圾回收器就会回收(销毁)对象, 在销毁对象前，会调用该对象的 finalize 方法
        //,程序员就可以在 finalize 中，写自己的业务逻辑代码(比如释放资源：数据库连接,或者打开文件..)
        //,如果程序员不重写 finalize,那么就会调用 Object 类的 finalize, 即默认处理
        //,如果程序员重写了 finalize, 就可以实现自己的逻辑
        bmw = null;
        System.gc();//主动调用垃圾回收器
        
        System.out.println("程序退出了	");
    }
}

class Car {
    private String name;

    //属性, 资源。。
    public Car(String name) {
        this.name = name;
    }

    //重写 finalize
    @Override
    protected void finalize() throws Throwable {
        System.out.println("我们销毁 汽车" + name);
        System.out.println("释放了某些资源	");

    }
}

断点调试(debug)（断点调试 过程中，是运行状态 ）

1. 在开发中，新手程序员在查找错误时,这时老程序员就会温馨提示，可以用断点调试一步一步的看源码执行的过程，从而发现错误所在。
2. 重要提示: 在断点调试 过程中，是运行状态，是以对象的 运行类型来执行的,A extends B : B b = new A(); box();

ldea debug 如何进入 Jdk 源码

解决方法1

使用 force stepinto:快捷键 alt+shift+F7

解决方法2

这个配置一下就好了:

点击 Setting --> Build,Execution,Deployment --> Debugger -->Stepping把 Do not step into the classes 中的 ajva.*，javax.*取消勾选，其他的随意

然后，就可以进入源码了