Java中的static、代码块执行顺序以及练习

 引入

 首先我们来看一段代码

class Students{
    private String name;
    private String num;
    private String age;
    private double score;
    public static String classRoom = "tian208";
}
public class student {
    public static void main(String[] args) {
        System.out.println(Students.classRoom);

    }
}

当用public来修饰classRoom时，可以通过类名来访问其中Static的修饰的classRoom

但是变成了private修饰，在还未编译时就开始发出警告了，那我们该如何访问呢？

我们应该使用静态方法来访问，所谓的静态方法就是static所修饰的成员方法,通过静态方法来访问封装的静态成员变量，即可进行访问

class Students{
    private String name;
    private String num;
    private String age;
    private double score;
    private static String classRoom = "tian208";
    public static String getClassRoom(){
        return classRoom;
    }
}
public class student {
    public static void main(String[] args) {
        System.out.println(Students.getClassRoom());
    }
}

静态方法的一些特性

1.静态方法可以通过类名直接调用，不需要经过实例化，也可以通过实例化调用（但是多此一举，建议使用类名进行调用）

2.不能在静态方法中访问任何非静态变量

3.静态方法只能访问静态成员变量（非静态方法可以访问类中的所有成员变量）

4.静态方法中不可以引用非静态变量如this

5.静态方法中无法调用任何非静态方法（但是可以调用静态方法）

加上static变成静态方法即可 

static成员变量的初始化

（静态成员变量一般不在构造方法中来初始化）所以分为两种初始化，第一种就是就地初始化，像我们上面一样，在定义时直接给出初始值。第二种时静态代码块初始化。然后我们来介绍一下代码块

代码块

代码块分为普通代码块、构造代码块（实例代码块）、静态代码块（非实例代码块）、同步代码块（涉及到多线程这里不谈）

class Students{
    //实例成员变量
    private String name;
    private String num;
    private String age;
    private double score;
    //静态成员变量
    private static String classRoom = "tian208";
    //静态代码块
    static{
        classRoom = "tian209";
    }
    //实例代码块（也叫构造代码块）
    {
        this.name = "2";
        this.num = "32260";
        this.age = "20";
        this.score = 100;
    }
    //以下为静态成员方法
    public static void doClass(){
        System.out.println("上课");
    }
    public static String getClassRoom(){
        doClass();
        return classRoom;
    }
}
public class student {
    //普通代码块
    public static void main(String[] args) {
        System.out.println(Students.getClassRoom());
        Students S = new Students();
        System.out.println("==============");
        System.out.println(S.getClassRoom());
    }
}

1.普通代码块即第一在方法中的代码块

2.实例代码块一般用汉语初始化实例成员变量

3.静态代码块一般用于初始化静态成员变量

注意：静态代码块不管生成了多少个对象，只会执行一次

如果有多个静态代码块的话，编译器会按照定义的先后顺序来执行

实例代码块只有在创建对象时才会执行

代码块的执行顺序

练习题

public class Test { 
    public int aMethod(){
        static int i = 0;
        i++; 
        return i;
    } 
public static void main(String args[]){
    Test test = new Test(); 
    test.aMethod(); 
    int j = test.aMethod();
    System.out.println(j);
    } 
}

在方法内部不能用静态变量，所以以上代码会导致编译失败

public class Pvf{
    static boolean Paddy;
    public static void main(String args[]){
        System.out.println(Paddy);
    }
}

A.编译时错误

B.编译通过并输出结果false

C.编译通过并输出结果true

D.编译通过并输出结果null

 

stastic boolean默认为false所以会输出false

public class Test{

  private float f=1.0f;

  int m=12;

  static int n=1;

  public static void main(String args[]){

    Test t=new Test();

  }

}

如下哪些在main函数中使用是正确的（）

A.t.f = 3.0

B.this.n

C.Test.m

D.Test.n

答：A首先f被private修饰，但是同属一个类可以通过实例化访问，缺少了个3.0f

B中this.n的静态成员变量不能通过this访问

C首先m不是静态变量，必须通过实例化才能调用，静态变量可以通过类名来调用，所以D是对的

public class Test{
    static int cnt = 6;
    static{
        cnt += 9;
    }
    public static void main(String[] args）{
        System.out.println（"cnt = " + cnt);
    }
    static{
        cnt /=3;
    };
}

A.cnt=5

B. cnt=2

C.cnt=3

D.cnt=6

 

答：这题先执行静态代码块由上往下执行，cnt先加上9变成15然后再除3等于5最后执行main函数进行打印出cnt = 5

class Test{	
	public String toString() {
		System.out.print("aaa");
		return "bbb";
	}
}

public static void main(String[] args) {
    Test test = new Test();
	System.out.println(test);
}

A.aaa

B.bbb

C.aaabbb

D.bbbaaa

 

答：首先创建test变量调用了Test中不带参数的构造方法，先打印aaa，注意System.out.print这个是不换行的打印，所以打印完aaa后返回一个bbb最后打印bbb，可以知道输出结果为aaabbb