常用API static类及单例模式

static于成员变量（属性）

如果一个成员变量使用了Static关键字，那么这个变量不在属于对象自己，而是属于所在的类，多个对象共享一份数据

定义一个Student类

public class Student {

    private int id;//学号
    private String name;//姓名
    private int age;//年龄
    static String room;//所在教室
    private static int idCoder = 0;//学号计数器，每当new了一个新的对象，计数器++

    public Student() {
        idCoder++;

    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++idCoder;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

main方法

public class Demo01StaticField {
    public static void main(String[] args) {
        Student one = new Student("郭靖",19);
        one.room = "101教室";
        System.out.println("姓名" + one.getName() + ".学号" + one.getId() + "，年龄:" + one.getAge() + "教室:" + one.room);
        Student two = new Student("黄蓉",16);
        System.out.println("姓名:" + two.getName() + ".学号" + two.getId() + "，年龄:" + two.getAge() + "教室：" + two.room);

    }
}

对于姓名、年龄、学号来说，每个对象都有自己独立的数据，但是对于教室来说，这应该是多个对象共享同一份数据才对。
一旦使用了static关键字，那么这样的内容就不属于对象自己，而是属于类的，所以凡是本类的对象，都共享同一份。

static于成员方法

一旦使用static修饰成员方法，那么这就成为了静态方法
静态方法不属于对象，而是属于类的
如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用
无论是成员变量，还是成员方法，如果有了static，都推荐使用类名称进行调用
静态变量：类名称.静态变量
静态方法：类名称.静态方法
注意事项：
1、静态只能直接访问静态，不能直接访问非静态
原因：因为在内存当中先有静态内容，后又非静态内容。
”先人不知道后人，但是后人知道先人“
2、静态方法当中不能用this
原因：this代表当前对象，通过谁调用的方法，谁就是当前对象

例如定义一个MyClass类

public class MyClass {
    int num;//成员变量
    static int numStatic;//静态变量

    //成员方法
    public void method(){
        System.out.println("这是一个成员方法。");
        //成员方法可以访问成员变量
        System.out.println(num);
        //成员方法可以访问静态变量
        System.out.println(numStatic);
    }
    //静态方法
    public static void methodStatic(){
        System.out.println("这是一个静态方法。");
        //静态方法可以访问静态变量
        System.out.println(numStatic);
        //静态方法不能访问成员变量[重点]
        //System.out.println(num);错误写法
        //System.out.println(this);错误写法
        //当调用静态方法，不应该用对象名调用，而是通过类名调用
    }

}

main方法

public class Demo02StaticMethod {
    public static void main(String[] args) {
        MyClass obj = new MyClass();//首先创建对象
        //然后才能使用没有staic关键的内容
        obj.method();//metod方法没有static就必须使用对象调用它

        //对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称类调用
        obj.methodStatic();//正确，不推荐，这种写法在编译后也会被javac翻译成为类名称.静态方法名
        MyClass.methodStatic();//正确，推荐使用

        //对于本类当中的静态方法，可以省略类名称
        myMethod();
        Demo02StaticMethod.myMethod();//上下等效
    }
    //对于本类当中的静态方法，可以省略类名称
    public static void myMethod() {
        System.out.println("自己的方法！");
    }
}

静态static内存图

静态代码块

静态代码块的格式是：
public class 类名称{
static{
//静态代码块的内容
}
}
特点：当第一次用到本类时，静态代码块执行唯一的一次
静态内容总是优先于非静态，所以静态代码块比构造方法先执行

注意：无参构造方法可以不用【.对象名】就能调用

public class Demo04Static {
    public static void main(String[] args) {
        Person one = new Person();
        Person two = new Person();
    }
}

package cn.itcast.day08.demo03;

public class Person {
    static {
        System.out.println("静态代码块执行");
    }
    public Person(){
        System.out.println("构造方法执行");
    }

}

执行结果，以验证静态代码块执行唯一的一次

staic关键字：用来表示共享变量
static是静态的意思，可以修饰成员变量和成员方法。
静态成员变量（有static修饰类，属于类，内存中加载一次），常表示在线人数，需要被共享的信息，可以被共享访问。
实例成员变量（无static修饰，存在于每个对象中），常表示name，age,等属于每个对象的信息。

1、成员变量的分类和访问是什么样子？

静态成员变量（有static修饰，数据类，加载一次，可以被共享访问），建议使用类名访问，也可以使用对象访问。访问格式为

类名.静态成员变量（推荐）
对象。静态成员变量（不推荐）

实例成员变量（无static修饰，属于对象），只能用对象触发访问，访问格式为：

对象.实例成员变量

2、两种成员变量各自在什么情况下定义？

静态成员变量：表示在线人数需要共享的信息。
实例成员变量：属于每个对象，且每个对象信息 不同时

使用场景

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

工具类

工具类中定义的都是一些静态方法，每个方法都是以完成一个共用的功能为目的。
1、工具类的定义注意
建议将工具类的构造器进行私有，工具类无需创建对象。里面都是静态方法，直接用类名访问即可。
2、工具类的好处，内部都是一些静态方法，每个方法完成一个功能，一次编写处处可用，提高代码的复用性。
3、在编写工具类时，需要将工具类的构造器私有化处理，工具类不需要创建对象。

static访问注意实现：

静态方法只能访问静态的成员，不可以直接访问实例成员。
实例方法可以访问静态的成员，也可以访问实例成员。
静态方法中是不可以出现this关键字的，因为this代表当前对象，通过谁调用的方法，谁就是当前对象。

代码块概述

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

代码块分为

静态代码块

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

构造代码块

格式：{}
特点：每次创建对象，调用构造器执行时，都会执行代码块中的代码，并且在构造器执行前执行。
使用场景：初始化实例资源。

设计模式

开发中经常遇到一些问题，一个问题通常有n种解决办法，但其中肯定有一种解法是最优的，这个最优的解法被人总结出来称为设计模式。
设计模式有20多种，对应20多种软件开发中会遇到的问题，学设计模式主要学2点：
第一：这种模式用来解决什么问题。
第二：遇到这种问题了，该模式是怎么写的，他是如何解决这个问题的。

单例模式

可以保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象。
例如任务管理器对象我们只需要一个就可以解决问题了，这样可以解决内存空间。
1、饿汉单例设计模式
在用类获取对象的时候，对象已经提前为你创建好了。

/*定义一个单例类*/
public class sigleInstace {

    /*定义一个静态变量存储一个对象即可：属于类，与类一起加载一次*/
    public static sigleInstace instance = new sigleInstace();

    /*单例必须私有构造器*/
    private sigleInstace (){
        System.out.println("创建了一个对象");
    }
}

2、懒汉单例设计模式
在真正需要该对象的时候，才去创建一个对象（延迟加载对象）

/*定义一个单例类*/
public class sigleInstace {

    /*定义一个静态变量存储一个对象即可：属于类，与类一起加载一次*/
    //懒汉单例已经要私有化对象
    privata static sigleInstace instance ; //null

    /*单例必须私有构造器*/
    private sigleInstace (){}
    
    public static sigleInstace getInstance(){
    if(instace == null){
    //第一次来拿对象时需要创建对象
    instance = new sigleInstance();
    }
    return intance;
}