javase（2023/11/13）

目录

1、多态的动态绑定机制

2、多态的应用

多态数组

多态参数

3、Object类中的一些方法

equals方法和==

hashcode方法

toString方法

finalize方法

 断点调试

---

1、多态的动态绑定机制

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

package zhh.chapter08;

public class Exer {
    public static void main(String[] args) {
        //a 的编译类型 A, 运行类型 B
        A a = new B();//向上转型

        //注释后，运行父类丽里的sum()，
        // 执行到getI()时，由于方法和运行类型绑定，这里运行B类的getI(),
        //而属性没有动态绑定，即此时B类的getI()返回B类中的i，即20
        //然后再执行20+10=
        System.out.println(a.sum());//?40 -> 30
        //sum1原理一样
        System.out.println(a.sum1());//?30-> 20
    }

}
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;

    //这里注释后，发生40->30
//    public int sum() {
//        return i + 20;
//    }

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

    //这里注释后，发生30->20
//    public int sum1() {
//        return i + 10;
//    }
}

2、多态的应用

多态数组

数组的定义类型为父类类型，里面保存的实际元素类型为子类类型

Person[] persons = new Person[5];
        persons[0] = new Person("jack", 20);
        persons[1] = new Student("mary", 18, 100);
        persons[2] = new Student("smith", 19, 30.1);
        persons[3] = new Teacher("scott", 30, 20000);
        persons[4] = new Teacher("king", 50, 25000);
        
        //循环遍历多态数组，调用 say
        for (int i = 0; i < persons.length; i++) {
            //person[i] 编译类型是 Person ,运行类型是是根据实际情况有 JVM 来判断
            System.out.println(persons[i].say());//动态绑定机制

            //使用 类型判断 + 向下转型. 
            if (persons[i] instanceof Student) {
                Student student = (Student) persons[i];//向下转型
                student.study();
                //可以使用一条语句 ((Student)persons[i]).study();
            } else if (persons[i] instanceof Teacher) {
                Teacher teacher = (Teacher) persons[i];
                teacher.teach();
            } else if (persons[i] instanceof Person) {
            } else {
                System.out.println("你的类型有误, 请自己检查...");
            }

多态参数

package zhh.chapter08.polyparameter;

public class Test extends Employee{

    public static void main(String[] args) {
        Test test = new Test();
        //这里不用上转型也ok，下边用时子类参数传给父类没问题
        Employee ordinaryStaff = new OrdinaryStaff("jack",3000.0);
        ordinaryStaff.info();
        test.showEmpAnnual(ordinaryStaff);
        test.testWork(ordinaryStaff);

        System.out.println("====================");
        Employee manager = new Manager("king", 6000.0, 5000.0);
        manager.info();
        test.showEmpAnnual(manager);
        test.testWork(manager);
    }




    public void showEmpAnnual(Employee e){
        System.out.println("年薪"+e.getAnnual());
    }

    public void testWork(Employee e){
        if(e instanceof Manager){
            ((Manager) e).manage();
        }else if(e instanceof OrdinaryStaff){
            ((OrdinaryStaff) e).work();
        }else{
            System.out.println("对象类型错误...");
        }
    }

}
package zhh.chapter08.polyparameter;

public class Employee {
    public String name;
    private double salary;

    public Employee() {
    }

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public double getAnnual(){
        return salary*12;
    }

    public void info(){
        System.out.println(getName()+"月薪"+getSalary());
    }
}
package zhh.chapter08.polyparameter;

public class Manager extends Employee{
    private double bonus ;

    public Manager() {
    }

    public Manager(String name, double salary, double bonus) {
        super(name, salary);
        this.bonus = bonus;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    public void manage(){
        System.out.println("经理"+getName()+"在工作...");
    }

    @Override
    public double getAnnual() {
        return super.getAnnual()+getBonus();
    }
}
package zhh.chapter08.polyparameter;

public class OrdinaryStaff extends Employee {

    public OrdinaryStaff() {
    }

    public OrdinaryStaff(String name, double salary) {
        super(name, salary);
    }

    public void work(){
        System.out.println("普通员工"+getName()+"在工作...");
    }

    @Override
    public double getAnnual() {
        return super.getAnnual();
    }
}

3、Object类中的一些方法

equals方法和==

看源码

//Object中的equals方法
        public boolean equals(Object obj) {
            return (this == obj);
        }
        //String中的equals方法
        public boolean equals(Object anObject) {
            if (this == anObject) {
                return 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;
                }
            }
            return false;
        }

因此可知

• ==:既可以判断基本类型，又可以判断引用类型
• ==:如果判断基本类型，判断的是值是否相等。
•  ==:如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象
• equals:是Object类中的方法，只能判断引用类型，默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。
   

hashcode方法

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

System.out.println("aaaa".hashCode());//2986048

toString方法

• 基本介绍 默认返回：全类名+@+哈希值的十六进制， 子类往往重写 toString 方法，用于返回对象的属性信息
• 重写 toString 方法，打印对象或拼接对象时，都会自动调用该对象的 toString 形式，
• 可以快捷重写，没有重写的话，就还是用Object中的toString

package zhh.chapter08;

public class Exer {
    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()
        System.out.println(monster+"hahahahaha");

    }
}
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 +
                '}';
    }

}

finalize方法

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

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

 断点调试

• F7(跳入)
• F8(跳过)
• shift+F8(跳出)
• F9(resume,执行到下一个断点)
• F7：跳入方法内 F8: 逐行执行代码.
• shift+F8: 跳出方法

使用断点调试的方法，可以追踪一个对象创建的过程，可以查看动态绑定机制的如何工作