Java（静态）变量、（静态）代码块、构造方法的执行顺序
Java（静态）变量、（静态）代码块、构造方法的执行顺序
总结
1、父类静态变量和静态代码块（先声明的先执行）;
2、子类静态变量和静态代码块（先声明的先执行）;
3、父类的变量和代码块（先声明的先执行）;
4、父类的构造方法;
5、子类的变量和代码块（先声明的先执行）;
6、子类的构造方法。
注意事项
1、非静态代码块于构造方法之前执行,并且每次实例化对象之前都会先执行非静态代码块,静态代码块于非静态代码块之前执行;
2、在类第一次被调用时,加载该类,静态代码块只执行一次;
3、静态代码块只能调用静态变量,静态方法只能调用静态变量;
4、非静态代码块或非静态方法可以调用任何(静态+非静态)变量;
5、非静态代码块在实例化对象时,于构造方法之前执行。
参考代码 1
class HelloA {
public HelloA() {
System.out.println("HelloA");
}
{
System.out.println("I'm A class");
}
static {
System.out.println("static A");
}
}
public class HelloB extends HelloA {
public HelloB() {
System.out.println("HelloB");
}
{
System.out.println("I'm B class");
}
static {
System.out.println("static B");
}
public static void main(String[] args) {
new HelloB();
}
}
运行结果
static A
static B
I'm A class
HelloA
I'm B class
HelloB
```
参考代码 2
class A {
public A() {
System.out.println("HelloA");
}
{
System.out.println("I'm A class");
}
static {
System.out.println("static A");
}
}
public class B extends A {
public B() {
System.out.println("HelloB");
}
{
System.out.println("I'm B class");
}
static {
System.out.println("static B");
}
public static void main(String[] args) {
new B();
}
}
运行结果
static A
static B
I'm A class
HelloA
I'm B class
HelloB
```
参考代码 3
class A {
static {
System.out.print("1");
}
public A() {
System.out.print("2");
}
}
class B extends A {
static {
System.out.print("a");
}
public B() {
System.out.print("b");
}
}
public class Hello {
public static void main(String[] args) {
new B();
new B();
}
}
运行结果
1a2b2b
```
参考代码 4
public class HelloA {
static {
System.out.println("static A");
}
{
System.out.println("I'm A class");
}
public HelloA() {
System.out.println("HelloA");
}
public HelloA(String s) {
System.out.println(s + "HelloA");
}
public static void main(String[] args) {
new HelloB();
}
}
class HelloB extends HelloA {
public HelloB() {
// 只能调用一次父类的构造方法，如果不写，Java 编译器会自动调用无参的构造方法。
// super();
super("parent");
System.out.println("HelloB");
}
{
System.out.println("I'm B class");
}
static {
System.out.println("static B");
}
}
运行结果
static A
static B
I'm A class
parentHelloA
I'm B class
HelloB
```
参考代码 5
public class People {
String name;
public People() {
System.out.println(1);
}
public People(String name) {
System.out.println(2);
this.name = name;
}
}
class Child extends People {
People father;
public Child() {
// super(); // 系统默认调用父类的无参构造方法
System.out.println(4);
}
public Child(String name) {
// super(); // 系统默认调用父类的无参构造方法
System.out.println(3);
this.name = name;
father = new People(name + ":F");
System.out.println(father.name);
}
public static void main(String[] args) {
new Child();
// new Child("mike");
}
}
运行结果
1
4
```
参考代码 6
public class People {
String name;
public People() {
System.out.println(1);
}
public People(String name) {
System.out.println(2);
this.name = name;
}
}
class Child extends People {
People father;
public Child() {
// super(); // 系统默认调用父类的无参构造方法
System.out.println(4);
}
public Child(String name) {
// super(); // 系统默认调用父类的无参构造方法
System.out.println(3);
this.name = name;
father = new People(name + ":F");
System.out.println(father.name);
}
public static void main(String[] args) {
// new Child();
new Child("mike");
}
}
运行结果
1
3
2
mike:F
```
参考代码 7
public class ExA {
private static ExA a = new ExA();
static {
System.out.println("父类---静态代码块");
}
public ExA() {
System.out.println("父类---构造方法");
}
{
System.out.println("父类---非静态代码块");
}
public static void main(String[] args) {
new ExB();
}
}
class ExB extends ExA {
private static ExB b = new ExB();
static {
System.out.println("子类---静态代码块");
}
{
System.out.println("子类---非静态代码块");
}
public ExB() {
System.out.println("子类---构造方法");
}
}
运行结果
父类---非静态代码块
父类---构造方法
父类---静态代码块
父类---非静态代码块
父类---构造方法
子类---非静态代码块
子类---构造方法
子类---静态代码块
父类---非静态代码块
父类---构造方法
子类---非静态代码块
子类---构造方法
```
参考代码 8
class Foo {
public Foo(String word) {
System.out.println(word);
}
}
class Parent {
static Foo FOO = new Foo("Parent's static parameter");
Foo foo = new Foo("Parent's parameter");
static {
System.out.println("Parent's static code block");
}
{
System.out.println("Parent's code block");
}
public Parent() {
System.out.println("Parent.Parent()");
}
}
public class Child extends Parent {
static Foo FOO = new Foo("Child's static parameter");
Foo foo = new Foo("Child's parameter");
static {
System.out.println("Child's static code block");
}
{
System.out.println("Child's code block");
}
public Child() {
System.out.println("Child.Child()");
}
public static void main(String[] args) {
new Child();
}
}
运行结果
Parent's static parameter
Parent's static code block
Child's static parameter
Child's static code block
Parent's parameter
Parent's code block
Parent.Parent()
Child's parameter
Child's code block
Child.Child()
```
参考代码 9
public class GFG {
public GFG(int x) {
System.out.println("ONE argument constructor");
}
public GFG() {
System.out.println("No argument constructor");
}
static {
System.out.println("1st static init");
}
{
System.out.println("1st instance init");
}
{
System.out.println("2nd instance init");
}
static {
System.out.println("2nd static init");
}
public static void main(String[] args) {
new GFG();
new GFG(8);
}
}
运行结果
1st static init
2nd static init
1st instance init
2nd instance init
No argument constructor
1st instance init
2nd instance init
ONE argument constructor
```
参考代码 10
class MyTest {
static {
initialize();
}
private static int sum;
public static int getSum() {
initialize();
return sum;
}
private static boolean initialized = false;
private static void initialize() {
if (!initialized) {
for (int i = 0; i < 100; i++)
sum += i;
initialized = true;
}
}
}
public class GFG {
public static void main(String[] args) {
System.out.println(MyTest.getSum());
}
}
运行结果
9900
```
参考代码 11
class MyTest {
static {
initialize();
}
private static int sum = 0;
public static int getSum() {
initialize();
return sum;
}
private static boolean initialized = false;
private static void initialize() {
if (!initialized) {
for (int i = 0; i < 100; i++)
sum += i;
initialized = true;
}
}
}
public class GFG {
public static void main(String[] args) {
System.out.println(MyTest.getSum());
}
}
运行结果
4950
```
参考代码 12
class MyTest {
static {
initialize();
}
private static int sum = 0;
public static int getSum() {
initialize();
return sum;
}
private static boolean initialized;
private static void initialize() {
if (!initialized) {
for (int i = 0; i < 100; i++)
sum += i;
initialized = true;
}
}
}
public class GFG {
public static void main(String[] args) {
System.out.println(MyTest.getSum());
}
}
运行结果
0
```
参考代码 13
class MyTest {
static {
initialize();
}
private static int sum;
public static int getSum() {
initialize();
return sum;
}
private static boolean initialized;
private static void initialize() {
if (!initialized) {
for (int i = 0; i < 100; i++)
sum += i;
initialized = true;
}
}
}
public class GFG {
public static void main(String[] args) {
System.out.println(MyTest.getSum());
}
}
运行结果
4950
```
10-13 题解析
解析:[https://www.cnblogs.com/javaee6/p/3714716.html](https://www.cnblogs.com/javaee6/p/3714716.html)
参考资料
- https://www.geeksforgeeks.org/order-execution-initialization-blocks-constructors-java/
- https://www.cnblogs.com/jj-chenjunjie/p/5331107.html
- https://www.cnblogs.com/javaee6/p/3714716.html
Java（静态）变量、（静态）代码块、构造方法的执行顺序的更多相关文章
- java学习(一)静态代码块 构造代码块 构造方法的执行顺序及注意问题
今天我总结了一下java中静态代码块 构造代码块 构造方法的执行顺序及其注意问题 首先要知道静态代码块是随着类的加载而加载,而构造代码块和构造方法都是随着对象的创建而加载 当时做了这么一个小案例(想必 ...
- Java面试题 静态代码块 构造代码块 构造方法 的执行顺序
JAVA中的静态代码块 构造代码块 构造方法执行顺序: 静态代码块(类加载时执行)>>构造代码块>>构造方法 下面展示一个简单的例子,推荐大家动手运行一遍: public cl ...
- java：构造方法：无参构造/有参构造 this static关键字 静态变量 静态方法 代码块 封装 静态常量。
/*构造方法是一种特殊的方法,专门用于构造/实例化对象,形式:[修饰符] 类名(){ }构造方法根据是否有参数分为无参构造和有参构造*/public class Dog { ...
- Java静态代码块、代码块及构造函数执行顺序
根据以下程序进行分析 定义一个父类 package sas.LearnJava; public class ExcuteOrderTest { { System.out.println("我 ...
- java中成员变量、代码块、构造函数运行顺序
1.java虚拟机执行程序,首先须要装载类,安装现装载父类,初始化父类的静态代码块和静态成员变量 再load子类. 初始化子类静态代码块和成员变量 2.load完成父类与子类后,从main函数入口运行 ...
- Java面向对象理解_代码块_继承_多态_抽象_接口
面线对象: /* 成员变量和局部变量的区别? A:在类中的位置不同 成员变量:在类中方法外 局部变量:在方法定义中或者方法声明上 B:在内存中的位置不同 成员变量:在堆内存 局部变量:在栈内存 C:生 ...
- java类成员变量与代码块初始化
首先根据下面的这个一段代码:引入关于java初始化顺序的问题public class InitationTest extends Person { public InitationTest() { S ...
- 【Java基础】继承中的代码块和构造方法的执行顺序探索
本文讲述有关一个类的静态代码块,构造代码块,构造方法的执行流程问题.首先来看一个例子 /** * Created by lili on 15/10/19. */ class Person{ stati ...
- No.4.测试子类继承父类各代码块和构造方法的执行顺序
Son子类 public class Son extends Parent { static String y ="son的static属性"; public static voi ...
随机推荐
- 手脱nSPack 2.2
1.PEID查壳 深度扫描下:nSPack 2.2 -> North Star/Liu Xing Ping 2.载入OD,上来就是一个大跳转,F8单步跟下去 0040101B >- E9 ...
- 微信小程序踩过的坑
之前用小程序开发工具做过一个项目了,最近又新开了一个项目,在登录的时候发现总是提示code不合法,找了半天也未发现原因 后来同事提醒是不是因为开发工具里设置的AppId的问题,果断将当前工具里默认Ap ...
- [Java多线程]-ThreadLocal源码及原理的深入分析
ThreadLocal<T>类:以空间换时间提供一种多线程更快捷访问变量的方式.这种方式不存在竞争,所以也不存在并发的安全性问题. //-------------------------- ...
- 巧用Java中Calendar工具类
Java的JDK中提供了一系列好用的util工具类.Calendar就是java.util中用于处理日期的工具类.且该工具类易学易用实用. 工具类Calendar是抽象类. PS:为什么把Calend ...
- [转]C/C++作用域详解
原文地址:http://www.cnblogs.com/yc_sunniwell/archive/2010/07/14/1777433.html 作用域规则告诉我们一个变量的有效范围,它在哪儿创建,在 ...
- this new call() apply()
如果没接触过动态语言,以编译型语言的思维方式去理解javaScript将会有种神奇而怪异的感觉,因为意识上往往不可能的事偏偏就发生了,甚至觉得不可理喻.如果在学JavaScript这自由而变幻无穷的语 ...
- 【CodeForces】915 F. Imbalance Value of a Tree 并查集
[题目]F. Imbalance Value of a Tree [题意]给定n个点的带点权树,求所有路径极差的和.n,ai<=10^6 [算法]并查集 [题解]先计算最大值的和,按点权从小到大 ...
- 发行NEO的NEP-5合约代币
NEO常见的资产有三种 TOKEN (全局资产) Share (全局资产,股份 ) NEP-5 (合约代币,相当于ETH的ERC20) NEP-5 合约代码 https://github.com/AN ...
- photoshop 安装问题
问题:“安装程序检测到计算机重新启动操作可能处于挂起状态.建议您退出安装程序,重新启动并重试.” 解决: 1.运行 regedit 打开注册表编辑器. 2.依次展开HKEY_LOCAL_MACHINE ...
- Linux 上配置 NTP SERVER
在CENTOS 6.2上面安装配置NTP SERVER 安装NTP:yum install ntp 配置时间源vi /etc/ntp.confserver 210.72.145.44server nt ...