静态代码块，final关键字，代码块复习

1.静态代码块:
      格式：static{}
      ①.位置：类里，方法外
      ②.执行时机：静态代码块也属于静态资源，随着类的加载而加载
        优先于对象加载，并且静态资源只会加载一次
      ③.作用：用于加载那些需要第一时间就加载，并且只加载一次的资源，常用来初始化

package cn.tedu.review;
/*本类用于复习代码块*/
public class TestBlock {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.eat();
    }
}
class Person{
    //构造代码块：类里方法外
    {
        System.out.println("我是构造代码块");
    }
    public Person(){
        System.out.println("无参构造");
    }
    public Person(int n){
        System.out.println("含参构造");
    }
    public void eat(){
        System.out.println("eat方法");
        //局部代码块：方法里
        {
            System.out.println("我是一个局部代码块");
            int i = 100;
            System.out.println(i);
        }
        //System.out.println(i);//不可以使用，因为超出变量i的使用范围

    }
}

package cn.tedu.oop;
/*本类用于测试代码块
* 静态代码块 > 构造代码块 > 构造方法 > 普通方法 > 局部代码块*/
public class TestBlock {
    public static void main(String[] args) {
        Apple a1 = new Apple();
        Apple a2 = new Apple();
        a1.clean();
    }
}
//1.创建类
class Apple{
    //6.创建本类的静态代码块
    /*格式：static{}
    位置：类里，方法外
    执行时机：静态代码块也属于静态资源，随着类的加载而加载，优先于对象加载
             并且静态资源只会加载一次
    作用：用于加载那些需要第一时间就加载，并且只加载一次的资源，常用来初始化*/
    static{
        System.out.println("我是一个静态代码块");
    }
    //2.创建本来的构造代码块
    /*位置：类里方法外
    * 执行时机：创建对象时执行，并且优先于构造方法执行
    * 作用：用于提取所有构造方法的共性功能*/
    {
        System.out.println("我是构造代码块");
    }
    //3.创建本类的无参构造
    public Apple(){
        System.out.println("我是无参构造");
    }
    //4.创建本类的普通方法
    public void clean(){
        System.out.println("我是一个普通方法");
        //5.创建本类局部代码块
        /*位置：方法里
        * 执行时机：每次调用局部代码所处的方法时才会执行
        * 作用，用于控制变量的作用范围*/
        {
            System.out.println("我是局部代码块");
        }
    }
}

2.静态：

   1.static可以修饰属性和方法
    2.被static修饰的资源成为静态资源
    3.静态资源随着类的加载而加载，最先加载，优先于对象进行加载
    4.静态资源可以通过类名直接调用
    5.静态被全局所有对象共享，值只有一份
    6.静态资源只能调用静态资源
    7.静态区域内不允许使用this与super关键字  

3.final关键字

            1.修饰类：最终类，不可以被继承
            2.修饰方法：这个方法的最终实现，不可以被重写
            3.修饰常量：值不可以被更改，并且定义是必须赋值

package cn.tedu.oop;
/*本类用于测试final关键字*/
public class TestFinal {
}
//1.定义父类
/*1.final可以用来修饰类，被final修饰的类最终类，不可以被继承
* 可以把被final修饰的类看成树结构中的叶子节点*/
//3.测试类被final修饰
//final class Father2{}
class Father2{
    //4.定义父类的普通方法
    /*2.final可以用来修饰方法，被final修饰的方法时这个方法的最终实现，不可以被重写*/
    //public void work(){}
    //6.
    public void work(){
        System.out.println("在工厂里上班");
    }
}
//2.定义子类
class Son2 extends Father2{
    final int C = 66;
    //5.重写父类的方法
    @Override//这个注解用来标记这是一个重写的方法
    public void work(){
        int a = 10;
        a= 100;
        /*3.被final修饰的是常量，常量的值不可以被修改
        * 注意：不管是成员位置还是局部位置，常量定义的时候必须赋值
        * 注意：常量的名称必须是全大写，单词与单词之间使用_分割*/
        final int B = 100;
        //B = 200;//报错，常量的值不可以被修改
        System.out.println("在互联网大厂上班");
        System.out.println(Integer.MAX_VALUE);
    }
}