代码块经典例题与枚举类

zhaoyangyj

已于 2022-09-29 15:36:51 修改

阅读量201

点赞数

分类专栏： java 文章标签： java

于 2022-07-19 10:19:49 首次发布

本文链接：https://blog.csdn.net/zhaoyangyj/article/details/125865807

版权

java 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

1.代码块例题：

当代码块中有静态代码块、普通代码块、继承关系、构造方法时的代码块先后的调用顺序：
先看完整代码：

public class Zuoye {
    public static void main(String[] args) {
      Zi zi = new Zi();
    }
}

class Zi extends Fu {
    private static int A = getA();
    private int A1 = getA1();

    public static int getA() {
        System.out.println("子类的静态方法被调用");
        return 1;
    }

    public int getA1() {
        System.out.println("子类的普通方法被调用");
        return 2;
    }

    static {
        System.out.println("子类的静态代码块被调用");
    }

    {
        System.out.println("子类的普通代码块被调用");
    }

    public Zi() {
        System.out.println("子类的构造器被调用");
    }
}

class Fu {
    private static int B = getB();
    private int B1 = getB1();

    public static int getB() {
        System.out.println("父类的静态方法被调用");
        return 3;
    }

    public int getB1() {
        System.out.println("父类的普通方法被调用");
        return 4;
    }

    static {
        System.out.println("父类的静态代码块被调用");
    }

    {
        System.out.println("父类的普通代码块被调用");
    }

    public Fu() {
        System.out.println("父类的构造器被调用");
    }
}

在这里我们定义两个实体类，每个实体类中都写一个静态代码块、普通代码块、构造器以及一个方法。再添加一个继承关系。创建一个子类的对象，运行代码，看看输出的效果：

父类的静态方法被调用
父类的静态代码块被调用
子类的静态方法被调用
子类的静态代码块被调用
父类的普通方法被调用
父类的普通代码块被调用
父类的构造器被调用
子类的普通方法被调用
子类的普通代码块被调用
子类的构造器被调用

进程已结束，退出代码 0

在这里可以看出，最先输出的是与静态代码块有关的代码，而后优先执行和父类相关的代码。那么得出与静态代码块有关的最先执行，然后是父类的代码，最后是子类的代码。
而静态的代码块也是父类的先执行，从而得出优先顺序：

1.父类的静态代码块和静态属性（优先级一样）

2.子类的静态代码块和静态属性（优先级一样）

3.父类的普通代码块和普通属性初始化

4.父类的构造方法

5.子类的普通代码块和子类的普通属性初始化

6.子类的构造方法

7.注意: 静态代码块只能直接调用静态成员，普通代码块可以调用任意成员
（在本类中）

理解：
因为每个构造器都有共同内容：
{
1.super()
2.普通代码块和普通属性初始化
3.。。。。。。
}

父类和子类走完静态相关之后，会首先来访问子类的构造器；而子类的构造器里面包含了
{
1.super()
2.普通代码块和普通属性初始化
3.。。。。。。
}

所以，首先会访问父类的构造器，父类的默认继承object，没有输出语句，所以先执行
1.普通代码块和普通属性初始化
2.在执行父类构造方法中的内容。

最后返回，子类的构造方法中也先执行子类的
1. 普通代码块和普通属性初始化
2. 在执行构造器中的内容

2. 枚举类

1.概述：

我们学习过单例模式，即一个类只有一个实例。而枚举其实就是多例，一个类有多个实例，但实例的个数不是无穷的，是有限个数的。

2.自定义枚举类：

特点：

1.构造器私有化

2.本类的内部创建一组固定的对象

3.对外提供一个对象（通过为对象添加public final static 修饰符）

4.可以通过get方法，但是不要提供set，防止属性值被修改。

代码：

public class Zuoye03 {
    public static void main(String[] args) {
        System.out.println(Season.AUTNUM);
    }
}

class Season {
   
 private String name;
    
private String desc;//描述

    public static final Season SPRING = new Season("春天", "温暖");
    
public static final Season WINTER = new Season("冬天", "寒冷");
   
 public static final Season AUTNUM = new Season("秋天", "凉爽");
    
public static final Season SUMMER = new Season("夏天", "炎热");


    private Season(String name, String desc) {
       
 this.name = name;
       
 this.desc = desc;
    }

   
 public String getName() {
        
return name;
    }

    
public String getDesc() {
        
return desc;
    }

    @Override
    public String toString() {
        return "Season{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}