JavaSE_day12_static关键字丶单列设计模式丶代码块

static关键字

• static 是 java 语言中的关键字，表示“静态的”，它可以用来修饰变量、方法、代码块等，修饰的变量叫做静态变量，修饰的方法叫做静态方法，修饰的代码块叫做静态代码块。在 java语言中凡是用 static 修饰的都是类相关的，不需要创建对象，直接通过“类名”即可访问，即使使用“引用”去访问，在运行的时候也和堆内存当中的对象无关。

静态变量

• java 中的变量包括：局部变量和成员变量，在方法体中声明的变量为局部变量，有效范围很小，只能在方法体中访问，方法结束之后局部变量内存就释放了，在内存方面局部变量存储在栈当中。在类体中定义的变量为成员变量，而成员变量又包括实例变量和静态变量，当成员变量声明时使用了 static 关键字，那么这种变量称为静态变量，没有使用 static 关键字称为实例变量，实例变量是对象级别的，每个对象的实例变量值可能不同，所以实例变量必须先创建对象，通过“引用”去访问，而静态变量访问时不需要创建对象，直接通过“类名”访问。实例变量存储在堆内存当中，静态变量存储在方法区当中。实例变量在构造方法执行过程中初始化，静态变量在类加载时初始化。

静态方法 

方法在什么情况下会声明为静态的呢？

• 方法实际上描述的是行为动作，我认为当某个动作在触发的时候需要对象的参与，这个方法应该定义为实例方法，例如：每个高中生都有考试的行为，但是你考试和学霸考试最终的结果是不一样的，一个上了“家里蹲大学”，一个上了“清华大学”，显然这个动作也是需要对象参与才能完成的，所以考试这个方法应该定义为实例方法。实例成员必须要创建对象才能访问。
• 当方法体中需要直接访问当前对象的实例变量或者实例方法的时候，该方法必须定义为实例方法，因为只有实例方法中才有 this，静态方法中不存在 this。
• 在实际的开发中，“工具类”当中的方法一般定义为静态方法，因为工具类就是为了方便大家的使用，将方法定义为静态方法，比较方便调用，不需要创建对象，直接使用类名就可以访问。

代码举例

/*
    static:
        1、static翻译为“静态”
        2、所有static关键字修饰的都是类相关的，类级别的。
        3、所有static修饰的，都是采用“类名.”的方式访问。
        4、static修饰的变量：静态变量
        5、static修饰的方法：静态方法
    
    变量的分类：
        变量根据声明的位置进行划分：
            在方法体当中声明的变量叫做：局部变量。
            在方法体外声明的变量叫做：成员变量。
        
        成员变量又可以分为：
            实例变量
            静态变量
*/

class VarTest{

    // 以下实例的，都是对象相关的，访问时采用“引用.”的方式访问。需要先new对象。
    // 实例相关的，必须先有对象，才能访问，可能会出现空指针异常。
    // 成员变量中的实例变量
    int i;

    // 实例方法
    public void m2(){
        // 局部变量
        int x = 200;
    }


    // 以下静态的，都是类相关的，访问时采用“类名.”的方式访问。不需要new对象。
    // 不需要对象的参与即可访问。没有空指针异常的发生。
    // 成员变量中的静态变量
    static int k;

    // 静态方法
    public static void m1(){
        // 局部变量
        int m = 100;
    }
    
}

类属性、类方法的设计思想

• 类属性作为该类各个对象之间共享的变量。在设计类时,分析哪 些属性不因对象的不同而改变，将这些属性设置为类属性。相应 的方法设置为类方法。
• 如果方法与调用者无关，则这样的方法通常被声明为类方法，由 于不需要创建对象就可以调用类方法，从而简化了方法的调用。

static使用范围：

• 在Java类中，可用static修饰属性、方法、代码块、内部类

被修饰后的成员具备以下特点：

• 随着类的加载而加载
• 优先于对象存在
• 修饰的成员，被所有对象所共享
• 访问权限允许时，可不创建对象，直接被类调用

非静态的成员方法的访问特点

• 能访问静态的成员变量
• 能访问非静态的成员变量
• 能访问静态的成员方法
• 能访问非静态的成员方法

静态的成员方法

• 能访问静态的成员变量
• 能访问静态的成员方法

总结成一句话就是：

• 静态成员方法只能访问静态成员

