Java关键字 —— static 与 final 详细解释！一看就懂 有代码实例运行！

欢迎来到dream_ready的博客，相信您对博主首页也很感兴趣o (ˉ▽ˉ；)

Java关键字 —— super 详细解释！一看就懂 有代码实例运行！

目录

前言

static

static修饰类中的成员变量

static修饰方法

static修饰常量

static修饰代码块

static修饰类

final

final关键字的含义是 “最终”

代码举例 

final和static的区别

---

前言

大家应该经常会遇到这static、this、super、final四个关键字，甚至容易把含义搞混。

其实static、this、super、final这四个关键字互相是没有什么联系的(除了this和super有一定关系外)，所以大家其实要刻意区分一下这几个对应的功能和使用场景

那么这篇博客带领大家学习一下static和final的用法

static

1. 使用static可以修饰成员变量，常量，方法和代码块
2. 静态成员是全局的，归整个类所有，不依赖特定的对象，是被所有类的对象所共享的。
3. 只要类被java虚拟机加载，就可以根据类名在全局数据域内找到他们

也就是说，静态成员不属于某个对象单独拥有，而是被类的所有实例对象共享。举个例子，我们在教室里放了一台饮水机，这台饮水机是本教室所有成员共享的，不属于张三，也不属于李四，这台饮水机就是”静态成员“。而每个人还可以有自己单独的一个水杯，张三、李四都有自己独有的水杯，水杯不是共享的。另外，默认情况下，这些水杯是不能混用的，张三和李四彼此的水杯是互相隔离的。也就是说，自己的隐私不可被侵犯和窥探。 

使用场景及对应作用

● 被static修饰的属性(成员变量)称为静态变量，也叫做类变量；

● 被static修饰的常量称为静态常量；

● 被static修饰的方法称为静态方法，也叫做类方法；

● 被static修饰的代码块叫做静态代码块；

● 被static修饰符的内部类，叫做静态内部类。

static修饰类中的成员变量

static修饰类中的成员变量，使其变为类变量，让这个变量归整个类所有，不属于某个单一的对象，也就是说无数的对象共用这一个类变量

访问方式不需要再通过对象来访问，而是可以直接通过类来访问

被static修饰前，需要new出对象后，用对象才可以访问，代码如下：

class User{
    public int userId;

    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }
}

public class Test {
    public void test() {
        User user = new User();
        user.userId = 1;
    }
}

被static修饰后，直接就可以通过类来访问，代码如下：

class User{
    public static int userId;

    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }
}

public class Test {
    public void test() {
        User.userId = 1;
    }
}

static修饰方法

static修饰方法后，对方法的进行的改变和static修饰属性极其类似

被static修饰前，需要new出对象后，用对象才可以访问，代码如下：

class User{
    private static int userId;

    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        User.userId = userId;
    }
}

public class Test {
    public void test() {
        User user = new User();
        user.setUserId(1);
    }
}

被static修饰后，直接就可以通过类来访问，代码如下：

class User{
    private static int userId;

    public int getUserId() {
        return userId;
    }

    public static void setUserId(int userId) {
        User.userId = userId;
    }
}

public class Test {
    public void test() {
        User.setUserId(1);
    }
}

需要注意的是，在非静态方法（也就是没有被static修饰的方法）中无论其他方法是否被static修饰都可以正常调用，但是在静态方法（也就是被static修饰的方法）中只可以调用静态方法，若调用的方法没有被static修饰，则会报错

static修饰常量

被static修饰的成员变量、常量、方法都归整个类所有，改变都是类似的

被static修饰前，需要new出对象后，用对象才可以访问，此处就不再展示，和前面修饰成员变量和方法操作类似

被static修饰后，直接就可以通过类来访问，代码如下：

class User{
    private static int userId;
    public static String username = "admin"; 

    public int getUserId() {
        return userId;
    }

    public static void setUserId(int userId) {
        User.userId = userId;
    }
}

public class Test {
    public void test() {
        User.username = "YiQuWuYou";
    }
}

static修饰代码块

被static修饰的代码块叫做静态代码块

执行优先级高于非静态的初始化块，它会在类初始化的时候执行一次，执行完成便销毁，它仅能初始化类变量，即 static 修饰的数据成员。

静态代码块写法：

