Java ---一些关键字

（一）this和super关键字

  Ⅰ  this

 ①含义：

this：当前对象

• 在构造器和非静态代码块中，表示正在new的对象

• 在实例方法中，表示调用当前方法的对象

②this用法：

• this.成员变量：表示当前对象的某个成员变量，而不是局部变量

• this.成员方法：表示当前对象的某个成员方法，完全可以省略this.

• this()或this(实参列表)：调用另一个构造器协助当前对象的实例化，只能在构造器首行，只会找本类的构造器，找不到就报错

Ⅱ super

①含义：

super：引用父类声明的成员

       无论是this和super都是和对象有关的。

②super的用法：

• super.成员变量：表示当前对象的某个成员变量，该成员变量在父类中声明的

• super.成员方法：表示当前对象的某个成员方法，该成员方法在父类中声明的

• super()或super(实参列表)：调用父类的构造器协助当前对象的实例化，只能在构造器首行，只会找直接父类的对应构造器，找不到就报错

 

 Ⅲ this和super关键字的用处 

 ⒈解决成员变量重名问题

具体做法： 

• ① 如果实例变量与局部变量重名，可以在实例变量前面加this.进行区别。

• ② 如果子类实例变量和父类实例变量重名，并且父类的该实例变量在子类仍然可见，在子类中要访问父类声明的实例变量需要在父类实例变量前加super.，否则默认访问的是子类自己声明的实例变量。

• ③ 如果父子类实例变量没有重名，只要权限修饰符允许，在子类中完全可以直接访问父类中声明的实例变量，也可以用this.实例访问，也可以用super.实例变量访问。

 具体代码：

class Father{
	int a = 10;
	int b = 11;
}
class Son extends Father{
	int a = 20;
    
    public void test(){
		//子类与父类的属性同名，子类对象中就有两个a
		System.out.println("子类的a：" + a);//20  先找局部变量找，没有再从本类成员变量找
        System.out.println("子类的a：" + this.a);//20   先从本类成员变量找
        System.out.println("父类的a：" + super.a);//10    直接从父类成员变量找
		
		//子类与父类的属性不同名，是同一个b
		System.out.println("b = " + b);//11  先找局部变量找，没有再从本类成员变量找，没有再从父类找
		System.out.println("b = " + this.b);//11   先从本类成员变量找，没有再从父类找
		System.out.println("b = " + super.b);//11  直接从父类局部变量找
	}
	
	public void method(int a, int b){
		//子类与父类的属性同名，子类对象中就有两个成员变量a，此时方法中还有一个局部变量a		
		System.out.println("局部变量的a：" + a);//30  先找局部变量
        System.out.println("子类的a：" + this.a);//20  先从本类成员变量找
        System.out.println("父类的a：" + super.a);//10  直接从父类成员变量找

        System.out.println("b = " + b);//13  先找局部变量
		System.out.println("b = " + this.b);//11  先从本类成员变量找
		System.out.println("b = " + super.b);//11  直接从父类局部变量找
    }
}
class Test{
    public static void main(String[] args){
        Son son = new Son();
		son.test();
		son.method(30,13);  
    }
}

总结：

• 变量前面没有super.和this.

  • 在构造器、代码块、方法中如果出现使用某个变量，先查看是否是——当前块——声明的 局部变量 ，

  • 如果不是局部变量，先从当前执行代码的  本类去找成员变量 

  • 如果从当前执行代码的本类中没有找到，会往上找——父类声明的成员变量 （权限修饰符允许在子类中访问的）

• 变量前面有this.

  • 通过this找成员变量时，先从当前执行代码的——本类去找成员变量 

  • 如果从当前执行代码的本类中没有找到，会往上找——父类声明的成员变量（权限修饰符允许在子类中访问的）

• 变量前面super.

  • 通过super找成员变量，直接从当前执行代码的直接父类去找成员变量（权限修饰符允许在子类中访问的）

  • 如果直接父类没有，就去父类的父类中找（权限修饰符允许在子类中访问的）

 

 ⒉ 解决成员方法重写后调用问题

 具体做法：

• 如果子类没有重写父类的方法，只有权限修饰符运行，在子类中完全可以直接调用父类的方法；

• 如果子类重写了父类的方法，在子类中需要通过super.才能调用父类被重写的方法，否则默认调用的子类重写的方法   

  具体代码：

class Father{
    int a = 10;
    int b = 11;
    public int getA() {
        return a;
    }
}
class Son extends Father{
    int a = 20;
    public int getA() {
        return a;
    }
    public void test(){
        System.out.println(getA());//10  本类没有找父类，执行父类中的getNum()
        System.out.println(this.getA());//10  本类没有找父类，执行父类中的getNum()
        System.out.println(super.getA());//10  本类没有找父类，执行父类中的getNum()
    }
}
 
class Test{
    public static void main(String[] args){
        Son son = new Son();
        son.test();
      
       /* 20
        20
        10        */
    }
}

总结：

 

• 方法前面没有super.和this.

  • 先从子类找匹配方法，如果没有，再从直接父类找，再没有，继续往上追溯

• 方法前面有this.

  • 先从子类找匹配方法，如果没有，再从直接父类找，再没有，继续往上追溯

• 方法前面有super.

  • 从当前子类的直接父类找，如果没有，继续往上追溯

（二）final关键字 

    final（最终的，不可更改的 ），在java中final可修饰类（表示这个类不能被继承，没有子类 ），方法（表示这个方法不能被子类重写 ），变量（final修饰某个变量（成员变量或局部变量），表示它的值就不能被修改，即常量，常量名建议使用大写字母）。

 具体代码：

  class Test {

    public static void main(String[] args){
        final int MIN_SCORE = 0;
        final int MAX_SCORE = 100;

        MyDate m1 = new MyDate();
        System.out.println(m1.getInfo());

        MyDate m2 = new MyDate(2022,2,14);
        System.out.println(m2.getInfo());
    }
}
final class MyDate{
    //没有set方法,必须有显示赋值的代码
    private final int year;
    private final int month;
    private final int day;

    public MyDate(){
        year = 1970;
        month = 1;
        day = 1;
    }

    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public int getYear() {
        return year;
    }

    public int getMonth() {
        return month;
    }

    public int getDay() {
        return day;
    }

    public String getInfo(){
        return year + "年" + month + "月" + day + "日";
    }
}
//public class CC extends MyDate{} Cannot inherit from final 'MyDate'

（三）native关键字

①定义：

      native（本地的），在Java中native只能修饰方法，表示这个方法的方法体代码不是用Java语言实现的，而是由C/C++语言编写的。但是对于Java程序员来说，可以当做Java的方法一样去正常调用它，或者子类重写它。

  

②用途：

它只能用在一个地方，方法的返回值类型前面，作为方法的一个修饰符。

③作用：

用它修饰方法，在.java中看不到这个方法的方法体。

④语法形式：

【修饰符】 class 类名{

   【权限修饰符】 native 返回值类型 方法名 (【形参列表】);

}

  class Test {
    public static void main(String[] args){
        Test t=new Test();
        System.out.println(t.hashCode());//同时按Ctrl+点击hashCode ->查看hashCode的源码
    }
}