Java面向对象（高级）-- 类的成员之四：代码块

文章目录

一、回顾
- （1）三条主线
- （2）类中可以声明的结构及作用
- - 1.结构
  - 2.作用
二、代码块
- （1）代码块的修饰与分类
- - 1. 代码块的修饰
  - 2. 代码块的分类
  - 3. 举例
- （2）静态代码块
- - 1. 语法格式
  - 2. 静态代码块的特点
- （3）非静态代码块
- - 1. 语法格式
  - 2. 非静态代码块的作用
  - 3. 非静态代码块的意义
  - 4. 非静态代码块的执行特点
- （4）举例
- - 1. 举例1
  - 2. 举例2
  - 3. 举例3
  - 4. 举例4
  - 5. 举例5
  - 6. 举例6
  - 7. 举例7
  - 8. 举例8
- （5）重点总结
- - 1. 静态代码块
  - 2. 非静态代码块
三、练习
- （1）练习
- （2）补充

一、回顾

（1）三条主线

面向对象三条主线：

①类及类的内部成员（属性、方法、构造器；代码块、内部类）

②封装、继承、多态

③关键字

（2）类中可以声明的结构及作用

1.结构

类中可以声明的结构：属性、方法、构造器；代码块（或初始化块）、内部类。

代码块：从长的样子来看的（就是封装了一下代码）

初始化块：从它的作用的角度

2.作用

属性：基本的变量值

方法：用来体现类的功能

构造器：用来实例化创建对象

代码块（或初始化块）：用来初始化类或对象的信息（即初始化类或对象的成员变量）

二、代码块

（1）代码块的修饰与分类

如果成员变量想要初始化的值不是一个硬编码的常量值，而是需要通过复杂的计算或读取文件、或读取运行环境信息等方式才能获取的一些值，该怎么办呢？

此时，可以考虑代码块（或初始化块）。

1. 代码块的修饰

方法可以被修饰的有很多，比如权限修饰符、返回值类型…

代码块可以被什么修饰呢？只能使用static进行修饰。（没有其他修饰了）

2. 代码块的分类

①静态代码块：一个类中代码块若有修饰符，则只能被static修饰，称为静态代码块(static block)

//静态代码块
static{
    
}

②非静态代码块：没有使用static修饰的，为非静态代码块。

//非静态代码块
{
    
}

3. 举例

如下：

package yuyi05;

/**
 * ClassName: BlockTest
 * Package: yuyi05
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/19 0019 8:47
 */
public class BlockTest {

}

class Person{
    //属性
    String name;
    int age;

    //方法
    public void eat(){
        System.out.println("民以食为天");
    }

    //构造器
    public Person(){

    }


    //非静态代码块
    {
        System.out.println("非静态代码块1");
    }

    //静态代码块
    static{
        System.out.println("静态代码块1");
    }

}

那么代码块什么时候执行呢？

之前说过方法，方法有名字，什么时候调用什么时候就执行。方法又分为静态与非静态，这里的eat()是非静态，调用它的话就需要创建对象。

首先造个对象，再通过对象去调用eat()方法。如下：

public class BlockTest {
    public static void main(String[] args) {
        Person p1=new Person();
        p1.eat();
    }
}

执行就可以输出结果了：

可以看到，除了调用了eat()方法之外，它将静态代码块和非静态代码块都执行了。

代码块都没有名字了，它就不会像方法一样调它的时候执行。既然没有名字，主动去调用吧，都不知道该怎么调。

所以这样的结构，不是我们主动调用的。它是在某个特定的场景下自动执行的。

那么静态代码块和非静态代码块在什么场景下执行呢？请看后面👇

（2）静态代码块

如果想要为静态变量初始化，可以直接在静态变量的声明后面直接赋值，也可以使用静态代码块。

1. 语法格式

在代码块的前面加static，就是静态代码块。

【修饰符】 class 类{
	static{
        静态代码块
    }
}

2. 静态代码块的特点

可以有输出语句。
可以对类的属性、类的声明进行初始化操作。
不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。
若有多个静态的代码块，那么按照从上到下的顺序依次执行。
静态代码块的执行要先于非静态代码块。
静态代码块随着类的加载而执行（它没有名字，就不能显示地调用它）。
由于类的加载只会执行一次，进而静态代码块的执行，也只会执行一次。

（3）非静态代码块

1. 语法格式

