static关键字整理

别打扰我OK

已于 2022-11-21 09:46:25 修改

阅读量338

点赞数

分类专栏： JAVA SE基础文章标签： java jvm

于 2022-11-20 21:30:04 首次发布

本文链接：https://blog.csdn.net/weixin_68151004/article/details/127946628

版权

JAVA SE基础专栏收录该内容

12 篇文章 0 订阅

订阅专栏

文章目录

一、static静态关键字
二、static应用知识：工具类
三、static应用知识：代码块
四、static应用知识：单例设计模式

一、static静态关键字

1.static的定义

static修饰成员变量和成员方法
在内存中只存储一份，可以被共享、修改

2.static修饰成员变量的用法

有static修饰，属于类，加载一次，可以被共享访问
访问特点：
类名.静态成员变量（推荐）
对象.静态成员变量（不推荐）

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

3.1成员变量分类

静态成员变量：有static修饰，与类一起加载、属于类
实例成员变量：没有static修饰，与实例有关
3.2

public class User {
    //静态成员变量，有static修饰，属于类，加载一次，可以被共享访问
    public static int onlineNumber=161;
    private String name;
    private int age;
    public static void main(String[] args) {
        //1.类名.静态成员变量
        System.out.println(User.onlineNumber);//161
        System.out.println(onlineNumber);//同一个类中访问静态成员变量可以省略类名//161
        User.onlineNumber++;//162
       // System.out.println(name);//报错
        //2.创建用户对象：对象.实例成员变量
        User u1=new User();
        u1.name="孙悟空";
        u1.age=35;
        System.out.println(u1.name);//孙悟空
        System.out.println(u1.age);//35
        //对象名称.静态成员变量，不推荐
        u1.onlineNumber++;//163
        User u2=new User();
        u2.name="猪八戒";
        u2.age=29;
        System.out.println(u2.name);//猪八戒
        System.out.println(u2.age);//29
        u2.onlineNumber++;
        //对象名称.静态成员变量，不推荐
        System.out.println(onlineNumber);//164
    }
}

在这里插入图片描述

4.static修饰成员方法的基本用法

4.1成员方法的分类：

静态成员方法：（有static修饰、归属于类），建议用类名访问，也可以用对象访问
实例成员方法：（无static修饰、对属于对象），只能用对象触发访问
4.2使用场景：表示对象自己行为的，且方法中需要访问实例成员的，则方法必须声明成实例方法
表示对象自己行为的，且方法中需要访问实例成员的，则方法必须声明成实例方法
如果该方法是以执行一个共用功能为目的，则可以声明成静态方法

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

public class Student {
    /**
     * 实例成员变量，无static修饰，属于对象
     */
    private String name;
    /**
     * 静态成员方法,有static修饰，归属于类，可以被共享访问用类名或者对象名都可以访问
     */
    public static int getMax(int age1,int age2){
        return age1>age2?age1:age2;
    }
    /**
     * 实例成员方法：属于对象，整只能用户对象触发访问
     */
    public void study(){
        System.out.println(name+"在好好学习");
    }
    public static void main(String[] args) {
        //1.类名.静态成员方法
        //注意：同一个类中访问静态成员方法可以省略类名
        System.out.println(Student.getMax(10, 3));
        //study();//会报错
        //2.对象.实例方法
        Student s=new Student();
        s.name="猪八戒";
        s.study();
        //3.对象.静态成员方法
        System.out.println(s.getMax(20, 10));//不推荐
    }
}

在这里插入图片描述

6.static的注意事项

静态方法只能访问静态的成员，不能直接访问实例成员，可通过创建对象间接访问实例成员
实例方法既可以访问静态成员，也可以访问实例成员
静态方法中不可以出现this关键字

