第八章 多态 成员对象的清理工作。引用计数构造器内部多态行为，初始化（真）

1.清理

• 一个对象拥有自己的成员对象，并且知道他们应该存活多久，因此一个对象可以调用其特殊方法对其成员对象进行释放。
  然而，如果这些成员对象存在于其他一个或多个对象共享的情况，问题就复杂了，这个时候需要使用引用计数来跟踪仍旧访问着共享对象的对象数量。
• 下面的代码可以清楚的说明这个问题的解决办法，也是引用计数法
  

  class Shared{
  	private int refcount = 0;
  	private static long counter = 0;
  	private final long id = counter ++;
  	public Shared(){
  		System.out.println("Createing " + this);
  	}
  	//每有一个对象使用就调用这个方法进行加1，
  	public void addRef(){
  		refcount ++;
  	}
  	protected void dispose(){
  		//如果共享这个对象都使用完了就清理这个类
  		if (--refcount == 0) {
  			System.out.println("Disposiing" + this);
  		}
  	}
  }
  
  class Composing{
  	private Shared shared;
  	private static long counter = 0;
  	private final long id = counter ++;
  	public Composing(Shared shared){
  		System.out.println("Createing " + this);
  		this.shared = shared;
  		this.shared.addRef();
  	}
  	protected void dispose(){
  		System.out.println("disposing " + this);
  		shared.dispose();
  	}
  	public String toString(){return "Composing " + id;}
  }
  public class ReferenceCounting {
  
  	public static void main(String[] args) {
  		Shared shared = new Shared();
  		/**
  		 * shared被对个Composing共享，不能释放一个Composiing就把这个shared对象给释放了，
  		 * 这样会报错的，所以使用引用计数，只有到最后一个对象使用完毕后才对shared进行释放
  		 */
  		Composing[] composing = {
  				new Composing(shared),
  				new Composing(shared),
  				new Composing(shared),
  				new Composing(shared),
  				new Composing(shared)
  		};
  		for (Composing c : composing) {
  			c.dispose();
  		}
  	} }
  

2.构造器内部的多态方法调用行为

• 什么意思呢，就是在一个父类的构造器内部调用其可以被子类重写的方法，这一种特殊的情况
  代码如下

  package com.yue.dt;
  
  class Glyph {
  	// 可以被子类覆盖的方法
  	void draw() {
  		System.out.println("Glyph.draw()");
  	}
  
  	Glyph() {
  		System.out.println("Glyph() before draw()");
  		// 调用这个方法，如果子类覆盖这个方法，那么在声明子类的时候回调用子类的这个方法
  		draw();
  		System.out.println("Glyph() after draw()");
  	}
  }
  
  class RoundGlyph extends Glyph {
  	private int radius = 1;
  
  	RoundGlyph(int r) {
  		radius = r;
  		System.out.println("RoundGlyph.RoundGlyph(),radius = " + radius);
  	}
  
  	void draw() {
  		System.out.println("RoundGlyph.draw(), radius = " + radius);
  	}
  }
  
  public class PolyConstructors {
  	public static void main(String[] args) {
  		new RoundGlyph(5);//声明初始化子类
  	}
  }
  /**
   * 输出结果
   * Glyph() before draw() 
   * RoundGlyph.draw(), radius = 0 调用了子类的方法
   * Glyph() after draw()
   * RoundGlyph.RoundGlyph(),radius = 5
   */

  由上面代码可以看出：由于集成过程中构造器的执行顺序问题，在加上调用了可以被子类重写的方法的问题的重合，只是输出了我们意想不到的结果
  

3.初始化的实际过程

1. 在其他事物发生之前，将分配给对象的存储空间初始化成二进制的零。
2. 如前面那样调用基类的构造器。此时调用覆盖后的子类中draw()方法，在调用子类构造器之前调用，由于1，radius （int）被初始化成默认值0，
3. 按照声明的顺序调用成员的初始化方法。
4. 最后，调用子类的构造器中的代码。

• 这样做的好处是所有的东西都至少初始化为0，其中通过“组合”嵌入进类内部的对象引用也被初始化为null,使用这样一个引用会抛出运行时异常。
• 怎样解决上面的奇葩问题呢。
  那就是不要在父类构造器中填写可以被覆盖的方法，如果要填写方法，就填写父类中private 或者final修饰的方法，尽量避免调用方法，尽可能的简单