【修饰符】 class 类{
    {
        非静态代码块
    }
    【修饰符】 构造器名(){
    	// 实例初始化代码
    }
    【修饰符】 构造器名(参数列表){
        // 实例初始化代码
    }
}

2. 非静态代码块的作用

和构造器一样，也是用于实例变量的初始化等操作。

3. 非静态代码块的意义

如果多个重载的构造器有公共代码，并且这些代码都是先于构造器其他代码执行的，那么可以将这部分代码抽取到非静态代码块中，减少冗余代码。

4. 非静态代码块的执行特点

可以有输出语句。
可以对类的属性、类的声明进行初始化操作。
除了调用非静态的结构外，还可以调用静态的变量或方法。
若有多个非静态的代码块，那么按照从上到下的顺序依次执行。
每次创建对象的时候，都会执行一次。且先于构造器执行。

（4）举例

1. 举例1

public class BlockTest {
    public static void main(String[] args) {
        //在创建对象之前，通过类调用静态属性
        System.out.println(Person.info);    //调用静态属性，既然调用了，那么一定会加载Person类

        //在加载类的时候，静态代码块就会被执行
    }
}

class Person{

    static String info="我是一个人"; //静态属性

    //构造器
    public Person(){

    }

    //非静态代码块
    {
        System.out.println("非静态代码块1");
    }

    //静态代码块
    static{
        System.out.println("静态代码块1");
    }

}

输出结果：

在main方法中调用静态属性，既然调用了，那么一定会加载Person类。

而在加载类的时候，静态代码块就会被执行。所以输出结果有静态代码块中的内容。

静态代码块随着类的加载而执行。

2. 举例2

System.out.println(Person.info);

虽然此语句执行了两次，但是类只加载一次，静态代码块也只加载一次。（类不加载了，静态代码块自然也不会去执行）

public class BlockTest {
    public static void main(String[] args) {
        //在创建对象之前，通过类调用静态属性
        System.out.println(Person.info);    //调用静态属性，既然调用了，那么一定会加载Person类
    	System.out.println(Person.info); 	//虽然此语句执行了两次，但是类只加载一次，静态代码块也只加载一次
    }
}

class Person{

    static String info="我是一个人"; //静态属性

    //构造器
    public Person(){

    }

    //非静态代码块
    {
        System.out.println("非静态代码块1");
    }

    //静态代码块
    static{
        System.out.println("静态代码块1");
    }

}

输出结果：

可以看到，“静态代码块1”只输出了一句。

类的加载只会执行一次，进而静态代码块也只会调用一次。

3. 举例3

在刚才的演示中，可以发现非静态代码块是没有执行的，因为它是非静态的，与类的加载没啥关系，只会跟**对象的加载（创建）**有关。

比如创建了一个当前类的对象p1，既然对象创建了，那么非静态的变量就会在堆空间中被分配了，非静态的方法也就可以通过对象来调用了，同样，非静态代码块也会执行了。

比如：

public class BlockTest {
    public static void main(String[] args) {
        //在创建对象之前，通过类调用静态属性
        System.out.println(Person.info);    //调用静态属性，既然调用了，那么一定会加载Person类
        System.out.println(Person.info);

        Person p1=new Person();
        //p1.eat();
    }
}

class Person{
    //属性
    String name;
    int age;

    static String info="我是一个人"; //静态属性

    //方法
    public void eat(){
        System.out.println("民以食为天");
    }

    //构造器
    public Person(){

    }


    //非静态代码块
    {
        System.out.println("非静态代码块1");
    }

    //静态代码块
    static{
        System.out.println("静态代码块1");
    }

}

输出结果：

非静态代码块随着对象的创建而执行。

4. 举例4

若是创建类的多个对象会怎么样呢？

比如此时又创建了一个对象p2：

package yuyi05;

public class BlockTest {
    public static void main(String[] args) {
        //在创建对象之前，通过类调用静态属性
        System.out.println(Person.info);    //调用静态属性，既然调用了，那么一定会加载Person类
        System.out.println(Person.info);

        Person p1=new Person();
        Person p2=new Person();
        //p1.eat();
    }
}

class Person{
    //属性
    String name;
    int age;

    static String info="我是一个人"; //静态属性

    //方法
    public void eat(){
        System.out.println("民以食为天");
    }

    //构造器
    public Person(){

    }