//目标：理解static访问的相关语法，面试笔试题，方面日后理解程序
public class Test {
    /**
     * 静态成员
     */
    public static int onlineNumber=10;
    //1.静态方法只能访问静态成员，不能直接访问实例成员
    public static void test2(){
        System.out.println("===============test2=====================");
    }
    /**
     * 实例成员
     */
    private String name;
    private void run(){
        System.out.println(name+"跑的快");
    }
    //3.静态方法中不可以出现this关键字
    public static void test3(){
       // System.out.println(this.name);this代表当前对象，静态方法可以不用对象调用
    }
    //2.实例方法可以访问静态成员，也可以访问实例成员
    public void go(){
        System.out.println(onlineNumber);//实例方法可以访问静态成员，静态成员是共享的
        System.out.println(name);//实例方法可以访问实例成员
        run();//实例方法可以访问实例成员
        test2();//实例方法可以访问静态成员
        System.out.println(this.name);
    }
    public static void test(){
        System.out.println(Test.onlineNumber);//Test.可省略
        Test.test2();//Test.可省略;
        Test t=new Test();
        System.out.println(t.name);//不能直接访问，可以通过创建对象间接访问
     //   System.out.println(name);//报错，不能直接访问实例成员
        //run();//报错,能直接访问成员方法,可通过创建对象间接访问
        t.run();
    }
    public static void main(String[] args) {

    }
}

二、static应用知识：工具类

1.定义

类中都有一些静态方法，每个方法都是以完成一个共用的功能为目的，这个类用来给系统开发人员共同使用

2.优点

调用方便，提高了代码的复用（一次编写，处处可用）

3.案例

/**
 * 工具类
 */
public class ItheimaUtil {
    /**
     * 静态方法
     */
    public static String createVerifyCode(int n){
        //开发一个验证码
        //1.定义一个变量，记住验证码
        String code="";
        //2.定义一个变量记住全部验证码字
        String data="abcdefghigklmnopqrstuvwxyzABCDEFGHIGKLKMOPQRSTUVWXYZ0123456789";
        //3.定义一个循环生成几个随机索引，去得到几个字符
        Random r=new Random();
        for(int i=0;i<n;i++){
            //4.获取随机索引对应的字符，连接code
            int index=r.nextInt(data.length());
            code+=data.charAt(index);
        }
        System.out.println("验证码为："+code);
        return code;
    }
}

public class Login {
    public static void main(String[] args) {
        System.out.println(ItheimaUtil.createVerifyCode(5));
    }
}

public class Check {
    public static void main(String[] args) {
        System.out.println(ItheimaUtil.createVerifyCode(6));
    }
}

4.工具类中的方法不用实例方法

实例方法需要创建对象调用
此时用对象只是为了调用方法，这样只会浪费内存

5.工具类定义时的其他要求

由于工具里面的都是静态方法，直接用类名即可访问，因此，工具类无需创建对象，建议将工具类的构造器进行私有

三、static应用知识：代码块

1.代码块概述

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

2.代码块的分类

2.1静态代码块

格式：static{}

public class StaticDemo1{
    public static String schoolName;
    public static ArrayList<String> cards=new ArrayList<>();
    /**
     * 静态代码块：有static修饰，与类一起优先加载一次，自动触发执行
     * 作用：可以用于初始化静态资源
     */
    static {
        System.out.println("-------静态代码块被触发执行了------------");
        schoolName="成功";
        cards.add("3");
        cards.add("4");
    }
    public static void main(String[] args) {
        //目标：理解静态代码块
        System.out.println("-----------------main方法执行--------------");
        System.out.println(schoolName);
        System.out.println(cards);
    }
}

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

public class StaticDemo1{
    public static String schoolName;
    public static ArrayList<String> cards=new ArrayList<>();
    /**
     * 静态代码块：有static修饰，与类一起优先加载一次，自动触发执行
     * 作用：可以用于初始化静态资源
     */
    static {
        System.out.println("-------静态代码块被触发执行了------------");
        schoolName="成功";
        cards.add("3");
        cards.add("4");
    }
    public static void main(String[] args) {
        //目标：理解静态代码块
        System.out.println("-----------------main方法执行--------------");
        System.out.println(schoolName);
        System.out.println(cards);
    }
}

2.2构造代码块（了解、见得少）

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

public class StaticDemo2 {
    private String name;
    StaticDemo2(){
        System.out.println("-------------无参构造器被触发执行了-----------------");
    }
    /**
     * 实例代码块，无static修饰，属于对象，每次构建对象时，都会触发一次执行
     */
    {
        name="张三";
        System.out.println("------------构造代码块被触发执行了------------------");
    }
    public static void main(String[] args) {
        //目标：理解构造代码块（实例代码块）
        StaticDemo2 s1=new StaticDemo2();
        System.out.println(s1.name);//张三
        StaticDemo2 s2=new StaticDemo2();
        System.out.println(s2.name);//张三
    }
}

