Java学习（static）

static

是什么:

  1. 静态的意思，可以修饰成员变量和成员方法。
  2. static修饰成员变量表示该成员只在内存中存储一份，可以被共享访问、修改

修饰成员变量分类

1. 静态成员变量（有static修饰，属于类，内存中加载一次）：

使用场景：常表示如在线人员等需要被共享的信息。
两种访问格式：类名. 静态成员变量或对象.静态成员变量

public class User{
    //静态成员变量
    public static String onlineNumber = 161 ;
}
public class StaticDemo {
    public static void main(String[] args) {
        //第一种访问格式
        System.out.println(User.onlineNumber);
        //第二种访问格式
        User u = new User();
        System.out.println(u.onlineNumber);
    }
}

注意：

1. 虽说两种方法都可以访问到类中的数据，但Java更推荐使用类名. 静态成员变量的方式来访问。
2. 同一个类中静态成员变量的访问可以省略类名。

2. 实例成员变量（无static修饰，存在于每个对象中）

使用场景：常表示姓名、年龄等属于每个对象的信息。
访问格式：对象.实例成员变量

内存原理

public class User{
    public static int onlineNumber = 161;
    private String name;
    private int age;

    public static void main(String[] args){
        System.out.println(User.onlineNumber);
        System.out.println(onlineNumber);
        User.onlineNumber++;
        //System.out.println(name);//会报错！
        //创建用户对象
        User u1 = new User()；
        u1.name = "孙悟空";
        u1.age = 35;
        System.out.println(u1.name);
        System.out.println(u1.age);
        u1.onlineNumber++;//不推荐
        User u2 = new User();
        u2.name = "猪八戒";
        u2.age = 29;
        System.out.println(u2.name);
        System.out.println(u2.age);
        u2.onlineNumber++;
        System.out.println(User.onlineNumber);
    }
}

从内存来看：

1. 执行User类的时候，同步在堆内存里加载一个静态变量区，之后提取main方法到栈内存。

2. main方法代码执行，前三行都是直接找到静态变量区进行操作，之后先创建u1变量指向堆内存的对象，再进行赋值、访问操作，u2同理。这里对象与静态变量区是存在联系的，故可以通过类名访问。

注意：
代码中第10行System.out.println(name);报错原因是name属于对象，应该通过对象来访问并且此时甚至没有对象。

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

成员方法分类

1. 静态成员方法（归属于类），建议用类名访问，也可以使用对象访问（不推荐）。
2. 实例成员方法（归属于对象），只能用对象触发访问。
   

使用场景

内存原理

public class Student {
    String name;
    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){
        System.out.println(Student.getMax(10,2));
        System.out.println(getMax(2,10));
        Student s = new Student();
        s.name = "猪八戒";
        s.study();
        System.out.println(s.getMax(10,2));//不推荐
    }
}

1. 静态方法与类一起加载，变为可访问状态，然后将main方法加载到栈内存中。

2. 代码开始执行，加载study实例方法到class类中，代码通过访问s访问对象，再通过对象访问实例方法。

注意：
此处虽然也可以通过访问对象来实现调用静态方法，但是从内存访问上看，会比直接访问类来调用方法更麻烦，所以说一般是推荐直接通过类来调用静态方法。

static访问注意事项

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

static应用知识

工具类

是什么

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

优点

1. 调用方便。
2. 提高代码复用率。

不采用实例方法做是因为实例方法需要创建对象调用，但是创建的这个对象只是为了调用方法，会浪费内存。

其他要求

由于工具类里面都是静态方法，可以直接使用类名访问，因此，工具类无需创建对象，建议将工具类的构造器私有。private User(){}

代码块

是什么

1. 类的五大成分之一，定义在类中方法外。
2. 在Java类下，使用{}括起来的代码。
   

分类

设计模式

是什么

1. 开发中经常会遇到一些问题，一个问题通常有n种解法，但肯定有一种是最优解，这个最优解的总结就是设计模式。
2. 设计模式共有20多种，对应20多种软件开发种会遇到的问题。

设计模式有很多，这里挑选其中的一个：单例模式来展开说说。

单例模式

**概述：可以保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象。
实现方式：**饿汉单例模式、懒汉单例模式……

饿汉单例模式

概述：在类获取对象的时候，对象已经创建好了。
设计步骤：

1. 定义一个类，把构造器私有。
2. 定义一个静态变量存储一个对象。

public class A{
    public static A a = new A();
    //单例必须私有构造器
    private A(){
        System.out.printf ("创建了一个对象")
    }
}

懒汉单例模式

概述：在真正需要该对象的时候，才去创建一个对象（延迟加载对象）。
设计步骤：

1. 定义一个类，把构造器私有。
2. 定义一个静态变量存储一个对象。
3. 提供一个返回单例对象的方法。

public class A{
    private static A a;
    //单例必须私有构造器
    private A(){
       
    }
    public static A getA(){
    	if(a==null){
            a = new A();
        }
        return a;
    }
}

这里第二行private static A a;，private不能改为public，不然将静态成员变量公开，用A a1=A.a方式去访问时会是一个null。

每日一练：斗地主发牌程序

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

分析：

1. 该房间只需要一副牌。
2. 定义一个静态的ArrayLIst集合存储54张牌对象，并且只需要加载一份。
3. 启动游戏房间前，应该将54张牌初始化好。

import java.util.ArrayList;

public class poker {
    //创建一个集合
    public static ArrayList<String> cards = new ArrayList<>();
    static{
        String[] sizes = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        String[] colors = {"♥","♦","♣","♠"};
        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);
            }
        }
        //添加大小王
        cards.add("🃏");
        cards.add("🃏");
    }

    public static void main(String[] args) {
        System.out.println(cards);
    }
}

最终结果：

结果太长，这里只截取了一部分。