Java学习笔记（4）——多态

多态

• 概念：对象具有多种形态。

1. 引用多态：父类的引用可以指向本类的对象；父类的引用可以指向子类的对象。

例：

Parents obj1 = new Parents();
Parents obj2 = new Students();

2. 方法多态：
   创建本类对象，调用的是本类的方法；
   创建子类对象，调用的方法为子类重写的方法或是子类继承的方法，不能调用子类独有的方法。

例：

public class Parents{
	public void fun(){
		System.out.println("Parents function");
	}
}

public class Students extends Parents{
	public void fun(){
		System.out.println("Students function");
	}

	public void method(){
		System.out.println("Students method");
	}
}

public class Initation{
	public static void main(String arg[]){
		Parents p = new Parents();
		Parents s = new Students();

		p.fun();
		s.fun();
	}
}

子类创建的对象s则不能调用方法method，s.mothed();会报错。

引用类型转换

• 向上类型转换(自动/隐式类型转换)：将小类型转换成大类型(子类转换成父类)。
• 向下类型转换(强制类型转换)：将大类型转换成小类型。这种操作会存在风险，容易造成溢出。可以通过instanceof来避免转换的溢出。

例：

Child c = new Chil();
Parents p = c;					//自动类型转换(将小类型转换为大类型)
Child c = (Child)p;				//强制类型转换(将大类型转换为小类型)

//Students类也继承Parents
Students s = (Students)p;		//Students类并不包含Child类，所以就算进行强制类型转换，也会在运行时报错(在编译时不会报错)

//instanceof判断某个引用是否是该类型或该类型的子类型
//在本质上p是指向Child的类型，s和p不是同一个类型
if(p instanceof s){
	Students s = (Students)p;
} else{
	System.out.println("对象s不能强制类型转换为p");
}

抽象类

• 语法定义：某一个类前用abstract修饰的类，被称为抽象类。
• 应用场景：

1. 某个父类只是知道其子类应该包含哪些方法，但不到如何实现这些方法时，就会用到抽象类。换句话说，抽象类只关注拥有哪些方法，并不关注如何去这些方法。
2. 可以将某些具有相同特征的类，抽象出一个抽象类，作为子类的模板，避免了子类设计的随意性。

• 作用：限制子类必须拥有哪些方法，但是又不规定如何实现。
• 使用规则：

1. 抽象类需要被abstract修饰；
2. 抽象方法需要被abstract修饰，只有方法名，不用具体实现；
3. 包含抽象方法的是抽象类；
4. 抽象类中可以没有抽象方法，也可以存在普通方法；
5. 抽象类不能直接创建，必须定义引用变量。

例：

//定义一个抽象类
public abstract class Telphone {
	public abstract void sendMessage();
	public abstract void call();
}

public class Cellphone extends Telphone {
	@Override
	public void sendMessage(){
		System.out.println("cellphone can send message.");
	}
	
	@Override
	public void call(){
		System.out.println("cellphone can connect others.");
	}
}

public class Smartphone extends Telphone {
	@Override
	public void sendMessage(){
		System.out.println("smartphone can send message.");
	}

	@Override
	public void call(){
		System.out.println("smartphone can connect others.");
	}
}

public class Initation{
	public static void main(String arg[]){
		Telphone phone1 = new Cellphone();
		Telphone phone2 = new Smartphone();

		phone1.sendMessage();
		phone2.sendMessage();
	}
}

接口

• 概念：接口可以理解为一个特殊的类，全部由全局变量和公共的抽象方法组成。接口定义了某一批类所需要遵守的规范，接口不关注这些类的内部数据，也不关注类的实现方法，它只规定了这些类需要实现那些方法。
• 定义：定义接口不适用class关键字，而是适用interface关键字。
• 基本语法：

[修饰符] (abstract) interface 接口名 extends [父接口1, 父接口2, ······] {
	//接口中无论是方法还是变量都应该为public
	public static final param;			//接口中所有的变量都是常量，就算不加修饰符系统也会默认添加

	public abstract void fun();			//接口中的方法都是抽象方法，就算不加修饰符系统也会默认添加	
}

• 接口的使用：

1. 一个类可以实现多个接口，用implements关键字调用接口。
2. 还可以和匿名内部类共同使用

例：

//定义一个接口
public interface IplayGame {
	public void playGame();
}

//实现接口
public class Smartphone implements IplayGame {
	@Override
	public void playGame(){
		System.out.println("执行IplayGame接口方法");
	}
}

//接口调用
public class Initation {
	public static void main(String arg[]){
		IplayGame ip = new Smartphone();
		ip.playGame();						//调用接口方法

		//创建匿名内部类
		IplayGame ip1 = new IplayGame(){
			@Override
			public void playGame(){
				System.out.println("执行匿名内部类的接口方法");
			}
		};
		ip1.playGame();						//调用匿名内部类的方法
		
		//直接创建接口对象，调用接口方法
		new IplayGame(){
			@Override
			public void playGame(){
				System.out.println("执行匿名内部类的接口方法");
			}
		}.playGame();
	}
}