final,static,this,super 关键字总结
一、final 关键字
final关键字主要用在三个地方:变量、方法、类。
1、对于一个final变量,如果是基本数据类型的变量,则其数值一旦在初始化之后便不能更改;如果是引用类型的变量,则在对其初始化之后便不能再让其指向另一个对象。
2、当用final修饰一个类时,表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。
3、使用final方法的原因有两个。第一个原因是把方法锁定,以防任何继承类修改它的含义;第二个原因是效率。在早期的Java实现版本中,会将final方法转为内嵌调用。但是如果方法过于庞大,可能看不到内嵌调用带来的任何性能提升(现在的Java版本已经不需要使用final方法进行这些优化了)。类中所有的private方法都隐式地指定为final。
二、static 关键字
static 关键字主要有以下四种使用场景:
1、修饰成员变量和成员方法
修饰成员变量和成员方法: 被 static 修饰的成员属于类,不属于单个这个类的某个对象,被类中所有对象共享,可以并且建议通过类名调用。被static 声明的成员变量属于静态成员变量,静态变量 存放在 Java 内存区域的方法区。调用格式:类名.静态变量名 类名.静态方法名()
方法区与 Java 堆一样,是各个线程共享的内存区域,它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分,但是它却有一个别名叫做 Non-Heap(非堆),目的应该是与 Java 堆区分开来。
HotSpot 虚拟机中方法区也常被称为 “永久代”,本质上两者并不等价。仅仅是因为 HotSpot 虚拟机设计团队用永久代来实现方法区而已,这样 HotSpot 虚拟机的垃圾收集器就可以像管理 Java 堆一样管理这部分内存了。但是这并不是一个好主意,因为这样更容易遇到内存溢出问题。
如果变量或者方法被 private 则代表该属性或者该方法只能在类的内部被访问而不能在类的外部被访问。
测试:
public class StaticBean { String name;
静态变量
static int age; public StaticBean(String name) {
this.name = name;
}
静态方法
static void SayHello() {
System.out.println(Hello i am java);
}
@Override
public String toString() {
return StaticBean{ +
name=' + name + ''' + age + age +
'}';
}
}
public class StaticDemo { public static void main(String[] args) {
StaticBean staticBean = new StaticBean(1);
StaticBean staticBean2 = new StaticBean(2);
StaticBean staticBean3 = new StaticBean(3);
StaticBean staticBean4 = new StaticBean(4);
StaticBean.age = 33;
StaticBean{name='1'age33} StaticBean{name='2'age33} StaticBean{name='3'age33} StaticBean{name='4'age33}
System.out.println(staticBean+ +staticBean2+ +staticBean3+ +staticBean4);
StaticBean.SayHello();Hello i am java
} }
2、静态代码块
静态代码块: 静态代码块定义在类中方法外, 静态代码块在非静态代码块之前执行(静态代码块—>非静态代码块—>构造方法)。 该类不管创建多少对象,静态代码块只执行一次.
静态代码块的格式是:
static {
语句体;
}
一个类中的静态代码块可以有多个,位置可以随便放,它不在任何的方法体内,JVM加载类时会执行这些静态的代码块,如果静态代码块有多个,JVM将按照它们在类中出现的先后顺序依次执行它们,每个代码块只会被执行一次。
静态代码块对于定义在它之后的静态变量,可以赋值,但是不能访问。
3、静态内部类
静态内部类(static修饰类的话只能修饰内部类):
静态内部类与非静态内部类之间存在一个最大的区别,我们知道非静态内部类在编译完成之后会隐含地保存着一个引用,该引用是指向创建它的外围类,但是静态内部类却没有。没有这个引用就意味着:
1、它的创建是不需要依赖外围类的创建。
2、它不能使用任何外围类的非static成员变量和方法。
Example(静态内部类实现单例模式)
1 public class Singleton {
2
3 声明为 private 避免调用默认构造方法创建对象
4 private Singleton() {
5 }
6
7 声明为 private 表明静态内部该类只能在该 Singleton 类中被访问
8 private static class SingletonHolder {
9 private static final Singleton INSTANCE = new Singleton();
10 }
11
12 public static Singleton getUniqueInstance() {
13 return SingletonHolder.INSTANCE;
14 }
15 }
当 Singleton 类加载时,静态内部类 SingletonHolder 没有被加载进内存。只有当调用 getUniqueInstance() 方法从而触发 SingletonHolder.INSTANCE 时 SingletonHolder 才会被加载,此时初始化 INSTANCE 实例,并且 JVM 能确保 INSTANCE 只被实例化一次。 这种方式不仅具有延迟初始化的好处,而且由 JVM 提供了对线程安全的支持。
4、静态导包
静态导包(用来导入类中的静态资源,1.5之后的新特性): 格式为:import static 这两个关键字连用可以指定导入某个类中的指定静态资源,并且不需要使用类名调用类中静态成员,可以直接使用类中静态成员变量和成员方法。
1 Math. --- 将Math中的所有静态资源导入,这时候可以直接使用里面的静态方法,而不用通过类名进行调用
2 如果只想导入单一某个静态方法,只需要将换成对应的方法名即可
3
4 import static java.lang.Math.;
5
6 换成import static java.lang.Math.max;具有一样的效果
7
8 public class Demo {
9 public static void main(String[] args) {
10
11 int max = max(1,2);
12 System.out.println(max);
13 }
14 }
静态方法与非静态方法
静态方法属于类本身,非静态方法属于从该类生成的每个对象。 如果您的方法执行的操作不依赖于其类的各个变量和方法,请将其设置为静态(这将使程序的占用空间更小)。 否则,它应该是非静态的。
1 class Foo {
2 int i;
3 public Foo(int i) {
4 this.i = i;
5 }
6
7 public static String method1() {
8 return An example string that doesn't depend on i (an instance variable);
9
10 }
11
12 public int method2() {
13 return this.i + 1; Depends on i
14 }
15
16 }
你可以像这样调用静态方法:Foo.method1()。 如果您尝试使用这种方法调用 method2 将失败。 但这样可行:Foo bar = new Foo(1);bar.method2();
总结:
1、在外部调用静态方法时,可以使用”类名.方法名”的方式,也可以使用”对象名.方法名”的方式。而实例方法只有后面这种方式。也就是说,调用静态方法可以无需创建对象。
2、静态方法在访问本类的成员时,只允许访问静态成员(即静态成员变量和静态方法),而不允许访问实例成员变量和实例方法;实例方法则无此限制
static{}静态代码块与{}非静态代码块(构造代码块)
相同点: 都是在JVM加载类时且在构造方法执行之前执行,在类中都可以定义多个,定义多个时按定义的顺序执行,一般在代码块中对一些static变量进行赋值。
不同点: 静态代码块在非静态代码块之前执行(静态代码块—非静态代码块—构造方法)。静态代码块只在第一次new执行一次,之后不再执行,而非静态代码块在每new一次就执行一次。 非静态代码块可在普通方法中定义(不过作用不大);而静态代码块不行。
一般情况下,如果有些代码比如一些项目最常用的变量或对象必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的。如果我们想要设计不需要创建对象就可以调用类中的方法,例如:Arrays类,Character类,String类等,就需要使用静态方法, 两者的区别是 静态代码块是自动执行的而静态方法是被调用的时候才执行的.
1 public class Test {
2 public Test() {
3 System.out.print(默认构造方法!--);
4 }
5
6 非静态代码块
7 {
8 System.out.print(非静态代码块!--);
9 }
10 静态代码块
11 static {
12 System.out.print(静态代码块!--);
13 }
14
15 public static void test() {
16 System.out.print(静态方法中的内容! --);
17 {
18 System.out.print(静态方法中的代码块!--);
19 }
20
21 }
22 public static void main(String[] args) {
23
24 Test test = new Test();
25 Test.test();静态代码块!--静态方法中的内容! --静态方法中的代码块!--
26 }
非静态代码块与构造函数的区别是: 非静态代码块是给所有对象进行统一初始化,而构造函数是给对应的对象初始化,因为构造函数是可以多个的,运行哪个构造函数就会建立什么样的对象,但无论建立哪个对象,都会先执行相同的构造代码块。也就是说,构造代码块中定义的是不同对象共性的初始化内容。
三、this 关键字
this关键字用于引用类的当前实例。 例如:
1 class Manager {
2 Employees[] employees;
3
4 void manageEmployees() {
5 int totalEmp = this.employees.length;
6 System.out.println("Total employees: " + totalEmp);
7 this.report();
8 }
9
10 void report() { }
11 }
在上面的示例中,this关键字用于两个地方:
this.employees.length:访问类Manager的当前实例的变量。
this.report():调用类Manager的当前实例的方法。
此关键字是可选的,这意味着如果上面的示例在不使用此关键字的情况下表现相同。 但是,使用此关键字可能会使代码更易读或易懂。
四、super 关键字
super关键字用于从子类访问父类的变量和方法。 例如:
public class Super {
protected int number; protected showNumber() {
System.out.println("number = " + number);
}
} public class Sub extends Super {
void bar() {
super.number = 10;
super.showNumber();
}
}
在上面的例子中,Sub 类访问父类成员变量 number 并调用其其父类 Super 的 showNumber() 方法。
使用 this 和 super 要注意的问题:
1、在构造器中使用 super() 调用父类中的其他构造方法时,该语句必须处于构造器的首行,否则编译器会报错。另外,this 调用本类中的其他构造方法时,也要放在首行。
2、this、super不能用在static方法中。
简单解释一下:
被 static 修饰的成员属于类,不属于单个这个类的某个对象,被类中所有对象共享。而 this 代表对本类对象的引用,指向本类对象;而 super 代表对父类对象的引用,指向父类对象;所以, this和super是属于对象范畴的东西,而静态方法是属于类范畴的东西。
final,static,this,super 关键字总结的更多相关文章
- java修饰符public final static abstract transient
JAVA 修饰符public final static abstract transient 关键字: public final static abstract ... 1.public prot ...
- Java中 final static super this instanceof 关键字用法
一.final关键字 final可以修饰变量.方法及类: 1.当定义一个final变量时,jvm会将其分配到常量池中,其所修饰的对象只能赋值一次,对基本类型来说是其值不可变,引用类型(包括作为函数形参 ...
- Java基础super关键字、final关键字、static关键字、匿名对象整理
super关键字 10.1子父类中构造方法的调用 public class Test { public static void main(String[] args) { new Zi(); } } ...
- 总结目前为止学到的关键字(break,continue,private,static,this,super,final,abstract)
1.控制跳转语句:break(结束) 使用的场景: a.循环当中 b.switch break关键字需要注意的问题: 1.break关键字只能用于循环和switch语句当中,其本质就是结束整段语句的意 ...
- java基础9 main函数、this、static、super、final、instanceof 关键字
一.main函数详解 1.public:公共的.权限是最大的,在任何情况都可以访问 原因:为了保证jvm在任何情况下都可以访问到main法2.static:静态,静态可以让jvm调用更方便,不需要用 ...
- 关键字this super final static
this关键字 1.this代表通过当前类实例化成的对象. 2.通过this来获取当前类的属性和方法 3.通过this和区分成员变量和局部变量 4.通过this(参数),调用当前类的构造方法 注意:通 ...
- Java—构造方法及this/super/final/static关键字
构造方法 构建创造时用的方法,即就是对象创建时要执行的方法. //构造方法的格式: 修饰符 构造方法名(参数列表) { } 构造方法的体现: 构造方法没有返回值类型.也不需要写返回值.因为它是为构建对 ...
- Java final,static 关键字
final关键字: 这是无法改变的”或者“终态的”含义,它可以修饰非抽象类.非抽象类成员方法和变量. final类不能被继承,没有子类,final类中的方法默认是final的.final方法不能被子类 ...
- java 关键字final static native详解
java 关键字native static final详解 一.final 根据程序上下文环境,Java关键字final有"这是无法改变的"或者"终态的"含义, ...
随机推荐
- 决策树防止过拟合(预剪枝(Pre-Pruning))
预剪枝(Pre-Pruning):预剪枝就是在构造决策树的过程中,先对每个结点在划分前进行估计,若果当前结点的划分不能带来决策树模型泛华性能的提升,则不对当前结点进行划分并且将当前结点标记为叶结点.
- Numpy-数组array操作
array是一个通用的同构数据多维容器,也就是说,其中的所有元素必须是相同类型的. 每个数组都有一个shape(一个表示各维度大小的元组)和一个dtype(一个用于说明数组数据类型的对象). 数组的形 ...
- Python练习题 006:输出九九乘法表
[Python练习题 006] 输出九九乘法表 --------------------------------------------------- 照理这题不难,逻辑关系弄对了就好办,但数学渣的我 ...
- [VBA原创源代码] excelhome 对花名册进行分类
最近在学习<菜鸟谈VBA最最基础入门<原创>>,其中第22节有一个VBA编程作业,实现对花名册进行分类. 自己花了点时间,自己丫丫学步,终于实现出来. 在原创聚集地cnblog ...
- Arduino Mega 2560
Arduino Mega 2560 www.theengineeringprojects.com/ 此板子有54个引脚,16个模拟量输入引脚,12个PWM输出引脚,4个串口,带I2C,SPI通讯口,更 ...
- JDK1.8源码安装
JDK1.8源码安装 一.先卸载openjdk #查找已安装的版本,若是没有结果,就表示没安装rpm -qa|grep jdkrpm -qa|grep java#有的话卸载 --nodeps卸载相关依 ...
- vue 项目打包后静态资源加载不到
1, 2,
- Cesium.Viewer
<!DOCTYPE html><html lang="en"><head> <meta charset="utf-8" ...
- 多测师讲解自动化测试_rf测试报告_高级讲肖sir
(一)运行失败 1.1 1.2 用例失败log 2.3Repor 1.4Output (二)运行成功 (三)分析报告 3.1 log: 3.2Report (测试报告) 3.3 Output
- c++程序设计实践——银行系统
银行系统 本科大二程序设计实践的作业,算是一个比较简单的项目吧,主要使用的编程范式有面向对象编程 其中引入<multimap><map>头文件实现多映射输出存取记录 引入< ...