Static关键字

最新推荐文章于 2024-08-06 10:22:43 发布

TDD️

最新推荐文章于 2024-08-06 10:22:43 发布

阅读量35

点赞数

分类专栏：学习计划文章标签： java

本文链接：https://blog.csdn.net/weixin_58140823/article/details/125944010

版权

学习计划专栏收录该内容

7 篇文章 0 订阅

订阅专栏

文章目录

1、饿汉单例模式（在获取对象时，已经提前准备好）

2、懒汉单例模式（延迟加载对象，在需要该对象时，才去创建一个对象，每次对象都是同一个）

六、总结

前言

这两天在写方法的时候，每次都很习惯性的加上static，但是明白这个static到底是什么用处，而且在类中用static修饰的方法也不能有this关键字，所以就去专门看了几节关于static关键字用法的课程和资料，这里就记录学习到的一部分关于static的知识。

一、static是什么？

它翻译过来就是静态的意思，所以被它修饰的成员变量和方法可以称作静态成员变量，静态方法；下面就介绍一下静态的成员变量和方法到底有什么用处。

二、静态成员变量

静态成员变量它在内存中只存储一份，可以被共享、修改；想要调用这个变量的时候可以不用new一个对象出来，直接用类名.变量名就可以直接访问，也是简化了程序的编写。比如在在线人数统计的时候，就可以用到这个静态成员变量，因为它是一个共享的，每进入一个用户，就让它自增一。

代码如下（示例）：

public class User {
    public static int onLineNumber = 161;//静态修饰，可以被共享
   }


public class StaticTest1 {
    public static void main(String[] args) {
        User.onLineNumber++;//直接通过类名.静态成员变量调用
        System.out.println(User.onLineNumber);

}

三、静态方法

在方法前面加一个static修饰又有什么用处呢？它的目的就是执行一个通用的功能，方便在别的地方访问；这也就很自然的衍生出了一个很重的类——工具类（该类中构造器要私有，防止在外产生对象浪费内存），里面包含着通用的功能，在写程序的时候需要用到这个功能时直接调用即可，要想维护啊也变得很方便，让程序变得更加健壮。但是有个要注意的地方就是，对象自己独有的行为（方法）就不能加static修饰了，不然别的对象也能去访问这个行为了。

代码如下（示例）：

import java.util.Random;
//当一个功能在一个小程序中需要被多次使用时，就可以封装为一个工具类，然后根据类名.方法名调用
//工具类里面的构造器应该为私有，防止尝生对象，浪费内存

public class TOOL {
    private TOOL(){

    }

    //随机生成验证码
    public static String creatCode(int a){
        String x = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        String code = "";
        Random random = new Random();
        for(int i = 0 ; i < 5 ; i++){
            int index = random.nextInt(x.length());
                        code +=  x.charAt(index);
        }
        return code;
    }

    //返回整数数组内容
    public static String ArraysUtils(int a[]){
        String result = "[";
        for (int i = 0; i < a.length; i++) {
            result += (i==a.length-1?a[i]:a[i]+",");
        }
        result+="]";
        return result;
    }

    //计算平均数
   public static double getAerage(int[] a){
        int sum = 0;
        double min = a[0];
        double max = a[1];
       for (int i = 2; i < a.length; i++) {
           if(min>a[i]){
               min =a[i];
           }
           if(max<a[i]){
               max=a[i];
           }
           sum +=a[i];
       }
       return sum-min-max/a.length;
   }
}

然后在测试类中去使用工具类，会发现程序就简介明了了很多

public class TOOLTest {
    public static void main(String[] args) {
        System.out.println("随机生成五位数的验证码：" +TOOL.creatCode(5));
          int []a = {1,2,3,4,5};
        System.out.println("输出数组元素：" +TOOL.ArraysUtils(a));

        System.out.println("计算数组平均数：" +TOOL.getAerage(a));
    }
}

四、代码块

它的主要特征就是与类一起加载，自动触发一次，优先执行，所以代码块一般是用来在程序加载时进行静态数据的初始化操作（准备内容），它是定义在类中方法外。

代码实例（斗地主的牌在开局之前就应该是准备好了，后面直接去发放，这里模拟的是一个简易的扑克牌准备）：

import java.util.ArrayList;

public class StaticTest {
    public static ArrayList<String> arrayList = new ArrayList<>();

    /**
     *  静态方法特点：随类一起加载，自动触发一次，优先执行
     *  用处：可以在程序加载时进行静态数据的初始化操作（准备内容）
     */
    static {
       String []colors = {"黑桃","红心","方块","梅花"};
       String []size = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};

        for (int i = 0; i < size.length; i++) {
            for (int j = 0; j < colors.length; j++) {
                arrayList.add(size[i]+colors[j]);
            }
        }
        arrayList.add("大 🃏");
        arrayList.add("小 🃏");
        System.out.println("我先执行");
    }

    public static void main(String[] args) {
        System.out.println("我再执行");
        System.out.println("扑克：" +arrayList);
    }
}

五、设计模式

其中static最重要的一个地方就是单例模式了，它保证系统中，应用该模式的这个类永远只有一个实例，即一个类只能创建一个对象；其中涉及到的就是饿汉单例模式和懒汉单例模式。

1、饿汉单例模式（在获取对象时，已经提前准备好）

（1）必须私有构造器，防止在外产生新的对象；

（2）定义一个静态变量存储一个对象；

/**
     饿汉单例：1.必须私有构造器
             2。定义一个静态变量存储一个对象
 **/
public class Singal1 {
    //定义一个静态变量存储一个对象
    public static Singal1 singal = new Singal1();
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    //私有构造器
    private Singal1(){
        System.out.println("这是饿汉单例设计模式！");
    }

    public static void main(String[] args) {
        //在想用对象时直接调用即可
        singal.setName("TT");
        System.out.println(singal.getName());
    }
}

2、懒汉单例模式（延迟加载对象，在需要该对象时，才去创建一个对象，每次对象都是同一个）

（1）私有构造器，防止产生对象；

（2）定义一个静态的变量存储一个对象（此时为null）；

（3）提供一个返回单例对象的方法，保证每次返回的对象都是同一个。

/**
 * 懒汉单例：1.私有一个构造器
 *         2.定义一个静态的变量存储一个对象（此时为null）
 *         3.提供一个返回单例对象的方法，可以保证每次返回的对象都是同一个
 */
public class Singal2 {
    //私有构造器
    private Singal2(){

    }
    //定义一个静态变量，存储本类的对象（不能初始化对象）
    public static Singal2 singal2; //null

    //定义一个方法，让别的地方可以调用获取一个对象
    public static Singal2 getInstance(){
        if(singal2==null){ //第一次获取对象
            singal2 = new Singal2();
        }
        return singal2;
    }

    public static void main(String[] args) {
        //通过调用类中的方法来获取对象，保证每次获取的对象都是一致的
        Singal2 s1 = Singal2.getInstance();
        Singal2 s2 = Singal2.getInstance();

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1==s2);

    }
}