这篇博客是把之前上课时的笔记整理一下，加上我个人的理解和注释，还有一些例子发出来
- 局部代码块
- 构造代码块
- 静态代码块
局部代码块首先在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，
可以分为局部代码块，构造代码块，静态代码块
局部代码块：
在方法中出现；
作用：限定变量的生命周期，及早释放，提高内存利用率
在同一个类出现的时候，多个局部代码块的执行顺序是自上而下的。
public class Demo1 {
public static void main(String[] args) {
//局部代码块
{
int x = 10;
System.out.println(x);
}
{
String y = "hello";
System.out.println(y);
}
}
}
结果为
那么现在，如果在局部代码块的外面访问x和y变量会怎么样
public class Demo1 {
public static void main(String[] args) {
//局部代码块
{
int x = 10;
System.out.println(x);
}
System.out.println(x);
{
String y = "hello";
System.out.println(y);
}
System.out.println(y);
}
}
结果为
局部代码块里面的变量无法在代码块的外面进行访问
构造代码块：
在类里面的方法外面出现的；
作用是将多个构造方法中相同的代码存放到一起，都放入构造代码块中
每次调用构造都执行，并且在构造方法前执行执行顺序： 局部代码块 ——> 构造代码块 ——> 构造方法
class Test{
//Test类的无参构造器
Test(){
System.out.println("Test类的无参构造方法");
}
//构造代码块
{
System.out.println("Test类的构造代码块");
}
}
public class Demo1 {
public static void main(String[] args) {
Test c1 = new Test();
}
}
结果为
在创建Test类的对象时，调用了类面的无参构造器和构造代码块，而且先执行构造代码快，后执行无参构造器
再来看看多个构造器的情况
class Test{
public int t1;
//Test类的无参构造方法
Test(){
System.out.println("Test类的无参构造方法");
}
//Test类的带一个参数的构造方法
Test(int i){
this.t1 = i;
System.out.println("Test类的带一个参数的构造方法");
}
//构造代码块
{
System.out.println("Test类的构造代码块");
}
}
public class Demo1 {
public static void main(String[] args) {
Test c1 = new Test();
Test c2 = new Test(2);
}
}
结果为
可以看出来创建对象时，都需要执行一次构造代码块，然后是执行构造器。所以可以将不同构造器中相同的内容都放入构造代码块中。
最后再来看局部代码块，构造代码块，构造方法的执行顺序
class Test{
public int t1;
// static {
// System.out.println("这是静态代码块1");
// }
Test(){
System.out.println("Test类的无参构造方法");
}
Test(int i){
this.t1 = i;
System.out.println("Test类的带一个参数的构造方法");
}
{
System.out.println("Test类的构造代码块");
}
// static {
// System.out.println("这是静态代码块2");
// }
}
public class Demo1 {
public static void main(String[] args) {
{
int x = 111;
System.out.println(x);
}
{
String y = "hello";
System.out.println(y);
}
Test c1 = new Test();
Test c2 = new Test(2);
}
}
结果为
执行顺序是局部代码块 —> 构造代码块 —> 构造方法
静态代码块：
在类里面的方法的外面出现，并加上static修饰；
用于给类进行初始化，在加载的时候就执行，并且只执行一次。局部代码块 ——> 静态代码块 ——> 构造代码块 ——> 构造方法静态代码块在一个类中的顺序，不影响它的执行顺序，但是多个静态代码块在一个类中，
他们之间的执行顺序是自上而下的。
class Test{
public int t1;
static {
System.out.println("这是一个静态代码块");
}
Test(){
System.out.println("Test类的无参构造方法");
}
Test(int i){
this.t1 = i;
System.out.println("Test类的带一个参数的构造方法");
}
{
System.out.println("Test类的构造代码块");
}
}
public class Demo1 {
public static void main(String[] args) {
Test c1 = new Test();
Test c2 = new Test(2);
}
}
结果为
静态代码块不是伴随着对象的创建而执行的，是伴随着类的初始化，执行且只执行一次
main方法中第一次创建对象的时候，会初始化一次类，静态代码块会在加载时执行
因此虽然创建了两个Test类的对象，但是只打印了一次静态代码块
现在来看一下代码块之间的执行顺序问题
class Test{
public int t1;
static {
System.out.println("这是第一个静态代码块");
}
Test(){
System.out.println("Test类的无参构造方法");
}
Test(int i){
this.t1 = i;
System.out.println("Test类的带一个参数的构造方法");
}
{
System.out.println("Test类的构造代码块");
}
static {
System.out.println("这是第二个静态代码块");
}
}
public class Demo1 {
public static void main(String[] args) {
{
int x = 111;
System.out.println(x);
}
{
String y = "hello";
System.out.println(y);
}
Test c1 = new Test();
Test c2 = new Test(2);
}
}
结果为
为了方便观察，打印了一些用于分隔的符号
从结果可以看出来，
先执行局部代码块，局部代码块之间按从上到下的顺序执行。
再执行静态代码块，静态代码块之间按从上到下的顺序执行。
再执行构造代码块，第一个对象的构造代码块与无参构造方法先后执行
最后执行第二个对象的构造代码块和带一个参数的构造方法
简短的来说就是
局部代码块 —> 静态代码块 —> 构造代码块 —> 构造方法
