探索Java面向对象编程的奇妙世界(六)

⭐ 多态(polymorphism)

多态指的是同一个方法调用，由于对象不同可能会有不同的行为。现实生活中，同一个方法，具体实现会完全不同。 比如：同样是调用人“吃饭”的方法，中国人用筷子吃饭，英国人用刀叉吃饭，印度人用手吃饭。

多态的要点：

🐟	多态是方法的多态，不是属性的多态（多态与属性无关）。
🐟	多态的存在要有 3 个必要条件：继承，方法重写，父类引用指向子类对象。
🐟	父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

【eg】多态和类型转换

	class Animal {
		public void shout() {
			System.out.println("叫了一声！");
	}
}
	class Dog extends Animal {
		public void shout() {
			System.out.println("旺旺旺！");
	}
		public void seeDoor() {
			System.out.println("看门中....");
	}
}
	class Cat extends Animal {
		public void shout() {
			System.out.println("喵喵喵喵！");
	}
}
	public class TestPolym {
		public static void main(String[ ] args) {
			Animal a1 = new Cat(); // 向上可以自动转型
			//传的具体是哪一个类就调用哪一个类的方法。大大提高了程序的可扩展性。
			animalCry(a1);
			Animal a2 = new Dog();
			animalCry(a2);//a2 为编译类型，Dog 对象才是运行时类型。
/*编写程序时，如果想调用运行时类型的方法，只能进行强制类型转换。否则通不过编译器的检查。*/
			Dog dog = (Dog)a2;//向下需要强制类型转换
			dog.seeDoor();
	}
		// 有了多态，只需要让增加的这个类继承 Animal 类就可以了。
			static void animalCry(Animal a) {
			a.shout();
	}
/* 如果没有多态，我们这里需要写很多重载的方法。
 * 每增加一种动物，就需要重载一种动物的喊叫方法。非常麻烦。
	static void animalCry(Dog d) {
		d.shout();
	}
	static void animalCry(Cat c) {
		c.shout();
	}*/
	}

执行结果如下所示：

如上示例，给大家展示了多态最为多见的一种用法，即父类引用做方法的形参，实参可以是任意的子类对象，可以通过不同的子类对象实现不同的行为方式。

由此，我们可以看出多态的主要优势是提高了代码的可扩展性。但是多态也有弊端，就是无法调用子类特有的功能，比如，我不能使用父类的引用变量调用 Dog 类特有的seeDoor()方法。
那如果我们就想使用子类特有的功能行不行呢？行！这就是我们下面所写的内容：
对象的转型。

⭐ 对象的转型(casting)

🐟	父类引用指向子类对象，我们称这个过程为向上转型，属于自动类型转换。
🐟	向上转型后的父类引用变量只能调用它编译类型的方法，不能调用它运行时类型的方法。这时，我们就需要进行类型的强制转换，我们称之为向下转型。

【eg】对象的转型

	public class TestCasting {
		public static void main(String[ ] args) {
			Object obj = new String("北京"); // 向上可以自动转型
// obj.charAt(0) 无法调用。编译器认为 obj 是 Object 类型而不是 String 类型
/* 编写程序时，如果想调用运行时类型的方法，只能进行强制类型转换。不然通不过编译器的检查。 */
			String str = (String) obj; // 向下转型
			System.out.println(str.charAt(0)); // 位于 0 索引位置的字符
			System.out.println(obj == str); // true.他们俩运行时是同一个对象
	}
}

执行结果如下所示：

