荐 java父类-Object类-equals与==-方法的重载和重写-游离块-this关键字

Super（用以引用父类）

    在Java类中使用super来引用父类的成分，super关键字不能使用在静态成分中。

① 在构造方法中使用 super(实参);

     创建子类对象时，父类的构造方法一定会被调用。并且是父类构造方法先调用super(实参); 这句代码必须定义在构造方法中且第1行。

② 调用父类的属性

     super.属性名 先找父类属性，若找到了则直接使用，若没有再找父类的父类，以此类推，直到Object类 

③ 调用父类的方法

    super.方法名(实参)； 

④ super的追溯不仅于直接父类

this

 this关键字代表本类对象的引用，this关键字不能使用在静态成分中。
 
在java类中每一个类都存在一个this对象，该this对象表示当前类的一个实例。 可以在类的内部通过this调用当前的重载的构造方法，属性，方法。

① this在非静态方法中使用

   哪个对象调用了该方法，那么this代表调用这个方法的对象

② this什么时候存在的?

 当创建了对象时候，this就存在了

③ 当成员变量和局部变量重名时，this区分

    this的作用：用来区分同名的成员变量和成员方法。

④ this出现在构造方法中

  <1> this.属性名=参数名; 代表使用这个构造方法创建的对象
 < 2> this(实参); 必须出现在构造方法中且第1行，代表调用当前类重载构造方法.

this和super区别

 注意： 当子类重写父类的方法， ① 观察两个类是否添加了extends关键字标明它们的继承关系 ② 观察这个父类方法的访问控制修饰符，是否能够在子类中访问的到 

public class Student { 
        private String name; 
        public Student() { 
        this("姓名"); // 调用本类重载的构造方法
      }
        // 你使用这个构造方法创建的对象 
        public Student(String name) {
           this.name = name; // 当变量名重名的时候，区分成员变量（属性）和局部变量 
           System.out.println("this=" + this); 
           }
           // 谁调用这个方法，this代表谁 
           public void study() { 
           System.out.println("study方法中的this=" + this.name);                     
         }
           public static void main(String[] args) { 
           Student s1 = new Student("张三"); 
           System.out.println("s1=" + s1); 
           Student s2 = new Student("李四"); s2.study(); 
           } 
        } 

游离块（初始化块）

//语法
{
    //代码块
 }

什么时候执行？

 1.不能直接调用游离块
 2.不管使用哪个构造方法创建对象，游离块先执行（多个游离块，则每个游离块都要按照定义顺序执行1遍），再执行构造方法

public class Student{

      protected String name;
      {
         System.out.println("游离块1执行");
      }

      {
         System.out.println("游离块2执行");
      }
      public Student(){
      System.out.println("构造器3执行");
      }
      public Student(String name){
         this.name = name;
         System.out.println("构造器4执行");
      }

      public static void main(String[] args){
             Student s = new Student();
             Student s1 =new Student("凯撒");

             //执行结果应该为1234
      }
}

重写与重载的区别

重写(override)

  在某些情况下，父类中的方法不能够满足子类的需求时，此时子类可以对父类的方法进行覆盖，这个操作称为重写。
 要求:
      1.重写是发生在有继承关系的类中
      2.三同1不严格 (返回值类型一样，参数一样，方法名一样，也可以是子类，控制访问修饰符不严格，从大到小的范围：protected   public   默认不写   public)

重载(overload)

 方法的重载:是多态的一种实现策略，方法的重载表现为存在方法名相同，参数列表不同的方法。(和返回值类型，访问控制修饰符无关)
 参数列表:参数个数不同或者参数对应位置数据类型不同

 注意： 当子类重写父类的方法
 ① 观察两个类是否添加了extends关键字标明它们的继承关系
 ② 观察这个父类方法的访问控制修饰符，是否能够在子类中访问的到 

public class Person{
     protected String name;
     protected int age;
     public Person(){
     
     }
      public void  m1(String name,int age){
      System.out.println("方法1");
      }
}

public class Student extends Person{

     public Student(){
     
     }
     //覆盖父类方法的重写
     public void m1(String name,int age){
     System.out.println("方法2");
     }
     //重载
     public void m1(int age){
     System.out.println("方法3");
     }
  
     public static void main(String[] args){
          Student s = new Student("凯撒",18);
     }
}

② == 和 equals的区别

 ① ==
 情况1：基本数据类型，比较值 
 情况2：引用数据类型，比较地址 (更准确的讲，判断两个引用是否指向同一个对象)
  ② equals 
  情况1： 若没有重写Object类的equals方法,其实本质还是比较地址 Object源码中equals方法的定义： public boolean equals(Object obj) { return (this == obj); } 
  情况2： 子类重写了Object类的equals方法,一定也要重写hashCode()方法 则按照重写后的规则比较 

Object

Object是所有类的父类

 声明一个类的时候，没有指定它的父类，则默认继承Object类 public class Animal extends Object{} ；

toString()方法

 Object类提供了一个方法 toString(),所有的类都有toString方法 作用：使用字符串表示对象 

getClass()方法

 作用： 返回运行时类 （对于初学的同学，这块不用纠结，后期会在反射章节讲解） 

equals(Object obj)方法

用于判断两个对象是否相等


 如何重写equals方法
       == 运算符
      finalize() 方法
      "请注意，无论何时覆盖equals方法，通常需要覆盖hashCode方法，以便维护hashCode方法的通用合 同，该方法规定相等的对象必须具有相等的哈希码。" 右键 ---> source ---> generate hashCode() and equals() 在弹出的窗体中，选中按照什么属性比较 

clone() 方法

 protected native Object clone() throws CloneNotSupportedException; 只有实现了Cloneable接口的类的对象才可以调用这个方法 这个方法会生成一个新的对象

instanceof

 使用规则： boolean 变量名= obj instanceof 类型(和obj有继承关系的类);
  含义： 判断 obj 是否属于 指定的类型， true √ false × instanceof会判断继承关系，子对象 instanceof 父类 会返回true，父对象 instanceof 子类 会返回false。 可以理解为判断两个问题："你是这个类吗？" "你是这个类的派生类吗？" getClass()判断两个对象的类型 // getClass返回的是一个类名，也就是说只会在类名相同时返回true // 不会判断子类与父类的继承关系。 System.out.println(obj1.getClass() == obj2.getClass()); 

本文地址：https://blog.csdn.net/weixin_44435366/article/details/107349300