package demo03;

/*
 * static关键字的使用
 *
 * 1.static:静态的
 * 2.static可以用来修饰：属性、方法、代码块、内部类
 *
 * 3.使用static修饰属性：静态变量（或类变量）
 *         3.1 属性，按是否使用static修饰，又分为：静态属性  vs 非静态属性(实例变量)
 *            实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的
 *              非静态属性时，不会导致其他对象中同样的属性值的修改。
 *       静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致
 *              其他对象调用此静态变量时，是修改过了的。
 *         3.2 static修饰属性的其他说明：
 *             ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
 *          ② 静态变量的加载要早于对象的创建。
 *          ③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
 *
 *          ④        类变量         实例变量
 *          类        yes        no
 *          对象    yes        yes
 *
 *      3.3 静态属性举例：System.out; Math.PI;
 *
 * 4.使用static修饰方法：静态方法
 *         ① 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
 *         ②            静态方法    非静态方法
 *          类        yes        no
 *          对象        yes        yes
 *         ③ 静态方法中，只能调用静态的方法或属性
 *        非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
 *
 * 5. static注意点：
 *    5.1 在静态的方法内，不能使用this关键字、super关键字
 *    5.2 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。
 *
 * 6. 开发中，如何确定一个属性是否要声明为static的？
 *         > 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
 *         > 类中的常量也常常声明为static
 *
 *    开发中，如何确定一个方法是否要声明为static的？
 *        > 操作静态属性的方法，通常设置为static的
 *      > 工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections
 */
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); // 错误写法！

        // 静态方法中不能使用this关键字。
//        System.out.println(this); // 错误写法！
    }

}

单列设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、 以及解决问题的思考方式。设计模免去我们自己再思考和摸索。就像是经典 的棋谱，不同的棋局，我们用不同的棋谱。”套路”

• 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对 某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。 如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构 造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生 类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无
• 法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象， 静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象 的变量也必须定义成静态的。

单例(Singleton)设计模式-饿汉式

package demo05;


/*
 * 单例设计模式：
 * 1. 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。
 *
 * 2. 如何实现？
 *      饿汉式  vs 懒汉式
 *
 * 3. 区分饿汉式 和 懒汉式
 *   饿汉式：
 *       坏处：对象加载时间过长。
 *       好处：饿汉式是线程安全的
 *
 *   懒汉式：好处：延迟对象的创建。
 *           目前的写法坏处：线程不安全。--->到多线程内容时，再修改
 *
 *
 */
public class SingletonTest1 {
    public static void main(String[] args) {


        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();

        System.out.println(bank1 == bank2);
    }
}

//饿汉式
class Bank{

    //1.私有化类的构造器
    private Bank(){

    }

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

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

单例(Singleton)设计模式-懒汉式

package demo05;

/*
 * 单例模式的懒汉式实现
 *
 */
public class SingletonTest2 {
    public static void main(String[] args) {

        Order order1 = Order.getInstance();
        Order order2 = Order.getInstance();

        System.out.println(order1 == order2);

    }
}


class Order{

    //1.私有化类的构造器
    private Order(){

    }

    //2.声明当前类对象，没有初始化
    //4.此对象也必须声明为static的
    private static Order instance = null;

