java静态代码块关键字 java类静态代码 构造代码执行时间

java中关键字 this 和super的作用及用法

Java关键字this、super使用总结

创新互联公司主要从事成都网站制作、网站建设、外贸网站建设、网页设计、企业做网站、公司建网站等业务。立足成都服务习水,十余年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:18980820575

一、this

Java关键字this只能用于方法方法体内。当一个对象创建后，Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是this。因此，this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this，这在“Java关键字static、final使用总结”一文中给出了明确解释。并且this只和特定的对象关联，而不和类关联，同一个类的不同对象有不同的this。下面给出一个使用this的综合实例，以便说明问题：

package org.leizhimin;

public class Test6 {

private int number;

private String username;

private String password;

private int x = 100;

public Test6(int n) {

number = n; // 这个还可以写为: this.number=n;

}

public Test6(int i, String username, String password) {

// 成员变量和参数同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.

this.username = username;

this.password = password;

}

// 默认不带参数的构造方法

public Test6() {

this(0, "未知", "空"); // 通过this调用另一个构造方法

}

public Test6(String name) {

this(1, name, "空"); // 通过this调用另一个构造方法

}

public static void main(String args[]) {

Test6 t1 = new Test6();

Test6 t2 = new Test6("游客");

t1.outinfo(t1);

t2.outinfo(t2);

}

private void outinfo(Test6 t) {

System.out.println("-----------");

System.out.println(t.number);

System.out.println(t.username);

System.out.println(t.password);

f(); // 这个可以写为: this.f();

}

private void f() {

// 局部变量与成员变量同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.

int x;

x = this.x++;

System.out.println(x);

System.out.println(this.x);

}

//返回当前实例的引用

private Test6 getSelf() {

return this;

}

}

运行结果如下：

-----------

未知

空

100

101

-----------

游客

空

100

101

通过上面的例子，说明在什么情况下需要用到this：

第一、通过this调用另一个构造方法，用发是this(参数列表)，这个仅仅在类的构造方法中，别的地方不能这么用。

第二、函数参数或者函数中的局部变量和成员变量同名的情况下，成员变量被屏蔽，此时要访问成员变量则需要用“this.成员变量名”的方式来引用成员变量。当然，在没有同名的情况下，可以直接用成员变量的名字，而不用this，用了也不为错，呵呵。

第三、在函数中，需要引用该函所属类的当前对象时候，直接用this。

其实这些用法总结都是从对“this是指向对象本身的一个指针”这句话的更深入的理解而来的，死记不然容易忘记而且容易搞错，要理解！

二、super

super关键和this作用类似，是被屏蔽的成员变量或者成员方法或变为可见，或者说用来引用被屏蔽的成员变量和成员成员方法。

不过super是用在子类中，目的是访问直接父类中被屏蔽的成员，注意是直接父类（就是类之上最近的超类）。下面是一个综合运用super的例子，有两个类：一个Father类，一个Father类的子类Son，通过这两个类完全演示了super的用法，一下是代码：

package org.leizhimin;

public class Father {

public String v="Father";

public String x="输出了Father类的public成员变量x!!!";

public Father() {

System.out.println("Father构造方法被调用!");

}

public Father(String v){

this.v="Father类的带参数构造方法!运行了.";

}

public void outinfo(){

System.out.println("Father的outinfo方法被调用");

}

public static void main(String[] args) {

// TODO 自动生成方法存根

}

}

package org.leizhimin;

