} {
System.out.println(\构造代码块\); }
public Student() {
System.out.println(\构造方法\); } }
public class StudentDemo { static {
System.out.println(\你好,明天!\); }
public static void main(String[] args) { System.out.println(\我是main方法\);
Student s1 = new Student(); Student s2 = new Student(); }
/*输出结果： 你好,明天! 我是main方法
Student 静态代码块 Student 构造代码块 Student 构造方法 Student 构造代码块 Student 构造方法*/ }
问题：不仅要输出局部范围的num，还要输出本类成员范围的num，我还想要输出父类成员范围的num。怎么办呢? class Father {
public int num = 10; }
class Son extends Father { public int num = 20;
public void show() { int num = 30;
System.out.println(num);
System.out.println(this.num); System.out.println(super.num); } }
class ExtendsDemo {
public static void main(String[] args) { Son s = new Son(); s.show(); } }
数据初始化的面试题
A:一个类的初始化过程 B:子父类的构造执行过程 C:分层初始化 class Father {
public Father() {
System.out.println(\的无参构造方法\); }
public Father(String name) {
System.out.println(\的带参构造方法\); } }
class Son extends Father { public Son() { //super();
System.out.println(\的无参构造方法\); }
public Son(String name) { //super();
System.out.println(\的带参构造方法\); } }
class ExtendsDemo {
public static void main(String[] args) { //创建对象 new Son();
System.out.println(\);
new Son(\蒙蒙\);
//运行结果：
//Father的无参构造方法 //Son的无参构造方法 //------------
//Father的无参构造方法 //Son的带参构造方法 } }
看程序写结果： A:成员变量 就近原则 B:this和super的问题 this访问本类的成员 super访问父类的成员
C:子类构造方法执行前默认先执行父类的无参构造方法 D:一个类的初始化过程 成员变量进行初始化 默认初始化 显示初始化 构造方法初始化 class Fu{
public int num = 10; public Fu(){
System.out.println(\); } }
class Zi extends Fu{ public int num = 20; public Zi(){
System.out.println(\); }
public void show(){ int num = 30;
System.out.println(num); //30 System.out.println(this.num); //20 System.out.println(super.num); //10 } }
class ExtendsTest {
public static void main(String[] args) { Zi z = new Zi();
z.show(); } }
结果： fu zi 30 20 10
看程序写结果：
A:一个类的静态代码块,构造代码块,构造方法的执行流程 静态代码块 > 构造代码块 > 构造方法 B:静态的内容是随着类的加载而加载 静态代码块的内容会优先执行
C:子类初始化之前先会进行父类的初始化 class Fu { static {
System.out.println(\静态代码块Fu\); }
{
System.out.println(\构造代码块Fu\); }
public Fu() {
System.out.println(\构造方法Fu\); } }
class Zi extends Fu { static {
System.out.println(\静态代码块Zi\); }
{
System.out.println(\构造代码块Zi\); }
public Zi() {
System.out.println(\构造方法Zi\); } }
public class ExtendsTest {
public static void main(String[] args) { Zi z = new Zi();
/*
结果是：
静态代码块Fu 静态代码块Zi 构造代码块Fu 构造方法Fu 构造代码块Zi 构造方法Zi*/ } }
看程序写结果：
A:成员变量的问题
int x = 10; //成员变量是基本类型 Student s = new Student(); //成员变量是引用类型 B:一个类的初始化过程 成员变量的初始化 默认初始化 显示初始化 构造方法初始化
C:子父类的初始化(分层初始化)
先进行父类初始化，然后进行子类初始化。 问题：
虽然子类中构造方法默认有一个super() 初始化的时候，不是按照那个顺序进行的。 而是按照分层初始化进行的。
它仅仅表示要先初始化父类数据，再初始化子类数据。 class X {
Y b = new Y(); X() {
System.out.print(\); } }
class Y { Y() {
System.out.print(\); } }