面向对象——static

前言

        Java语言是面向对象的编程语言，所以面向对象在Java中占据重要地位。今天介绍的是面向对象中的一个关键字：static。

正文

一、static的概念

1、含义：static 是Java的一个关键字，表示的含义是“静态的”。

2、应用场景：static 一般用于修饰成员变量和成员方法。被static修饰的成员变量又称为类变量/静态变量；被 static修饰的方法又称为 类方法/静态方法。

无static 修饰的成员变量又称为 实例变量；无static修饰的方法又称为实例方法。

二、书写格式、调用方式

1、类变量/静态变量、实例变量：

//书写格式
class Main {
    //修饰符 static 数据类型 变量名;(类变量)
    public static String name;
    
    //修饰符 数据类型 变量名;(实例变量)
    public String id;
}
//调用方式
public class Test {
    public static void main(String[] args) {
        //类名.变量名;(推荐使用)(类变量)
        Main.name = "ahhh";
        //对象名.变量名;(不推荐)(类变量)
        Main m = new Main();
        m.name = "ahhh";
        
        //对象名.变量名;(实例变量)
        m.id = "111";
    }
}

2、类方法/静态方法、实例方法：

//书写格式
class Main {
    //修饰符 static 数据类型 方法名(){数据};(类方法)
    public static String name(){
        return ……;
    };
    
    //修饰符 数据类型 方法名(){数据};(实例方法)
    public String id(){
        return ……;
    }
}
//调用方式
public class Test {
    public static void main(String[] args) {
        //类名.方法名;(推荐使用)(类方法)
        Main.name();
        //对象名.方法名;(不推荐)(类方法)
        Main m = new Main();
        m.name();
        
        //对象名.方法名;(实例方法)
        m.id();
    }
}

三、特点、使用场景

1、类变量

        属于类的，它们与类一起加载，所以在内存中只有一份。被所有的对象共享。

        例子：王者荣耀的地图就像一个类变量，是进行游戏的玩家公用的一幅地图；

public class Test {
    public static void main(String[] args) {
        MainTest mt1 =new MainTest();
​
        System.out.println(MainTest.name); //打印了张三
​
        mt1.name = "李四";
        System.out.println(MainTest.name); //因为共享，所以打印了 "李四"
​
        System.out.println(MainTest.arr);//[I@776ec8df    //同一份，所以记录的地址一样
​
        System.out.println(mt1.arr);     //[I@776ec8df
​
    }
}
class MainTest {
​
    public static String name = "张三";
​
    public static int[] arr = new int[3];
}

2、类方法

        static修饰的方法属于类，它们与类一起加载。没有static修饰的方法属于对象，所以对象每new一次就加载一次。

        static修饰的方法一般用于工具类。而工具类的书写格式分成了两步：

        1 、私有构造器

        2 、创建方法，方法均为static修饰的类方法。

public class Demo02 {
    public static void main(String[] args) {
        int[] arr = {11, 22, 33, 44};
        System.out.println(MyArrays.getMax(arr));
        MyArrays.toString(arr);
        //定义一个工具类MyArrays，要求类中实现：
        //1.定义一个方法getMax(int[] arr)，可以接受一个整数数组，方法中实现获取数组的最大值并且返回.
        //2.定义一个方法toString(int[] arr),可以接受一个整数数组，方法中实现把数组的内容拼接成一个字符串，并且返回。格式如：
    }
}
​
class MyArrays { //工具类
    private MyArrays() {
​
    }//构造器私有，无法访问
​
    static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        return max;
    }
​
    static void toString(int[] arr) {
        System.out.print("[");
​
        for (int i = 0; i < arr.length - 1; i++) {
            System.out.print(arr[i] + ", ");
        }
​
        System.out.println(arr[arr.length - 1] + "]");
    }
​
}

四、注意事项

        1、类方法中可以直接访问类的成员，不可以直接访问实例成员。 ​

         2、实例方法中既可以直接访问类成员，也可以直接访问实例成员。 ​

        3、实例方法中可以出现this关键字，类方法中不可以出现this关键字的。

class Main {
    static int age = 10;
​
    String name = "张三";
​
    static void man(){
        System.out.println("男士");
    }
​
    public void girl(){
        System.out.println("女孩");
    }
    static void year() {
        System.out.println("他今年" + age + "岁");
​
        //Non-static field 'name' cannot be referenced from a static context
        //System.out.println("他的名字是" + name); //报错 ，name是实例变量
        man();
​
        //Non-static method 'gril()' cannot be referenced from a static context
        //gril(); //报错 ， girl()是实例方法
        
        //'Main.this' cannot be referenced from a static context
        //this.year();//类方法不可以用this
    }
​
    public void People() {
        System.out.println(age);//实例方法可以调用类变量
        System.out.println(name);//实例方法可以调用实例变量
​
        girl();//实例方法可以调用实例方法
        man();//实例方法可以调用类方法
        this.People();//实例方法可以用this
    }
}

五、代码块

        代码块是Java五大成分之一（成员变量、构造器、方法、代码块、内部内）。

1、静态代码块

        静态代码块，顾名思义，是一种让static修饰的代码块，

        特点：类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次。

        完成类的初始化，例如：对类变量的初始化赋值。书写格式为：

class Main {
    static {
        
    }//static{}就是静态代码块
}

2、实例代码块

        实例代码块，是一种没有任何修饰的代码块

        特点：每次创建对象时，执行实例代码块，并在构造器前执行。

        作用：和构造器一样，都是用来完成对象的初始化的，例如：对实例变量进行初始化赋值。

class Main {
    {
    
    }//{}就是实例代码块
}

六、单例设计模式

        一个问题的解法有很多，但每一个问题都会有一个最优解，在Java中，这个最优解就是设计模式。Java中，一共有20多种设计模式，分别对应了20多种设计问题。这里就介绍一种设计模式——单例设计模式。

        单例设计模式的作用是：为了确保一个类有且只有一个对象。根据书写格式的不同，可以分成懒汉式单例、饿汉式单例

1、饿汉式单例

特点：创建类的时候就加载。

运行场景、好处：任务管理器对象、获取运行时对象。在这些业务场景下，使用单例模式，可以避免浪费内存。

书写格式：

        ①把类的构造器私有。 ​

        ②定义一个类变量记住类的一个对象。

        ​ ③定义一个类方法，返回对象。

class Main {
    private Main() {
​
    }//①把类的构造器私有。
​
    static Main m = new Main();//②定义一个类变量记住类的一个对象。
​
    public static Main getM() {
        return m;
    }//③定义一个类方法，返回对象。
}

2、懒汉式单例

特点：要用类的对象时才创建对象（延迟加载对象）

书写格式：

        ①把构造器私有

        ②定义一个类变量用于存储对象，不要new对象。

        ③定义一个类方法，需要先判断，保证返回的是同一个对象。

class Main {
    private Main() {
​
    }//①把构造器私有
​
    static Main m;//②定义一个类变量用于存储对象，不要new对象。
​
    public static Main getM() {
        if (m == null){
            m = new Main();
        }//一定要进行判断
        return m;
    }//③定义一个类方法，需要先判断，保证返回的是同一个对象。
}

七、总结

                static 关键字，可以修饰变量、方法和代码块。在使用的过程中，其主要目的还是想在不创建对象的情况 下，去调用方法。