Java基础知识-----this关键字和super关键字的区别

===>>this(哪个对象调用，this就代表哪个对象)

1、为什么要用this？

public class Example2_5{
     
	public static void main(String []args){
     
		Dog dog1 = new Dog("大壮", 3);
		System.out.println("dog1的hashCode = " + 					dog1.hashCode());
		dog1.info();
		Dog dog2 = new Dog("大黄", 2);
		System.out.println("dog2的hashCode = " + 					dog2.hashCode());
		// dog2这个对象的地址与构造器中的this的地址相同，通过比较两个hashCode的值，this说明表示是当前类。
		dog2.info();
	}	 
}
class Dog{
     
	String name;
	int age;
	/*
	public Dog(String dName, int dAge){
		// 构造器
		name = dName;
		age = dAge;
	}
	*/
	// 如果我们构造器的形参，能够直接写成属性名，就更好了
	// 属性名和局部变量名相同时，就近原则
	// 引出关键字this
	/*
	public Dog(String name, int age){
		// 构造器
		name = name; //两个name都是局部变量
		age = age;  // 两个age都是局部变量
	}
	*/
	public Dog(String name, int age){
     			
		this.name = name; // this.name表示当前对象的属性，name表示局部变量
		this.age = age;// this.age表示当前对象的属性，age表示局部变量
		System.out.println("this.hashCode = " + 					this.hashCode());
		// hashCode()一般是将对象的地址转换为一个整数
	}
	public void info(){
     	
		// 成员方法，输出属性
		System.out.println(name + "\t" + age + "\t");
	}
}

2、hashCode()是Object类中的方法

• 返回该对象的哈希码值，这样可以提高哈希表的性能。
• 由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。（这一般是通过将该对象的内部地址转换成一个整数来实现的）
• 提高具有哈希结构的容器的效率
• 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的
• 两个引用，如果指向的不是同一个对象，则哈希值肯定是不一样的
• 哈希值主要根据地址号来的，但是不能将哈希值等价于地址。

===>>super

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

2、注意

（1）、访问父类的属性，但不能访问父类的private属性

（2）、访问父类的方法，不能访问父类的private方法

（3）、访问父类的构造器，只能放在构造器的第一句（只能有一句）

3、细节

（1）、调用父类的构造器的好处（分工明确，父类属性由父类初始化，子类的属性由子类初始化）

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

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

===>>this关键字和super关键字的区别

	区别点	this关键字	super关键字
1	访问属性	访问本类中的属性（如果本类中没有，则从父类中继续查找）	访问父类中的属性
2	调用方法	访问本类中的方法（若本类中没有，则从父类中找）	直接访问父类中的方法
3	调用构造器	调用本类构造器（必须放在第一行）	调用父类的构造器（放在子类构造器的第一行）
4	特殊	表示当前对象	子类中访问父类对象

【【注】】：在构造器中利用this关键字和super关键字分别调用本类的构造器、父类构造器时，不能同时使用，因为两者使用都是放在第一行。

package com.hspedu.super_;

public class Super01 {
     
    public static void main(String[] args) {
     
        B b = new B();
        b.hi();
        System.out.println("=======");
        b.sum();

    }
}
class A{
     
    public int n1 = 100;
    protected int n2 = 200;
    int n3 = 300;
    private int n4 = 400;
    public A(){
     

    }
    public A(String name){
     }
    public A(String name,int age){
     }
    public void test100(){
     }
    protected void test200(){
     }
    void test300(){
     }
    private void test400(){
      }
    public void cal(){
     
        System.out.println("A类的cal()");
    }
}
class B extends A{
     
    	public int n1 = 888;
    	public void hi(){
     
   		// 子类通过【super.父类属性名】访问父类的属性，不能访问父类的Private的属性
   		System.out.println("n1 = " + super.n1 + "\nn2 = " + super.n2 + "\nn3 = " + super.n3);
    }
    // 子类通过【super.父类方法名】访问父类的方法，但是不能访问父类的private的方法
    public void  ok(){
     
        super.test100();
        super.test200();
        super.test300();
    }
    // 子类同【super（参数列表）】访问父类的某个构造器，只能放在第一句，只能有一句
    public B(){
     
        // super();
        super("jack", 10);
    }
    public void sum(){
     
        System.out.println("B类的sum()");
        /*
        希望调用父类A的cal方法
        这时，因为本类B没有cal方法，可以使用以下三种方式进行调用
        用cal方法时，顺序时是，先找本类，如果有，则调用，如果没有就找父类（如果有，并可以调用，则调用）
        如果父类没有，则继续找父类的父类。
        注：如果查找方法的过程中，找到了，但是不能被调用，则报错cannot access
        如果没找到，则提示方法不存在
         */
        // cal();
        this.cal();// this表示当前，从当前开始找，等价于cal()
        super.cal();// super,这里没有查找本类的过程，直接在父类中查找
        System.out.println("=====");
        System.out.println(n1);// 先找本类的，本类没有再找父类
        System.out.println(this.n1);//，从本类开始查找等价于n1
        System.out.println(super.n1); // 直接从B的父类A开始查找
    }
    public void cal(){
     
        System.out.println("B类的cal()");
    }

}

【笔记来源于B站中韩顺平老师讲解的Java，老师讲的非常好，大家有兴趣可以去看看！！！这不是打广告】