    //非静态代码块
    {
        System.out.println("非静态代码块1");
    }

    //静态代码块
    static{
        System.out.println("静态代码块1");
    }

}

输出结果：

每创建当前类的一个实例，就会执行一次非静态代码块

5. 举例5

静态代码块用来初始化类的信息，非静态代码块用来初始化对象的信息。

那这些信息指的是什么？代码块里面可以写什么呢？

代码块的大括号就相当于方法的大括号，方法里面可以调用当前类中的成员变量、方法、自己写的输出语句…

代码块里面也是同样的，它里面也可以做这些事儿。

比如定义了静态属性info，那么在静态代码块中也可以调用它。如下：

//静态代码块
static{
    System.out.println("静态代码块1");
    System.out.println("修改前的info= "+info);  //打印info
    info="我是超人";//修改info (相当于对info初始化)
    System.out.println("修改后的info= "+info);
}

同样，对于非静态代码块，每造一个对象它就会执行一次，比如在里面将age赋值为1。如下：

//非静态代码块
{
    System.out.println("非静态代码块1");
    age=1;  //修改age的值
}

若此时通过对象调用age：System.out.println(p1.age); ，它的值是多少呢？（空参构造器没有给它赋值，也没有显示赋值）

整体代码：

package yuyi05;

public class BlockTest {
    public static void main(String[] args) {
        //在创建对象之前，通过类调用静态属性
        System.out.println(Person.info);    //调用静态属性，既然调用了，那么一定会加载Person类
        System.out.println(Person.info);

        Person p1=new Person();
        Person p2=new Person();

        System.out.println(p1.age); //输出age
    }
}

class Person{
    //属性
    String name;
    int age;

    static String info="我是一个人"; //静态属性

    //方法
    public void eat(){
        System.out.println("民以食为天");
    }

    //构造器
    public Person(){

    }


    //非静态代码块
    {
        System.out.println("非静态代码块1");
        age=1;  //修改age的值
    }

    //静态代码块
    static{
        System.out.println("静态代码块1");
        System.out.println("修改前的info= "+info);  //打印info
        info="我是超人";//修改info (相当于对info初始化)
        System.out.println("修改后的info= "+info);
    }

}

输出结果：

执行结果是1，因为在创建对象的时候，非静态代码块执行了，执行的时候就把当前正在创建的对象的属性赋值了。（初始化对象的信息）

无论是静态代码块还是非静态代码块，内部都可以进行声明变量、调用属性或方法、编写输出语句等操作。

对应的执行代码：

①

②

③

④

先执行静态代码块，后执行非静态代码块。

因为类先加载（类加载的时候静态代码块执行，且执行一次），然后构造器就加载了，通过构造器才能造对象（每造一个对象就执行一次非静态代码块）。

6. 举例6

在一个类中，可以写多个静态代码块和非静态代码块吗？可以的。

比如：

package yuyi05;

public class BlockTest {
    public static void main(String[] args) {
        //在创建对象之前，通过类调用静态属性
        System.out.println(Person.info);    //调用静态属性，既然调用了，那么一定会加载Person类
        System.out.println(Person.info);

        Person p1=new Person();
        Person p2=new Person();

        System.out.println(p1.age); //输出age
        //p1.eat();
    }
}

class Person{
    //属性
    String name;
    int age;

    static String info="我是一个人"; //静态属性

    //方法
    public void eat(){
        System.out.println("民以食为天");
    }

    //构造器
    public Person(){

    }


    //非静态代码块
    {
        System.out.println("非静态代码块1");
        age=1;  //修改age的值
    }

    {
        System.out.println("非静态代码块2");
    }

    //静态代码块
    static{
        System.out.println("静态代码块1");
    }
    static{
        System.out.println("静态代码块2");
    }

}

输出结果：

在一个类中，可以写多个静态代码块和非静态代码块。

7. 举例7

在静态代码块和非静态代码块中的代码执行顺序取决于写的顺序。

比如：

public class BlockTest {
    public static void main(String[] args) {
        //在创建对象之前，通过类调用静态属性
        System.out.println(Person.info);    //调用静态属性，既然调用了，那么一定会加载Person类
        System.out.println(Person.info);

        Person p1=new Person();
        Person p2=new Person();

        //System.out.println(p1.age); //输出age
        //p1.eat();
    }
}

class Person{
    //属性
    String name;
    int age;

