浅谈java中static关键字修饰的几种用法

最新推荐文章于 2024-08-11 08:00:00 发布

清如许.

最新推荐文章于 2024-08-11 08:00:00 发布

阅读量1.4k

点赞数 4

分类专栏： javaSE基础入门指南 JAVA面试攻略文章标签： java中的static关键字 static用法

本文链接：https://blog.csdn.net/MacWx/article/details/89321600

版权

JAVA面试攻略同时被 2 个专栏收录

37 篇文章 5 订阅

订阅专栏

javaSE基础入门指南

36 篇文章 2 订阅

订阅专栏

在java的关键字中，static和final是两个我们必须掌握的关键字。不同于其他关键字，他们都有多种用法，而且在一定环境下使用，可以提高程序的运行性能，优化程序的结构。下面我们先来了解一下static关键字及其用法。

static关键字

1，修饰成员变量
类，里面有属性和方法
属性里面又分局部变量，实例变量和类变量

实例变量,在创建对象的时候分配空间初始化
类变量不再属于某一个对象，它属于全类公有；
实例变量和类变量区分主要看加不加static，统称变量
属性和方法合称为成员

所以这里我再次区分一下，
（1），static修饰变量时的用法：
static修饰的变量叫做类变量
//类变量不再属于某一个对象，它属于全类公有；

static int b = 20;

类变量是在类加载的时候初始化的；
什么是类加载：
所有数据都是存在虚拟机内存里面
jvm启动后，在程序之执行的过程中，肯定会用到很多的类
.class文件的读取过程只有一次，在第一次用到这个类的时候；这就是类的加载
类加载：当虚拟机第一次使用一个类时，需要通过Classpath找到这个类对应的.class文件
把这个文件中包含的类的信息读jvm并保存起来。
一般的说，一个类只会加载一次；
所有的类变量是在类加载的时候分配空间，并且初始化！

类加载的时机：
1，创建类的对象
2，访问类的静态成员
3，加载子类必须先加载父类
4，如果仅仅是声明类的引用，不会类加载；

（2）修饰成员方法
static的另一个作用，就是修饰成员方法。相比于修饰成员属性，修饰成员方法对于数据的存储上面并没有多大的变化，因为我们从上面可以看出，方法本来就是存放在类的定义当中的。static修饰成员方法最大的作用，就是可以使用"类名.方法名"的方式操作方法，避免了先要new出对象的繁琐和资源消耗，我们可能会经常在帮助类中看到它的使用：

static修饰的静态方法：允许直接用类名调用
在静态方法中，只能访问类的静态成员

静态方法中不能直接访问本类非静态成员(方法和属性)
非静态方法中可以去访问静态成员
静态方法中不能使用this和super关键字
静态方法可以被覆盖，但是只能被静态方法覆盖，而且没有多态

（3），初始代码块
静态初始代码块中的代码，在类加载的时候执行一次；

其中，
局部变量
类
构造方法
等都不能静态

（4）
父类的静态方法只能被子类的静态方法覆盖

为便于理解下面程序加了详细注释说明，每一种使用都有详细标注，相信把下面这个程序看懂就能理解static的具体用法了！

   package test;
    
    public class TestStatic{
    /**
    static   静态的
    修饰的   1，属性
    		2，方法
    		3，初始代码块
     */
    	public static void main(String[] args) {
    		 MyClass m1 = new MyClass();
    		 MyClass m2 = new MyClass();
    		 m1.a++;
    		 m1.b++;
    		 System.out.println(m1.a);//11
    		  System.out.println(m1.b);//21
    		 System.out.println(m2.a);//10
    		 System.out.println(m2.b);//21
    		 //类变量允许直接用类名访问，与对象无关
    		 System.out.println(MyClass.b);//21
    		 //静态方法：允许直接用类名调用
    		 MyClass.print(); 
    		 //如果不是静态方法，需要创建对象然后通过对象去调用
    		 MyClass mc = new MyClass();
    		 mc.prints();
    
     		System.out.println("****************************");
    
    		 //静态初始代码块中的代码，只在类加载的时候执行一次；
    		 /* 所以就算两次创建，也只会输出
    			hahahha
    			 MyClass2()
    			 MyClass2()  */
    		 new MyClass2();
    		 new MyClass2();

    		 //多态
    		 Super s = new Sub();
    		 //对一个引用，调用其静态方法，仅相当于对引用的引用类型调用静态方法
    		 //例， s.method();等价于Super.method();
    		 s.method();//输出Super  
    		 /*根据以往学的多态的知识，此处应该打印Sub；
    		 //所以，静态方法可以被子类的静态方法覆盖，而且没有多态
    		 //没有多态，是指多态三条原则中的第三条不再适用，
    		 //不会根据对象实际类型去找子类覆盖之后的方法
    		 //即，静态方法的覆盖没有多态，*/
    		 Super s2 = null;
    		 s2.method();  		
    	}
    }
    class MyClass{
    	//实例变量,在创建对象的时候分配空间初始化 
    	int a = 10;
    /*	1，属性
    	//静态变量   类变量，
    	//类变量不再属于某一个对象，它属于全类公有； */
    	static int b = 20;
    	
    /*2，方法
    	静态方法：允许直接用类名调用
    	在静态方法中，只能访问类的静态成员     */
    	public static void print(){
    		System.out.println("==	========");
    		//在静态方法中，只能访问类的静态成员
    		//System.out.println("=========="+a);error!!!
    		System.out.println("=========="+b);//true
    			//访问myclass类对象的成员就可以了
    			MyClass ma = new MyClass();
    			System.out.println(ma.a);//true
    	}
    	//非静态方法
    	public void prints(){
    		System.out.println("-----------");
    	}
    }
     /*3，初始代码块 
    	静态初始代码块中的代码，在类加载的时候执行一次； */
    class MyClass2{
    	static{
    		System.out.println("hahahha");
    	}
    	public MyClass2(){
    		System.out.println(" MyClass2()");
    	}
    }
    /*  局部变量, 类, 构造方法
    等都不能静态     */   
    //父类的静态方法只能被子类的静态方法覆盖
    class Super{
    	public static void method(){
    		System.out.println("Super");
    	}
    }
    class Sub extends Super{
    	public static void method(){
    		System.out.println("Sub");
    	}
    
    }