static关键字，main()方法，代码块，final关键字

static关键字的使用:

1. static:静态的

2. static可以修饰：属性、方法、代码块、内部类

3. 使用static修饰的变量：静态变量(类变量)

   3.1属性：

   实例变量：我们创建了多个类的对象，每个对象都拥有一套独立的类的非静态属性，当修改其中一个对象的非静态属性时，不会导致其他对象中相同的属性值更改。

   静态变量：当我们创建了多个对象时，多个对象共享一个静态变量。当我们修改某一个对象的静态变量时会导致其他对象调用此变量是修改过的。

   3.2 static修饰属性的其他说明：

   • 静态变量随着类的加载而加载，可以通过"类.静态变量"的方法进行调用，可以不用创建类的对象。
   • 静态变量早于类的创建。
   • 由于类只会加载一次，静态变量在内存中也只会存在一份，存在方法区的静态域中。

   3.3static属性举例：

   System.out，Math.PI。

4. 使用static修饰方法，静态方法

   • 随着类的加载而加载可以通过"类.静态变量方法"的方法进行调用，可以不用创建类的对象。

   • 静态方法只能调用静态方法或者静态变量

     非静态方法可以调用非静态方法属性或者静态方法属性

5. static注意点：

   静态方法中不能用super、this关键字。

6. 开发中如何确定一个属性是否要声明为static的？

   • 属性可以被多个对象所共享的，不会随着对象不同而不同的。
   • 类中的常量也常常声明为静态的。

   开发中如何确定一个方法是否要声明为static的？

   • 操作静态属性的方法，通常设置为static的
   • 工具类的方法，习惯上声明为static的，如Math，Arrays

类变量VS实例变量内存解析：

---

单例设计模式

什么是单例设计模式？

• 单例类只能有一个实例。
• 单例类必须自己创建自己的唯一实例。
• 单例类必须给所有其他对象提供这一实例。

单例模式优缺点

优点：

• 1、提供了对唯一实例的受控访问。
• 2、由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。
• 3、允许可变数目的实例。

缺点：

• 1、由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。
• 2、单例类的职责过重，在一定程度上违背了“单一职责原则”。
• 3、滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。

区分饿汉式和懒汉式

​ 饿汉式：

​ 好处：饿汉式是线程安全的

​ 坏处：对象加载时间过长

​ 懒汉式：

​ 好处：延迟对象创建。

​ 坏处：

单例模式的饿汉式实现

先创建实例

/**
 *饿汉式：
 * 1.类的单例设计模式就是采取一定方法保证整个软件系统中，对某个类只能存在一个对象实例。
 * 
 */
public class Bank {
    //1.私有化构造器
    private Bank(){

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

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

单例模式的懒汉式实现

先判断是否创建，未创建就先创建，创建好了就返回实例

/**
 *懒汉式单例模式
 *！！！目前线程不安全！！！
 */

public class Order {
    //1.私有化构造器
    private Order(){

    }
    //2.生命当前类对象，没有初始化
    //4.对象也要声明static
    private static Order instance = null;

    //3.声明public、static的返回当前对象的方法
    public static Order OrdergetInstance(){
        if(instance == null)
            instance = new Order();
        return instance;
    }

}

---

main()方法

main()方法使用说明：

1. main()方法作为程序入口
2. main()方法也是一个普通的静态方法
3. main()方法可以作为我们与控制台交互的方式

main()方法作为程序入口的例子：

IDEA在控制台给main()方法传参步骤：

---

代码块

代码块相关知识：

/**
 * 类的成员之四，代码块(初始化块)
 *
 * 1.作用：用于初始化；类，对象
 * 2.代码块如果有修饰必须用static
 * 3.分类：静态代码块/非静态代码块
 *
 * 4.静态代码块
 *  >内部可以有输出语句
 *  >随着类的加载而执行，而且只执行一次
 *  >初始化类的信息
 *  >多个静态代码块按顺序执行
 *  >静态代码块执行优先于非静态代码块执行
 *  >静态代码块只能调用静态属性、静态方法，不能调用非静态的结构
 *
 * 5.非静态代码块
 *  >内部可以有输出语句
 *  >随着对象的创建而执行，每创建一个对象就执行一次
 *  >作用：可以在创建对象的时候，对对象的属性等进行初始化
 *  >如果一个类中定义了多个非静态代码块，则按照声明先后顺序执行
 *  >非静态代码块内可以调用静态属性、静态方法，或非静态的属性，非静态的方法
 */
public class Bank {
    public static void main(String args[]){
        String n = Person.des;
    }
}

class Person{
    //属性
    private String name;
    private int age;
    static String des = "hhh";

    //构造器
    public Person(){

    }
    public Person(String name,int age){
        this.age=age;
        this.name=name;
    }
    //非静态代码块
    {
        name ="无名";
        System.out.println(222);
        //调用静态方法
        eat();
        //调用非静态方法
        walk();
    }
    //静态代码块
    static {
        System.out.println(111);
        des = "www";
        eat();
    }

    public static void eat(){
        System.out.println("吃吃吃");
    }
    public void walk(){
        System.out.println("肘，跟我进屋");
    }
}

代码块使用场景：

• 比如数据库连接池，只需要创建一个池子，使用静态代码块保证执行一次

对属性可以赋值的顺序：

1. 默认初始化
2. 显示初始化/在代码块中赋值
3. 构造器中初始化
4. 有了对象后，通过“对象.属性”或"对象.方法"进行赋值

---

final关键字

final的使用

final：最终的
1、final可以修饰的结构：类、方法、变量

2、final修饰一个类：此类不能被其他类所继承
比如：String类、System类、StringBuffer类

3、final修饰方法：表明此方法不能再被重写
比如Object中的getClass()方法

4、final修饰变量：此时"变量"就是一个常量
4.1final修饰属性：可以考虑赋值的位置有：显示初始化、代码块中初始化、构造器中初始化
修饰变量一定是要在类被加载之前被赋值
4.2final修饰局部变量：
尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。