java关键字汇总_java result关键字

（1）this

用法1：this.属性名

解决成员变量与局部变量名称冲突的问题
当一个类的属性（成员变量）名与访问该属性的方法参数名相同时，则需要使用 this 关键字来访问类中的属性，即引用当前类的实例变量，即this关键字来区分局部变量和实例变量，以区分类的属性和方法中的参数。

public class Teacher {
    private String name;    // 教师名称
    private double salary;    // 工资
    private int age;    // 年龄
}
// 创建构造方法，为上面的3个属性赋初始值
public Teacher(String name,double salary,int age) {
    this.name = name;    // 设置教师名称
    this.salary = salary;    // 设置教师工资
    this.age = age;    // 设置教师年龄
}
public static void main(String[] args) {
    Teacher teacher = new Teacher("王刚",5000.0,45);
    System.out.println("教师信息如下：");
    System.out.println("教师名称："+teacher.name+"\n教师工资："+teacher.salary+"\n教师年龄："+teacher.age);
}
//输出结果
教师信息如下
教师名称：王刚
教师工资：5000.0
教师年龄：45
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

this.name表示当前对象具有的变量name.等号右边的name表示通过参数传递过来的值。

用法2：this.方法名(参数)

让类中一个方法访问类中的另一个方法和变量
_this 可以代表任何对象，当 this 出现在某个方法体中时，它所代表的对象是不确定的，但它的类型是确定的，它所代表的只能是当前类的实例。只有当这个方法被调用时，它所代表的对象才被确定下来，_谁在调用这个方法，this 就代表谁。

// 定义一个run()方法，run()方法需要借助jump()方法
//
public class sports{
    String shoes;
    static String water;
public void run() {
    // 使用this引用调用run()方法的对象
    this.jump();
    this.shoes;
    sports.water;
    System.out.println("正在执行run方法");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

大部分时候，一个方法访问该类中定义的其他方法、成员变量时加不加 this 前缀的效果是完全一样的。

public void run() {
    jump();
    shoes;
    water;
    System.out.println("正在执行run方法");
}
1
2
3
4
5
6

• 注意：对于 static 修饰的方法而言，可以使用类来直接调用该方法，如果在 static 修饰的方法中使用 this 关键字，则这个关键字就无法指向合适的对象。
• 所以，static 修饰的方法中不能使用 this 引用。
• Java 语法规定，静态成员不能直接访问非静态成员。

用法3：this()访问构造方法

• this()不能再普通方法中使用，只能再构造方法中使用
• 在构造方法中使用时，必须是第一条语句
• 括号内可以有参数，有参数表明调用指定的构造方法

public class this3_person {
        int age;
        String name;
        int sex;
        String job;
        public this3_person(int age, String name, int sex){
            this.age=age;
            this.name=name;
            this.sex=sex;
        }
        public this3_person(int age, String name, int sex, String job) {
            this(age, name, sex);
            this.job = job;
        }
void display(){
    System.out.println(age+name+sex+job);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

test类

public class this3_test {
    public static void main(String[] args) {
        this3_person pe=new this3_person(2,"张三",0);
        this3_person per=new this3_person(3,"李四",1);
pe.display();
per.display();

    }
}
1
2
3
4
5
6
7
8
9

注意：this括号内的参数必须与成员变量的参数一致，不可自定义，而构造方法内的参数可以自定义

（2）static关键字

• static修饰的成员变量称为静态变量（类变量），修饰的方法称为静态方法（类方法），统称为静态成员，归整个类所有
• static修饰的方法或变量不需要依赖与对象来访问，可直接访问（输入方法名）或通过类名来访问。

静态变量

• 在类中定义静态的属性（成员变量），在 main() 方法中可以直接访问，也可以通过类名访问，还可以通过类的实例对象来访问。
• 在类的内部，可以在任何方法内直接访问静态变量。
• 在其他类中，可以通过类名访问该类中的静态变量。

public class static_person {
    public static String name="a";
    public static void main(String[] args) {
    String age="b";
        System.out.println(name+age);//直接访问name
        System.out.println(static_person.name+age);//通过 类名访问
        static_person s=new static_person();
        System.out.println(s.name);//通过类的实例去访
        }
    }
1
2
3
4
5
6
7
8
9
10

静态方法

见方法概述一节

（3）final关键字

1. final修饰变量，表示变量的值不可改变，即称为常量

• final 修饰的变量不能被赋值这种说法是错误的，严格的说法是，final 修饰的变量不可被改变，一旦获得了初始值，该 final 变量的值就不能被重新赋值。
• 使用 final 修饰的引用类型变量不能被重新赋值，但可以改变引用类型变量所引用对象的内容。例如一个数组名Arr所引用的数组对象，final 修饰后的 Arr 变量不能被重新赋值，但 Arr 所引用数组的数组元素可以被改变。

2. final修饰方法，表示方法不可被重写

• final 修饰的方法仅仅是不能被重写，并不是不能被重载。
• 如果子类中定义一个与父类 private方法有相同方法名、相同形参列表、相同返回值类型的方法，也不是方法重写，只是重新定义了一个新方法。因此，即使使用 final 修饰一个 private 访问权限的方法，依然可以在其子类中定义与该方法具有相同方法名、相同形参列表、相同返回值类型的方法。

3. final修饰类，表示该类不可被继承

• final不能用来修饰构造方法，因为“方法覆写”仅适用于类的成员方法，而不适用于类的构造方法，父类的构造方法和子类的构造方法之间不存在覆写关系。

（4）super关键字

1. 访问直接父类中被子类隐藏的同名成员变量。

super.成员变量名;

2. 访问直接父类中被子类覆写的同名成员方法。

super.成员方法名(参数表);

3. 调用直接父类的构造方法。构造方法不能被继承，_在子类构造方法中，第一条语句默认调用父类的构造方法，不写super()代表默认调用父类的无参构造方法。_因此，子类如果想使用父类的构造方法，必须在子类的构造方法中使用，关键字super来表示，而且super必须是子类构造方法中的第一条有效语句。

super（参数）; //该语句必须是构造方法的第一条有效语句。

class Father{
  private int x=10;
  public Father(int x) {
     //默认调用Father父类Object的空构造方法
     this.x=x;
  }
  public void show() { 
     System.out.println(this.x);
   }
}
class Son extends Father{
	private int y=20;
	public Son(int x,int y) {
		super(x);    //调用Father的构造方法
		this.y=y;		
	}
	public void show() {  //子类覆写父类的同名方法
		System.out.println(this.y);
	}
	public  void print() {
		this.show();//调用Son的show方法
		super.show();//调用father的show方法
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

（5）instanceof关键字

• 用于判断一个对象是否为一个类（或接口、抽象类、父类）的实例
• 格式：boolean result = obj instanceof Class
  • 返回值为true or false
  • Class 表示一个类或接口
  • obj 是 class 类（或接口）的实例或者子类实例