在向下转型过程中，必须将引用变量转成真实的子类类型(运行时类型）否则会出现类型转换异常 ClassCastException。如下所示。

【eg】类型转换异常

	public class TestCasting2 {
		public static void main(String[ ] args) {
		Object obj = new String("北京");
//真实的子类类型是 String，但是此处向下转型为 StringBuffer
		StringBuffer str = (StringBuffer) obj;
		System.out.println(str.charAt(0));
	}
}

执行结果：

为了避免出现这种异常，我们可以使用 instanceof 运算符进行判断。

【eg】向下转型中使用 instanceof

	public class TestCasting3 {
		public static void main(String[ ] args) {
		Object obj = new String("北京尚学堂");
		if(obj instanceof String){
		String str = (String)obj;
		System.out.println(str.charAt(0));
		}else if(obj instanceof StringBuffer){
		StringBuffer str = (StringBuffer) obj;
		System.out.println(str.charAt(0));
		}
	}
}

⭐ 抽象类

抽象方法和抽象类

抽象方法

🐟	使用 abstract 修饰的方法，没有方法体，只有声明。
🐟	定义的是一种“规范”，就是告诉子类必须要给抽象方法提供具体的实现。

抽象类

🐟	包含抽象方法的类就是抽象类。
🐟	通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。

【eg】抽象类和抽象方法的基本用法

	//抽象类
		abstract class Animal {
		abstract public void shout(); //抽象方法
	}
		class Dog extends Animal {
		//子类必须实现父类的抽象方法，否则编译错误
		public void shout() {
			System.out.println("汪汪汪！");
	}
		public void seeDoor(){
			System.out.println("看门中....");
	}
}
	//测试抽象类
		public class TestAbstractClass {
			public static void main(String[ ] args) {
				Dog a = new Dog();
				a.shout();
				a.seeDoor();
	}
}

抽象类的使用要点:

🐟	有抽象方法的类只能定义成抽象类
🐟	抽象类不能实例化，即不能用 new 来实例化抽象类。
🐟	抽象类可以包含属性、方法、构造方法。但是构造方法不能用来 new 实例，只能用来被子类调用。
🐟	抽象类只能用来被继承。
🐟	抽象方法必须被子类实现。

⭐ 接口 interface

接口就是一组规范（就像我们人间的法律一样），所有实现类都要遵守。

面向对象的精髓，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如 C++、Java、C#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。

接口的作用

为什么需要接口?接口和抽象类的区别?

接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离。

接口是两个模块之间通信的标准，通信的规范。如果能把你要设计的模块之间的接口定义好，就相当于完成了系统的设计大纲，剩下的就是添砖加瓦的具体实现了。大家在工作中，做系统时往往就是使用“面向接口”的思想来设计系统。

接口和实现类不是父子关系，是实现规则的关系。比如：我定义一个接口 Runnable，Car 实现它就能在地上跑，Train 实现它也能在地上跑，飞机实现它也能在地上跑。就是说，如果它是交通工具，就一定能跑，但是一定要实现 Runnable 接口。

如何定义和使用接口

声明格式：

	[访问修饰符] interface 接口名 [extends 父接口 1，父接口 2…] {
			常量定义；
			方法定义；
	}

定义接口的详细说明：

🐟	访问修饰符：只能是 public 或默认。
🐟	接口名：和类名采用相同命名机制。
🐟	extends：接口可以多继承。
🐟	常量：接口中的属性只能是常量，总是：public static final 修饰。不写也是。
🐟	方法：接口中的方法只能是：public abstract。 省略的话，也是 public abstract。

注意：

🐟	子类通过 implements 来实现接口中的规范。
🐟	接口不能创建实例，但是可用于声明引用变量类型。
🐟	一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是 public 的。
🐟	JDK1.8（不含 8）之前，接口中只能包含静态常量、抽象方法，不能有普通属性、构造方法、普通方法。
🐟	JDK1.8（含 8）后，接口中包含普通的静态方法、默认方法。

【eg】接口的使用

	public class TestInterface {
		public static void main(String[ ] args) {
			Volant volant = new Angel();
			volant.fly();
		 System.out.println(Volant.FLY_HIGHT);
 
		 Honest honest = new GoodMan();
 		 honest.helpOther();
	}
}
/*飞行接口*/
	interface Volant { 
	int FLY_HIGHT = 100; // 总是：public static final 类型的；
	void fly(); //总是：public abstract void fly();
	}
/*善良接口*/
	interface Honest { 
	void helpOther();
	}
/*Angel 类实现飞行接口和善良接口*/
	class Angel implements Volant, Honest{
	public void fly() {
	System.out.println("我是天使，飞起来啦！");
	}
	public void helpOther() {
	System.out.println("扶老奶奶过马路！");
	}
}
	class GoodMan implements Honest {
	public void helpOther() {
	System.out.println("扶老奶奶过马路！");
	} 
}
	class BirdMan implements Volant {
	public void fly() {
	System.out.println("我是鸟人，正在飞！");
	}
}

执行结果：

接口中定义静态方法和默认方法(JDK8)

JAVA8 之前，接口里的方法要求全部是抽象方法。
JAVA8（含 8）之后，以后允许在接口里定义默认方法和静态方法。

JDK8 新特性_默认方法

Java 8 及以上新版本，允许给接口添加一个非抽象的方法实现，只需要使用 default
关键字即可，这个特征又叫做默认方法（也称为扩展方法）。

默认方法和抽象方法的区别是抽象方法必须要被实现，默认方法不是。作为替代方式，接口可以提供默认方法的实现，所有这个接口的实现类都可以得到默认方法。

【eg】默认方法

	public class Test {
	 	public static void main(String[] args) {
 			A a = new Test_A();
 			a.moren();
	 }
}
	interface A {
 	default void moren(){
	System.out.println("我是接口 A 中的默认方法！");
 	}
}
	class Test_A implements A {
 
 	@Override
 	public void moren() {
 	System.out.println("Test_A.moren");
 	}
}

JDK8 新特性_静态方法

JAVA8 以后，我们也可以在接口中直接定义静态方法的实现。这个静态方法直接从属于接口（接口也是类，一种特殊的类），可以通过接口名调用。

如果子类中定义了相同名字的静态方法，那就是完全不同的方法了，直接从属于子类。可以通过子类名直接调用。

	public class Test {
 		public static void main(String[] args) {
 			A.staticMethod();
 			Test_A.staticMethod();
 	}
}
		interface A {
 		public static void staticMethod(){
 		System.out.println("A.staticMethod");
 	}
}
		class Test_A implements A {
 		public static void staticMethod(){
 		System.out.println("Test_A.staticMethod");
 	}
}

静态方法和默认方法

本接口的默认方法中可以调用静态方法。

	public class Test {
 		public static void main(String[] args) {
 			A a = new Test_A();
 			a.moren();
 	}
}
		interface A {
 		public static void staticMethod(){
 		System.out.println("A.staticMethod");
 	}
 		public default void moren(){
 		staticMethod();
 		System.out.println("A.moren");
 	}
}
		class Test_A implements A {
 		public static void staticMethod(){
 		System.out.println("Test_A.staticMethod");
 	}
}

接口的多继承

接口支持多继承。和类的继承类似，子接口 extends 父接口，会获得父接口中的一切。

【eg】接口的多继承

	interface A {
		void testa();
	}
	interface B {
		void testb();
	}
/**接口可以多继承：接口 C 继承接口 A 和 B*/
	interface C extends A, B {
		void testc();
	}
	public class Test implements C {
		public void testc() {
	}
		public void testa() {
	}
		public void testb() {
	}
}