package com.atguigu.test05.exer1;
/*
* （1）Father类的类初始化
* ①类变量显式赋值：这里没有
* ②静态代码块
* System.out.println("（1）父类的静态代码块");
* （2）Son类的类初始化
* ①类变量显式赋值：这里没有
* ②静态代码块
* System.out.println("（4）子类的静态代码块");
*
* （3）执行Father类的是实参初始化方法<init>()
* ①非静态成员变量的显式赋值：这里没有
* ②非静态代码块：
* System.out.println("（2）父类的非静态代码块");
* ③父类的无参构造
* System.out.println("（3）父类的无参构造");
*
* （4）执行Son类的实例初始化方法<init>()
* ①非静态成员变量的显式赋值：这里没有
* ②非静态代码块：
* System.out.println("（5）子类的非静态代码块");
* ③子类的无参构造
* System.out.println("（6）子类的无参构造");
*/
public class TestExer1 {
public static void main(String[] args) {
Son son = new Son();
}
}
class Father{
static{
System.out.println("（1）父类的静态代码块");
}
{
System.out.println("（2）父类的非静态代码块");
}
Father(){
System.out.println("（3）父类的无参构造");
}
}
class Son extends Father{
static{
System.out.println("（4）子类的静态代码块");
}
{
System.out.println("（5）子类的非静态代码块");
}
Son(){
System.out.println("（6）子类的无参构造");
}
}
package com.atguigu.test05.exer2;
/*
* （1）Fu类的类初始化
* ①类变量显式赋值：
* i = getNum("（1）i");
* public static int getNum(String str){
print(str);
public static void print(String str){
System.out.println(str + "->" + i); (1)i -> 0（默认值）
}
return ++i; i=1
}
* ②静态代码块
* static{
print("（3）父类静态代码块");
public static void print(String str){
System.out.println(str + "->" + i); （3）父类静态代码块 -> 1
}
}
* （2）Zi类的类初始化
* ①类变量显式赋值：
* k = getNum("（6）k");
*
public static int getNum(String str){
print(str);
public static void print(String str){
System.out.println(str + "->" + k); （6）k -> 0（默认值）
}
return ++k; k=1
}
* ②静态代码块
* static{
print("（8）子类静态代码块");
public static void print(String str){
System.out.println(str + "->" + k); （8）子类静态代码块 -> 1
}
}
*
* （3）执行Fu类的是实参初始化方法<init>()
* ①非静态成员变量的显式赋值：
* j = getNum("（2）j");
*
public static int getNum(String str){
print(str);
public static void print(String str){
System.out.println(str + "->" + i); （2）j -> 1
}
return ++i; i=2
}
* ②非静态代码块：
* {
print("（4）父类非静态代码块，又称为构造代码块");
public static void print(String str){
System.out.println(str + "->" + i); （4）父类非静态代码块，又称为构造代码块 -> 2
}
}
* ③父类的无参构造
* Fu(){
print("（5）父类构造器");
public static void print(String str){
System.out.println(str + "->" + i); （5）父类构造器 -> 2
}
}
*
* （4）执行Zi类的实例初始化方法<init>()
* ①非静态成员变量的显式赋值：
* h = getNum("（7）h");
public static int getNum(String str){
print(str);
* public static void print(String str){
System.out.println(str + "->" + k); （7）h ->1
}
return ++k; k=2
}
*
* ②非静态代码块：
* {
print("（9）子类非静态代码块，又称为构造代码块");
public static void print(String str){
System.out.println(str + "->" + k); （9）子类非静态代码块，又称为构造代码块 ->2
}
}
* ③子类的无参构造
* Zi(){
print("（10）子类构造器");
public static void print(String str){
System.out.println(str + "->" + k); （10）子类构造器 ->2
}
}
*/
public class TestExer2 {
public static void main(String[] args) {
Zi zi = new Zi();
}
}
class Fu{
private static int i = getNum("（1）i");
private int j = getNum("（2）j");
static{
print("（3）父类静态代码块");
}
{
print("（4）父类非静态代码块，又称为构造代码块");
}
Fu(){
print("（5）父类构造器");
}
public static void print(String str){
System.out.println(str + "->" + i);
}
public static int getNum(String str){
print(str);
return ++i;
}
}
class Zi extends Fu{
private static int k = getNum("（6）k");
private int h = getNum("（7）h");
static{
print("（8）子类静态代码块");
}
{
print("（9）子类非静态代码块，又称为构造代码块");
}
Zi(){
print("（10）子类构造器");
}
public static void print(String str){
System.out.println(str + "->" + k);
}
public static int getNum(String str){
print(str);
return ++k;
}
}
package com.atguigu.test05.exer3;
/*
* （1）类初始化
* ①静态代码块
* static{
i = 100;//可以
MyClass.i++;// i=101
System.out.println("（1）静态代码块 i=" + MyClass.i); //（1）静态代码块 i=101
}
②静态变量的显示赋值
i = getNum("（4）i");
public static int getNum(String str){
print(str);
public static void print(String str){
System.out.println(str + "->" + i); //（4）i-》101
}
return ++i; i=102
}
* （2）实例初始化
* ①非静态代码块
* {
j = 100;
this.j++; j=101
System.out.println("（2）构造代码块j=" + this.j); //（2）构造代码块j=101
//构造代码块：就是非静态代码块，因为它总是和构造器一起执行，所以就把它叫做构造代码块
}
②非静态变量的显式赋值
j = getNum("（5）j");
public static int getNum(String str){
print(str);
public static void print(String str){
System.out.println(str + "->" + i); //（5）j->102
}
return ++i; i=103
}
③构造器
MyClass(){
j = 200;
j++; j=201
System.out.println("（3）构造器j=" + j); //（3）构造器j=201
}
*/
public class TestExer3 {
public static void main(String[] args) {
MyClass obj = new MyClass();
}
}
class MyClass{
static{
i = 100;//可以
MyClass.i++;//stackoverflow
System.out.println("（1）静态代码块 i=" + MyClass.i);
}
{
j = 100;
this.j++;
System.out.println("（2）构造代码块j=" + this.j);
}
MyClass(){
j = 200;
j++;
System.out.println("（3）构造器j=" + j);
}
private static int i = getNum("（4）i");
private int j = getNum("（5）j");
public static void print(String str){
System.out.println(str + "->" + i);
}
public static int getNum(String str){
print(str);
return ++i;
}
}
package com.atguigu.test05.exer3_0;
/*
* （1）以下代码是否可以编译通过
* 不能
* （2）如果能，运行结果是什么
* （3）如果不能怎么改
* 第一种修改方法：把声明挪到前面；
* 第二种修改方法：看TestExer3
*/
/*public class TestExer3_0 {
public static void main(String[] args) {
MyClass obj = new MyClass();
}
}
class MyClass{
static{
i++;//声明i在后面
System.out.println("（1）静态代码块 i=" + i);
}
{
j = 100;
j++;
System.out.println("（2）构造代码块j=" + j);
}
MyClass(){
j = 200;
j++;
System.out.println("（3）构造器j=" + j);
}
private static int i = getNum("（4）i");
private int j = getNum("（5）j");
public static void print(String str){
System.out.println(str + "->" + i);
}
public static int getNum(String str){
print(str);
return ++i;
}
}
*/
package com.atguigu.test05.exer4;
/*
* 对于T来说，就是完成类初始化
*
* 创建对象，调用类的实例初始化<init>()或<init>(String str)
*
*
* （1）静态变量的显式赋值
* k = 0;
t1 = new T("t1");
<init>(String str)
①j = print("j");
public static int print(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n); 1：j i=0 n=0
++n; n=1 k=1
return ++i; i=1
}
② {
print("构造块");
public static int print(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n); 2：构造块 i=1 n=1
++n; n=2 k=2
return ++i; i=2
}
}
③public T(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n); 3:t1 i=2 n=2
++n; n=3 k=3
++i; i=3
}
* t2 = new T("t2");
<init>(String str)
①j = print("j");
public static int print(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n); 4：j i=3 n=3
++n; n=4 k=4
return ++i; i=4
}
② {
print("构造块");
public static int print(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n); 5：构造块 i=4 n=4
++n; n=5 k=5
return ++i; i=5
}
}
③public T(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n); 6:t2 i=5 n=5
++n; n=6 k=6
++i; i=6
}
i = print("i");
public static int print(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n); 7：i i=6 n=6
++n; n=7 k=7
return ++i; i=7
}
n = 99;
* （2）静态代码块
* static{
print("静态块");
public static int print(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n); 8：静态块 i=7 n=99
++n; n=100 k=8
return ++i; i=8
}
}
*/
public class T {
public static int k = 0;
public static T t1 = new T("t1");
public static T t2 = new T("t2");
public static int i = print("i");
public static int n = 99;
public int j = print("j");
{
print("构造块");
}
static{
print("静态块");
}
public T(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
++n;
++i;
}
public static int print(String str){
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
++n;
return ++i;
}
public static void main(String[] args) {
}
}
* （1）Father类的类初始化
* ①类变量显式赋值
* ②静态代码块
* （2）Son类的类初始化
* ①类变量显式赋值
* ②静态代码块
* （3）执行Father类的是实例初始化方法<init>()
* ①非静态成员变量的显式赋值：这里没有
* ②非静态代码块：
* ③父类的无参构造
* （4）执行Son类的实例初始化方法<init>()
* ①非静态成员变量的显式赋值：这里没有
* ②非静态代码块：
* ③子类的无参构造
