类的复用

1.类的复用——组合（has-a）

·汽车类 Car 由引擎 Engine、车灯 Light、车窗 Window、轮胎 Wheel、车门 Door 等组成

public class Car {
		// a Car has-a a Engine
		private String type;
		private Door[] d;
		private Window[] w;
		private Engine en;
			private Wheel[] wh;
		private Light[] l;
		Car(String type){
		this.type = type;
		d = new Door[4];
		w = new Window[2];
		wh =new Wheel[4];
		l = new Light[10];
		en = new Engine();
		d[0] = new Door();
		d[1] = new Door();
		d[2] = new Door();
		d[3] = new Door();
		}
	}

·注意：在类的设计中，能用组合的尽量不要使用继承来实现

2.类的复用——继承（is-a）

·Animal 动物类 可以派生出 狗 Dog 类 ，a Dog is-a Animal
A 派生出 B 类， 我们称 B 类为 A 类的子类，A 类为 B 类的父类
定义语法： Class B extends A{ }

	public class A {
	int a;
	public void fun() {
	System.out.println("fun() of Class A");
	}
	}
	public class B extends A {
	//类 B 是类 A 的子类，继承得到成员变量 a 和方法 fun()
	}

3.方法的重载（overload）

·一个类中，名称相同而参数列表不同的方法，构成了重载方法

public class Ca {
public void fun() {
System.out.println("method fun() of Ca");
}
public void fun(int n) {
System.out.println("method fun(int n) of Ca");
}
public void fun(double d) {
System.out.println("method fun(double d) of Ca");
}
}
public class Cb extends Ca {
public void fun(int m,int n) {
//该方法与父类继承得到的其他 3 个 fun 方法，相互构成了方法的重载
System.out.println("method fun(int m,int n) of Cb");
}
}

4.方法的覆盖（重写、override）

·子类可以重新编写父类同名、同参数的方法，覆盖掉父类中的方法

	public class Father {
	public void fun() {
	System.out.println("Method fun() of class Father");
	}
	}
	public class Son extends Father {
	public void fun() { //覆盖了父类同名、同参数列表方法
	System.out.println("Method fun() of class Son");
	}
	}

5.this 与 super

·this 代表当前类对象本身
·super 代表父类

public class Father {
public void fun() {
System.out.println("Method fun() of class Father");
}
public void fun(int n) {
System.out.println("Method fun(int n) of class Father");
}
}
public class Son extends Father {
public void fun(double x) {
// this.fun((int)x);
System.out.println("Method fun(double x) of Son");
}
public void fun(int n) {
super.fun(n);//调用父类的 fun(int n)
System.out.println("Method fun(int n) of Son");
}
}

6.构造器

·构造器是在通过 new 关键字创建一个对象的时候运行的代码
·构造器是可以重载的
·通过 new 关键字创建子类对象时，首先会自动的去调用父类的无参构造器

public class Ca {
Ca() {
System.out.println("Constructor Ca() of class Ca");
}
Ca(String str){
System.out.println("Constructor Ca(String str) of class Ca");
}
}
public class Cb extends Ca {
Cb(){
System.out.println("Constructor Cb() of class Cb");
}
}·