Static

static静态关键字

1、static是什么、修饰成员变量的用法

static在内存中只有一份，可以与他人进行共享

static可以修饰成员变量和成员方法

package staticStu;

public class User {
    /**
     在线人数
     注意：static修饰的成员变量：静态成员变量，只在内存中有一份，可以被共享
     */
    public static int onlineNumber=161;

}

package staticStu;

public class StaticDemo1 {
    public static void main(String[] args) {
        // 目标：理解static修饰成员变量的作用和访问特点
        // 1、类名.静态成员变量
        System.out.println(User.onlineNumber);

        // 不推荐这样写
        User u=new User();
        u.onlineNumber++;
        System.out.println(u.onlineNumber);


    }
}

访问形式是：类名.静态成员变量

注意：同一个类中静态成员变量的访问可以省略类名
使用类名访问会更快

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

3、static修饰成员方法的基本用法

package staticStu;

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));
        // 注意：同一个类中，访问静态方法，类名可以省略不写
        System.out.println(getMax(10,32));

        // study();//报错了
        //2、对象.实例方法
        Student s=new Student();
        s.name="猪八戒";
        s.study();

        //3、对象.静态方法(语法是可行的，但是不推荐)
        System.out.println(s.getMax(13,34));
    }
}

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

类进方法区；静态的东西与类优先加载进方法区

5、static的注意事项

package staticStu;

public class StaticDemo2 {
    /**
     * 静态成员
     */
    public static int onlineNumber=10;
    public static void test2(){
        System.out.println("===test2====");
    }

    /**
     * 实例成员
     */

    private String name;
    public void run(){
        System.out.println(name+"跑的快~~");
    }

    //1、静态方法只能访问静态成员，不能直接访问实例成员
    public static void test(){
        System.out.println(StaticDemo2.onlineNumber);
        System.out.println(onlineNumber);
        test2();
        // System.out.println(name);// 不能直接访问实例成员,可以间接访问
    }

    // 2、实例方法可以访问静态成员，也可以访问实例成员
    public void go(){

        //静态成员是共享的，可以在所有的地方访问
        System.out.println(StaticDemo2.onlineNumber);
        System.out.println(onlineNumber);
        test2();
        System.out.println(name);// 实例方法属于对象，对象调用go()方法时，name也是访问当前对象的name
        run();
        System.out.println(this.name);
        System.out.println(this);//代表对象的地址
    }

    //3、静态方法中不可以出现this关键字
    public static void test3(){
        // System.out.println(this);//this代表当前对象！！静态方法可以不用对象调用
    }


    public static void main(String[] args) {

    }
}

总结

static应用知识：工具类

调用方便，提高了代码复用

package staticStu.util;

import java.util.Random;

    /**
     * 工具类
     */

public class ItheimUtil {

    /**
        注意：由于工具类无需创建对象，所以把其构造器私有化会显得很专业
     */
    private ItheimUtil(){   // 私有构造器，对外不能实例化对象
    }


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

}

package staticStu.util;

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

package staticStu.demo4;

public class ArrayUtil {
    /**
        私有构造器
     */
    private ArrayUtil(){

    }

    /**
        工具方法：静态方法
     */
    public static String toString(int[] arr){
        // 1、一些校验
        if(arr==null){
            return null;
        }
        
        // 2、拼接内容并返回
        String result="[";
        for (int i = 0; i < arr.length; i++) {
            result+=(i== arr.length-1? arr[i]:arr[i]+", ");
        }
        result+="]";
        return result;
    }

}

package staticStu.demo4;

public class TestDemo4 {
    public static void main(String[] args) {
        int[] arr=null;
        int[] arr1={};
        int[] arr2={12,34,56,78};

        System.out.println(ArrayUtil.toString(arr));
        System.out.println(ArrayUtil.toString(arr1));
        System.out.println(ArrayUtil.toString(arr2));
    }


}

static应用知识：代码块

1、代码块的分类、作用

package staticStu.static_code;

import java.util.ArrayList;

public class StaticCode {

    public static String schoolName;
    public static ArrayList<String> cards=new ArrayList<>();//整个系统只有一份 54张牌



    /**
     静态代码块：有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);
    }


}

静态代码块：有static修饰，属于类，与类一起优先加载一次，自动触发执行

package staticStu.static_code;

public class StaticCode2 {

    private String name;

    public StaticCode2(){
        System.out.println("===无参构造器触发执行===");
    }

    /**
     实例代码块：无static修饰，属于对象，每次构建对象时，都会触发一次执行
     */

    {
        name="张三";
        System.out.println("===实例代码块被触发执行===");
    }


    public static void main(String[] args) {
        //目标：理解实例代码块(构造代码块)
        StaticCode2 s1=new StaticCode2();
        System.out.println(s1.name);

        StaticCode2 s2=new StaticCode2();
        System.out.println(s2.name);

    }
}

实例代码块：无static修饰，属于对象，每次构建对象时，都会触发一次执行

代码块每次都在无参构造器前面执行

2、静态代码块的应用案例

静态代码块可以在启动之前用于静态资源的初始化

package staticStu.demo5;

import java.util.ArrayList;

public class StaticTest {
    /**
     1、定义一个静态的集合，这样这个集合只加载一个，因为当前房间只需要一副牌
     */
    public static ArrayList<String> cards=new ArrayList<>();

    /**
     2、在程序真正运行main方法前，把54张牌放进去，后续游戏可以直接使用了
     */
    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++) {
            //遍历花色
            for (int j = 0; j < colors.length; j++) {
                //一张牌
                String card=sizes[i]+colors[j];
                cards.add(card);
            }
        }
        // e、单独加入大小王
        cards.add("小王");
        cards.add("大王");

    }

    public static void main(String[] args) {
        // 目标：模拟游戏启动前，初始化54张牌数据
        System.out.println("新牌："+cards);
    }
    
}

static应用知识：单例

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

单例类：说白了就是那对象，拿的是同一个对象

package staticStu.demo6;
/**
 * 使用饿汉单例实现单例类
 */

public class SingleTest {

    /**
     2、饿汉单例是在获取对象前，对象已经提前准备好了一个。
     这个对象只能是一个，所以定义静态成员变量记住
     */
    public static SingleTest instance=new SingleTest();
    public static int age=21;


    /**
     * 必须把构造器私有化
     */
    private SingleTest(){

    }

}

package staticStu.demo6;

public class Test {
    public static void main(String[] args) {
        SingleTest s1 = SingleTest.instance;
        SingleTest s2 = SingleTest.instance;
        System.out.println(s1==s2);// 地址是一样的

    }
}

2、懒汉单例模式

懒汉单例：等到需要的时候才会去创建对象

package staticStu.demo7;

public class SingleInstance {
    /**
     * 1、私有化构造器
     */
    private SingleInstance(){

    }

    /**
     * 2、定义一个静态的成员变量负责存储一个对象。
     * 只加载一次，只有一份
     * 注意：最好私有化，这样可以避免给别人挖坑
     */
    private static SingleInstance instance;

    /**
     * 3、提供一个方法，对外返回单例对象
     */
    public static SingleInstance getInstance(){
        if(instance==null){
            // 第一次来拿对象：此时需要创建对象
            instance=new SingleInstance();
        }
        return instance;
    }


}

package staticStu.demo7;

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