static与fianl

---

static

1、概念

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

2 、特点

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

案例：

package cn.zhu.oop;
/*本类用于测试静态关键字static*/
public class TestStatic1 {
    public static void main(String[] args) {
        Fruit f = new Fruit();
        Fruit f2 = new Fruit();
        f.grow();
        f.clean();//没有提示需要自己写
        System.out.println(f.weight);
        System.out.println(f.kind);//没有提示需要自己写

        //我们可以通过类名直接调用静态资源，而且这个IDEA会提示
        Fruit.clean();
        System.out.println(Fruit.kind);

        /*1.静态在内存中只有一份，被全局所有对象共享
        * 所以我们会发现：通过任意一种方式修改了静态变量的值以后，其他任何方式查看都是修改后的值*/
        Fruit.kind = "苹果";
        System.out.println(Fruit.kind);
        System.out.println(f.kind);
        System.out.println(f2.kind);
        f.kind = "香蕉";
        System.out.println(Fruit.kind);
        System.out.println(f.kind);
        System.out.println(f2.kind);
        f2.kind = "猕猴桃";
        System.out.println(Fruit.kind);
        System.out.println(f.kind);
        System.out.println(f2.kind);
    }
}
/*0.被static修饰的资源，称作是静态资源
* 静态资源是随着类加载而加载到内存中的，比对象优先进入内存
* 所以静态资源可以通过类名直接调用，即使没有创建对象，也可以调用*/
//1.创建一个水果类
class Fruit{
    /*1.可以用static修饰属性吗？可以*/
    //2.定义属性
    static String kind;//种类
    double weight;//重量

    //3.定义普通方法
    /*2.可以用static修饰方法吗？可以*/
    public static void clean(){
        System.out.println("洗水果呀洗水果~");
    }
    public void grow(){
        System.out.println("这个果子长的真好吃");
    }
}

3、注意事项

• 静态方法只能访问静态成员
• 静态方法中不可以写this，super关键字
• 主函数是静态的

4、成员变量和静态变量的区别？

1. 两个变量的生命周期不同。
   成员变量随着对象的创建而存在，随着对象的被回收而释放。
   静态变量随着类的加载而存在，随着类的消失而消失。

2. 调用方式不同。
   成员变量只能被对象调用。
   静态变量可以被对象调用，还可以被类名调用。

3. 别名不同。
   成员变量也称为实例变量。
   静态变量称为类变量。

4. 数据存储位置不同。
   成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据.
   静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据.

5、static静态调用关系

总结：

• 1.普通资源既可以调用普通资源，也可以调用静态资源
• 2.静态资源只能调用静态资源

静态代码块

1、格式

static{}

静态资源随着类的加载而加载，并且只被加载一次，一般用于项目的初始化
特点: 被static修饰,位置在类里方法外

2、 三种代码块的比较

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

案例：

执行顺序：
静态代码块->构造代码块->构造方法【对象创建成功】->局部代码块

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("我是一个局部代码块~");
        }
    }

}

final

1、 概念

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

2、 特点

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

3、final入门案例

/*本类用于测试final关键字*/
public class TestFinal {
    public static void main(String[] args) {
        //创建对象，测试常量的值不可以被修改
        Son s = new Son();
        System.out.println(s.a);
        //s.a = 100;//报错，不可以给被final修饰的变量a重新赋值
    }
}
/*1.final可以用来修饰类吗？可以
* 被final修饰的类是最终类，不可以被继承
* 可以把被final修饰的类看成树结构中的叶子节点*/
//1.定义父类
//3.测试类被final修饰
//final class Father{
class Father{
    /*2.final可以用来修饰方法吗？--可以
    * 被final修饰的方法是这个方法的最终实现，不可以被重写*/
    //4.测试方法被final修饰
    //public final void work(){
    public void work(){
        System.out.println("在工厂里上班~");
    }
}
//2.定义子类
//class Son extends Father{//报错，不可以继承一个被final修饰的类
class Son extends Father{
    /*3.final可以用来修饰变量吗？
    * 被final修饰的是常量，值不可以被修改
    * 注意：定义常量时必须赋值*/
    final int a = 10;

    //5.重写父类的方法
    //public void work(){}//报错,不可以重写一个被final修饰的方法
    @Override
    public void work(){
        System.out.println("在互联网大厂上班~");
    }
}