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();}
}

执行就可以输出结果了：

image.png

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

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

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

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

（2） 静态代码块

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

1. 语法格式

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

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

2. 静态代码块的特点

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

（3）非静态代码块

1. 语法格式

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

2. 非静态代码块的作用

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

3. 非静态代码块的意义

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

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

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

（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");}}

输出结果：

image.png

在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");}}

输出结果：

image.png

可以看到，“静态代码块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");}}

输出结果：

image.png

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

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");}}

输出结果：

image.png

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

5. 举例5

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

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

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

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

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

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

输出结果：

image.png

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

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

对应的执行代码：

①
image.png

②
image.png

③
image.png

④
image.png

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

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

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");}}

输出结果：

image.png

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

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");}
}

输出结果：

image.png

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

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

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");}
}

输出结果：

image.png

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

（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());}
}

输出结果：

image.png

这也没有用到代码块啊？

现在我们写一个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对象的时候，代码块就执行了，跟用哪个构造器无关。

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

image.png

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

//非静态代码块
{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;
}

这里的变化如下：

image.png

当我们通过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());}
}

输出结果：

image.png

在构造器里面写的一些相同的代码，可以写入代码块中。（以前是用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);}

现在声明了一个DataSource类型的静态变量dataSource，并且给它赋一个值，一方面可以直接给它赋值，另一方面可以通过静态代码块去赋。

此时直接显示赋值不靠谱：

image.png

给dataSource赋值的时候，一行代码搞不定，需要提前准备很多东西（这个变量赋值又要参数，又要方法，不适合在一行直接定义)，显示赋值不靠谱，放在构造器也不合适，只能放在静态代码块中。

若此时通过new，那么直接显示赋值就可以了，但是现在是通过一个方法调用返回的值是这个类型的，但是现在这个返回的一行代码也搞不定，因为参数pros也需要通过好几行代码才能搞定，而那么多行代码是执行语句，不可以在显示赋值的时候写。

写构造器里面？每造一次对象都要执行一遍，若此时这些代码所在的类不打算造对象了，既然不造对象，那要构造器也没啥用。况且每调用一次构造器，这些代码都执行一遍，没有必要，因为静态的执行一次就够了。所以不能放在构造器中。

放在静态方法里面？比如给dataSource变量设置一个set方法，但是晚了，我希望的是类一加载完，它就执行好了。

这时候显示不能赋值，构造器不让用，set方法也不让用，就得是代码块啦。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/198041.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【数据结构】栈与队列面试题（C语言）

【数据结构】栈与队列面试题（C语言）

我们再用C语言做题时，是比较不方便的，因此我们在用到数据结构中的某些时只能手搓或者Ctrlcv 我们这里用到的栈或队列来自栈与队列的实现 目录 有效的括号解题思路：代码实现： 用队列实现栈解题思路：代码实现&#xff1a…
阅读更多...
4月2日-3日·上海 | 3DCC 第二届3D细胞培养与类器官研发峰会携手CGT Asia 重磅来袭

4月2日-3日·上海 | 3DCC 第二届3D细胞培养与类器官研发峰会携手CGT Asia 重磅来袭

类器官（Organoids）作为干细胞研究领域最重要的成果之一，在基础医学研究、转化医学及药物研发领域展现出巨大的应用潜力，特别是在精准医疗以及药物安全性和有效性评价等方向凭借其先天优势引起了极大的市场关注，成为各大…
阅读更多...
LabVIEW进行MQTT通信及数据解析

LabVIEW进行MQTT通信及数据解析

需求：一般通过串口的方式进行数据的解析，但有时候硬件的限制，没法预留串口，那么如何通过网络的方式特别是MQTT数据的通信及解析 解决方式： 1.MQTT通信控件： 参考开源的mqtt-LabVIEW https://github.com…
阅读更多...
【iOS】——知乎日报第五周总结

【iOS】——知乎日报第五周总结

文章目录 一、评论区展开与收缩二、FMDB库实现本地持久化FMDB常用类：FMDB的简单使用： 三、点赞和收藏的持久化 一、评论区展开与收缩 有的评论没有被回复评论或者被回复评论过短，这时就不需要展开全文的按钮，所以首先计算被回复评…
阅读更多...
量化交易：借助talib使用技术分析指标

量化交易：借助talib使用技术分析指标

什么是技术分析？ 所谓股票的技术分析，是相对于基本面分析而言的。基本分析法着重于对一般经济情况以及各个公司的经营管理状况、行业动态等因素进行分析，以此来研究股票的价值，衡量股价的高低。而技术分析则是透过图表或技术指标…
阅读更多...
vulhub redis-4-unacc

vulhub redis-4-unacc

环境搭建 cd vulhub/redis/4-unacc docker-compose up -d 漏洞复现 检测 redis-cli -h ip 使用redis工具 工具地址：https://github.com/vulhub/redis-rogue-getshell 下载完成后，先进入RedisModulesSDK/exp/ 目录进行make操作 获得exp.so后可以进行…
阅读更多...
Jenkinsfile+Dockerfile前端vue自动化部署

Jenkinsfile+Dockerfile前端vue自动化部署