注：设计开发中并不会这样用

2.3静态代码块的应用案例

需求：在启动游戏房间的时候，应该准备好54张牌，后续才可以使用这些数据

/**
 * 1.定义一个静态的集合，这样这个集合只能加载一个，因为当前房价只需要一副牌
 */
public class StaticTest3 {
    public static ArrayList<String> cards=new ArrayList<>();
    static{
        //3.正式做牌，放到集合中去
        //a.先定义一个数组存储全部点数（类型确定，个数确定用数组）
        String[] sizes={"3","4","5","6","7","8","9","10","J","Q","k","A","2"};
        //b.定义一个数组存储全部花色（个数确定、类型确定用数组）
        String[] colors={"♥","♠","♦","♣"};
        //c.遍历
        for (int i = 0; i < sizes.length; i++) {
            //size[i]
            //d.遍历花色
            for (int j = 0; j < colors.length; j++) {
                //colors[j]
                String card=sizes[i]+colors[j];
                cards.add(card);
            }
        }
        //e.单独加入大小王
        cards.add("小王");
        cards.add("大王");
    }
    public static void main(String[] args) {
        //目标：模拟游戏启动前初始化54张牌数据
        /**
         * 2.在程序真正运行main方法前，把54张牌放进去，后续游戏可以直接使用
         */
        System.out.println("新牌："+cards);
    }
}

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

1.设计模式的定义

开发中经常遇到的一些问题，一个问题通常有n种解法，但其中肯定有一种解法是最优的，这个最优解法被人总结出来称为设计模式

2.单例模式

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

3.单例模式的实现方式有很多

饿汉单例模式
懒汉单例模式

4.饿汗单例设计模式

4.1在用类获取对象时，对象已经提前创建好了

4.2饿汗单例的实现步骤

定义一个类，将构造器私有

private SingleInstance(){

    }

定义一个静态变量存储一个对象

 public static SingleInstance instance=new SingleInstance();

/**
 * 使用饿汗单例实现单例类
 */
public class SingleInstance {
    /**
     * 2.饿汗单例是在获取对象前，对象已经准备好了一个
     * 这个对象只能是一个，所以定义静态成员变量
     */
    public static SingleInstance instance=new SingleInstance();
    /**
     * 1.必须将构造器私有
     */
    private SingleInstance(){

    }
}

public class Test1 {
    public static void main(String[] args) {
        //目标：理解饿汗单例的设计步骤
        SingleInstance s1=SingleInstance.instance;
        SingleInstance s2=SingleInstance.instance;
        System.out.println(s1==s1);//true
    }
}

5.懒汉单例模式

5.1定义

在真正需要该对象的时候，才去创建一个对象（延迟加载对象）

5.2懒汉单例的设计步骤

定义一个类，将构造器私有
定义一个静态变量存储一个对象

 private static SingleInstance2 instance;

注意:私有化，这样避免给别人造成麻烦

提供一个返回单例对象的方法

public static SingleInstance2 getInstance(){
        if(instance==null){
            //第一次来拿对象，此时需要创建对象
            instance=new SingleInstance2();
        }
        return instance;
    }

public class SingleInstance2 {
    /**
     * 2.定义一个静态的成员变量，负责存储单例对象,
     * 静态成员变量只加载一次，只有一份
     * 注意:私有化，这样避免给别人造成麻烦
     */
    private static SingleInstance2 instance;
    /**
     * 3.提供一个方法，对外返回单例的对象
     */
    public static SingleInstance2 getInstance(){
        if(instance==null){
            //第一次来拿对象，此时需要创建对象
            instance=new SingleInstance2();
        }
        return instance;
    }
    /**
     * 1.私有化构造器
     */
    public SingleInstance2() {
        
    }
}

public class Test2 {
    public static void main(String[] args) {
        //目标：掌握懒汉单例的设计，并理解其思想
        SingleInstance2 s1=SingleInstance2.getInstance();
        SingleInstance2 s2=SingleInstance2.getInstance();
        System.out.println(s1==s2);
    }
}