《Java编程思想》笔记05------多态

一、再论向上转型

/**
 * 向上转型
 * @author LiangYu
 * 2018-01-09
 */
public class UpCastTest {
	@Test
	public void test() throws Exception {
		Draw draw = new Draw();
		drawBlue(draw);
	}
	
	public void drawBlue(Art art){
		art.paint("blue");
	}
}

class Art{
	public void paint(String color){
		System.out.println("Art paint()---->"+color);
	}
}

class Draw extends Art{
	@Override
	public void paint(String color) {
		System.out.println("Draw paint()---->"+color);
	}
}
复制代码

在drawBlue()接受一个Art类的引用，同时，它也可以接受一个Art的子类引用。因此，当传入Draw类的引用时，该方法也可以执行。因为，Draw类是从Art类继承而来的，Art类的接口必然存在于Draw中，从Draw类向上转型会缩小接口，但接口不会比Art类更窄。

向上转型，实际上就是从特殊到普通的过程。

例如：鱼是动物的子类，就具备动物的所有特征。但并不是所有动物都具备鱼的特征

二、多态

方法调用绑定： 将一个方法调用同一个方法主体关联起来。

前期绑定：编译时绑定

如果Java采用前期绑定，则即使传入Draw的引用，程序也不清楚究竟要执行Draw的paint方法还是执行Art的paint方法。

因此，Java通常会采用后期绑定。

后期绑定：运行时绑定

编译器一直都不知道对象的类型，但是方法调用机制能够找到正确的方法体，并加以调用。即：运行时根据对象的类型进行绑定。

特例：Java中，static、final、private修饰的方法会进行前期绑定

/**
 * 多态
 * @author LiangYu
 * 2018-01-09
 */
public class PolymorphismTest {
	@Test
	public void test() throws Exception {
		Shape shape1 = new Circle();
		Shape shape2 = new Square();
		shape1.draw();
		shape2.erase();
	}
}

class Shape{
	public void draw(){
		System.out.println("shape draw");
	}
	
	public void erase(){
		System.out.println("shape erase");
	}
}

class Circle extends Shape{
	@Override
	public void draw() {
		System.out.println("circle draw");
	}
	
	@Override
	public void erase() {
		System.out.println("circle erase");
	}
}

class Square extends Shape{
	@Override
	public void draw() {
		System.out.println("square draw");
	}
	
	@Override
	public void erase() {
		System.out.println("square erase");
	}
}
复制代码

三、多态的缺陷

1.“覆盖”私有方法

/**
 * 多态的缺陷1 ----- “覆盖”私有方法
 * @author LiangYu
 * 2018-01-09
 */
public class PrivateMethodTest {
	
	private void privateMethod(){
		System.out.println("parent");
	}
	
	@Test
	public void test() throws Exception {
		PrivateMethodTest test = new Child();
		test.privateMethod();
	}
}

class Child extends PrivateMethodTest{
	public void privateMethod(){
		System.out.println("child");
	}
}
复制代码

输出结果： parent

结论：

只有非private方法才可以被覆盖

在子类中，对于基类的private方法，最好采用不同的名字。

2.域和静态方法

/**
 * 域和静态方法的多态
 * @author LiangYu
 * 2018-01-09
 */
public class FieldAndStaticMethodTest {
	@Test
	public void test() throws Exception {
		Person person = new Student();
		System.out.println(person.id);
		System.out.println(person.getId());
		person.toText();
		
	}
}


class Person{
	public String id = "p007";
	public String getId(){
		return id;
	}
	public static void toText(){
		System.out.println("Person");
	}
}

class Student extends Person{
	public String id = "s005";
	public String getId(){
		return id;
	}
	public static void toText(){
		System.out.println("Student");
	}
}
复制代码

输出结果：

p007

s005

Person

结论：

域访问操作是由编译器解析，不是多态

静态方法是前期绑定，也不是多态

四、构造器和多态

构造器本身是不具备多态性的。因为：它们实际上是隐式的static方法

基类构造器总是在子类的构造过程中被调用

原因：

子类只能访问自己的成员，无法访问基类成员（基类成员通常是private类型）。只有基类的构造器才有恰当的权限来对自身的成员进行初始化，所以，必须要让所有的构造器都得到调用。

/**
 * 构造方法的初始化顺序
 * @author LiangYu
 * 2018-01-09
 */
public class OrderOfConstructorTest extends FootballManager {
	private Movie movie = new Movie();
	private Music music = new Music();
	@Test
	public void test() throws Exception {
	}
	public OrderOfConstructorTest() {
		System.out.println("OrderOfConstructorTest()");
	}
}

class Game{
	Game(){
		System.out.println("Game()");
	}
}

