0528

单例模式（Singleton ）

🎈采取一定的方法，对于某个类来说只有一个实例化对象。

私有化类的构造器
内类包含一个声明为static 的对象
类命名的对象共享一个内存（实际上只有一个对象）

🎈区分（优先懒汉式)

饿汉式
1. 直接就实例化对象
2. 对象加载时间过长（生命周期过长）
3. 饿汉式 线程安全
懒汉式（相比更好一点，不会提前占用内存，即用即new）
1. 啥时候用，啥时候实例化对象
2. 延迟对象的创建
3. 目前的写法 线程不安全 （）

public class Day0528 {
    public static void main(String[] args) {
        // System.out.println("d" + "chcp936");
        Bank bank1 = Bank.GetInstance();
        Bank bank2 = Bank.GetInstance();
        System.out.println(bank1 == bank2); // true

        Flower f1 = Flower.GetInstance();
        Flower f2 = Flower.GetInstance();
        System.out.println(f1 == f2); // true

    }
}

// 饿汉式
class Bank {
    private Bank() { // 私有化构造器
        System.out.println("Bank Singleton");
    }

    private static Bank instance = new Bank(); // 内部创建类的对象
    // 要求此对象也声明为静态的

    public static Bank GetInstance() { // 提供公共的静态的方法，返回类的对象
        return instance;
    }
}

// 懒汉式
class Flower {
    private Flower() {
    }

    private static Flower instance = null;

    public static Flower GetInstance() {
        if (instance == null)
            instance = new Flower();
        return instance;

    }

}

使用场景

🎈好处：只生成一个实例，减小了系统的开销（Runtime 类）

计数器
应用程序的日志应用
数据库连接池
Application
Windows的任务管理器（Task Manager）就是很典型的单例模式
Windows的回收站（Recycle Bin）就是很典型的单例模式

理解main方法的语法

🎈main方法的使用说明：

main()方法作为程序的入口
main()也是一个普通的静态方法
其他的方法也可以调用main()方法

String [] args 形参，也可以作为我们于控制台交互的方式，

使用java.util.Scanner ,也可以使用编译器设定 args[] 的初始值(默认用String接收)

public static void main(String[] args) {
    for(String str :args)
    {
        int num=Integer.parseInt(str);
        System.out.println(num+"  ");
    }
}

public class Day0528 {
    public static void main(String[] args) {
        Main.main(new String[100]);
        //如果没有 static 声明show ，则需要new对象（包括匿名对象）
        show();
    }
    public static void show()
    {
	
    }
}

class Main {
    public static void main(String[] args) {
        for(int i=0;i< args.length;i++)
        {
            System.out.println("args_"+i);
		}
        System.out.println("my main");
    }
}

代码块

1
2
3

{
// 类的四个部分 属性  方法 构造器 代码块
}

🎈作用：

用来初始化类、对象
不能主动去调用代码块

⭐是否用static修饰:

如果代码快被修饰，只能被static 修饰
静态代码块的执行要优先于非静态代码块
执行顺序都按照定义的先后顺序

⭐静态代码块：

内部可以有输出语句
会随着类的加载而执行（可以单独调用类中的static成员，不创建对象）
只会执行一次
初始化类的信息
如果一个类中定义了多个静态代码块，则按照定义的先后顺序执行
静态代码块内只能调用静态内容。

🎈非静态代码块：

会随着对象的创建而执行
每次创建对象都会执行
作用：对对象的属性赋值
如果一个类中定义了多个非静态代码块，则按照定义的先后顺序执行
可以调用静态的内容以及非静态内容

public class Day0528 
{
    public static void main(String[] args) 
    {
        String desc = Person0528.desc;
        new Person0528("dd", 12);
        System.out.println(desc);
    }
}
class Person0528 {
    // 属性
    public String name;
    int age;
    static String desc = "Person05228";

    Person0528(String n, int a) { // 构造器
        name = n;
        age = a;
    }

    // 方法
    public void eat() {
        System.out.println("吃饭");

    }

    public void walk() {
        System.out.println("walking ");
    }

    // 代码块
    {
        System.out.println("hello unstatic block");
        eat();
    }

    static { // 静态代码块
        desc = "modify by static block -1";
        System.out.println("hello static block -1");
    }
    static { // 静态代码块
        desc = "modify by static block -2";
        System.out.println("hello static block -2");
    }
}