Static静态关键字

Static静态关键字

定义

static是静态的意思，可以修饰成员变量和成员方法。

static修饰成员变量表示该成员变量在内存中只能存储一份，可以被共享访问，修改。

成员变量可以分为两类

• 静态成员变量(有static修饰，属于类，内存中加载一次)：常表示如在线人数信息、等需要被共享的信息，可以被共享访问。

• 实例成员变量(无static修饰，存在于每个对象中)：常表示姓名name、年龄age、等属于每个对象的信息。

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

statci修饰成员方法的基本用法

public class User {
    /**
     * 在线人数
     * 注意：static修饰的成员变量：静态变量，只在内存中存一份
     */
    public static int onlineNumber = 161;
    /**
     * 实例成员变量：无static修饰，属于每个对象的，必须用对象名.访问
     */
    private String name;
    private int age;

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

        // 2.对象名.实例成员变量
        User u = new User();
        u.name = "张三";
        u.age = 23;
        System.out.println(u.name);
        System.out.println(u.age);
        u.onlineNumber++;//新来一个人

        User u2 = new User();
        u.name = "李四";
        u.age = 23;
        System.out.println(u2.name);
        System.out.println(u2.age);
        u.onlineNumber++;//新来一个人

        System.out.println(u.onlineNumber);
        System.out.println(User.onlineNumber); // 推荐方式
        //注意：同一个类中静态成员变量的访问可以省略类名
        System.out.println(onlineNumber);
    }
}

成员方法的分类

• 静态成员方法(有static修饰，归属于类)，建议用类名访问，也可以用对象访问
• 实例成员方法(无static修饰，归属于对象)，只能用对象出发访问。

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

public class Student {
    /**
     * 实例成员变量，无staitc修饰。属于对象。
     */
    private String name;

    /*
        静态成员方法:有static修饰，归属于类，可以被共享访问，用类名或方法名都可以访问
     */
    public static int getMax(int age1,int age2){
        return age1 > age2 ? age1 : age2;
    }

    /*
       实例方法：属于对象的，只能用对象出发访问
     */
    public void study(){
        System.out.println(this.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(10,3));
    }

}

static的注意事项（可能出面试题）

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

public class Test3 {
    // 目标：理解static 访问相关的语法：面试笔试题，或者以后理解程序很重要的知识（拓展）

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

    /*
        实例成员
     */
    private String name;
    public void run(){
        System.out.println(name+"跑得快");
    }

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

    // 2.实例方法可以访问静态成员，也可以访问实例成员
    public void go(){
        System.out.println(onlineNumber);
        System.out.println(Test3.onlineNumber);
        test2();
        System.out.println(name);
        System.out.println(this.name);
        run();
    }


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

    }

    public static void main(String[] args) {

    }
}

static应用知识：工具类

工具类是什么

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

案例

/**
 * 工具类
 */
public class zzxUtil {

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

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

工具类的优势

• 内部都是一些静态方法，每一个方法完成一个功能
• 一次编写，出出可用

工具类的要求

• 建议工具类的构造器私有化处理。

练习

ArraysUtils工具类

/**
 * ArraysUtils工具类
 */
public class ArraysUtils {

    //隐藏构造器，构造器私有化
    private ArraysUtils(){
    }

    /**
     * 静态方法：将整数数组的内容按照[1,2,3...]的格式返回
     * @param arrays 传入的整数数组
     * @return 返回字符串格式的数组内容
     */
    public static String toString(int[] arrays){
        //判断数组为空的情况
        if (arrays ==null){
            return null;
        }
        String s = "[";
        for (int i = 0; i < arrays.length; i++) {
            if (i != arrays.length-1){
                s = s + arrays[i] + ",";
            }else {
                s = s + arrays[i] ;
            }
        }
        s = s + "]";
        return s;
    }

    /**
     * 去掉数组内最大值、最小值后求取数组的平均值并返回
     * @param scores 传入的分数数组
     * @return 平均值
     */
    public static double getAverage(double[] scores){
        //判断数组为空的情况
        if (scores == null){
            return 0;
        }
        Arrays.sort(scores);
        double sumScore = 0;
        for (int i = 1; i < scores.length-1; i++) {
            sumScore +=  scores[i];
        }
        double average = sumScore/(scores.length-2);
        return average;
    }
}

TestDemo测试类

/**
 * 测试类
 */
public class TestDemo {

    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,6};
        int[] a2 = null;
        int[] a3 = {};
        System.out.println(ArraysUtils.toString(a));
        System.out.println(ArraysUtils.toString(a2));
        System.out.println(ArraysUtils.toString(a3));

        double[] b = {50,60,70,80,90};
        double[] b2 = null;
        double[] b3 = {};
        System.out.println(ArraysUtils.getAverage(b));
        System.out.println(ArraysUtils.getAverage(b2));
        System.out.println(ArraysUtils.getAverage(b3));

    }
}

static应用知识：代码块

代码块概述

• 代码块是类的五大成分之一(成员变量、构造器、方法、代码块、内部类)，定义在类中方法外

• 在Java类下，使用 { } 括起来的代码被称为代码块

静态代码块

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

public class StaticDemo1 {

    public static String schhoolName;

    /**
     * 静态代码块：有static修饰，属于类，与类一起优先加载一次，自动出发执行
     * 作用：可以用于初始化静态资源
     */
    static {
        System.out.println("------静态代码块被触发执行了------");
        schhoolName = "黑马";
    }

    public static void main(String[] args) {
        //目标：先理解静态代码块。
        System.out.println("------main代码块被触发执行了------");
        System.out.println(schhoolName);

    }
}

构造代码块(了解，见得少)

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

public class StaticDemo2 {

    private String name;

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

    /*
        实例代码块：无static修饰：属于对象，每次构建对象时，都会触发一次
          初始化实例资源
     */
    {
        System.out.println("===实例代码块被触发执行===");
        name = "张三";

    }

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

静态代码块的应用案例

斗地主游戏

public class StaticTest3 {

    /*
        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++) {
            // sizes[i]
            // d.遍历花色
            for (int j = 0; j < colors.length; j++) {
                // colors[j]
                String card = sizes[i] + colors[j];
                cards.add(card);
            }
        }
        // e.单独加入大小王。
        cards.add("小

标签：String,静态,System,关键字,static,println,Static,public,out	

From： https://www.cnblogs.com/zzx944964684/p/17008825.html