class Movie{
	public Movie() {
		System.out.println("Movie()");
	}
}

class Music{
	public Music() {
		System.out.println("Music()");
	}
}

class ComputerGame extends Game{
	public ComputerGame() {
		System.out.println("ComputerGame()");
	}
}

class FootballManager extends ComputerGame{
	public FootballManager(){
		System.out.println("FootballManager()");
	}
}
复制代码

运行结果：

Game()

ComputerGame()

FootballManager()

Movie()

Music()

OrderOfConstructorTest()

复杂对象调用构造器的顺序：

1.首先调用基类构造器，例如上面的示例中，根据Game->ComputerGame->FootballManager->OrderOfConstructorTest的四层结构，依次调用了Game()、ComputerGame()、FootballManager()

2.按照声明顺序调用成员的初始化方法。在上面的示例中： 依次调用：Movie()、Music()

3.调用子类的构造器主体：OrderOfConstructorTest()

继承与清理

应用组合和继承方法来创建新类时，永远不必担心对象的清理问题。子对象通常都会留给垃圾回收器进行处理。

如果确实遇到了清理问题，则需要为新类创建dispose()方法。由于继承的缘故，需要在子类覆盖dispose()，当覆盖dispose()时，还需要调用基类的dispose()。

/**
 * 继承与清理
 * @author LiangYu
 * 2018-01-09
 */
public class CleanTest{
	@Test
	public void test() throws Exception {
		JavaProgrammer javaProgrammer = new JavaProgrammer();
		System.out.println("Bye");
		javaProgrammer.dispose();
	}
}

class Eye{
	private String string;
	public Eye(String string) {
		this.string = string;
		System.out.println("Eye creating..."+string);
	}
	protected void dispose(){
		System.out.println("Eye disposing:"+this.string);
	}
}

class Ear{
	private String string;
	public Ear(String string) {
		this.string = string;
		System.out.println("Ear creating..."+string);
	}
	protected void dispose(){
		System.out.println("Ear disposing:"+this.string);
	}
}

class People{
	private Eye eye = new Eye("People Eye");
	private Ear ear = new Ear("People Ear");
	public People() {
		System.out.println("People()");
	}
	protected void dispose(){
		System.out.println("People disposing...");
		ear.dispose();
		eye.dispose();
	}
}

class Farmer extends People{
	private Eye eye = new Eye("Farmer Eye");
	private Ear ear = new Ear("Farmer Ear");
	public Farmer() {
		System.out.println("Farmer()");
	}
	protected void dispose(){
		System.out.println("Farmer disposing...");
		ear.dispose();
		eye.dispose();
		super.dispose();
	}
}

class SoftwareProgrammer extends Farmer{
	private Eye eye = new Eye("SoftwareProgrammer Eye");
	private Ear ear = new Ear("SoftwareProgrammer Ear");
	public SoftwareProgrammer() {
		System.out.println("SoftwareProgrammer()");
	}
	protected void dispose(){
		System.out.println("SoftwareProgrammer disposing...");
		ear.dispose();
		eye.dispose();
		super.dispose();
	}
}

class JavaProgrammer extends SoftwareProgrammer{
	private Eye eye = new Eye("JavaProgrammer Eye");
	private Ear ear = new Ear("JavaProgrammer Ear");
	public JavaProgrammer() {
		System.out.println("JavaProgrammer()");
	}
	protected void dispose(){
		System.out.println("JavaProgrammer disposing...");
		ear.dispose();
		eye.dispose();
		super.dispose();
	}
}
复制代码

运行结果：

Eye creating...People Eye

Ear creating...People Ear

People()

Eye creating...Farmer Eye

Ear creating...Farmer Ear

Farmer()

Eye creating...SoftwareProgrammer Eye

Ear creating...SoftwareProgrammer Ear

SoftwareProgrammer()

Eye creating...JavaProgrammer Eye

Ear creating...JavaProgrammer Ear

JavaProgrammer()

Bye

JavaProgrammer disposing...

Ear disposing:JavaProgrammer Ear

Eye disposing:JavaProgrammer Eye

SoftwareProgrammer disposing...

Ear disposing:SoftwareProgrammer Ear

Eye disposing:SoftwareProgrammer Eye

Farmer disposing...

Ear disposing:Farmer Ear

Eye disposing:Farmer Eye

People disposing...

Ear disposing:People Ear

Eye disposing:People Eye

结论：清理的顺序和初始化的顺序相反。从子类向基类逐渐清理。

GC中的引用计数法：每new一个对象的时候，计数器counter计算count对象的数量。此后清理的时候，会根据这个count值进行清理。

以后会专门写几篇关于GC的文章