前言 本篇主要介绍如何自动化部署前端vue项目 其中，有两种方案： 第一种是利用nginx进行静态资源转发；第二种方案是利用nodejs进行启动访问； 各个组件版本如下： Docker 最新版本；Jenkins 2.387.3nginx …
阅读更多...
物联网AI MicroPython学习之语法 I2C总线

物联网AI MicroPython学习之语法 I2C总线

学物联网，来万物简单IoT物联网！！ I2C 介绍 模块功能: I2C Master设备驱动 接口说明 I2C - 构建硬件I2C对象 函数原型：I2C(id, scl, sda, freq)参数说明： 参数类型必选参数？说明idintYI2C外设&#xff…
阅读更多...
带你快速掌握Linux最常用的命令（图文详解）- 最新版（面试笔试常考）

带你快速掌握Linux最常用的命令（图文详解）- 最新版（面试笔试常考）

最常用的Linux指令（图文详解）- 最新版 ls：列出目录中的文件和子目录（重点）cd：改变当前工作目录绝对路径：相对路径 pwd：显示当前工作目录的路径mkdir：创建一个新的目录tou…
阅读更多...
【开源】基于Vue.js的音乐偏好度推荐系统的设计和实现

【开源】基于Vue.js的音乐偏好度推荐系统的设计和实现

项目编号： S 012 ，文末获取源码。 \color{red}{项目编号：S012，文末获取源码。} 项目编号：S012，文末获取源码。 目录 一、摘要1.1 项目介绍1.2 项目录屏 二、系统设计2.1 功能模块设计2.1.1 音乐档案模块2.1…
阅读更多...
spring中的DI

spring中的DI

【知识要点】 控制反转（IOC）将对象的创建权限交给第三方模块完成，第三方模块需要将创建好的对象，以某种合适的方式交给引用对象去使用，这个过程称为依赖注入（DI）。如：A对象如果需要…
阅读更多...
代码随想录算法训练营Day 54 || 392.判断子序列、115.不同的子序列

代码随想录算法训练营Day 54 || 392.判断子序列、115.不同的子序列

392.判断子序列 力扣题目链接(opens new window) 给定字符串 s 和 t ，判断 s 是否为 t 的子序列。 字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，&quo…
阅读更多...
多svn仓库一键更新脚本分享

多svn仓库一键更新脚本分享

之前分享过多git仓库一键更新脚本，本期就分享下svn仓库的一键更新脚本 1、首先需要设置svn为可执行命令行 打开SVN安装程序，选择modify，然后点击 command client tools，安装命令行工具 2、update脚本 echo 开始更新SVN目录&…
阅读更多...
计算机视觉：使用opencv实现车牌识别

计算机视觉：使用opencv实现车牌识别

1 引言 汽车车牌识别（License Plate Recognition）是一个日常生活中的普遍应用，特别是在智能交通系统中，汽车牌照识别发挥了巨大的作用。汽车牌照的自动识别技术是把处理图像的方法与计算机的软件技术相连接在一起，以准…
阅读更多...
Linux管道的工作过程

Linux管道的工作过程

常用的匿名管道（Anonymous Pipes），也即将多个命令串起来的竖线。管道的创建，需要通过下面这个系统调用。 int pipe(int fd[2]) 我们创建了一个管道 pipe，返回了两个文件描述符，这表示管道的两端&#xff…
阅读更多...
jvm 内存结构 ^_^

jvm 内存结构 ^_^

1. 程序计数器 2. 虚拟机栈 3. 本地方法栈 4. 堆 5. 方法区 程序计数器 定义： Program Counter Register 程序计数器（寄存器） 作用，是记住下一条jvm指令的执行地址 特点： 是线程私有的 不会存在内存溢出 虚拟机栈…
阅读更多...
SQL练习02

SQL练习02

1.买下所有产品的客户 SQL Create table If Not Exists Customer (customer_id int, product_key int); Create table Product (product_key int); Truncate table Customer; insert into Customer (customer_id, product_key) values (1, 5); insert into Customer (customer_…
阅读更多...
开源供应链管理系统 S2B2B2C系统方案及源码输出

开源供应链管理系统 S2B2B2C系统方案及源码输出

这个开源供应链管理系统提供针对企业供应链管理需求的开放源代码解决方案。通过开源供应链管理系统，企业能够实现对供应商、进销存和物流配送等方面的全面管理和优化，涵盖了从供应商选择到门店到消费者服务交付的整个流程。开源系统使企业能够根据自身需…
阅读更多...
Linux|僵死进程

Linux|僵死进程

1.僵死进程产生的原因或者条件: 什么是僵死进程? 当子进程先于父进程结束,父进程没有获取子进程的退出码,此时子进程变成僵死进程. 简而言之,就是子进程先结束,并且父进程没有获取它的退出码; 那么僵死进程产生的原因或者条件就是:子进程先于父进程结束,并且父进程没有获取…
阅读更多...
使用内网穿透解决支付宝回调地址在公网问题

使用内网穿透解决支付宝回调地址在公网问题

使用natapp解决内网穿透问题 前言NATAPP使用购买隧道 支付宝回调地址测试之后的学习计划 前言 最近一个项目用到了支付宝，但是本地调试的时候发现支付宝的回调地址需要在公网上能够访问到。为了更加方便地调试，就使用了natapp内网穿透，将回调…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023