静态成员及应用

1.静态变量

1.定义:

 1..访问修饰符 + static + 数据类型 + 变量名

​ 2.调用方式：

​	1.对象名.静态变量名
    2.类名.静态变量名

​

public class Use{
	public static void main(String args []){
			//对象名调用静态成员变量
			Temp temp01 = new Temp();
			System.out.println(temp01.temp);
			//类名调用静态成员变量
			System.out.println(Temp.temp);
	}
}
class Temp{
		public static String temp="静态成员变量";
}

​

2.作用:

 1.该类创建的所有对象都共享一个变量

​

3.原理

​1.解读：当创建非静态变量时是创建在堆区中的对象空间上的当创建静态成员变量时：
		1.jdk8.0之后在类加载时会在堆空间中开辟静态变量空间，所有对象引用此变量
		2.jdk8.0之前在类加载时会在方法区的静态域中创建静态成员变量，所有对象引用此变量

4.细节：

​		1.所有的对象共享同一静态成员变量

​		2.静态成员变量依然被访问修饰符修饰

​    	3.静态成员变量的生命周期随类信息的加载而被创建，随着类信息的销毁而被销毁（重点）

​		4.扩展：

​				1.会导致类信息被加载的情况：（重点）
										  1.当创建一个对象实例类信息会被加载

​										  2.当子类继承父类，创建一个子类对象时，父类子类都会被加载

​										  3.当调用一个静态成员变量或静态成员方法时类信息会被加载

2.静态方法

1.定义：

​			1.访问修饰符+static+ 返回值类型+方法名（形参列表）{方法体}

​			2.static+访问修饰符+ 返回值类型+方法名（形参列表）{方法体}

​ 3.调用：

​						1.对象名.方法名

​						2.类名.方法名

2.作用：

​				1.当该方法不涉及对象成员时，可以将创建静态成员方法，或将其当作工具类来使用从而提高代码开发效

​				率

​				2.将具有通用性的代码设置为静态成员方法

​ （最直接的便利，不用创建对象就可以直接调用静态成员，节省了对象创建的空间）

3.细节：

​				1.静态成员方法只能调用本类中的静态成员（静态成员变量和静态成员方法）

​				2.静态成员方法中不能使用 this 和 super 关键字 （涉及对象的引用）

​				3.非静态成员方法既可以调用本类的静态成员也可以调用非静态成员

​ （重点：静态方法只能调用静态成员！！！！！！！！）

public class staticMethod {
    public static void main(String[] args) {
        temp.speak();
        //temp.say();非静态成员无法通过类名进行访问
        temp temp = new temp();
        temp.say();

    }
}
class temp{
    private static String test01="静态测试";
    private String test02="非静态测试";
    public void  say(){
        System.out.println("静态成员say"+temp.test01);
        System.out.println("非静态成员say"+test02);
    }
    public static void speak(){
        System.out.println("静态成员speak"+temp.test01);
        //System.out.println("静态成员speak"+test02); 无法访问非静态成员
        //say(); 无法访问非静态成员
    }
}

3.静态成员经典的应用

1.单例设计模式

​ 1.定义：

						1. 在软件开发的过程中尽量保证仅存在一个对象实例

​ 2.分类：

​		1.饿汉模式：

​						1.将构造器私有化

​						2.创建私有静态成员对象属性

​						3.提供公共静态成员方法来返回对象
​					  （静态成员属性保证了返回的对象实例始终是同一个）

​ 2.原理：

1.将构造器私有化，使得外部其他类不能创建本类对象，在类内部创建静态私有
  本类的对象，通过静态成员方法进行访问返回，保证了对象的唯一性

​

public class SingleTon01 {
    public static void main(String[] args) {
       // Temp temp = new Temp(); 构造器私有化无法创建对象
       Temp test = Temp.getInstance(); //通过调用静态方法调用
       System.out.println(test);
       Temp test2 =Temp.getInstance();
       System.out.println(test2);
        //存在资源浪费的问题
        //当调用类中的其他静态成员变量时，类信息也会被加载，该对象也会被创建
        System.out.println(test);
        
    }
}

class Temp {
    public static String test;

    private static Temp temp = new Temp("单例饿汉式");

    private Temp(String test) {//构造器私有化
        this.test = test;
        System.out.println("构造器被调用，类信息被加载！！！");
    }

    public static Temp getInstance() {
        return temp;
    }
}

​ (调用静变量导致类信息被加载且创建了对象)

3.懒汉模式：

​	1.将构造器私有化

​	2.创建私有静态空的对象引用变量

​    3.创建公共静态方法进行判断对象引用变量如果为空则创建对象

public class SingleTon02{
    public static void main(String args[]){
            System.out.println();
    }
}
class SingleClass{
    private static SingleClass temp; //默认为null
    private SingleClass(){
    }
    public static SingleClass getInstance(){
        if(temp == null ){  //满足为空的条件则创建对象，否则则存在该对象
            temp = new SingleClass(); //创建对象
        }
        return temp; 
    }
}

​
3.饿汉模式和懒汉模式的区别：

​区别:两者创建对象的时机不同，饿汉模式在类加载时创建该对象懒汉模式在使用该对象时创建该对象
1.饿汉模式：存在资源浪费的问题，当调用普通静态成员信息时，该单例对象会被创建
2.懒汉模式：存在线程安全问题，当多线程同时调用时，会破坏单例