java static静态关键字、单例、代码块 学习笔记

目录

一、理解static修饰变量的作用及访问特点

1.static关键字的概念

2.static关键字与变量 

二、static修饰成员变量的基本方法

1.静态成员的分类

 2.使用场景

static访问注意事项

三、工具类 

1.概念

2.使用工具类的好处

3.工具类中不建议使用实例方法做

4.工具类定义时的其他要求

四、代码块 

1.代码块概述

2.代码块的划分 

*案例_斗地主游戏

 五、单例模式

1.设计模式的概念

2.单例模式概念

3.饿汉单例设计模式 

4.懒汉单例设计模式

---

一、理解static修饰变量的作用及访问特点

1.static关键字的概念

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

public class zy1 {
    public static String name = "123";
}

//调用方式

类名.静态成员变量

对象.静态成员变量

举个例子：

public class Users {
    //static关键字修饰成员变量和静态变量 内存中只有一份
    public static String uName = "虹猫";
}

public class zy1 {
    public static void main(String[] args) {
        //类名访问
        String N =Users.uName;
        System.out.println(N);

        //对象访问 官方不推荐使用该方法
        Users nn = new Users();
        System.out.println(nn.uName);
    }
}

执行结果：

虹猫

虹猫

2.static关键字与变量 

• 实例变量无static修饰 存于每个对象中
• 静态成员变量：共享信息
• 实例成员变量：属于每个对象 且每个信息不同时

public class zy1 {
    //实例变量 无sattic修饰 属于每个对象 必须用对象名访问
    private String name;
    private int age;

    public static void main(String[] args) {
        //对象访问 官方不推荐使用该方法
        zy1 nn = new zy1();
        //实例成员对象可以直接用对象访问
        nn.name = "大角牛";
        nn.age = 17;
        System.out.println(nn.name);
        System.out.println(nn.age);
    }
}

二、static修饰成员变量的基本方法

1.静态成员的分类

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

public class zy1 {

    public static void main(String[] args) {
        //类名.静态成员方法
        System.out.println(zy1.get1(10, 5));
        //**注意：同一个类中 访问静态方法 类名可以省略
        System.out.println(get1(10, 5));

        //类名.实例方法
        zy1 z = new zy1();
        z.name = "小六";
        z.dy();

        //对象.静态方法 (支持这种写法 但不推荐)
        System.out.println(z.get1(10, 5));
    }
    //实例成员变量：无static修饰 属于对象

    private String name;

    //静态成员方法 有static修饰 归属于类 可以被共享访问（用类名或对象名访问）
    public static int get1(int num1, int num2) {
        return num1 > num2 ? num1 : num2;
    }

    //实例方法:属于对象 (访问必须要用 对象.实例方法 来访问)
    public void dy() {
        System.out.println(name + "很快乐！");
    }
}

 2.使用场景

• 表示对象自己的行为的 且方法中需要访问实例成员的 则该方法必须申明成实例方法
• 如果该方法是执行一个共用功能为目的 则可以声明成静态方法

static访问注意事项

静态方法只能访问静态的成员 不可以直接访问实例成员

实例方法可以访问静态的成员 也可以访问实例成员

静态方法中是不可以出现this关键字

三、工具类 

1.概念

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

例如：验证码系统防止恶意刷新

同一个功能多处开发 会出现代码重复度过高

2.使用工具类的好处

调用方便 提高了代码的复用率（编写一次 次次多用）

import java.util.Random;
//工具类
public class Tool {
    //静态方法
    public static String creatNume(int n){
        //开发一个验证码
        //定义字符串信息
        String data = "abcdefghijklmnopqrstuvwxyzABCDEFJHIJKLMNOPQRSTUVWXYZ0123456789";
        //定义一个空字符串来存储
        String fio = "";
        //循环5次 每次生成一个随机的索引 提取对应字符然后连接起来
        Random r = new Random();
        for (int i = 0; i < n; i++) {
            //随机索引
            int ind = r.nextInt(data.length());
            char c = data.charAt(ind);
            fio += c;
        }
        return fio;
    }
}

执行如下
public class D_1 {
    public static void main(String[] args) {
        //开发一个验证码
        System.out.println(Tool.creatNume(5)); //直接调用工具类
    }
}