    static String info="我是一个人"; //静态属性

    //方法
    public void eat(){
        System.out.println("民以食为天");
    }

    //构造器
    public Person(){

    }


    //非静态代码块
    {
        System.out.println("非静态代码块2");
    }

    {
        System.out.println("非静态代码块1");
        age=1;  //修改age的值
    }



    //静态代码块
    static{
        System.out.println("静态代码块2");
    }

    static{
        System.out.println("静态代码块1");
    }
}

输出结果：

在一个类中，若是编写了很多静态代码块和非静态代码块，它们的执行顺序就是声明的顺序。

在实际开发中，不会去声明多个的。既然是按照先后顺序执行的，那跟写在一个里面没啥区别。（如果写了好几个，生成的字节码文件也会帮我们合并起来）。所以写一个就好，没必要写多个。

8. 举例8

静态代码块内部只能调用静态的结构（即静态的属性、方法），不能调用非静态的结构（即非静态的属性、方法）。

//静态代码块
static{
    System.out.println("静态代码块2");
    System.out.println("info= "+info);  //静态代码块中可以调用静态属性或方法

    //静态代码块中不可以调用非静态属性或方法
    //System.out.println("age= "+age);
    //eat();

}

static{
    System.out.println("静态代码块1");
}

非静态代码块内部可以调用静态的结构（即静态的属性、方法），也可以调用非静态的结构（即非静态的属性、方法）。

//非静态代码块
{
    System.out.println("非静态代码块2");
}

{
    System.out.println("非静态代码块1");
    age=1;  //修改age的值 ，非静态代码块中可以调用非静态的属性或方法

    //非静态代码块中可以调用静态属性或方法(提前就已经加载过了)
    System.out.println("info= "+info);

}

整体代码：

package yuyi05;

/**
 * ClassName: BlockTest
 * Package: yuyi05
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/19 0019 8:47
 */
public class BlockTest {
    public static void main(String[] args) {
        //在创建对象之前，通过类调用静态属性
        System.out.println(Person.info);    //调用静态属性，既然调用了，那么一定会加载Person类
        System.out.println(Person.info);

        Person p1=new Person();
        Person p2=new Person();

        //System.out.println(p1.age); //输出age
        //p1.eat();
    }
}

class Person{
    //属性
    String name;
    int age;

    static String info="我是一个人"; //静态属性

    //方法
    public void eat(){
        System.out.println("民以食为天");
    }

    //构造器
    public Person(){

    }


    //非静态代码块
    {
        System.out.println("非静态代码块2");
    }

    {
        System.out.println("非静态代码块1");
        age=1;  //修改age的值 ，非静态代码块中可以调用非静态的属性或方法

        //非静态代码块中可以调用静态属性或方法(提前就已经加载过了)
        System.out.println("info= "+info);

    }



    //静态代码块
    static{
        System.out.println("静态代码块2");
        System.out.println("info= "+info);  //静态代码块中可以调用静态属性或方法

        //静态代码块中不可以调用非静态属性或方法
        //System.out.println("age= "+age);
        //eat();

    }

    static{
        System.out.println("静态代码块1");
    }
}

输出结果：

有类不一定有对象，有对象一定有类

（5）重点总结

1. 静态代码块

随着类的加载而执行（它没有名字，就不能显示地调用它）。
由于类的加载只会执行一次，进而静态代码块的执行，也只会执行一次。
作用：用来初始化类的信息。
内部可以声明变量、调用属性或方法、编写输出语句等操作。
静态代码块的执行要先于非静态代码块的执行。
如果声明有多个静态代码块，则按照声明的先后顺序执行。
静态代码块内部只能调用静态的结构（即静态的属性、方法），不能调用非静态的结构（即非静态的属性、方法）。

2. 非静态代码块

随着对象的创建而执行。
每创建当前类的一个实例，就会执行一次非静态代码块。
作用：用来初始化对象的信息。
内部可以声明变量、调用属性或方法、编写输出语句等操作。
如果声明有多个非静态代码块，则按照声明的先后顺序执行。
非静态代码块内部可以调用静态的结构（即静态的属性、方法），也可以调用非静态的结构（即非静态的属性、方法）。

一般在开发中使用的时候，静态代码块初始化的时候，把静态的属性做一个赋值；非静态代码块初始化的时候，可以对非静态的属性做一些赋值。

