标签：
应用一：引用成员变量
public class Student{ //定义一个类，类的名字为student。
public Student(){ //定义 一个方法，名字与类相同故为构造方法 this(“luobo”) //这个this就是调用了下面的有参数的构造方法 } public Student(String name){ //定义一个带形式参数的构造方法 } }
如上面这个代码中，有一个成员变量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关键字其代表的就是对象的名字。掌握这个基本的原 理之后，再了解后续的一些高级应用，也就是水到渠成的事情了。
笔者这里只是以一个形式参数为例。其实如果是局部变量的话，也是相同的道理。如在上面的代 码中，name不是形式参数，而是一个局部变量。此时Java也会遇到相同的疑惑，即变量名name代表的到底 是局部变量还是形式参数?name=name到底代表的是什么含义?根据局部变量的作用域，在方法内部，如果 局部变量与成员变量同名的话，那么是以局部变量为准。可是在name=name这个赋值语句中，将局部变量 的值赋值给自己，显然并不是很合适。根据代码的含义，本来的意思应该是将局部变量赋值给成员变量。 为了更清晰的表达这个含义，为此最好采用如下的书写格式：this.name=name。这里的this关键字含义就 是对象名student。为此this.name就表示student.name。这就转换为正规的成员变量应用了。
应用二：调用类的构造方法
this(“luobo”)就是调用了
public Student(String name)方法
应用三：返回对象的值
this关键字除了可以引用变量或者成员方法之外，还有一个重大的作用就是返回类的引用。如在 代码中，可以使用return this，来返回某个类的引用。此时这个this关键字就代表类的名称。如这个代 码在上面这个student类中，那么这个代码其代表的含义就是return student。可见，这个this关键字除 了可以引用变量或者成员方法之外，还可以做为类的返回值。这才是this关键字最引人注意的地方。
在使用this关键字的时候，需要注意一个细节问题。在笔者谈到的第一个案例中，利用this关键 字来引用成员变量。即this.name=name。这个语句是将局部变量或则形式参数赋值给成员变量。其实，此 时这个this关键字不加也可以起到类似的效果。即上面这个语句中，与name=name这个语句时相同的。即 Java编译器会自动将第一个name当作成员变量来对待。而将等号右边的name变量当作形式参数。虽然这么 书写代码，可以节省this这几个字符的输入。但是对于代码的阅读是不利的。为此，从代码的阅读性考虑 ，如果成员变量与形式参数或者局部变量相同的话，那么最好是使用this.成员变量(成员方法)的方式来 引用成员变量。虽然语法上没有错误，但是作为一个高级的JAVA程序员，在代码书写的规范上，也不能够 忽视。
调用一个静态方法就是“类名.方法名”,静态方法的使用很简单如上所示。一般来说，静态方法常常为应用程序中的其它类提供一些实用工具所用，在Java的类库中大量的静态方法正是出于此目的而定义的。
静态变量
静态变量与静态方法类似。所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间，当然对于final则另当别论了。看下面这段代码：
class Value{ static int c=0; static void inc(){ c++; } } class Count{ public static void prt(String s){ System.out.println(s); } public static void main(String[] args){ Value v1,v2; v1=new Value(); v2=new Value(); prt("v1.c="+v1.c+" v2.c="+v2.c); v1.inc(); prt("v1.c="+v1.c+" v2.c="+v2.c); } } //结果如下： //v1.c=0 v2.c=0 //v1.c=1 v2.c=1
1 class Person{ 2 public int c; 3 private String name; 4 private int age; 5 protected void setName(String name){ 6 this.name=name; 7 } 8 protected void setAge(int age){ 9 this.age=age; 10 } 11 protected void print(){ 12 System.out.println("Name="+name+" Age="+age); 13 } 14 } 15 public class DemoSuper extends Person{ 16 public void print(){ 17 System.out.println("DemoSuper:"); 18 super.print(); 19 } 20 public static void main(String[] args){ 21 DemoSuper ds=new DemoSuper(); 22 ds.setName("kevin"); 23 ds.setAge(22); 24 ds.print(); 25 } 26 }
在DemoSuper中，重新定义的print方法覆写了父类的print方法，它首先做一些自己的事情，然后调用父类的那个被覆写了的方法。输出结果说明了这一点：
DemoSuper:
Name=kevin Age=22
这样的使用方法是比较常用的。另外如果父类的成员可以被子类访问，那你可以像使用this一样使用它，用“super.父类中的成员名”的方式，但常常你并不是这样来访问父类中的成员名的。
在构造函数中
构造函数是一种特殊的方法，在对象初始化的时候自动调用。在构造函数中，this和super也有上面说的种种使用方式，并且它还有特殊的地方，请看下面的例子：
class Person{ public static void prt(String s){ System.out.println(s); } Person(){ prt("A Person."); } Person(String name){ prt("A person name is:"+name); } } public class Chinese extends Person{ Chinese(){ super(); //调用父类构造函数（1） prt("A chinese.");//(4) } Chinese(String name){ super(name);//调用父类具有相同形参的构造函数（2） prt("his name is:"+name); } Chinese(String name,int age){ this(name);//调用当前具有相同形参的构造函数（3） prt("his age is:"+age); } public static void main(String[] args){ Chinese cn=new Chinese(); cn=new Chinese("kevin"); cn=new Chinese("kevin",22); } }
在这段程序中，this和super不再是像以前那样用“.”连接一个方法或成员，而是直接在其后跟上适当的参数，因此它的意义也就有了变化。super后加参数的是用来调用父类中具有相同形式的构造函数，如1和2处。this后加参数则调用的是当前具有相同参数的构造函数，如3处。当然，在Chinese的各个重载构造函数中，this和super在一般方法中的各种用法也仍可使用，比如4处，你可以将它替换为“this.prt”(因为它继承了父类中的那个方法）或者是“super.prt”（因为它是父类中的方法且可被子类访问），它照样可以正确运行。但这样似乎就有点画蛇添足的味道了。
最后，写了这么多，如果你能对“this通常指代当前对象，super通常指代父类”这句话牢记在心，那么本篇便达到了目的，其它的你自会在以后的编程实践当中慢慢体会、掌握。另外关于本篇中提到的继承，请参阅相关Java教程。
final在Java中并不常用，然而它却为我们提供了诸如在C语言中定义常量的功能，不仅如此，final还可以让你控制你的成员、方法或者是一个类是否可被覆写或继承等功能，这些特点使final在Java中拥有了一个不可或缺的地位，也是学习Java时必须要知道和掌握的关键字之一。
final成员
当你在类中定义变量时，在其前面加上final关键字，那便是说，这个变量一旦被初始化便不可改变，这里不可改变的意思对基本类型来说是其值不可变，而对于对象变量来说其引用不可再变。其初始化可以在两个地方，一是其定义处，也就是说在final变量定义时直接给其赋值，二是在构造函数中。这两个地方只能选其一，要么在定义时给值，要么在构造函数中给值，不能同时既在定义时给了值，又在构造函数中给另外的值。下面这段代码演示了这一点：
import java.util.List; import java.util.ArrayList; import java.util.LinkedList; public class Bat{ final PI=3.14; //在定义时便给址值 final int i; //因为要在构造函数中进行初始化，所以此处便不可再给值 final List list; //此变量也与上面的一样 Bat(){ i=100; list=new LinkedList(); } Bat(int ii,List l){ i=ii; list=l; } public static void main(String[] args){ Bat b=new Bat(); b.list.add(new Bat()); //b.i=25; //b.list=new ArrayList(); System.out.println("I="+b.i+" List Type:"+b.list.getClass()); b=new Bat(23,new ArrayList()); b.list.add(new Bat()); System.out.println("I="+b.i+" List Type:"+b.list.getClass()); } }
此程序很简单的演示了final的常规用法。在这里使用在构造函数中进行初始化的方法，这使你有了一点灵活性。如Bat的两个重载构造函数所示，第一个缺省构造函数会为你提供默认的值，重载的那个构造函数会根据你所提供的值或类型为final变量初始化。然而有时你并不需要这种灵活性，你只需要在定义时便给定其值并永不变化，这时就不要再用这种方法。在main方法中有两行语句注释掉了，如果你去掉注释，程序便无法通过编译，这便是说，不论是i的值或是list的类型，一旦初始化，确实无法再更改。然而b可以通过重新初始化来指定i的值或list的类型，输出结果中显示了这一点：
I=100 List Type:class java.util.LinkedList
I=23 List Type:class java.util.ArrayList
还有一种用法是定义方法中的参数为final，对于基本类型的变量，这样做并没有什么实际意义，因为基本类型的变量在调用方法时是传值的，也就是说你可以在方法中更改这个参数变量而不会影响到调用语句，然而对于对象变量，却显得很实用，因为对象变量在传递时是传递其引用，这样你在方法中对对象变量的修改也会影响到调用语句中的对象变量，当你在方法中不需要改变作为参数的对象变量时，明确使用final进行声明，会防止你无意的修改而影响到调用方法。
另外方法中的内部类在用到方法中的参变量时，此参变也必须声明为final才可使用，如下代码所示：
public class INClass{ void innerClass(final String str){ class IClass{ IClass(){ System.out.println(str); } } IClass ic=new IClass(); } public static void main(String[] args){ INClass inc=new INClass(); inc.innerClass("Hello"); } }
final方法
将方法声明为final，那就说明你已经知道这个方法提供的功能已经满足你要求，不需要进行扩展，并且也不允许任何从此类继承的类来覆写这个方法，但是继承仍然可以继承这个方法，也就是说可以直接使用。另外有一种被称为inline的机制，它会使你在调用final方法时，直接将方法主体插入到调用处，而不是进行例行的方法调用，例如保存断点，压栈等，这样可能会使你的程序效率有所提高，然而当你的方法主体非常庞大时，或你在多处调用此方法，那么你的调用主体代码便会迅速膨胀，可能反而会影响效率，所以你要慎用final进行方法定义。
final类
当你将final用于类身上时，你就需要仔细考虑，因为一个final类是无法被任何人继承的，那也就意味着此类在一个继承树中是一个叶子类，并且此类的设计已被认为很完美而不需要进行修改或扩展。对于final类中的成员，你可以定义其为final，也可以不是final。而对于方法，由于所属类为final的关系，自然也就成了final型的。你也可以明确的给final类中的方法加上一个final，但这显然没有意义。
下面的程序演示了final方法和final类的用法：
final class final{ final String str="final Data"; public String str1="non final data"; final public void print(){ System.out.println("final method."); } public void what(){ System.out.println(str+" "+str1); } } public class FinalDemo { //extends final 无法继承 public static void main(String[] args){ final f=new final(); f.what(); f.print(); } }
以上就是本人最近学习心得，原作者写的太好，所以基本没做修改，原文地址如下：
http://www.cnblogs.com/-cyb/articles/Java-this.html
http://www.cnblogs.com/wjun530/archive/2007/09/15/893802.html
学习Java基础的一些收获一（this、static、super、final）
标签：
原文地址：http://www.cnblogs.com/halamadrid/p/4344860.html