3.工具类中不建议使用实例方法做

• 实例方法需要创建对象调用
• 此时用对象只是为了调用方法 这样做会浪费时间

4.工具类定义时的其他要求

 由于工具类里面都是用的静态方法 直接用类名即可访问 因此工具类创建对象 建议将工具类的构造器进行私有。

四、代码块 

1.代码块概述

• 代码块是类的五大成分之一（成员变量、构造器、方法、代码块、内部类）定义在类中 方法之外
• 在java类中 使用{ }括起来的代码称为代码块

2.代码块的划分 

2.1静态代码块(被优先加载)

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

    public static void main(String[] args) {
        System.out.println("----main方法后执行----");
    }
    //作用：用于初始化静态资源
    static {
        System.out.println("----static代码块先执行----");
    }

2.2构造代码块 (实例代码块)

格式：{ }

特点：每次创建对象，调用构造器执行时 都会执行该代码块中的代码 并且在构造器执行前执行

使用场景：初始化实例资源 

*案例_斗地主游戏

要求：启动游戏时 应会提前准备好54张牌 后续可直接使用这些牌的数据

思路：

1.该游戏只需要一副牌

2.定义一个静态的集合存储54张牌对象 静态集合只会加载一份

3.启动游戏前 把54张牌初始化好

  //定义一个静态集合
    public static ArrayList<String> cards = new ArrayList<>();
        //在游戏运行前 把54张牌放进去 后续方便使用

    static {
    //定义牌 放到集合中去

        //定义一个数组存储所有牌的数字
        String[] sis = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};

        //定义一个数组 存储全部花色
        String[] car = {"♥","♠","♦","♣"};

        //遍历点数
        for (int i = 0; i < sis.length; i++) {


            //遍历花色
            for (int j = 0; j < car.length; j++) {
                String card = sis[i] + car[j];
                cards.add(card);
            }
        }
        //单独加入大小王
        cards.add("大王");
        cards.add("小王");
    }

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

    }

执行结果：

[3♥, 3♠, 3♦, 3♣, 4♥, 4♠, 4♦, 4♣, 5♥, 5♠, 5♦, 5♣, 6♥, 6♠, 6♦, 6♣, 7♥, 7♠, 7♦, 7♣, 8♥, 8♠, 8♦, 8♣, 9♥, 9♠, 9♦, 9♣, 10♥, 10♠, 10♦, 10♣, J♥, J♠, J♦, J♣, Q♥, Q♠, Q♦, Q♣, K♥, K♠, K♦, K♣, A♥, A♠, A♦, A♣, 2♥, 2♠, 2♦, 2♣, 大王, 小王]

 五、单例模式

1.设计模式的概念

开发中常遇到一些问题 一个问题有n中解法，但其中肯定会有最优解法 这种解法被称为设计模式

1.1设计模式学习方向

• 这种模式用来解决什么问题
• 遇到了这种问题 该模式怎么写 如何解决这个问题

2.单例模式概念

可以保证系统中应用到该模式的这个类只有一个实例 即一个类只能创建一个对象。

例如任务管理器对象我们只需要一个就可以解决问题 这样可以节省内存空间

3.饿汉单例设计模式 

在类获取对象时 对象已经提前为你创建好了

3.1设计步骤

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

public class newDemo {
    //在获取单例前 对象已经提前准备好了一个
    //对象只能时一个 所以定义静态成员变量
    public static newDemo inst = new newDemo();

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

    }
}

class aww{
    public static void main(String[] args) {
        newDemo s1 = newDemo.inst;
        newDemo s2 = newDemo.inst;
        System.out.println(s1 = s2); //确定是否返回同一对象
        //是true
    }
}

4.懒汉单例设计模式

在真正需要该对象时 才去创建一个对象（延迟加载对象）

4.1设计步骤：

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

public class newDemo {
    //定义一个静态变量 负责存储一个对象
    //只加载一次
    private static newDemo inst;

    //提供一个方法 对外返回单例对象
    public static newDemo getnewDemo(){
        if (inst == null){
           //第一次来拿对象
            inst = new  newDemo();
        }
        return inst;
    }

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

    }
}

class aww{
    public static void main(String[] args) {
        newDemo s1 = newDemo.getnewDemo();
        System.out.println(s1);

    }
}