有类就有静态代码块，不创造对象构造器也不会执行；继承的时候普通代码块和构造器的区别就体现了。

三、练习

（1）练习

🌋题目描述

（1）声明User类，

包含属性：username（String类型），password（String类型），registrationTime（long类型），私有化
包含get/set方法，其中registrationTime没有set方法
包含无参构造，
- 输出“新用户注册”，
- registrationTime赋值为当前系统时间，
- username就默认为当前系统时间值，
- password默认为“123456”
包含有参构造(String username, String password)，
- 输出“新用户注册”，
- registrationTime赋值为当前系统时间，
- username和password由参数赋值
包含public String getInfo()方法，返回：“用户名：xx，密码：xx，注册时间：xx”

（2）编写测试类，测试类main方法的代码如下：

    public static void main(String[] args) {
        User u1 = new User();
        System.out.println(u1.getInfo());

        User u2 = new User("song","8888");
        System.out.println(u2.getInfo());
    }

💨代码

【User.java】

package yuyi05;

/**
 * ClassName: User
 * Package: yuyi05
 * Description:
 *  - 包含属性：userName（String类型），password（String类型），registrationTime（long类型），私有化
 *
 * - 包含get/set方法，其中registrationTime没有set方法
 *
 * - 包含无参构造，
 *   - 输出“新用户注册”，
 *   - registrationTime赋值为当前系统时间，
 *   - userName就默认为当前系统时间值，
 *   - password默认为“123456”
 *
 * - 包含有参构造(String userName, String password)，
 *   - 输出“新用户注册”，
 *   - registrationTime赋值为当前系统时间，
 *   - username和password由参数赋值
 *
 * - 包含public String getInfo()方法，返回：“用户名：xx，密码：xx，注册时间：xx”
 * @Author 雨翼轻尘
 * @Create 2023/11/19 0019 14:45
 */
public class User {
    //属性
    private String username;
    private String password;
    private long registrationTime;  //注册时间

    //方法
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public long getRegistrationTime() {
        return registrationTime;
    }

    public String getInfo(){
        return "用户名："+username+",密码："+password+",注册时间"+registrationTime;
    }

    //构造器
    public User(){
        System.out.println("新用户注册");
        registrationTime=System.currentTimeMillis();    //获取系统当前时间 (距离1970-1-1  00：00：00 的毫秒数，得到的是long类型的值)
        username=System.currentTimeMillis()+""; //字符串连接操作中隐式类型转换 (不是自动类型提升，自动类型 提升只针对于基本数据类型)
        password="123456";
    }

    public User(String username,String password){
        System.out.println("新用户注册");
        registrationTime=System.currentTimeMillis();    //获取系统当前时间
        this.username=username;
        this.password=password;
    }


}

【UserTest.java】

package yuyi05;

/**
 * ClassName: UserTest
 * Package: yuyi05
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/19 0019 15:13
 */
public class UserTest {
    public static void main(String[] args) {
        User u1=new User();
        System.out.println(u1.getInfo());

        User u2=new User("Tom","5664321");
        System.out.println(u2.getInfo());
    }
}

输出结果：

这也没有用到代码块啊？

现在我们写一个User1类，将刚才的User代码拿过来。（记得更改构造器的名字为类名）

package yuyi05;

/**
 * ClassName: User1
 * Package: yuyi05
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/19 0019 15:19
 */
public class User1 {
    private String username;
    private String password;
    private long registrationTime;  //注册时间

    //方法
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public long getRegistrationTime() {
        return registrationTime;
    }

    public String getInfo(){
        return "用户名："+username+",密码："+password+",注册时间"+registrationTime;
    }

    //构造器
    public User1(){
        System.out.println("新用户注册");
        registrationTime=System.currentTimeMillis();    //获取系统当前时间 (距离1970-1-1  00：00：00 的毫秒数，得到的是long类型的值)
        username=System.currentTimeMillis()+""; //字符串连接操作中隐式类型转换 (不是自动类型提升，自动类型 提升只针对于基本数据类型)
        password="123456";
    }

    public User1(String username,String password){
        System.out.println("新用户注册");
        registrationTime=System.currentTimeMillis();    //获取系统当前时间
        this.username=username;
        this.password=password;
    }
}

现在没有涉及到静态的性质，所以就用不着静态代码块了。

这个类在加载的时候需要干点什么么？此时没啥可干的。

