案例分析 --构造方法，代码块，重写 的应用

案例分析 –构造方法，代码块，重写 的应用

参考资料：

掌握java中的三种代码块的定义及使用

java中构造方法和方法全面解析

1. 分析下面代码 的结果

public class HDemo {
public static void main(String[] args) {
Person son=new Son(7);
son.show();
}

}
class Son extends  Person {
int i = 2;
{
i=8;
System.out.println(i);
}

public Son(int p) {
super(p);
super.show();
}

@Override
public void show() {
System.out.println(i);
}
}

public abstract class Person {
int i=4;
{
i=3;
System.out.println(i);
}
public Person(int p){
show();

}
public void show(){
System.out.println(i);
}

}

2.结果为 3 ，0 ，8，3，8

3. 分析：

一. Person son=new Son(7);

该方法先获取 Person 的引用 son ,实例化 Son () 对象

new Son() 主要过程

1. 调用 super(p) 的实现

会执行 Person 的构造方法
public Person(int p){
show();

}
主要过程：
在执行 super(),Object 的构造方法后执行：

1. 初始化参数 int i=4；
2. 执行 构造块

{
i=3;
System.out.println(i);------------------3
}

3. 执行 show();

由于 子类对其进行重写，调用子类的
@Override
public void show() {
System.out.println(i);-------------0
}

而此时，子类还没有 初始化，执行构造方法，所以 i=0;

执行 子类构造方法 初始化

public Son(int p) {
super(p); --已执行
super.show();
}

会执行

1. 初始化参数 int i=2；
2. 执行 构造块

{
i=8;
System.out.println(i);------------------8
}

3. 执行  super.show();

调用 父类的方法
此时父类已完成初始化操作：
super.i=3
super.show();
public void show() {
System.out.println(i);-------------3
}

执行 son.show();

此时调用 子类的引用 son ,son.show() ,执行

@Override
public void show() {
System.out.println(i);------8
}

此时子类完成初始化操作 ：i=8;
所以。。

基本概念：

1. 代码块的概念

代码块本身并不是一个很难理解的概念，实际上之前也一直在使用。所谓代码块是指使用“{}”括起来的一段代码，根据位置不同，代码块可以分为四种：普通代码块、构造块、静态代码块、同步代码块，其中同步代码块本书将在多线程部分进行讲解，本章先来观察其他三种代码块。

普通代码块

直接定义在方法中的代码块称为普通代码块。

public class CodeDemo01{
public static void main(String args[]){
{  // 普通代码块
int x = 30 ; // 就属于一个局部变量
System.out.println("普通代码块 --> x = " + x) ;
}
int x = 100 ;  // 与局部变量名称相同
System.out.println("代码块之外 --> x = " + x) ;
}
};

运行结果：

C:\Documents and Settings\Administrator\桌面\java>java CodeDemo01
普通代码块 --> x = 30
代码块之外 --> x = 100

构造块：

将代码块直接定义在类中，则称为构造代码块。

==构造块优先于构造方法执行，且执行多次，只要一有实例化对象产生，就执行构造块中的内容。==

class Demo{
{ // 直接在类中编写代码块，称为构造块
System.out.println("1、构造块。") ;
}
public Demo(){ // 定义构造方法
System.out.println("2、构造方法。") ;
}
};
public class CodeDemo02{
public static void main(String args[]){
new Demo() ;  // 实例化对象
new Demo() ;  // 实例化对象
new Demo() ;  // 实例化对象
}
};

运行结果：

C:\Documents and Settings\Administrator\桌面\java>java CodeDemo02
1、构造块。
2、构造方法。
1、构造块。
2、构造方法。
1、构造块。
2、构造方法。

静态代码块：

直接使用static关键字声明就称为静态代码块.

==静态块优先于主方法执行，如果在普通类中定义的静态块，优先于构造块执行，不管不多少个实例化对象产生，静态代码块只执行一次，静态代码块的主要功能就是为静态发生初始化。==

class Demo{
{ // 直接在类中编写代码块，称为构造块
System.out.println("1、构造块。") ;
}
static{ // 使用static，称为静态代码块
System.out.println("0、静态代码块") ;
}
public Demo(){ // 定义构造方法
System.out.println("2、构造方法。") ;
}
};
public class CodeDemo03{
static{  // 在主方法所在的类中定义静态块
System.out.println("在主方法所在类中定义的代码块") ;
}
public static void main(String args[]){
new Demo() ;  // 实例化对象
new Demo() ;  // 实例化对象
new Demo() ;  // 实例化对象
}
};

运行结果：

C:\Documents and Settings\Administrator\桌面\java>java CodeDemo03
在主方法所在类中定义的代码块
0、静态代码块
1、构造块。
2、构造方法。
1、构造块。
2、构造方法。
1、构造块。
2、构造方法。

同步代码块

　同步代码块主要出现在多线程中。

2. 重写

方法的重写：

1、在子类中可以根据需要对从基类中继承来的方法进行重写。

2、重写的方法和被重写的方法必须具有相同方法名称、参数列表和返回类型。

3、重写方法不能使用比被重写的方法更严格的访问权限。

3.构造方法

个人理解： 调用 super 方法类似 调用 递归方法 ，有前进，有返回，到顶 为 object (递归头–递归条件)

==构造方法能被调用，不能被继承。==

初始化的顺序包括构造方法调用的顺序如下：

　　1．主类的静态成员首先初始化。

　　2．主类的超类的构造方法按照从最高到最低的顺序被调用。

