新手小白学JAVA static final 静态/构造/局部代码块之间的关系

矫情吗；* 2021-09-07 16:46 257阅读 0赞

# 1 static #

## 1.1 概念 ##

是java中的一个关键字  
用于修饰成员（成员变量和成员方法）

## 1.2 特点 ##

1.  可以修饰成员变量与成员方法
2.  随着类的加载而加载，优先于对象加载
3.  只加载一次，就会一直存在，不再开辟新空间, 直到类消失才一起消失
4.  静态资源也叫做类资源,全局唯一,被全局所有对象共享
5.  可以直接被类名调用
6.  静态只能调用静态，非静态可以随意调用
7.  static不能和this或者super共用，因为有static时可能还没有对象

## 1.3 练习：static入门案例 ##

创建包: cn.tedu.oopstatic  
创建类: TestStatic1.java

package cn.tedu.oopstatic;
    /*本类用作静态的入门案例*/
    public class TestStatic1 { 
        public static void main(String[] args) { 
            /*3.静态资源可以通过类名直接调用 * 原因：静态资源优先于对象进行加载，它是随着类的加载而加载的 * 比对象先加载进入内存，所以没对象时也可以通过类名直接调用*/
            //5.测试类名直接调用静态资源
            System.out.println(Student.name);
            Student.study();
            //4.创建对象进行测试
            Student s = new Student();
            System.out.println(s.sno);
            System.out.println(s.name);
            s.study();
            //6.测试静态属性赋值
            s.name = "黄桃罐头";
            System.out.println(s.name);//黄桃罐头
            System.out.println(Student.name);//黄桃罐头
            //7.创建多个对象进行测试
            /*4.静态资源被全局所有对象共享*/
            Student s2 = new Student();
            System.out.println(s2.name);
            System.out.println(Student.name);
            s2.name = "橘子罐头";
            System.out.println(s.name);
            System.out.println(s2.name);
            System.out.println(Student.name);
        }
    }
    
    //1.创建学生类
    class Student{ 
        /*1.可以通过static关键字来修饰成员变量与方法，修饰方法一般写在权限修饰符之后*/
        /*2.被static修饰的资源称作静态资源*/
        //2.定义属性
        int sno;//学号
        static String name;//姓名
    
        //3.定义方法
        public static void study(){ 
            System.out.println("别闹，学Java呢~");
        }
        public void speak(){ 
            System.out.println("会要大声说出来~");
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70]

## 1.4 练习：static静态调用关系 ##

创建包: cn.tedu.oopstatic  
创建类: TestStatic2.java

package cn.tedu.oopstatic;
    /*本类用于测试静态的调用关系*/
    /*总结： * 1.普通资源既可以调用普通资源，也可以调用静态资源 * 2.静态资源只能调用静态资源*/
    public class TestStatic2 { 
    }
    //1.创建老师类
    class Teacher{ 
        //2.定义普通属性与方法
        String name;
        public void teach(){ 
            System.out.println("正在授课中...");
            /*1.普通资源能否调用静态资源？--可以！！！*/
            System.out.println(age);
            ready();
        }
        //3.定义静态属性与方法
        static int age;
        public static void ready(){ 
            System.out.println("正在备课中...");
            /*2.静态资源能否调用普通资源？--不可以！*/
            //System.out.println(name);
            //teach();
        }
        public static void eat(){ 
            System.out.println("正在吃饭中...");
            /*3.静态资源能否调用静态资源？--可以！*/
            System.out.println(age);
            ready();
        }
    }

# 2 静态代码块、构造代码块、局部代码块 #

## 2.1 静态代码块格式 ##

![在这里插入图片描述][20210510110210185.png]  
静态资源随着类的加载而加载，并且只被加载一次，一般用于项目的初始化  
特点: 被static修饰,位置在类里方法外

## 2.2 三种代码块的比较 ##

1.  静态代码块：在类加载时就加载，并且只被加载一次，一般用于项目的初始化
2.  构造代码块：在创建对象时会自动调用，每次创建对象都会被调用,提取构造共性
3.  局部代码块：方法里的代码块,限制局部变量的范围

## 2.3 练习：几种代码块的关系 ##

创建包: cn.tedu. block  
创建类: TestBlock.java

package cn.tedu.oopstatic;
    /*本类用于学习静态代码块*/
    /*执行顺序： * 静态代码块->构造代码块->构造方法【对象创建成功】->局部代码块*/
    public class TestStaticBlock { 
        public static void main(String[] args) { 
            //6.创建对象进行测试
            Person p = new Person();
            Person p2 = new Person();
            //7.触发局部代码块
            p.play();
        }
    }
    
    //1.创建Person类
    class Person{ 
        //8.创建静态代码块
        /*位置：类里方法外 * 执行时机：静态代码块也属于静态资源，随着类的加载而加载，优先于对象加载 * 并且静态资源只会加载一次 * 作用：用于加载那些需要第一时间就加载，并且只加载一次的资源*/
        static{ 
            System.out.println("我是静态代码块");
        }
        //2.创建构造代码块
        /*位置：类里方法外 执行时机：每次创建对象时被触发，并且优先于构造方法执行 作用：用于提取所有构造方法的共性功能*/
        { 
            System.out.println("我是构造代码块");
        }
        //5.创建构造方法
        public Person(){ 
            System.out.println("我是无参构造");
        }
        //3.创建普通方法
        public void play(){ 
            System.out.println("我是一个普通方法");
            //4.创建局部代码块
            /*位置：方法里 * 执行时机：执行本局部代码块所在的方法时才会执行 * 作用：用于限制变量的作用范围*/
            { 
                System.out.println("我是一个局部代码块~");
            }
        }
    
    }

结论:执行顺序:静态代码块 --> 构造代码块 --> 构造方法 --> 局部代码块

# 3 final #

## 3.1 概念 ##

1.  是java提供的一个关键字
2.  final是最终的意思
3.  final可以修饰类，方法，字段(属性)  
    初衷：java出现继承后，子类可以更改父类的功能，当父类功能不许子类改变时,可以利用final关键字修饰父类。

## 3.2 特点 ##

1.  被final修饰的类，不能被继承
2.  被final修饰的方法，不能被重写
3.  被final修饰的字段是个常量，值不能被修改
4.  常量的定义形式：final 数据类型 常量名 = 值

## 3.3 练习：final入门案例 ##

创建包: cn.tedu.oopfinal  
创建类: TestFinal.java

package cn.tedu.oopfinal;
    /*本类用于final的学习*/
    public class TestFinal { 
        public static void main(String[] args) { 
            //6.2创建子类对象进行测试
            Son s = new Son();
            //s.name = "干饭人";//会报错，因为常量的值不能被修改
        }
    
    }
    /*1.final表示最终，可以用来修饰类 * 但是被final修饰类是最终类,无法被继承 * 也就是没有子类，它自己就是叶子节点*/
    //1.创建父类
    //3.测试类被final修饰
    //final class Father{ 
    class Father{ 
        //4.定义父类的普通方法
        /*2.final可以用来修饰方法，被final修饰的方法是这个方法的最终实现 * 不可以被重写*/
        //final public void work(){//不然子类重写的方法会报错
        public void work(){ 
            System.out.println("在车间上班~");
        }
    }
    //2.创建子类
    class Son extends Father{ 
        //6.1创建成员变量
        /*3.final可以用来修饰“变量”，注意其实不是“变量”，而是常量 * 常量的值是不可以被更改的 * 定义常量时必须要给常量同时赋值，不能先定义再赋值，不符合语法*/
        final String name = "打工人";
        final int a = 0;
        //5.重写父类的work()
        @Override
        public void work(){ 
            System.out.println("在格子间里上班");
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70]: /images/20210827/b4da7610cc994cbdbef8eed552df57d3.png
[20210510110210185.png]: /images/20210827/b04a928ac5b7402cb87e97187c4069e3.png