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 ...
随机推荐
- socketserver多线程处理
一.简介 SocketServer简化了网络服务器的编写.在进行socket创建时,使用SocketServer会大大减少创建的步骤,并且SocketServer使用了select它有5个类:Base ...
- C#微信开发系列笔记（1）入门指引
(1)基本配置 这节具体的详情请看官方文档,我只提示一点,非常重要,非常容易忽视的,我是吃了苦头的... 在“修改配置”这个地方,如下图: 在URL处,一定要填写http://www.xxx.com/ ...
- 第2章-Vue.js指令
一.学习目标 了解 什么 是 Vue.js 指令 理解 Vue.js 指令的 用途 掌握 Vue.js 指令的书写规范 能够 使用 Vue.js 指令完成部门页面交互效果(难点和重点) 二.指令的基本 ...
- OpenCV---Numpy数组的使用以及创建图片
一:对头像的所有像素进行访问,并UI图像进行像素取反 (一)for循环取反 import cv2 as cv import numpy as np def access_pixels(image): ...
- Java的StringAPI的小练习
//-------------String类-------------- //求两个字符串的最大相同子串 /* 思路: 1.找出较短的那个字符串 2.找出短串的所有子串,使用contains函数判断是 ...
- JS笔记加强版3
JS 面向对象及组件开发 JS的面向对象: 1.什么是面向对象编程 用对象的思想去写代码,就是面向对象编程 过程式写法 面向对象写法 我们一直都在使用对象 数组 Array 时间 Date ...
- bootstrap下laydate样式错乱问题
查看发现bs使用了 * {box-sizing:border-box;}重置了盒子模型 那么我们再把它重置回来,在样式中加入以下代码 .laydate_box, .laydate_box * { bo ...
- git使用（1）----推送代码到远程
git使用(1) 首先要明白git上有三个区域 1.工作区 2.暂存区 3.历史记录区 步骤: 1.git init 2.配置环境(如果配置一次了以后就不用再继续配置) git config - ...
- 【BZOJ】1711: [Usaco2007 Open]Dining吃饭
[算法]最大流 [题解] S连向食物连向牛连向牛‘连向饮料连向T. 经典的一个元素依赖于两个元素的建图方式. #include<cstdio> #include<algorithm& ...
- 数据库-Core Data
技术博客http://www.cnblogs.com/ChenYilong/ 新浪微博http://weibo.com/luohanchenyilong 数据库-Core Data 技术博客htt ...