JAVA中的关键字

this关键字

this关键字主要有三个应用：

(1)this调用本类中的属性，也就是类中的成员变量；

(2)this调用本类中的其他方法；

(3)this调用本类中的其他构造方法，调用时要放在构造方法的首行。

public class Student {
	String name; // 定义一个成员变量name
	public void setName(String name) { // 定义一个参数(局部变量)name
        //这个this一定不能省略
		this.name = name; // 将局部变量的值传递给成员变量
	}
   
    public void fun(){
        //这个this可以省略,可以写成 setName(“张三”);
		this.setName("张三"); //调用setName()的方法
	}
}

如上面这段代码中，有一个成员变量name，同时在方法中有一个形式参数，名字也是name，然后在方法中将形式参数name的值传递给成员变量name，虽然我们可以看明白这个代码的含义，但是作为Java编译器它是怎么判断的呢?到底是将形式参数name的值传递给成员变量name，还是反过来将成员变量name的值传递给形式参数name呢?也就是说，两个变量名字如果相同的话，那么Java如何判断使用哪个变量?此时this这个关键字就起到作用了。this这个关键字其代表的就是对象中的成员变量或者方法。也就是说，如果在某个变量前面加上一个this关键字，其指的就是这个对象的成员变量或者方法，而不是指成员方法的形式参数或者局部变量。为此在上面这个代码中，this.name代表的就是对象中的成员变量，又叫做对象的属性，而后面的name则是方法的形式参数，代码this.name=name就是将形式参数的值传递给成员变量。这就是上面这个代码的具体含义。

一般情况下，在Java语言中引用成员变量或者成员方法都是以对象名.成员变量或者对象名.成员方法的形式。不过有些程序员即使在没有相同变量的时候，也喜欢使用this.成员变量的形式来引用变量，这主要是从便于代码的阅读考虑的。一看到这个this关键字就知道现在引用的变量是成员变量或者成员方法，而不是局部变量。这无形中就提高了代码的阅读性。不过话说回来，这是this关键字在Java语言中的最简单的应用。从这个应用中，我们可以看出this关键字其代表的就是对象的名字。

static 关键字

static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。

只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象时，不生成static变量的副本，而是类的所有实例共享同一个static变量。

static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：

类名.静态方法名(参数列表…)

类名.静态变量名

用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块（用处非常大）。  

public class TestStatic1 {
	int a;  //a 是属性,是对象的成员变量,每一个对象都会有自己的属性
	static int b; //这个是类变量,所有的该类的对象都共享它
	
	public static void main(String[] args) {
		//创建本类的一个对象
		TestStatic1 t1 = new TestStatic1();
		t1.a = 10; //给属性赋值
		t1.b = 20;//给类变量赋值,也可以写成: TestStatic1.b=20;
		
		//创建本类的另外一个对象
		TestStatic1 t2 = new TestStatic1();
		t2.a = 5; 
		t2.b = 8;
		
		System.out.println("t1对象:t1.a="+t1.a);
		System.out.println("t1对象:t1.b="+t1.b);
		
		System.out.println("t2对象:t2.a="+t2.a);
		System.out.println("t2对象:t2.b="+t2.b);
		
	}
}

运行结果 

结论:

通过上面的运行结果,我们发现t1对象中a的属性的值是10,而t2对象中a的属性的值是5,它们是不一样的,这说明每个对象都有它自己的属性,这就像我们每个人都有自己的姓名一样,都是大家又会发现t1对象中的b,与t2对象中的b的值竟然一样,这是为什么呢?而且t1给b赋的值是20,而t2给b赋的值是8,最后它们都变成了8,这么神奇.

这是因为b的前面是不是用了一个static修饰的关键字,如果用static修饰的变量,那么这个变量将不会作为类的属性,而是变成了类变量,被这个类所有的对象所共享,也就是说, TestStatic1类中的b只有一个,当执行t1.b=20时,先把20的值赋给b,这个时候,所有TestStatic1类的对象来访问b都是20,当程序运行到t2.b=8时,就把b的值改为8了,那此时TestStatic1类的对象来访问b都是8,这也就是为什么t1.b是8,t2.b的值也是8.

静态方法

静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员方法)，只能访问所属类的静态成员变量和成员方法。

public class TestStatic2 {
	int a;
	static int b;
	public static void fun1(){
		System.out.println("这是TestStatic2类的静态方法fun1");
	}
	
	public static void fun2(){
	    //	a=10;// 不能直接访问a,因为static修饰的方法只能直接访问本类的静态的成员变量
		//fun3();//报错,不能直接访问fun3,因为static修饰的方法只能直接访问本类的静态方法
		b=10;//可以访问,因为b是静态的
		fun1();//可以方法
		System.out.println("这是TestStatic2类的静态方法fun2");
	}
	
	public void fun3(){
		System.out.println("这是TestStatic2类的非静态方法fun3");
	}
}

public class TestStatic3 {
	public static void main(String[] args) {
		//访问TestStatic2总的fun2方法,只需要使用类名.fun2()
		//因为fun2是静态方法
		TestStatic2.fun2();
		//调用TestStatic2非静态方法,只能使用对象名.方法名()来调用
		System.out.println("====================");
		TestStatic2 t1 = new TestStatic2();
		t1.fun3();
	}
}

在使用类的静态方法时，我们要注意以下几点：

1. 在静态方法里只能直接调用同类中其它的静态成员（包括变量和方法），而不能直接访问类中的非静态成员。这是因为，对于非静态的方法和变量，需要先创建类的实例对象后才可使用，而静态方法在使用前不用创建任何对象。

2. 静态方法不能以任何方式引用this和super关键字（super 关键字在下一章讲解）。与上面的道理一样，因为静态方法在使用前不用创建任何实例对象，当静态方法被调用时，this所引用的对象根本就没有产生。

3. main()方法是静态的，因此JVM 在执行main 方法时不创建main 方法所在的类的实例对象，因而在main()方法中，我们不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员，这种情况，我们在以后的例子中会多次碰到。

对于上面的几个注意点，不必要死记硬背，只要从原理上去想为什么，反而很容易记住。