JAVA基础12-单例设计模式与main方法

单例设计模式

1. 单例设计模式就是采取一定的方法保证在这整个系统中一个类只能存在一个实例对象，而且该类中只提供一个获得它的实例对象的方法
2. 将类构造器的访问权限设置为private，在外面就不能用new产生新对象了
3. 类内部使用静态方法创建并返回该类的对象，由于静态方法内部只能访问静态资源，所以该类对应的对象变量也要定义为静态的
4. 实例：

• 单例设计模式-饿汉式

// 单例设计模式
public class SingleTonTest1 {
    public static void main(String[] args) {
        Bank bank1=Bank.getInstance();
        Bank bank2=Bank.getInstance();
        System.out.println(bank1==bank2);
        // 结果true
    }
}
// 饿汉式
class Bank{
    // 1.私有化构造器 不让外面造对象
    private Bank(){

    }
    // 2. 内部创造Bank实例
    // 4. 实例化对象也必须是静态的
    private static Bank instance=new Bank();
    // 3. 给个静态方法让外部调用的到
    public static Bank getInstance(){
        return instance;
    }
}

• 单例设计模式-懒汉式

public class SingleTonTest2 {
    public static void main(String[] args) {
        Order order1=Order.getInstance();
        Order order2=Order.getInstance();
        System.out.println(order1==order2);
        // 结果true
    }
}
// 单例设计模式 懒汉式
class Order{
    // 1. 私有化构造器，不让外面调用
    private Order(){

    }
    // 2. 定义内部构造，暂时为null
    private static Order instance=null;
    // 3. 定义方法让外面调用
    public static Order getInstance(){
        if(instance==null){
            instance=new Order();
        }
        return instance;
    }
}

5. 饿汉式和懒汉式区别

• 饿汉式
  • 对象加载事件过长，从程序加载就创建着，一直到线程结束
  • 饿汉式线程是安全的
• 懒汉式
  • 延迟对象创建，需要时才创建
  • 存在安全性问题

6. 单例模式优点

• 只生成一个实例，减小了性能开销
• 对象有较多的资源开销（读取配置，产生其他依赖对象），产生一个永久对象存储在内存中

main方法

1. main()作为程序的入口文件
2. main()也是一个静态方法
3. main()也可以作为与控制台交互方式（Scanner相似）

public class MianTest {
    public static void main(String[] args) {
        Main.main(new String[10]); 
        /*
        * 可以调静态属性
        * 不能调非静态的，可以new一个对象再调用
        */ 
    }
}
class Main{
    public static void main(String[] args){
        for(int i=0;i<args.length;i++){
            args[i]="args"+i;
            System.out.println(args[i]);
        }
    }
}

代码块

1. 代码块在一对{}内，用来初始化对象和类，也叫初始化块
2. 代码块分类

• 静态代码块
  • 内部可以有输出语句
  • 随着类的加载而执行（自动执行，只执行一次）
  • 可以初始化类的属性
  • 可以有多个静态代码块，执行顺序按照书写顺序执行
  • 静态代码块先于非静态执行
  • 静态代码块可以调用静态的属性和方法，但是不能调用非静态的结构
• 非静态代码块
  • 内部可以有输出语句
  • 随着对象的创建而执行了（每创建一个对象就执行一次）
  • 在创建时，对对象的属性等进行初始化
  • 可以有多个非静态代码块，执行顺序按照书写顺序执行
  • 非静态代码块可以调用静态的属性和方法，也能调用非静态的属性和方法

3. 实例：

public class BlockTest {
    public static void main(String[] args) {
        String desc=Person.desc;
        System.out.println(desc);
        Person p1=new Person();
    }
}

class Person{
    String name;
    int age;
    static String desc="这是一个人";
    Person(){}
    Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    // 静态代码块
    static {
        System.out.println("static block running ");
    }
    static {
        System.out.println("static block running updata desc");
        desc="这是一个爱学习的人";
        // eat(); 不能调用非静态属性
        info();
    }
    // 非静态代码块
    {
        System.out.println("unstatic block runnin");
    }
    {
        info();
        eat();
    }

    public void eat(){
        System.out.println("吃饭");
    }
    public String show(){
        return "[name=" + name + "],[age=" + age +"";
    }
    public static void info(){
        System.out.println("这是一个快乐的人");
    }
}
/* 
* static block running             静态代码块先执行
* static block running updata desc 执行第二个静态代码块，并执行更改desc
* 这是一个快乐的人                  执行info()
* 这是一个爱学习的人                执行desc的打印输出
* unstatic block runnin            执行非静态代码块
* 这是一个快乐的人                  执行info()
* 吃饭                             执行rea()
* 
*/

属性赋值的顺序

默认初始化=>显示初始化/在代码块中赋值=>构造器中初始化=>有了对象后，通过对象.属性，对象.方法进行赋值