equals，hashCode，toString，finalize，断点调试

1. ==是一个比较运行算符
   1. 即可以判断基本类型，又可以判断引用类型
   2. 如果判断基本类型，判断的是值是否相等。
   3. 如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象。
2. equals：是Object类中的方法，只能判断引用类型
3. 默认判断的是地址是否相等，子类（String，Integer）中往往重写该方法，用于判断内容是否相等
4. 注意这里对象都是用的哪个类里面的equals，第一个不是同一个对象，第二个String，第三个Object，第四个String，第五个不是同一个对象。
5. hashCode
   1. 提高具有哈希结构的容器的效率
   2. 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的
   3. 两个引用，如果指向的是不同对象，则哈希值是不一样
   4. 哈希值主要根据地址号来的！，不能完全将哈希值等价于地址
   5. 在讲集合......

   6. package com.hspedu.ploy_.polyparameter_;
      
      
      
      public class HashCode_ {
          public static void main(String[] args) {
              AA aa = new AA();//两个不同的空间在堆里
              AA aa1 = new AA();
              AA aa2 = aa;
              System.out.println("aa.hashcode()="+aa.hashCode());
              System.out.println("aa1.hashcode()="+aa1.hashCode());
              System.out.println("aa2.hashcode()="+aa2.hashCode());
          }
      }
      /*
      aa.hashcode()=460141958//输出，但不能说这个是对象的地址
      aa1.hashcode()=1163157884
      aa2.hashcode()=460141958
       */
      class AA{
      
      }
      

      相同的地址，哈希值一样

6. toString

   1. package com.hspedu.ploy_.polyparameter_;
      
      public class ToString_ {
          public static void main(String[] args) {
              Monster monster = new Monster("小妖怪", "巡山", 10000);
              System.out.println(monster.toString());//3.这里Monster类里没有重写toString方法
              //所以就执行Object的toString方法。
              //输出   com.hspedu.ploy_.polyparameter_.Monster@1b6d3586
      
              //1.有toString重写输出   Monster{name='小妖怪', job='巡山', sal=10000.0}
          
      
              //2.当直接输出一个对象时，toString方法会被默认的调用
              System.out.println(monster);//Monster{name='小妖怪', job='巡山', sal=10000.0}
              /*
              Object的toString()的原码
              1.getClass().getName()//类的全类名（包名+类名）
              2.Integer.toHexString(hashCode())//哈希值的十六进制
              public String toString() {
                  return getClass().getName() + "@" + Integer.toHexString(hashCode());
              }
               */
          }
      }
      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 +
                      '}';
          }
      }
      

7. finalize

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

   2. 什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finalize方法。

   3. 垃圾回收机制的调用，是由系统来决定，也可以通过System.gc()主动触发垃圾回收机制。

   4. 不是run后立马垃圾回收，它有自己的算法。

   5. package com.hspedu.ploy_.polyparameter_;
      
      public class Finalize_ {
          public static void main(String[] args) {
              car bmw = new car("宝马");//创建堆空间
              bmw = null;//创建的堆空间就断了，这时没有能够引用到之前创建的对象堆空间
              //car对象就是一个垃圾，垃圾回收器就会回收对象，堆空间给你收回。
              //在销毁对象前，会调用该对象的finalize方法，
              //这时程序员就可以在finalize中写自己的代码。
              //如果不重写finalize，那么就会调用Object类的finalize，即默认处理
              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);
      
          }
      }
      

      一般开发不用

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

   1. F7跳入，F8跳过，shift+F8跳出，F9resume执行到下一个断点。