非静态代码块可以稍微体会一下，可以对当前类中的属性做一些赋值操作。（每创建一个对象它就会执行一次，和用哪个构造器无关）

在new对象的时候，代码块就执行了，跟用哪个构造器无关。

此时可以看到，两个构造器有相同的代码，比如前两行：

既然有相同的代码，意味着这两行都要执行，既然都要被执行，那在调用构造器的时候，代码块也会执行，不妨将这两行的逻辑写入代码块中。

//非静态代码块
{
    System.out.println("新用户注册");
    registrationTime=System.currentTimeMillis();    //获取系统当前时间 (距离1970-1-1  00：00：00 的毫秒数，得到的是long类型的值)
}

//构造器
public User1(){
    username=System.currentTimeMillis()+""; //字符串连接操作中隐式类型转换 (不是自动类型提升，自动类型 提升只针对于基本数据类型)
    password="123456";
}

public User1(String username,String password){
    this.username=username;
    this.password=password;
}

这里的变化如下：

当我们通过User1()构造器造对象的时候，非静态代码块中的内容一定会执行。

现在整体的代码如下：

【User1.java】

package yuyi05;

/**
 * ClassName: User1
 * Package: yuyi05
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/19 0019 15:19
 */
public class User1 {
    private String username;
    private String password;
    private long registrationTime;  //注册时间

    //方法
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public long getRegistrationTime() {
        return registrationTime;
    }

    public String getInfo(){
        return "用户名："+username+",密码："+password+",注册时间"+registrationTime;
    }

    //非静态代码块
    {
        System.out.println("新用户注册");
        registrationTime=System.currentTimeMillis();    //获取系统当前时间 (距离1970-1-1  00：00：00 的毫秒数，得到的是long类型的值)
    }

    //构造器
    public User1(){
        username=System.currentTimeMillis()+""; //字符串连接操作中隐式类型转换 (不是自动类型提升，自动类型 提升只针对于基本数据类型)
        password="123456";
    }

    public User1(String username,String password){
        this.username=username;
        this.password=password;
    }
}

测试类【UserTest.java】

package yuyi05;

/**
 * ClassName: UserTest
 * Package: yuyi05
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/11/19 0019 15:13
 */
public class UserTest {
    public static void main(String[] args) {
        User u1=new User();
        System.out.println(u1.getInfo());

        User u2=new User("Tom","5664321");
        System.out.println(u2.getInfo());

        System.out.println();

        User1 u3=new User1();
        System.out.println(u3.getInfo());
    }
}

输出结果：

在构造器里面写的一些相同的代码，可以写入代码块中。（以前是用this()相互调用）

（2）补充

⚡注意

从刚才的例子来看，代码块可用可不用，但是有一种情况代码块还是有必要用的。

静态代码块是用来初始化类的信息，假设这个类里面有一个静态的属性，这个属性现在需要赋值，要么显示赋值，要么在代码块里面赋值。

构造器里面就不用了（构造器主要用来初始化对象的信息），在构造器里面给静态的属性赋值，可以赋值但不推荐，静态只有一份，若是每造一个对象在构造器里就给它赋一个值，那么就会把已有的对象的值也给影响了，所以在构造器里面不要去操作静态的。

有些时候，用显示赋值不是特别靠谱，这个时候就要用静态代码块了。

比如：

private static DataSource dataSource = null;

static{
	InputStream is = null;
	try {
		is = DBCPTest.class.getClassLoader().getResourceAsStream("dbcp.properties");
		Properties pros = new Properties();
		pros.load(is);
		//调用BasicDataSourceFactory的静态方法，获取数据源。
		dataSource = BasicDataSourceFactory.createDataSource(pros);
	} catch (Exception e) {
		e.printStackTrace();
	}finally{
		if(is != null){
			try {
				is.close();
			} catch (IOException e) {
				e.printStackTrace();
			}		
		}		
	}		
}

这里要用到以后要说的“异常”，可以暂时不用看。看这些代码就好了：

private static DataSource dataSource = null;

static{
	InputStream is = null;
    
		is = DBCPTest.class.getClassLoader().getResourceAsStream("dbcp.properties");
		Properties pros = new Properties();
		pros.load(is);
		//调用BasicDataSourceFactory的静态方法，获取数据源。
		dataSource = BasicDataSourceFactory.createDataSource(pros);
    
}