Java:static关键字小记
Java:static关键字小记
对 Java 中的 static 关键字,做一个微不足道的小小小小记
static 修饰变量
静态变量:是被 static 修饰的变量,也称为类变量,它属于类,因此不管创建多少个对象,静态变量在内存中有且仅有一个拷贝;静态变量可以实现让多个对象共享内存;可以直接通过 类名.静态变量名
来访问它。
静态的注意事项:
- 静态方法只能访问静态成员(包括静态成员变量和静态成员方法),不能访问非静态成员或方法;非静态方法可以访问静态也可以访问非静态方法或成员。
- 静态方法中不能出现 this,super 关键字。因为静态是优先于对象存在的,所以不能出现 this,super 关键字。
- 主函数是静态的。
实例变量:属于某一实例,需要先创建对象,然后通过对象才能访问到它。
总之:静态变量属于类的级别,而实例变量属于对象的级别。
static 修饰方法
静态方法:被 static 修饰的方法,静态方法在类加载的时候就存在了,它不依赖于任何实例。所以静态方法必须有实现,也就是说它不能是抽象方法。只能访问所属类的静态字段和静态方法,方法中不能有 this 和 super 关键字;
再次注意:
- 被 static 修饰的静态变量与静态方法为静态资源,静态资源是类初始化的时候加载的,而非静态资源是类new的时候加载的;
- 静态方法不能引用非静态资源:非静态资源为new的时候才会产生的东西,对于初始化后就存在的静态资源来说,根本不认识它。
- 静态方法里面可以引用静态资源;
- 非静态方法里面可以引用静态资源:非静态方法就是实例方法,那是new之后才产生的,那么属于类的内容它都认识。
static 修饰代码块
静态代码块:静态代码块在类初始化时运行一次;
初始化顺序:静态变量和静态代码块优先于实例变量和普通语句块,静态变量和静态代码块的初始化顺序取决于它们在代码中的顺序。
public class InitialOrderTest { // 1:被调用
public static String staticField = "静态变量";
// 2:被调用
public static String staticMethod = staticMethod(); // 4:只有new的时候才会输出
{
System.out.println("普通语句块");
} // 3:被调用
static {
System.out.println(staticField);
System.out.println("静态语句块");
} public String field = "实例变量"; public static String staticMethod(){
System.out.println("静态变量调用静态方法");
return "staticMethod";
} // 最后才是构造函数的初始化
public InitialOrderTest() {
// 5:只有new的时候才会输出
System.out.println("构造函数");
} public static void main(String[] args) {
new InitialOrderTest();
}
}
// 结果:
// 静态变量调用静态方法
// 静态变量
// 静态语句块
// 普通语句块
// 构造函数
从字节码的角度对上述调用顺序进行解释:
<cinit>()V
编译器会按从上至下的顺序,收集所有 static 静态代码块和静态成员赋值的代码,合并为一个特殊的方法
<cinit>()V
:// java源码:
public class Demo3_8_1 {
static int i = 10;
static {
i = 20;
}
static {
i = 30;
}
} // 对应的字节码:
0: bipush 10 // 把10放入栈中
2: putstatic #2 // Field i:I,常量池中找到i变量
5: bipush 20 // 把20放入栈中
7: putstatic #2 // Field i:I
10: bipush 30 // 把20放入栈中
12: putstatic #2 // Field i:I
15: return
<cinit>()V
方法会在类加载的初始化阶段被调用<init>()V
编译器会按从上至下的顺序,收集所有
{} 代码块
和成员变量赋值
的代码,形成新的构造方法,但原始构造方法内的代码总是在最后// java源码:
public class Demo3_8_2 {
private String a = "s1"; {
b = 20;
} private int b = 10; {
a = "s2";
} public Demo3_8_2(String a, int b) {
this.a = a;
this.b = b;
} public static void main(String[] args){
Demo3_8_2 d = new Demo3_8_2("s3", 30);
System.out.println(d.a); // "s3"
System.out.println(d.b); // 30
}
} // 对应的字节码:
Code:
stack=2, locals=3, args_size=3
0: aload_0 // this
1: invokespecial #1 // super.<init>()V
4: aload_0
5: ldc #2 // <- "s1"
7: putfield #3 // -> this.a
10: aload_0
11: bipush 20 // <- 20
13: putfield #4 // -> this.b
16: aload_0
17: bipush 10 // <- 10
19: putfield #4 // -> this.b
22: aload_0
23: ldc #5 // <- "s2"
25: putfield #3 // -> this.a
28: aload_0 // ------------------------------
29: aload_1 // <- slot_1(a) "s3" |
30: putfield #3 // -> this.a |
33: aload_0 // |
34: iload_2 // <- slot 2(b) 30 |
35: putfield #4 // -> this.b --------------------
38: return
参考:https://www.bilibili.com/video/BV1yE411Z7AP?p=116 ~ https://www.bilibili.com/video/BV1yE411Z7AP?p=117
静态代码块对于定义在它之后的静态变量,可以赋值,但是不能访问
public class InitialOrderTest { static {
// 不能访问,报错↓↓↓
// System.out.println(staticField);
// 可以赋值
staticField = "?????";
System.out.println("静态语句块");
} public static String staticField; static {
System.out.println(staticField); // 结果:?????
} public static void main(String[] args) {
new InitialOrderTest();
}
}
对上述现象做进一步解释:
对上述代码查看静态代码块的字节码如下:
{
// 类加载的链接中的 **准备阶段**,为static变量分配空间,即staticField已经分配好了空间
public static java.lang.String staticField;
descriptor: Ljava/lang/String;
flags: ACC_PUBLIC, ACC_STATIC public cn.xyc.other.InitialOrderTest();
// ... 略
public static void main(java.lang.String[]);
// ... 略 // 在类的初始化阶段调用<cinit>()V完成对静态变量的赋值
static {};
descriptor: ()V
flags: ACC_STATIC
Code:
stack=2, locals=0, args_size=0
0: ldc #4 // String ?????
2: putstatic #5 // Field staticField:Ljava/lang/String;
5: getstatic #6 // Field java/lang/System.out:Ljava/io/PrintStream;
8: ldc #7 // String 静态语句块
10: invokevirtual #8 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
13: getstatic #6 // Field java/lang/System.out:Ljava/io/PrintStream;
16: getstatic #5 // Field staticField:Ljava/lang/String;
19: invokevirtual #8 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
22: return
LineNumberTable:
line 9: 0
line 10: 5
line 16: 13
line 17: 22
}
SourceFile: "InitialOrderTest.java"
静态代码块是严格按照:父类静态代码块->子类静态代码块的顺序加载的,且只加载一次。
对初始化顺序的补充:存在继承的情况下,初始化顺序为:
- 父类(静态变量、静态代码块)
- 子类(静态变量、静态代码块)
- 父类(实例变量、普通代码块)
- 父类(构造函数)
- 子类(实例变量、普通代码块)
- 子类(构造函数)
static 修饰内部类
静态内部类:非静态内部类依赖于外部类的实例,而静态内部类不需要。但静态内部类不能访问外部类的非静态的变量和方法;
静态内部类是不需要依赖于外部类的,通常称为嵌套类(nested class);
对于普通内部类对象,其隐含的保存了一个指向创建它的外围类对象的引用;然而当内部类用static修饰后变为静态内部类,就没有这个引用了,这就意味着:
- 要创建嵌套类的对象,并不需要其外围类的对象;
- 不能从嵌套类的对象中访问非静态的外围类对象。
// 静态内部类
public class Outer{
private static int num1 = 10;
private int num2 = 20;
private String name = "Java";
// 外部类普通方法
public void outer_func1(){
System.out.println("外部类Outer的普通方法:outer_func1");
}
// 外部类静态方法
public static void outer_func2(){
System.out.println("外部类Outer的普通方法:outer_func2");
}
// 静态内部类可以用public、protected、private修饰
// 静态内部类可以定义静态类或非静态内部类
public static class Inner{
static int num3 = 30;
String name = "Gava";
// 静态内部类里的静态方法
static void inner_func1(){
System.out.println("静态内部类的静态方法");
// 静态内部类只能访问外部类的静态成员(静态变量、静态方法)
System.out.println(num1);
// System.out.println(num2); //error
// outer_func1(); //error
outer_func2();
}
//静态内部类非静态方法
void inner_func2(){
System.out.println("静态内部类的非静态方法");
System.out.println(num1);
System.out.println(num3);
System.out.println(name); // 可以访问静态内部类中的非静态成员
}
}
public static void main(String[] args) {
// 静态内部类的静态方法
Outer.Inner.inner_func1();
// 静态内部类的非静态方法
Inner inner = new Inner();
inner.inner_func2();
}
}
通过静态内部类还可以实现安全的单例模式,后续再写
参考
https://www.cnblogs.com/jasonboren/p/11052500.html
https://www.cnblogs.com/xrq730/p/4820992.html
https://www.cnblogs.com/GrimMjx/p/10105626.html
Java:static关键字小记的更多相关文章
- Java Static关键字详解
提起static关键字,相信大家绝对不会陌生,但是,想要完全说明白,猛的一想,发现自己好像又说不太明白... ...比方说,昨天被一个同学问起的时候... ... 当然,不是所有人都像我一样学艺不精的 ...
- java static关键字
方便在没有创建对象的情况下来进行调用(方法/变量). 很显然,被static关键字修饰的方法或者变量不需要依赖于对象来进行访问,只要类被加载了,就可以通过类名去进行访问. static可以用来修饰类的 ...
- Java static 关键字详解
引言 在<Java编程思想>中有这样一段话:static方法就是没有this的方法.在static方法内部不能调用非静态方法,反过来是可以的.而且可以在没有创建任何对象的前提下,仅仅通过类 ...
- 【转载】java static 关键字的四种用法
原文链接点这里,感谢博主分享 在java的关键字中,static和final是两个我们必须掌握的关键字.不同于其他关键字,他们都有多种用法,而且在一定环境下使用,可以提高程序的运行性能,优化程序的结构 ...
- [java]static关键字的四种用法
在java的关键字中,static和final是两个我们必须掌握的关键字.不同于其他关键字,他们都有多种用法,而且在一定环境下使用,可以提高程序的运行性能,优化程序的结构.下面我们先来了解一下stat ...
- Java——static关键字
前言 static关键字算是Java中比较复杂的关键字之一,它可以修饰变量.方法.类以及代码块.下面将介绍static的具体使用. static引入的目的 static的作用 static修饰变量 s ...
- Java——static关键字---18.09.27
static表示“全局”或者“静态”的意思,用来修饰成员变量和成员方法,也可以形成静态static代码块,但在Java语言中没有全局变量的概念. static关键字主要有两种作用: 一.为某特定数据类 ...
- Java static关键字的重新思考
上完Java课,虽然也写了不少的Java代码,但是一直有不少的疑惑,而static关键字一直困惑着我很久,今天无意探究竟,上知乎再仔细查了一下,发现了这个话题的优秀答案https://www.zhih ...
- java static关键字和代码块
static关键字 代码块 方法重写 1. 方法重写的特点: 2. 注意事项: static关键字 为什么需要学习static关键字? 针对某一个变量属于类而不属于某一个具体的对象的时候,我们可以考虑 ...
随机推荐
- ubuntu14.04 安装MySQL 5.7
ubuntu14.04 默认在线安装MySQL 5.5 1) wget http://dev.mysql.com/get/mysql-apt-config_0.7.3-1_all.deb 2) dpk ...
- C# AutoMaper简单使用
AutoMapper它是一种对象与对象之间的映射器,让AutoMapper有意思的就是在于它提供了一些将类型A映射到类型B这种无聊的实例,只要B遵循AutoMapper已经建立的惯例,那么大多数情况下 ...
- Webpack:打包项目报错(eslint: debugger)
打包项目需要把项目中的debugger删除,否则会报错.
- 这些解决 Bug 的套路,你都会了不?
最近整理了我原创的 140 篇编程经验和技术文章,欢迎大家阅读,一起成长!指路:https://t.1yb.co/ARnD 大家好,我是鱼皮. 学编程的过程中,我们会遇到各式各样的 Bug,也常常因为 ...
- 离散化模板题 I ——重复元素离散化后的数字相同
离散化模板题 I --重复元素离散化后的数字相同 题目描述 现有数列A1, A2, ⋯, An,数列中可能有重复元素. 现在要求输出该数列的离散化数列,重复元素离散化后的数字相同. 输入 第一行,一 ...
- Java Web实现登录验证码(Servlet+jsp)
1.生成验证码图片(Servlet) import java.awt.Color; import java.awt.Font; import java.awt.Graphics2D; import j ...
- win8 连接到OneDrive时出现问题-感叹号
显示最后更新时间是1970年... 还有感叹号,没法同步 解决办法: 管理员运行cmd命令: 输入"netsh int ip reset c: esetlog.txt",按下回车键 ...
- Orchar Core 创建一个模块化的ASP.NET Core应用程序
您将构建什么?您将构建一个模块化的ASP.NET Core MVC Web应用程序,类似于Orchard Core附带的示例"Hello World"应用程序.它包括一个Web应用 ...
- Jmeter系列(14)- Setup与tearDown线程组
与普通线程组区别 #Setup线程组:在普通线程组执⾏前触发 #tearDown线程组:在普通线程组执⾏后触发 线程组属性配置详情完全⼀致 使⽤策略建议 #Setup 线程组 – 压测执⾏准备阶段,准 ...
- mysql8 navicat远程链接失败
原因:mysql 8加密规则问题 更改加密规则: ALTER USER 'ycc'@'%' IDENTIFIED BY 'you password' PASSWORD EXPIRE NEVER; 修改 ...