Java面向对象编程——static 关键字

        

目录

静态变量

静态方法

静态代码块

单列模式

---

        将每个方法的类型设置为 static(静态的)，这是有原因的，通常情况下，类成员必须通过类的对象访问，有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象，不必借助特定实例。在成员的声明前面加上关键字 static 就能创建这样的成员。如果一个成员被声明为 static，它就能在其类的任何对象创建之前被访问，而不必引用任何对象。你可将方法和变量都声明static，所以有了 static 关键字，我们就不必创建对象，可直接使用类名来调用静态方法。

        static 成员的最常见例子是 main()，因为在程序开始执行时必须调用 main()，所以它被声明为 static。声明为 static 的变量实质上就是全局变量。当声明一个对象时,并不产生 static变量的拷贝，而是该类所有的实例变量共用同一个 static 变量。

声明为static 的方法有一下几条限制。

1. 它们仅能调用其他的static方法
2. 它们只能访问static数据
3. 它们不能以任何对象引用this或super(关键字super与继承有关，在之后文章会发布)

静态变量

通常，我们可以通过一个类创建多个对象，每个对象都有自己独立的成员，但是，在某些时候，我们希望一个类的所有对象共享一个成员，这个时候我们就需要使用static关键字来进行修饰了。Java 中被 static 关键字修饰的成员称为静态成员或类成员，属于整个类，也就是被类的所有对象所共享,静态成员可通过类名直接访问，也可通过类对象进行访问，推荐使用类名直接调用，那样更加方便简洁。

        首先来看一下静态变量是如何定义和使用的

//静态变量的定义和使用
public class Dcc {
	static String name = "hope";	//使用关键字static修饰的变量称为静态变量
	public static void main(String[] args) {
		//1.通过类名直接访问静态变量，推荐使用
		System.out.println("通过类名调用name:"+Dcc.name);	//输出打印字符串文字及调用类中属性
		
		//2.通过创建对象来调用静态变量，不推荐使用
		Dcc dc = new Dcc();		//对象实例化
		System.out.println("通过创建对象调用name:"+Dcc.name);		//输出打印字符串文字及调用类中属性
	}
}

运行结果如下

        我们创建了一个名为name的静态变量，并赋值为"hope"，在主方法中既可以通过创建对象来访问该静态变量，也可以使用类名直接访问静态变量，在运行效果中都得到了准确结果，不过，推荐大家使用类名直接访问静态变量。

静态方法

        与静态变量一样，大家也可以使用static关键词修饰方法，这样的方法称为静态方法或方法，大家经常使用的main()方法就是静态方法。

        下面来看一下静态方法的定义与使用

//静态方法的定义和使用
public class StaticMethod {
	
	//使用static关键字修饰方法，称为静态方法或类方法
	public static void show() {
		System.out.println("北京欢迎你.....");
	}
	//普通方法
	public void test() {
		System.out.println("你好......");
	}
	public static void main(String[] args) {
		//在mian()方法中，可以直接调用静态方法
		show();
		//只有通过创建对象才能调用方法
		StaticMethod sm = new StaticMethod();
		sm.test();
	}

运行结果如下：

        对于静态方法，在main()方法中，我们可以直接调用，但对于普通方法，如果想要访问，就必须要通过创建对象才能进行调用。

静态代码块

        在java中，使用"{}"括起来的代码称之为代码块，代码块分为四类。分别是普通代码块，构造代码块，静态代码块，静态代码块及同步代码块，我们先来了解静态代码块的定义和使用，使用static{}括起来的代码块片段称之为静态代码块，静态代块在第一次加载类时时执行只执行一次，静态代码块优先于构造方法块执行。

代码如下：

public class StaticBlock {
	String  name = "hope";
	//使用static关键字修饰的代码块称之为静态代码块
	static {
		System.out.println("我是静态代码块，我只执行一次...");
	}
	public static void main(String[] args) {
		System.out.println("静态代码的使用...");
		//创建一个对象并访问普通变量
		StaticBlock sb = new StaticBlock();		//对象实例化
		System.out.println("普通变量"+ sb.name);
	
	}
}

运行结果如下：

 

         静态代码块随着类的加载而执行，并且只执行一次，可在一个类中定义多个静态代码块。

单列模式

        大家都知道我们可以基于一个类创建多个对象，但有时为了保证Java应用程序中，一个类只有一个实例存在，我们需要使用java设计模式中的单列模式。此模式可节省内存，因为限制了实例个数，有利于java垃圾回收，单列模式具有以下特点。

1. 单例类只能有一个实例
2. 单例类必须自行创建唯一实例
3. 单例类必须给其他所有对象提供这一实例。

         介绍一下饿汉式和懒汉式单例模式，如下代码

饿汉式：

//饿汉式
public class Single {
	// 创建一个私有的，静态类的对象并初始化
	private static Single s = new Single();

	// 私有构造方法
	private Single() {
	}

	// 提供一个公有的静态方法获取该对象
	private static Single getInstance() {
		return s;    //返回s值
	}
}

懒汉式：

//懒汉式
public class Single2 {
	// 创建一个私有的，静态的类变量，初始值为null
	private static Single2 s = null;

	// 私有方法
	private Single2() {
	}

	// 提供一个公有的静态方法，当变量为null时，创建一个对象并返回
	public static Single2 getInstance() {
		//if判断s是否等于null
        if (s == null) {
            //s等于null执行创建对象s        
			s = new Single2();
		}
		return s;

	}

}

        当类加载时，饿汉式完成单例的初始化，保证执行getInstance时，单例已经存在，而懒汉式只有当调用getInstance时，才去初始化相应的单例。

        饿汉式在创建类时就实例化一个静态对象。不管之后是否有使用过这个单例，都占据一定内存，而且第一次调用的速度更快，因为资源已经初始化过了

        懒汉式会延迟加载，在第一次使用单例时才会实例化对象，性能稍差。