package com.hspedu.codeblock_;
public class Course385 {
public static void main(String[] args) {
// 代码块
Movie movie = new Movie("你好李焕英");
System.out.println("========================");
Movie movie2 = new Movie("唐探3", 100, "陈思诚");
}
}
class Movie {
private String name;
private double price;
private String director;
// 代码块
/*
* 1、构造器都会执行相同的代码语句
* 2、相同的部分可以提出到代码块
* 3、不管调用哪一个构造器都会优先调用代码块
* 4、代码块优先于构造器执行
* 5、代码块可以用static修饰，也可以不修饰
* */
{
System.out.println("广告开始..");
System.out.println("电影开始..");
}
public Movie(String name) {
System.out.println("《" + name + "》");
this.name = name;
}
public Movie(String name, double price) {
System.out.println(name + ", " + price);
this.name = name;
this.price = price;
}
public Movie(String name, double price, String director) {
System.out.println("《" + name + "》" + ", " + price + ", " + director);
this.name = name;
this.price = price;
this.director = director;
}
}
package com.hspedu.codeblock_;
public class Course386 {
public static void main(String[] args) {
// 代码块细节
/*
* 1、static代码块：静态代码块，作用是对类的初始化，随着类加载而执行
* 并且只会执行一次。如果是非静态代码块则每次创建对象，就会执行一次
* 2、类什么时候被加载？(重要)
* 1）new创建对象实例
* 2）new创建子类对象实例
* 3）使用类的静态成员（静态属性、静态方法）
* 3、非静态代码块，在创建对象实例时，会隐式调用，
* 如果只使用类的静态成员则不会执行非静态代码块
*
* */
// （1）new实例化对象加载
AA aa = new AA();
System.out.println("======================");
// （2）new子类实例化加载，而且父类先加载，子类后加载
AA aa2 = new AA();
System.out.println("======================");
// （3）调用静态成员，类加载，执行静态代码块(父类会先加载，先执行父类的静态代码块)
System.out.println(Cat.n1);
System.out.println("======================");
// 静态代码块只会在类加载时执行一次，同AA类执行效果一样
// DD d1 = new DD();
// DD d2 = new DD();
System.out.println(DD.n1); // 只调用静态成员不会执行非静态代码块，静态代码块在第一次类加载时调用
}
}
class Animal {
static {
System.out.println("Animal类的静态代码块");
}
}
class Cat extends Animal {
public static int n1 = 999;
static {
System.out.println("Cat类的静态代码块");
}
}
class AA extends BB {
// 静态代码块
static {
System.out.println("AA类的静态代码块1");
}
public AA() {
System.out.println("AA对象创建");
}
}
class BB {
static {
System.out.println("BB类的静态代码块1");
}
public BB() {
System.out.println("BB对象创建");
}
}
class DD {
public static int n1 = 100;
static {
System.out.println("DD类的静态代码块");
}
// 类加载和非静态代码块的执行没有关系
{
System.out.println("DD类的非静态代码块");
}
}
package com.hspedu.codeblock_;
public class Course387 {
public static void main(String[] args) {
// 代码块细节 2
/*
* 4、在同一个类中创建对象的调用顺序：
* （1）先调用静态代码块和静态属性的初始化：调用顺序按照代码定义的顺序执行
* （2）然后调用非静态代码块和非静态属性初始化：调用顺序同样按照定义的顺序执行
* （3）最后调用构造器方法
* 原因分析：类加载在对象创建之前，静态成员在类加载时调用执行，非静态成员在创建对象执行
* */
//
A a = new A();
}
}
class A {
// 非静态代码块
{
System.out.println("A类的非静态代码块"); // 3
}
// 静态属性初始化
private static int n1 = getN1();
// 非静态属性初始化
private int n2 = getN2();
// 静态代码块
static {
System.out.println("A类的静态代码块 static"); // 2
}
// 静态方法
public static int getN1() {
System.out.println("getN1方法被调用 static"); // 1
return 100;
}
// 非静态方法
public int getN2() {
System.out.println("getN2方法被调用"); // 4
return 200;
}
public A() {
System.out.println("对象A创建"); // 5
}
}
package com.hspedu.codeblock_;
public class Course388 {
public static void main(String[] args) {
// 代码块细节 3
/*
* 5、构造器前隐藏了super(..);和调用非静态代码块，先执行super再执行非静态代码块
* 存在继承关系执行顺序：
* 父类静态 => 子类静态 => 父类非静态 => 父类构造器 => 子类非静态 => 子类的构造器
*
* */
new BBB();
}
}
class AAA {
{
System.out.println("AAA非静态代码块");
}
static {
System.out.println("AAA static block");
}
public AAA() {
System.out.println("创建AAA类对象");
}
}
class BBB extends AAA {
{
System.out.println("BBB非静态代码块");
}
static {
System.out.println("BBB static block");
}
public BBB() {
System.out.println("创建BBB类对象");
}
}
package com.hspedu.codeblock_;
public class Course389 {
public static void main(String[] args) {
// 代码块细节 3
/*
* 6、创建子类对象时，代码块执行顺序：
* （1）先执行父类的静态代码块和静态属性初始化
* （2）再执行子类的静态代码块和静态属性初始化
* （3）父类的普通代码块和普通属性初始化（父类非静态成员）
* （4）父类的构造器
* （5）子类的普通代码块和普通属性初始化（子类非静态成员）
* （6）子类的构造器
*
* 7、静态代码块只能调用静态成员，非静态代码块可以调用任意成员
* */
/*
* 创建对象：
* 1、进行类的加载
* 1.1先加载父类A02，再加载B02（静态代码块和静态属性初始化和类加载相关）
* 2、创建对象
* 2.1先执行非静态代码块和非静态属性初始化
* 2.2再执行构造器内的语法
* (有继承会执行super()方法)
* */
new B02();
System.out.println("====================");
new C02();
}
}
class A02 {
private static int n1 = getVal01();
static {
System.out.println("A02静态代码块"); // 2
}
{
System.out.println("A02非静态代码块"); // 5
}
public int n3 = getVal02();
public static int getVal01() {
System.out.println("getVal01"); // 1
return 10;
}
public int getVal02() {
System.out.println("getVal02"); // 6
return 10;
}
public A02() {
System.out.println("A02构造器执行"); // 7
}
}
class B02 extends A02 {
private static int n3 = getVal03();
static {
System.out.println("B02的静态代码块"); // 4
}
public int n5 = getVal04();
{
System.out.println("B02的非静态代码块"); // 9
}
public static int getVal03() {
System.out.println("getVal03"); // 3
return 10;
}
public int getVal04() {
System.out.println("getVal04"); // 8
return 10;
}
public B02() {
System.out.println("B02构造器执行"); // 10
}
}
class C02 {
private int n1 = 100;
private static int n2 = 200;
private void m1() {
}
private static void m2() {
}
// 静态代码块只能使用静态成员
static {
// System.out.println(n1);
System.out.println(n2);
// m1();
m2();
}
// 非静态代码块都可以调用
{
System.out.println(n1);
System.out.println(n2);
m1();
m2();
}
}