　　3．主类的非静态对象（变量）初始化。

　　4．调用主类的构造方法

特点：

1.构造器必须与类同名（如果一个源文件中有多个类，那么构造器必须与公共类同名）

2.每个类可以有一个以上的构造器

3.构造器可以有0个、1个或1个以上的参数

4.构造器没有返回值

5.构造器总是伴随着new操作一起调用

```

==构造方法和方法的区别：==

构造方法要与类名相同，无返回类型，在类初始化的时候调用。

方法最好与类名不同，对象调用，静态方法可用类名.方法（）.

构造器和方法在下面三个方面区别：修饰符，返回值，命名：
1。和方法一样，构造器可以有任何访问的修饰： public, protected, private或者没有修饰（通常被package 和 friendly调用）. 不同于方法的是，构造器不能有以下非访问性质的修饰： abstract, final, native, static, 或者 synchronized。
2。返回类型也是非常重要的。方法能返回任何类型的值或者无返回值（void），构造器没有返回值，也不需要void。
3。两者的命名。构造器使用和类相同的名字，而方法则不同。按照习惯，方法通常用小写字母开始，而构造器通常用大写字母开始。构造器通常是一个名词，因为它和类名相同；而方法通常更接近动词，因为它说明一个操作。

构造方法和方法中this和supper的用法区别：
> "this"的用法
构造器和方法使用关键字this有很大的区别。方法引用this指向正在执行方法的类的实例。静态方法不能使用this关键字，因为静态方法不属于类的实  例，所以this也就没有什么东西去指向。构造器的this指向同一个类中，不同参数列表的另外一个构造器，我们看看下面的代码：

package com.dr.gouzao;

public class Platypus {

String name;

Platypus(String input) {
name = input;
}

Platypus() {
this("John/Mary Doe");
}

public static void main(String args[]) {
Platypus p1 = new Platypus("digger");
Platypus p2 = new Platypus();
System.out.println(p1.name + "----" + p2.name);
}

}

在上面的代码中，有2个不同参数列表的构造器。第一个构造器，给类的成员name赋值，第二个构造器，调用第一个构造器，给成员变量name一个初始值 “John/Mary Doe”.

在构造器中，如果要使用关键字this,那么，必须放在第一行，如果不这样，将导致一个编译错误。

在一个构造方法中只能调用一次其它的构造方法，并且调用构造方法的语句必须是第一条语句。

>   "super"的用法

构造器和方法，都用关键字super指向超类，但是用的方法不一样。方法用这个关键字去执行被重载的超类中的方法。看下面的例子：

构造器使用super去调用超类中的构造器。而且这行代码必须放在第一行，否则编译将出错。看下面的例子：

public class SuperClassDemo {

SuperClassDemo() {

}

}

class Child extends SuperClassDemo {

Child() {

super();

}

}

在上面这个没有什么实际意义的例子中，构造器 Child()包含了 super,它的作用就是将超类中的构造器SuperClassDemo实例化，并加到 Child类中。

编译器自动加入代码 ，当我们写一个没有构造器的类，编译的时候，编译器会自动加上一个不带参数的构造器。

2. 介绍对象的初始化顺序问题。

class One

{

One(String str)

{

System.out.println(str);

}

}

class Two

{

One one_1 = new One(“one-1”);

One one_2 = new One(“one-2”);

One one_3 = new One(“one-3”);

Two(String str)

{

System.out.println(str);

}

}

public class Test

{

public static void main(String[] args)

{

System.out.println(“Test main() start”);

Two two = new Two(“two”);

}

}

输出结果：

Test main() start…

one-1

one-2

one-3

two

>　在main()方法中实例化了一个Two类的对象。但程序在初始化Two类的对象时，并非先调用Two类的构造方法，而是先初始化Two类的成员变量。这里Two类有3个成员变量，它们都是One类的对象，所以要先调用3次One类的相应的构造方法。最后在初始化Two类的对象。
即在创建对象时，对象所在类的所有数据成员会首先进行初始化，如果其中的成员变量有对象，那么它们也会按照顺序执行初始化工作。在所有类成员初始化完成后，才调用对象所在类的构造方法创建对象。构造方法作用就是初始化。

4. 静态顺序
如果一个类中有静态对象，那么它会在非静态对象前初始化，但只初始化一次。非静态对象每次调用时都要初始化。

class One

{

One(String str)

{

System.out.println(str);

}

}

class Two

{

One one_1 = new One(“one-1”);

One one_2 = new One(“one-2”);

static One one_3 = new One(“one-3”);

Two(String str)

{

System.out.println(str);

}

}

public class Test

{

public static void main(String[] args)

{

System.out.println(“Test main() start”);

Two two_1 = new Two(“two-1”);

System.out.println(“————”);

Two two_2 = new Two(“two-2”);

}

}

输出结果：

Test main() start…

one-3

one-1

one-2

two-1

one-1

one-2

two-2

　　

5. 不仅第1次创建对象时，类中所有的静态变量要初始化，第1次访问类中的静态变量（没有创建对象）时，该类中所有的静态变量也要按照它们在类中排列的顺序初始化。

class One

{

One(String str)

{

System.out.println(str);

}

}

class Two

{

static int i = 0;

One one_1 = new One(“one-1”);

static One one_2 = new One(“one-2”);

static One one_3 = new One(“one-3”);

Two(String str)

{

System.out.println(str);

}

}

public class Test

{

public static void main(String[] args)

{

System.out.println(“Test main() start”);

System.out.println(“Two.i = ” Two.i);

}

}

“`