java中this&super的用法小结.doc

. . . .
This: this关键字必须放在非静态方法里面
this关键字代表自身，在程序中主要的使用用途有以下几个方面：
1. 使用this关键字引用成员变量
在一个类的方法或构造方法部，可以使用“this.成员变量名〞这样的格式来引用成员变量名，有些时候可以省略，有些时候不能省略。
eg1. public class ReferenceVariable {
private int a;
public ReferenceVariable(int a){
this.a = a;
}
public int getA(){
return a;
}
public void setA(int a){
this.a = a;
}
}
按照Java语言的变量作用围规定，参数a的作用围为构造方法或方法部，成员变量a的作用围是类的部，这样在构造方法和setA方法部就存在了变量a的冲突，Java语言规定当变量作用围重叠时，作用域小的变量覆盖作用域大的变量。所以在构造方法和setA方法部，参数a起作用。
这样需要访问成员变量a那么必须使用this进展引用。当然，如果变量名不发生重叠，那么this可以省略。
但是为了增强代码的可读性，一般将参数的名称和成员变量的名称保持一致，所以this的使用频率在规的代码部应该很多。

2. 使用this关键字在自身构造方法部引用其它构造方法, this语句是是构造函数的第一个语句，它的形式是this(参数表〕
在一个类的构造方法部，也可以使用this关键字引用其它的构造方法，这样可以降低代码的重复，也可以使所有的构造方法保持统一，这样方便以后的代码修改和维护，也方便代码的阅读。
public class ReferenceConstructor {
int a;
public ReferenceConstructor(){
this(0); //调用了另一个构造方法
}
public ReferenceConstructor(int a){
this.a = a;
}
}
这里在不带参数的构造方法部，使用this调用了另外一个构造方法，其中0是根据需要传递的参数的值，当一个类部的构造方法比拟多时，可以只书写一个构造方法的部功能代码，然后其它的构造方法都通过调用该构造方法实现，这样既保证了所有的构造是统一的，也降低了代码的重复。
在实际使用时，需要注意的是，在构造方法部使用this关键字调用其它的构造方法时，调用的代码只能出现在构造方法部的第一行可执行代码。这样，在构造方法部使用this关键字调用构造方法最多会出现一次。

3. 使用this关键字代表自身类的对象
在一个类的部，也可以使用this代表自身类的对象，或者换句话说，每个类部都有一个隐含的成员变量，该成员变量的类型是该类的类型，该成员变量的名称是this。
eg1. public class ReferenceObject {
ReferenceObject instance;
public ReferenceObject(){
instance = this;
}
public void test){
System.out.println(this);
}
}
在构造方法部，将对象this的值赋值给instance，在test方法部，输出对象this的容，这里的this都代表自身类型的对象。

4. 使用this关键字引用成员方法
在一个类的部，成员方法之间的互相调用时也可以使用“this.方法名(参数)〞来进展引用，只是所有这样的引用中this都可以省略。

Super
1.在子类构造方法中要调用父类的构造方法，用“super(参数列表)〞的方式调用，参数不是必须的。同时还要注意的一点是：“super(参数列表)〞这条语句只能用在子类构造方法体中的第一行。 2.当子类方法中的局部变量或者子类的成员变量与父类成员变量同名时，也就是子类局部变量覆盖父类成员变量时，用“super.成员变量名〞来引用父类成员变量。当然，如果父类的成员变量没有被覆盖，也可以用“super.成员变量名〞来引用父类成员变量，不过这是不必要的。
3.当子类的成员方法覆盖〔重写〕了父类的成员方法时，也就是子类和父类有完全一样的方法定义〔但方法体可以不同〕，此时，用“super.方法名(参数列表)〞的方式访问父类的方法。
eg1. class Country{
　　　　String name;
　　　　void value()
　　　　 { name="China";
}　
}
class City extends Country{
　　　　String name;
　　　　void value()
　　　　{
　　　　　name="Beijing";
　　　　　super.value();
　　　　　System.out.print(name); //父类的成员变量被覆盖
　　　　　System.out.print(super.name); //输出父类成员变量
　　　　}
//输出的结果为 Beijing China

Static
1. 在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法。
class Simple
{
static void go()
{
System.out.println("Go...");
}
} 
public class Cal
{
public static void main(String[] args)
{
Simple.go();
}
}
//输出为Go. . .，调用一个静态方法就是“类名.方法名〞

2. 静态变量与静态方法类似。所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间。
eg1. 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("v1c="+v1.c+" v2.c="+v2.c);
}
}
//结果：v1.c=0 v2.c=0
v1.c=1 v2.c=1 //都显示为1，但是只调用了v1.inc()，可以证明它们共享一块存储区

eg2.class Value
{
static int c=0;
Value()
{
c=15;
}
Value(int i)
{
c=i;
}
static void inc()
{
c++;
}
}
class Count
{
public static void prt(String s)
{
System.out.println(s);
}

//static定义的变量会优先于任何其它非static变量,虽然v出现在v1和v2的前面，但是结果却是v1和v2的初始化在v的前面
Value v=new Value(10);
static Value v1,v2;

//在static{后面跟着一段代码，这是用来进展显式的静态变量初始化，这段代码只会初始化一//次，且在类被第一次装载时。
Static
{
prt("v1.c="+v1.c+" v2.c="+v2.c);
v1=new Value(27);
prt("v1.c="+v1.c+" v2.c="+v2.c);
v2=new Value(15);
prt("v1.c="+v1.c+" v2.c="+v2.c);
}
public static void main(String[] args)
{
Count ct=new Count();
prt("ct.c="+ct.v.c);//这句？
prt("v1.c="+v1.c+" v2.c="+v2.c);
v1.inc();
prt("v1.c="+v1.c+" v2.c="+v2.c);
prt("ct.c="+ct.v.c);
}
} 
//运行结果 v1.c=0 v2.c=0
v1.c=27 v2.c=27
v1.c=15 v2.c=15
ct.c=10
v1.c=10 v2.c=10
v1.c=11 v2.c=11
ct.c=11

3. 通常一个普通类不允许声明为静态的，只有一个部类才可以。这时这个声明为静态的部类可以直接作为一个普通类来使用，而不需实例一个外部类 .
eg1.public class StaticCls{
public static void main(String[] args){
//注意此处用法，创建一个类的部类对象OuterCls.InnerCls oi=new OuterCls.InnerCls();
}
}
class OuterCls{
public static class InnerCls{
InnerCls(){
System.out.println("InnerCls");
}
}
//结果：InnerCls

Final
Final成员：
1. 在类中定义变量加上final关键字，那便是说，这个变量一旦被初始化便不可改变〔对根本类型来说是其值不可变，而对于对象变量来说其引用不可再变〕。其初始化可以在两个地方，一是其定义处，，二是在构造函数中。这两个地方只能选其一。
2. 方法中的部类在用到方法中的参变量时，此参变也必须声明为final才可使用
eg. 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方法：
1. final方法不需要进展扩展，并且也不允许任何从此类继承的类来覆写这个方法，但是继承仍然可以继承这个方法〔即可以直接使用〕。
2. inline的机制，它会使你在调用final方法时，直接将方法主体插入到调用处，而不是进展例行的方法调用
Final类：
一个final类是无法被任何人继承。对于final类中的成员，你可以定义其为final，也可以不是final。而对于方法，由于所属类为final的关系，自然也就成了final型的。
常量的定义：final static
定义时候：屡次引用的字符串和数字等需要定义常量。
定义地点：根据引用的围〔同一个类、不同类〕：类中、单独的常量类或者接口。
如何定义：常量的定义处需要详细的注释。

9 / 9