您的位置：首页 > 编程语言 > Java开发

javaSE学习笔记之几个关键字this、super、final、static

2015-07-02 20:49 706 查看

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

this:

1. 解决局部变量与成员变量同名问题

2. 解决方法参数与成员变量同名问题

3. 调用该类的另一个构造方法：在一个类的构造方法中调用另一个构造方法，可以使用this（）的方式调用，括号中的参数表示目标构造方法的参数。this（）必须作为构造方 法的第一条语句，this只能在非static中使用。

public class ConstructorOverload
{
public ConstructorOverload()
{
this(3);

System.out.println("test");
}

public ConstructorOverload(int i)
{
System.out.println(++i);
}

public static void main(String[] args)
{
ConstructorOverload col = new ConstructorOverload();

}
}


super

1. 子类使用super（）显示调用父类的某个构造方法，super（）也必须作为构造方法的第一条语句。super（参数）

public class SuperTest2
{
public static void main(String[] args)
{
Dog dog = new Dog();
dog.run();
}
}

class Animal
{
public void run()
{
System.out.println("animal is running");
}
}

class Dog extends Animal
{
public void run()
{
super.run(); //调用父类的run方法}}




2.        在子类中调用父类中被覆盖的方法： super.methodName(参数)

3.          在子类中访问父类中被隐藏的成员变量： super.variableName

final

1.        修饰属性，表示该属性必能被改写（常量）：当修饰基本数据类型时，表示值不能发生改变，当修饰引用类型时，表示该应用类型不能指向其他对象了（所指的地址不能             改变），但该引用所指向的对象的内容是可以发生变化的。

2.        修饰方法：终态方法，不能被重写（override）。

public class FinalTest
{
public static void main(String[] args)
{
H h = new H();
h.output();
}
}

class G
{
public final void output() //不能被重写（override）
{
System.out.println("G");
}
}

class H extends G
{
public void output()
{
System.out.println("H");
}
}


3.        修饰类：终态类，不能被继承（exetend）

static
1.        修饰属性：无论一个类生成了多少个对象，所有这些对象，共同使用唯一一份静态的成员变量；一对象对该静态成员变量进行了修改，其他对象的该静态成员变量的值也             会随之发生变化。可以使用类名.方法名访问

public class StaticTest
{
public static void main(String[] args)
{
/*
MyStatic myStatic = new MyStatic();

MyStatic myStatic2 = new MyStatic();

myStatic.a = 10;

System.out.println(myStatic2.a);
*/

MyStatic myStatic = new MyStatic();

MyStatic.a = 10;

System.out.println(myStatic.a);
}
}

class MyStatic
{
static int a;
}


2.        修饰方法：静态方法只能继承，不能被子类重写。可使用类名.方法名访问

public class StaticTest3
{
public static void main(String[] args)
{
M m = new N();

m.output();
}
}

class M
{
public <span style="font-family: Arial, Helvetica, sans-serif;">static  </span>void output()
{
System.out.println("M");
}
}

class N extends M
{
public static void output()
{
System.out.println("N");
}
}
输出j结果：M   //若不用static修饰则输出N

3.        修饰代码块

  静态代码块的作用是完成一些初始化工作。首先执行静态代码块，然后执行构造方法。 静态代码块在类被加载的时候执行，而构造方法是在生成对象的时候执行；要想调用某个类来生成对象，首先需要将类加载到 Java 虚拟机上（JVM），然后由 JVM 加载这个类来生成对象。
 类的静态代码块只会执行一次，是在类被加载的时候执行的，因为每个类只会被加载一次，所以静态代码块也只会被执行一次；而构造方法则不然，每次生成一个对象的时候都会调用类的构造方法，所以 new 一次就会调用构造方法一次
如果继承体系中既有构造方法，又有静态代码块，那么首先执行最顶层的类的静态代码块，一直执行到最底层类的静态代码块，然后再去执行最顶层类的构造方法，一直执行到最底层类的构造方法。注意：静态代码块只会执行一次。

public class StaticTest
{
public static void main(String[] args)
{
new S();
new S();
}
}

class P
{
static
{
System.out.println("P static block");
}

public P()
{
System.out.println("P constructor");
}
}

class Q extends P
{
static
{
System.out.println("Q static block");
}

public Q()
{
System.out.println("Q constructor");
}
}

class S extends Q
{
static
{
System.out.println("S static block");
}

public S()
{
System.out.println("S constructor");
}
}


4.小结：不能在静态方法中访问非静态成员变量；可以在静态方法中访问静态的成员变量。可以在非静态方法中访问静态的成员变量。（静态的只能访问静态的；非静态的可以访问一切）
                                            

                                        

                        
                        内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息 
                    

                    

                    

                        

                         标签： 
                                                

                        

                    


                

            


            

                
相关文章推荐

                

                
            

        

        

            

            
            

                

                    
新的分享

                    

                        
                    

                

            


            

                

                    
章节导航