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

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

参考资料：

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);
}
}
“`