Java static关键字详解

碳烤小肥羊。。。

已于 2022-08-01 22:38:04 修改

阅读量928

点赞数 1

分类专栏： Java基础知识文章标签： java

于 2022-03-11 21:14:46 首次发布

本文链接：https://blog.csdn.net/qq_43751200/article/details/123417738

版权

Java基础知识专栏收录该内容

71 篇文章 16 订阅

订阅专栏

文章目录

static的作用、修饰成员变量的用法

1：static是静态的意思，可以修饰成员变量和成员方法。
2：static**修饰成员变量表示该成员变量只在内存中只存储一份，可以被共享访问、修改。

问题1：成员变量的分类和访问分别是什么样的？
静态成员变量（有static修饰，属于类、加载一次，可以被共享访问），访问格式：

类名.静态成员变量(推荐)
对象.静态成员变量(不推荐)。

实例成员变量（无static修饰，属于对象），访问格式：

对象.实例成员变量。

问题2：两种成员变量各自在什么情况下定义？

静态成员变量：表示在线人数等需要被共享的信息。
实例成员变量：属于每个对象，且每个对象信息不同时（name,age,…等）

实例代码：

/**
public class User {
    // 静态成员变量：有static修饰，属于类，加载一次，可以被共享访问
    public static int onLineNumber = 161;
    // 实例成员变量：无static修饰，属于每个对象
    private String name;
    private int age;

    public static void main(String[] args) {
        // 1.类名.静态成员变量
        System.out.println(User.onLineNumber);
        System.out.println(onLineNumber);
        User.onLineNumber++;

        //2. 创建用户对象：对象.实例成员
        User user = new User();
        user.name = "luShiMeng";
        user.age = 22;
        System.out.println(user.name);
        System.out.println(user.age);
        // 对象名称：静态成员变量(不推荐)
        System.out.println(user.onLineNumber);

        User user1 = new User();
        user1.name = "yangYinYu";
        user1.age = 18;
        System.out.println(user1.name);
        System.out.println(user1.age);
        // 对象名称：静态成员变量(不推荐)
        user1.onLineNumber++;

        System.out.println(User.onLineNumber);

    }
}

static修饰成员变量的内存原理：

在这里插入图片描述

static修饰成员方法的基本使用：

成员方法的分类：

1： 静态成员方法（**有static修饰**，属于类），建议用类名访问**，也可以用对象访问。
2： 实例成员方法（无static修饰，属于对象），只能用对象触发访问(即先实例化一个对象，然后用对象引用方法)。

使用场景分析：

表示对象自己的行为的，且方法中需要访问实例成员的，则该方法必须申明成实例方法。
如果该方法是以执行一个**共用功能为目的**，则可以申明成静态方法。

问题1：成员方法的分类和访问分别是什么样的？

 静态成员方法（有static修饰，属于类和对象共享）访问格式：
		类名.静态成员方法。
		对象.静态成员方法。（不推荐）
 实例成员方法（无static修饰，属于对象）的访问格式：
		对象.实例成员方法。

问题2：每种成员方法的使用场景是怎么样的？

表示对象自己的行为的，且方法中需要访问实例成员的，则该方法必须申明成实例方法。
 如果该方法是以执行一个通用功能为目的，或者需要方便访问，则可以申明成静态方法

实例代码：

public class Student {
    private String name;
    // 1. 实例方法： 无static修饰的，属于对象的
    public void study(){
        System.out.println(name + "在好好学习~~~~");
    }
    // 2. 静态方法：有static修饰，属于类和对象共享的
    public static int getMax(int a, int b){
       return (a > b ? a : b);
    }

    public static void main(String[] args) {
        // 1. 类名.静态成员方法
        System.out.println(Student.getMax(10, 100));
        // 注意： 同一个类中访问静态成员类名可以不写
        System.out.println(getMax(10, 100));

        // 2.对象.实例成员方法
        Student student = new Student();
        student.name = "lushimeng";
        student.study();

        // 3. 对象.静态成员方法(不推荐)
        System.out.println(student.getMax(10, 100));
    }
}

static修饰成员方法的内存原理：

在这里插入图片描述

static实际应用案例：定义工具类

工具类：

工具类中定义的都是一些静态方法，每个方法都是以完成一个共用的功能为目的。

问题1：工具类是什么，有什么好处？

内部都是一些静态方法，每个方法完成一个功能
一次编写，处处可用，提高代码的重用性。

问题2：工具类有什么要求？

建议工具类的构造器私有化处理(这样工具类就不能实例化对象了，可以减少内存的浪费)。
工具类不需要创建对象。

验证码工具类应用
login类

import java.util.Random;
public class login {
    public static void main(String[] args) {
        // 调用工具类，随机产生5位数验证码
        String code = VerifyTool.generateCode(5);
        System.out.println(code);
    }
}

Register类

import java.util.Random;
public class Register{
    public static void main(String[] args) {
        // 调用工具类，随机产生5位数验证码
        String code = VerifyTool.generateCode(5);
        System.out.println(code);
    }
}

VertifyTool类

/**
import java.util.Random;
public class VerifyTool {
    // 定义成私有变量的原因防止工具类实例化，浪费内存，访问静态方法可以直接通过类名的方式进行访问
    private VerifyTool(){
    }

    /**
     * 随机产生n位验证码
     * @param n
     * @return
     */
    public static String generateCode(int n){
        String str = "0123456789QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm";
        String code = "";
        Random random = new Random();
        for(int i = 0; i < n; i++){
            int index = random.nextInt(str.length());
            code += str.charAt(index);
        }
        return code;
    }
}

