一、  static关键字的使用

1.static：静态的

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

 3.使用static修饰属性：静态变量

3.1 属性：按是否使用static修饰，分为 静态变量（类变量）  vs  非静态变量（实例变量）
    静态变量:我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致
            其他对象调用此静态变量时，是修改过了的。
    实例变量:我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的
            非静态属性时,不会导致其他对象中同样的属性值的修改。
    3.2 static修饰的属性的其他说明：
        ① 静态变量随着类的加载而加载。可以通过"类﹒静态变量"的方式进行调用
        ② 静态变量的加载要早于对象的创建。
        ③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
        ④ 类变量用类和实例对象都可以调用，实例变量只能用实例变量来进行调用

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

① 随着类的加载而加载,可以通过"类.静态方法"的方式进行调用
    ② 静态方法中，只能调用静态的方法或属性
      非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

 5.注意：

① 在静态的方法中，不能使用this关键字，也不能使用super关键字，他俩都是当前对象的...意思，而静态的方法可以用类调用 
② 类加载时便有了静态变量和静态方法，创建了对象以后才有了this、super这类说法，关于调用，按照生命周期的顺序去思考

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

①属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
②我们也常看见类中的一些常量也用static修饰。如Math.PI,使得PI可以直接用Math这个类来调用并且每个圆的Π都是这个值，可以公用一样的，但是它还用final来修饰了，因为是一个常量，不让修改
③操作静态属性的方法,通常设置为static的。
④工具类中的方法，习惯上声明为static的。比如:Math、Arrays.Collections

public class StaticTest {
	public static void main(String[] args) {

		Chinese.nation = "中国";

		Chinese c1 = new Chinese();
		c1.name = "海玉";
		c1.age = 18;
		// c1.nation = "CHN";

		Chinese c2 = new Chinese();
		c2.name = "嗨嗨";
		c2.age = 11;
		System.out.println(c2.nation);// CHN
		Chinese.sleep();
		System.out.println(c1.toString());
	}
}

class Chinese {
	String name;
	int age;
	static String nation;

	public void eat() {
		System.out.println("中国人吃中国菜");
	}

	public static void sleep() {
		System.out.println("中国人睡中国炕");
		// eat();报错
		System.out.println(Chinese.nation);
		walk();
	}

	public static void walk() {
	}

}

二、单例模式

1.了解单例模式

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

2、实现方式：

        饿汉式就是直接构造器中创建好了实例，而懒汉式就是调用方法的时候才会创建实例

2.1饿汉式

public final class SingletonTest1 {
public static void main(String[] args) {
	Bank bank1 = Bank.getBank();
	Bank bank2 = Bank.getBank();
	//此时，居然有两个银行出现，实际上它俩是一个，都是调用的构造器中的那个
	//证明
	System.out.println(bank1 == bank2);//true
	
}
}

//*********************************************①饿汉式
class Bank{
	//1.私有化构造器
	private Bank(){
		
	}
	//2.内部创建一个对象实例
	//4.对象设置为静态的
	 private static Bank bank = new Bank();
	 
	//提供方法调用这个对象 ，外面不能创建实例，无法调用方法，我们就想到用类来调用，于是使用static，
	//但是静态方法只能调用静态变量，所以这个bank实例也静态化，于是在第二步使用static
	 public static Bank getBank() {
		 return bank;
	 }
	
}

2.2懒汉式

package com.haiyu.java;

public class SingletonTest2 {
	public static void main(String[] args) {
		Bank bankk1 = Bank.getBank();
		Bank bankk2 = Bank.getBank();
		
		System.out.println(bankk1 == bankk2);//true表明这是一个bankk
	}
}

//*******************************②懒汉式
class Bankk {//这里在同一个包下不能有两个相同的类
	// 1.私有化构造器
	private Bankk() {

	}

	// 2.声明当前类对象，但是没有初始化
	//将bank设置为静态的
	private static Bankk bankk = null;
	//3.声明public、static的返回对象实例的方法
	public static Bankk getBankk() {
		if(bankk == null) {
			bankk = new Bankk();
		}
		return bankk;
	}
}

标签：调用,饿汉,静态,对象,static,单例,Bank,变量
来源： https://blog.csdn.net/m0_61454947/article/details/121737661