    //3.声明public、static的返回当前类对象的方法
    public static Order getInstance(){

        if(instance == null){

            instance = new Order();

        }
        return instance;
    }

}

单例(Singleton)设计模式-应用场景

• 网站的计数器，一般也是单例模式实现，否则难以同步。
• 应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志 文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
• 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库 资源。
• 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置 文件数据，都生成一个对象去读取。
• Application 也是单例的典型应用
• Windows的Task Manager (任务管理器)就是很典型的单例模式
• Windows的Recycle Bin (回收站)也是典型的单例应用。在整个系统运行过程 中，回收站一直维护着仅有的一个实例。

代码块

代码块(或初始化块)的作用：

• 对Java类或对象进行初始化

代码块(或初始化块)的分类：

• 一个类中代码块若有修饰符，则只能被static修饰，称为静态代码块 (static block)，
• 没有使用static修饰的，为非静态代码块。

代码块之静态代码块

​

态代码块实际上是 java 语言为程序员准备的一个特殊的时刻，这个时刻就是类加载时刻，如果你想在类加载的时候执行一段代码，那么这段代码就有的放矢了。例如我们要在类加载的时候解析某个文件，并且要求该文件只解析一次，那么此时就可以把解析该文件的代码写到静态代码块当中了。

静态代码块：

用static 修饰的代码块

• 可以有输出语句。
• 可以对类的属性、类的声明进行初始化操作。
• 不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。
• 若有多个静态的代码块，那么按照从上到下的顺序依次执行。
• 静态代码块的执行要先于非静态代码块。
• 静态代码块随着类的加载而加载，且只执行一次。

/*
    1、使用static关键字可以定义：静态代码块
    2、什么是静态代码块，语法是什么？
        static {
            java语句;
            java语句;
        }
    3、static静态代码块在什么时候执行呢？
        类加载时执行。并且只执行一次。
        静态代码块有这样的特征/特点。

    4、注意：静态代码块在类加载时执行，并且在main方法执行之前执行。

    5、静态代码块一般是按照自上而下的顺序执行。

    6、静态代码块有啥作用，有什么用？
        第一：静态代码块不是那么常用。（不是每一个类当中都要写的东西。）
        第二：静态代码块这种语法机制实际上是SUN公司给我们java程序员的一个特殊的时刻/时机。
        这个时机叫做：类加载时机。

    具体的业务：
        项目经理说了：大家注意了，所有我们编写的程序中，只要是类加载了，请记录一下
        类加载的日志信息（在哪年哪月哪日几时几分几秒，哪个类加载到JVM当中了）。
        思考：这些记录日志的代码写到哪里呢？
            写到静态代码块当中。
        
*/
public class StaticTest06{

    // 静态代码块（特殊的时机：类加载时机。）
    static {
        System.out.println("A");
    }

    // 一个类当中可以编写多个静态代码块
    static {
        System.out.println("B");
    }

    // 入口
    public static void main(String[] args){
        System.out.println("Hello World!");
    }

    // 编写一个静态代码块
    static{
        System.out.println("C");
    }
}

/*
A
B
C
Hello World!
*/

​​​​​​​非静态代码块

没有static修饰的代码块

• 可以有输出语句。
• 可以对类的属性、类的声明进行初始化操作。
• 除了调用非静态的结构外，还可以调用静态的变量或方法。
• 若有多个非静态的代码块，那么按照从上到下的顺序依次执行。
• 每次创建对象的时候，都会执行一次。且先于构造器执行。

/*
1、除了静态代码块之外，还有一种语句块叫做：实例语句块
2、实例语句在类加载是并没有执行。
3、实例语句语法？
    {
        java语句;
        java语句;
        java语句;
    }
4、实例语句块在什么时候执行？
    只要是构造方法执行，必然在构造方法执行之前，自动执行“实例语句块”中的代码。
    实际上这也是SUN公司为java程序员准备一个特殊的时机，叫做对象构建时机。
*/
public class InstanceCode{

    //入口
    public static void main(String[] args){
        System.out.println("main begin");
        new InstanceCode();
        new InstanceCode();

        new InstanceCode("abc");
        new InstanceCode("xyz");
    }


    //实例语句块
    {
        System.out.println("实例语句块执行！");    
    }

    // Constructor
    public InstanceCode(){
        System.out.println("无参数构造方法");
    }

    // Constructor
    public InstanceCode(String name){
        System.out.println("有参数的构造方法");
    }

}

​​​​​​​代码的执行顺序练习题

package demo05;

//判断以下程序的执行顺序
public class CodeOrder {

    // 静态代码块
    static {
        System.out.println("A");
    }

    // 入口
    // A X Y C B Z
    public static void main(String[] args) {
        System.out.println("Y");
        new CodeOrder();
        System.out.println("Z");
    }

    // 构造方法
    public CodeOrder() {
        System.out.println("B");
    }

    // 实例语句块
    {
        System.out.println("C");
    }

    // 静态代码块
    static {
        System.out.println("X");
    }

}

总结：程序中成员变量赋值的执行顺序

​

/*
 * 对属性可以赋值的位置：
 * ①默认初始化
 * ②显式初始化/⑤在代码块中赋值
 * ③构造器中初始化
 * ④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值
 * 
 * 
 * 执行的先后顺序：① - ② / ⑤（②和⑤谁先写，谁先赋值） - ③ - ④  
    
 */