Java子类对象初始化执行顺序

子类对象初始化执行顺序：

package BreakPoint;

class Pare {
	int i = 3;
	Pare() {}
}
public class Construct extends Pare {
	int i = 8;
	Construct() {}
	Construct(int num) {this();}
	int getSuper() {return super.i;}
	public static void main(String[] args) {
		Construct ct = new Construct(9);
		System.out.println(ct.i);
		System.out.println(ct.getSuper());
	}

}

首先调用子类的有参数构造函数，通过有参数构造函数里的this()调用子类无参数构造函数，然后隐含调用super()，即父类的无参数构造函数，再给父类的i赋初值，然后依次执行Pare()，给子类i赋初值，Construct()，Construct(int num)，完成ct的构造。

package BreakPoint;

class AddClass {
	public int x = 0, y = 0, z = 0;
	AddClass (int x)
	{ this.x = x; }
	AddClass (int x, int y)
	{ this(x); this.y = y; }
	AddClass (int x, int y, int z)
	{ this(x,y); this.z = z; }
	public int add()
	{ return x + y + z; }
}
public class RunAddClass{

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		AddClass p1 = new AddClass(2,3,5);
		AddClass p2 = new AddClass(10,20);
		AddClass p3 = new AddClass(1);
		System.out.println("x + y + z = " + p1.add());
		System.out.println("x + y = " + p2.add());
		System.out.println("x = " + p3.add());
	}

}

构造p1时，首先调用AddClass的三参数构造函数，通过三参数构造函数中的this(x,y)调用两参数构造函数，同理，通过两参数构造函数调用一参数构造函数，然后再依次执行AddClass中成员变量的赋值，AddClass (int x)，AddClass (int x, int y)，AddClass (int x, int y, int z)，完成p1的构造。

实现两个对象之间互发消息：

//方法一
package EachMessage;

class A {
	B b;
	void test() {
		System.out.println("succeed2");
	}
}
class B{
	A a;
	B (A a) {
		this.a = a;
		a.b = this;
	}
	void test() {
		System.out.println("succeed1");
	}
}
public class EachMessage {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		A a = new A();
		B b = new B(a);
		a.b.test();
		b.a.test();
	}

}

输出结果为：
succeed1
succeed2

//方法二
package EachMessage;

class A {
	B b;
	void each(B b) {
		this.b = b;
	}
	void test() {
		System.out.println("succeed2");
	}
}
class B{
	A a;
	B (A a) {
		this.a = a;
	}
	void test() {
		System.out.println("succeed1");
	}
}
public class EachMessage {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		A a = new A();
		B b = new B(a);
		a.each(b);
		a.b.test();
		b.a.test();
	}

}

输出结果为：
succeed1
succeed2

组合和继承的区别及两者的使用场景：

组合是用已有的对象组合成一个功能更复杂强大的对象。比如用黑板、讲台、课桌、椅子等对象组合成一个教室对象。

class Classroom {
	Blackboard bb;
	Platform pf;
	Desk dk;
	Chair cr;
}

继承是一个对象复制另一个对象的属性和功能，并可以对其属性和功能进行扩充。比如在教室的基础上加上电脑变成机房。

class MachineRoom extends Classroom {
	int num;//表示电脑数量
	void computer() {
		System.out.println("You can study PC technology there");
	}
}

组合可以是一对多的关系，而继承只能是一对一的关系。如果需要一个由多个对象组合成的复杂对象，则用组合；如果只需要对一个对象进行扩展，则用继承。

Java运行时多态的含义及作用：

在程序运行时，对同种类的对象发送相同的消息，产生不同的结果。
作用，提高了代码的可扩展性，同时使代码更加简洁，修改代码时也更加方便。

package RunTimeDT;

class Parent {
	void speak () {
		System.out.print("Parent speak");
	}
}
class Son extends Parent {
	void speak () {
		System.out.print("Son speak");
	}
}
class Doughter extends Parent {
	void speak () {
		System.out.print("Doughter speak");
	}
}
public class RunTimeDT {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Parent p = new Son();
		p.speak();
		System.out.println();
		p = new Doughter();
		p.speak();
	}
}

运行结果为：
Son speak
Doughter speak

用接口修改程序：

package Interface;

import java.awt.*;
import java.applet.*;

interface Shape {
	public abstract double getArea();
	public abstract double getPerimeter();
}

abstract class Shapes implements Shape{
	protected int x, y, k;
	protected double m;
	public Shapes(int x, int y, int k, double m) {
		this.x = x;
		this.y = y;
		this.k = k;
		this.m = m;
	}
}

class Rect extends Shapes {
	public double getArea()
	{ return(k * m); }
	public double getPerimeter()
	{ return(2 * k + 2 * m); }
	public Rect(int x, int y, int width, int height)
	{ super(x,y,width,height); }
}

class Triangle extends Shapes {
	public double getArea()
	{ return(Math.sqrt(m * (m - k) * (m - x) * (m - y))); }
	public double getPerimeter()
	{ return(k + x + y); }	
	public Triangle(int baseA, int baseB, int baseC) {
		super(baseA, baseB, baseC, 0);
		m = (baseA + baseB + baseC)/2.0;
	}
}

class Circle extends Shapes {
	public double getArea()
	{ return(m *  m * Math.PI); }
	public double getPerimeter()
	{ return(2 * Math.PI * m); }
	public Circle(int x, int y, int width) {
		super(x, y, width, width/2.0);
	}
}

public class Interface extends Applet{
	Rect rect = new Rect(5, 15, 25, 25);
	Triangle tri = new Triangle(5, 5, 8);
	Circle cir = new Circle(13, 90, 25);
	public void paint(Graphics g) {
		// TODO Auto-generated method stub
		g.drawRect(rect.x, rect.y, rect.k, (int)rect.m);
		g.drawString("Rect Area: " + rect.getArea(), 50, 35);
		g.drawString("Rect Perimeter: " + rect.getPerimeter(), 50, 55);
		g.drawString("Triangle Area: " + tri.getArea(), 50, 75);
		g.drawString("Triangle Perimeter: " + tri.getPerimeter(), 50, 95);
		g.drawOval(cir.x - (int)cir.k/2, cir.y - (int)cir.k/2, cir.k, cir.k);
		g.drawString("Circle Area: " + cir.getArea(), 50, 115);
		g.drawString("Circle Perimeter: " + cir.getPerimeter(), 50, 135);
	}

}

运算符instanceof的使用场景：

使用instanceof比较引用类型。运算符的格式为：“a instanceof A”，其中a为对象的引用，A为类。如果a为A的实例或A子类的实例，则返回true；如果a为A父类的实例，则返回false；如果a对象的类和A没有任何关系，则编译不会通过。