public class Son extends Father{

public String v="Son";

public Son() {

super(); //调用超类的构造方法,只能放到第一行.

System.out.println("Son无参数构造方法被调用!");

//super(); //错误的,必须放到构造方法体的最前面.

}

public Son(String str){

super(str);

System.out.println("Son带参数构造方法被调用!");

}

//覆盖了超类成员方法outinfo()

public void outinfo(){

System.out.println("Son的outinfo()方法被调用");

}

public void test(){

String v="哈哈哈哈!"; //局部变量v覆盖了成员变量v和超类变量v

System.out.println("------1-----");

System.out.println(v); //输出局部变量v

System.out.println(this.v); //输出(子类)成员变量v

System.out.println(super.v); //输出超类成员变量v

System.out.println("------2-----");

System.out.println(x); //输出超类成员变量v,子类继承而来

System.out.println(super.x); //输出超类成员变量v

System.out.println("------3-----");

outinfo(); //调用子类的outinfo()方法

this.outinfo(); //调用子类的outinfo()方法

super.outinfo(); //调用父类的outinfo()方法

}

public static void main(String[] args) {

new Son().test();

}

}

子类Son运行结果：

Father构造方法被调用!

Son无参数构造方法被调用!

------1-----

哈哈哈哈!

Son

Father

------2-----

输出了Father类的public成员变量x!!!

输出了Father类的public成员变量x!!!

------3-----

Son的outinfo()方法被调用

Son的outinfo()方法被调用

Father的outinfo方法被调用

说明：次例子仅仅为了说明super的用法，实际在设计类的时候一般都尽可能私有(private)化。

通过上面的例子，下面总结一下super的用法：

第一、在子类构造方法中要调用父类的构造方法，用“super(参数列表)”的方式调用，参数不是必须的。同时还要注意的一点是：“super(参数列表)”这条语句只能用在子类构造方法体中的第一行。

第二、当子类方法中的局部变量或者子类的成员变量与父类成员变量同名时，也就是子类局部变量覆盖父类成员变量时，用“super.成员变量名”来引用父类成员变量。当然，如果父类的成员变量没有被覆盖，也可以用“super.成员变量名”来引用父类成员变量，不过这是不必要的。

第三、当子类的成员方法覆盖了父类的成员方法时，也就是子类和父类有完全相同的方法定义（但方法体可以不同），此时，用“super.方法名(参数列表)”的方式访问父类的方法。

Java代码中，如何在静态（由static关键字修饰）方法或静态代码块中（static{}）获取当前类的位置。。。

这是不可能的，static方法不隶属于任何类/对象，所以无从获取。static的内容由JVM统一管理，甚至都不在堆上.

看了你的补充说明。如果是想知道本静态方法在哪个类被实现真的不可行，你的程序设计有错误。如果你是想读取工作目录下的一个文件，你只能知道改工作目录的磁盘路径，而文件名（类名）必须手工写明，无法自动获取。

java 方法 中 { } 括起来的代码 有什么特别？

一、普通代码块

直接在一个方法中出现的{}就称为普通代码块，例子程序如下：

public class CodeDemo01{

public static void main(String[] args){

//普通代码块

{

int x = 10;

System.out.println("x=" + x);

}

int x = 100;

System.out.println("x=" + x);

}

}

二、构造代码块

直接在类中定义的没有加static关键字的代码块{}称为构造代码块，例子程序如下：

public class CodeDemo02{

public CodeDemo02(){

System.out.println("========这是构造方法=========");

}

//这是构造代码块，而且在new对象时，构造代码块优先构造方法执行

{

System.out.println("=========这是构造块!=========");

}

public static void main(String[] args){

new CodeDemo02();

new CodeDemo02();

}

}

三、静态代码块

使用static关键字声明的代码块称为静态代码块，静态块的主要目的是用来为静态属性初始化，例子程序如下：

public class CodeDemo03

{

static{

System.out.println("这是主类中的静态代码块!");

}

public static void main(String[] args){

new Demo();

new Demo();

new Demo();

}

}

class Demo

{

static{

System.out.println("这是Demo类中的静态代码块!");

}

{

System.out.println("这是Demo类中的构造块!");

}

public Demo(){

System.out.println("这是构造方法!");

}

}

静态块优先于主方法的执行，静态块优先于构造方法的执行，而且只执行一次！

四、同步代码块

同步代码块主要出现在多线程中。