接口继承和多态

一.类的继承

基本思想是基于某个父类的扩展，制定出一个新的子类，子类可以继承父类原有的属性和方法，也可以增加父类所不具备的属性和方法，或者直接重写父类中的某些方法

<span style="font-family:SimSun;font-size:18px;">class Test {
	public Test() { // 构造方法
		// SomeSentence
	}
	
	protected void doSomething() { // 成员方法
		// SomeSentence
	}
	
	protected Test doIt() { // 方法返回值类型为Test类型
		return new Test();
	}
}

class Test2 extends Test { // 继承父类
	public Test2() { // 构造方法
		super(); // 调用父类构造方法
		super.doSomething(); // 调用父类成员方法
	}
	
	public void doSomethingnew() { // 新增方法
		// SomeSentence
	}
	
	public void doSomething() { // 重写父类方法
		// SomeNewSentence
	}
	
	protected Test2 doIt() { // 重写父类方法，方法返回值类型为Test2类型
		return new Test2();
	}
}
</span>

二.Object类和对象类型的转换

Object是所有类的父类，常用的方法包括getClass(),toString()和equals()方法

注：equals()比较的是两个对象的引用是否相等，而equals()方法比较的是两个对象的实际内容。

<span style="font-family:SimSun;font-size:18px;">class V { // 自定义类V
}

public class OverWriteEquals {
	public static void main(String[] args) {
		String s1 = "123"; // 实例化两个对象，内容相同
		String s2 = "123";
		System.out.println(s1.equals(s2)); // 使用equals()方法调用
		V v1 = new V(); // 实例化两个V类对象
		V v2 = new V();
		System.out.println(v1.equals(v2)); // 使用equals()方法比较v1与v2对象
	}
}
</span>

注：在向上转型中总是安全的，但是向下转型不一定，这时候需要用到显示类型转换。

注：instanceof操作符用来判断对象是否为类的实例对象，语法格式：myobject instanceof ExampleClass。

注：方法的重载部分：不定长参数方法

<span style="font-family:SimSun;font-size:18px;">public class OverLoadTest2 {
	public static int add(int a, int b) {
		return a + b;
	}
	
	public static double add(double a, double b) {
		return a + b;
	}
	
	public static int add(int a) {
		return 1;
	}
	
	public static int add(int a, double b) {
		return 1;
	}
	
	public static int add(double a, int b) {
		return 1;
	}
	
	public static int add(int... a) { // 定义不定长参数方法
		int s = 0;
		for (int i = 0; i < a.length; i++)
			// 根据参数个数做循环操作
			s += a[i]; // 将每个参数累加
		return s; // 将计算结果返回
	}
	
	public static void main(String args[]) {
		System.out.println("调用add(int,int)方法：" + add(1, 2));
		System.out.println("调用add(double,double)方法：" + add(2.1, 3.3));
		System.out.println("调用add(int)方法：" + add(1));
		// 调用不定长参数方法
		System.out.println("调用不定长参数方法：" + add(1,2, 3,4, 5,6, 7, 8, 9));
		System.out.println("调用不定长参数方法：" + add(1));
	}
}
</span>

三.多态

多态机制的使用可以动态调整对象的调用，降低对象之间的依存关系。

<span style="font-family:SimSun;font-size:18px;">public class Quadrangle {
	// 实例化保存四边形对象的数组对象
	private Quadrangle[] qtest = new Quadrangle[6];
	private int nextIndex = 0;
	
	public void draw(Quadrangle q) { // 定义draw()方法，参数为四边形对象
		if (nextIndex < qtest.length) {
			qtest[nextIndex] = q;
			System.out.println(nextIndex);
			nextIndex++;
		}
	}
	
	public static void main(String[] args) {
		// 实例化两个四边形对象，用于调用draw()方法
		Quadrangle q = new Quadrangle();
		q.draw(new Square()); // 以正方形对象为参数调用draw()方法
		// 以平行四边形对象为参数调用draw()方法
		q.draw(new Parallelogramgle());
	}
}

class Square extends Quadrangle { // 定义一个正方形类，继承四边形类
	public Square() {
		System.out.println("正方形");
	}
}

// 定义一个平行四边形类，继承四边形类
class Parallelogramgle extends Quadrangle {
	public Parallelogramgle() {
		System.out.println("平行四边形");
	}
}
</span>

四.抽象类和接口

abstract为定义抽象类的关键字，只要类中有一个抽象方法，此类就被标记为抽象类，继承和抽象类的所有子类需要将抽象类中的抽象方法进行覆盖。

由于java中类不能继承对个父类的限制，所以产生了接口。

接口可以看做纯粹的抽象类，interface为定义接口的关键字

<span style="font-family:SimSun;font-size:18px;">interface drawTest { // 定义接口
	public void draw(); // 定义方法
}

// 定义平行四边形类，该类继承了四边形类，并实现了drawTest接口
class ParallelogramgleUseInterface extends QuadrangleUseInterface
		implements drawTest {
	public void draw() { // 由于该类实现了接口，所以需要覆盖draw()方法
		System.out.println("平行四边形.draw()");
	}
	
	void doAnyThing() { // 覆盖父类方法
		// SomeSentence
	}
}

class SquareUseInterface extends QuadrangleUseInterface implements
		drawTest {
	public void draw() {
		System.out.println("正方形.draw()");
	}
	
	void doAnyThing() {
		// SomeSentence
	}
}

class AnyThingUseInterface extends QuadrangleUseInterface {
	void doAnyThing() {
		
	}
}

public class QuadrangleUseInterface { // 定义四边形类
	public void doAnyTthing() {
		// SomeSentence
	}
	
	public static void main(String[] args) {
		drawTest[] d = { // 接口也可以进行向上转型操作
		new SquareUseInterface(), new ParallelogramgleUseInterface() };
		for (int i = 0; i < d.length; i++) {
			d[i].draw(); // 调用draw()方法
		}
	}
}
</span>