static {
    // 根据需求填写语句
}

在这里提下 非静态代码块

执行的时候如果有静态初始化块，先执行静态初始化块再执行非静态初始化块，在每个对象生成时都会被执行一次，它可以初始化类的实例变量。非静态初始化块会在构造函数执行时，在构造函数主体代码执行之前被运行。

非静态代码块写法：

{
    //...
}

静态代码块与非静态代码块的区别：

• 静态代码块的执行顺序：静态代码块----->非静态代码块-------->构造函数
• 静态代码块被 static 修饰，是属于类的，只在项目运行后类初始化时执行一次
• 而非静态代码块在每个对象生成时都会被执行一次

static修饰类

如果一个类要被声明为static的，只有一种情况，就是静态内部类。

如果在外部类声明为static，程序会编译都不会过

• 静态内部类跟静态方法一样，只能访问静态的成员变量和方法，不能访问非静态的方法和属性，但是普通内部类可以访问任意外部类的成员变量和方法
• 静态内部类可以声明普通成员变量和方法，而普通内部类不能声明static成员变量和方法。
• 静态内部类可以单独初始化

静态内部类不能访问非静态的方法和属性，但是内部类中可以定义非静态的方法和属性，代码如下：

public class Outer {
    private String name;
    private int age;

    public static class Builder {
        private String name;
        private int age;

        public Builder(int age) {
            this.age = age;
        }

        public Builder withName(String name) {
            this.name = name;
            return this;
        }

        public Builder withAge(int age) {
            this.age = age;
            return this;
        }

        public Outer build() {
            return new Outer(this);
        }
    }

    private Outer(Builder b) {
        this.age = b.age;
        this.name = b.name;
    }
}

静态内部类调用外部类的构造函数，来构造外部类，由于静态内部类可以被单独初始化说有在外部就有以下实现：

public Outer getOuter()
{
    Outer outer = new Outer.Builder(2).withName("Yang Liu").build();
    return outer;
}
 

对于静态类的建议有：

1.如果类的构造器或静态工厂中有多个参数，设计这样类时，最好使用Builder模式，特别是当大多数参数都是可选的时候。

2.如果现在不能确定参数的个数，最好一开始就使用构建器即Builder模式。

final

final相对static的用法，就简单很多，此处不会讲太多，但该讲的都会讲到

final关键字的含义是 “最终”

• fianl 修饰类，不存在子类，比如String类
• final修饰方法，子类不能重写。
• final进行修饰属性，为常量，需要初始化，并且不可修改 ，常量命名通常用大写字母，每个字母中间用下划线隔开
• final进行修饰属性，子类可以使用，但也不能修改

其实结合final的含义 “最终” 这两个字的话，很容易想到下面三点：

• final修饰变量时，表示该变量是最终的值，即表示该变量是常量，其值不可以再变化
• final修饰的方法称为终极方法，不能被子类重写
• final修饰的类称为最终类，不能被继承

需要注意的是

用final修饰的整形，字符型一旦设定进不能改变，但是修饰数组时，可以修改数组的某个位置的值，但是不能修改数组空间。

代码举例 

final修饰常量代码举例：

public class Constants {
    final int MAX_VALUE = 100; // 常量 MAX_VALUE，一旦赋值就不能再更改
    final double PI = 3.14; // 常量 PI，一旦赋值就不能再更改
}

final修饰类代码举例：

final class FinalClass {
    // 类定义
}

final修饰方法代码举例：

class Parent {
    final void finalMethod() {
        // 方法定义
    }
}

class Child extends Parent {
    // 试图重写 finalMethod()，但会导致编译错误
    // void finalMethod() {
    //     // 方法定义
    // }
}

final和static的区别

虽然，但是...

这俩其实没啥联系，所以要说区别的话，啥都是区别

他俩作用互不相同，但是他俩可以一起用

比如共同修饰类中属性时，表示创建一个所有对象共用的静态常量，代码如下：

public class Constants {
    public static final int MAX_VALUE = 100; // 声明一个静态常量 MAX_VALUE
    public static final String APP_NAME = "MyApp"; // 声明一个静态常量 APP_NAME
}

所以修饰方法，修饰类等也都可以一起用，作用是二者的叠加，此处就不再举例子了！

前路漫漫，愿星光与您相伴！