static的注意事项

1、静态方法只能访问静态的成员，不可以直接访问实例成员。
2、实例方法可以访问静态的成员，也可以访问实例成员。
3、静态方法中是不可以出现this关键字的。

public class Test {
    // 静态成员变量
    public static int onLineNumber;
    // 实例成员变量
    private String name;

    // 1. 静态方法可以直接访问静态成员变量
    // 不能直接访问实例成员变量，但可以通过实例化对象进行访问
    public static void getMax(){
        System.out.println(Test.onLineNumber);
        System.out.println(onLineNumber);
        //System.out.println(name);  // 错误，实例化成员变量只能有实例化对象去访问，不能放在静态方法中
        //System.out.println(this);  // 静态方法中不能出现this变量
        Test t = new Test();  // 静态方法中可以通过实例化对象访问实例成员变量
        System.out.println(t.name);

        inAddress();  // 静态方法中可以访问静态方法
    }

    public static void inAddress(){
        System.out.println(onLineNumber);
    }

    // 2. 实例方法可以直接访问静态成员，也可以访问实例成员
    public void run(){
        System.out.println(onLineNumber);  // 访问静态成员变量
        System.out.println(name);  // 访问实例化成员变量
        System.out.println(this.name);
        inAddress();  // 访问静态方法
        getMax();
        sing();  // 访问实例化方法
    }
    
    public void sing(){
    }
}

static应用知识：代码块

代码块的分类、作用

代码块概述
代码块是类的5大成分之一（成员变量、构造器，方法，代码块，内部类），定义在类中方法外。
在Java类下，使用 { } 括起来的代码被称为代码块 。

代码块分为
	静态代码块: 
				格式：static{}
				特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次
				使用场景：在类加载的时候做一些静态数据初始化的操作，以便后续使用。

 	构造代码块（了解，用的少）：
				格式：{}
				特点：每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行
				使用场景：初始化实例资源。

问题1：静态代码块的作用是什么?

1、可以在系统启动时对静态成员变量进行初始化。
2、建议使用静态代码块完成数据的初始化操作，代码优雅。

静态代码块的应用案例

在这里插入图片描述 斗地主游需求：在启动游戏房间的时候，应该提前准备好54张牌，后续才可以直接使用这些牌数据。

需求分析：
1、该房间只需要一副牌。
2、定义一个静态的ArrayList集合存储54张牌对象，静态的集合只会加载一份。
3、在启动游戏房间前，应该将54张牌初始化好
4、当系统启动的同时需要准备好54张牌数据，此时可以用静态代码块完成。

import java.util.ArrayList;

public class StaticCodeTest {
    /**
     * 模拟初始牌操作
     * 点数: "3","4","5","6","7","8","9","10","J","Q","K","A","2"
     * 花色: "♠", "♥", "♣", "♦"
     * 1. 准备一个容器，存储54张牌对象，这个容器建议使用静态的集合。静态的集合只加载一次
     */
    public static ArrayList<String> cards = new ArrayList<>();
    // 2、在游戏启动之前需要准备好54张牌放进去，静态代码快，随着类的加载而加载，并且自动触发、只执行一次
    static {
        // 3、加载54张牌进去
        // 4、准备4中花色，类型确定，个数确定
        String[] colors = {"♠", "♥", "♣", "♦"};
        // 5、 定义点数
        String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        // 6、先定义点数再定义花色
        for (int i = 0; i < numbers.length; i++) {
            for (int j = 0; j < colors.length; j++) {
                cards.add(numbers[i] + colors[j]);  // 组装牌
            }
        }

        // 7、添加大小王
        cards.add("大王");
        cards.add("小王");

    }

    public static void main(String[] args) {
        System.out.println("初始化牌：" + cards);
    }
}

在这里插入图片描述

static应用知识：单例设计模式

设计模式、单例模式介绍、饿汉单例模式
单例模式

1、可以保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象。
2、例如任务管理器对象我们只需要一个就可以解决问题了，这样可以节省内存空间。

饿汉单例设计模式：在用类获取对象的时候，对象已经提前为你创建好了。

设计步骤：
1、定义一个类，把构造器私有。
2、定义一个静态变量存储一个对象。

代码实例：
在这里插入图片描述

懒汉单例模式：在真正需要该对象的时候，才去创建一个对象(延迟加载对象)。

设计步骤：
1、定义一个类，把构造器私有。
2、定义一个静态变量存储一个对象(一开始并不实例化对象，采用默认值的方式)。
3、提供一个返回单例对象的方法

代码实例：
在这里插入图片描述

碳烤小肥羊。。。

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
2
评论
Java static关键字详解

static的作用、修饰成员变量的用法1：static是静态的意思，可以修饰成员变量和成员方法。2：static修饰成员变量表示该成员变量只在内存中只存储一份，可以被共享访问、修改。问题1：成员变量的分类和访问分别是什么样的？静态成员变量（有static修饰，属于类、加载一次，可以被共享访问），访问格式：类名.静态成员变量(推荐)对象.静态成员变量(不推荐)。实例成员变量（无static修饰，属于对象），访问格式：对象.实例成员变量。问题2：两种成员变量各自在什么情况下定义？静态成员
复制链接

扫一扫