多态抽象类

Posted 2020-08-22 ai哟

多态：

　　多态：多种形式；

　　　　多态是指一个对象有多种形式的能力；

　　　　　多态描述：相同的行为；不同的实现；

　　多态分类：

　　　　静态多态：程序在编译时，系统就能决定调用哪个方法，所以称为编译时多态；实现的方式就是方法的重载，调用规则是依据对象在定义时的类型相应的调用对应类中的重载方法；

　　　　动态多态：在运行中系统才能动态确定方法所指的对象，所以称为运行时多态，实现的方式是重写父类中的同名成员方法，动态多态主要是通过动态绑定和重写机制来实现。

　　技术基础：

　1、向上转型技术：一个父类的引用变量可以指向不同的子类对象，或者一个子类对象可以被当做一个父类类型；

　2、instanceof关键字：instanceof关键字用于判断运行时对象的真正类型；

　3、动态绑定技术：运行时根据父类引用变量所指对象的时机类型执行相应的子方法，从而实现多态性；

　　基本数据类型的转型：

　1、自动类型转换、隐式转换、从小范围的数据类型往大范围的数据类型转换

　　无风险/肯定成功；

int a = ‘b‘;
double f = 254;

　2、强制类型转换、显式转换、从大范围的数据往小范围的数据类型转换

　　有风险/丢失精度/无意义

a = (int)3.14;
char c = (char)12345670;

　　引用数据类型的转换——只有有继承关系的类才能使用类型转换

public class PetBean {
	
	private String name;
	
	private int age;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
}

 

public class DogBean extends PetBean {
	
	private int boneNum;

	public int getBoneNum() {
		return boneNum;
	}

	public void setBoneNum(int boneNum) {
		this.boneNum = boneNum;
	}
	
}　

public class TestMain {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

　1、向上类型转换、自动类型转换、隐式类型转换、从小范围的数据类型往大范围的数据类型转换

　　无风险\肯定成功

　　　　　　　　PetBean p = new PetBean();//父类的引用可以指向子类的对象

　2、向下类型转换、强制类型转换、显式转换、从大范围的数据往小范围的数据类型转换

　　有风险/可能会抛出异常，终止程序的运行

　　只有运行起来后，确实是本类引用指向本类对象或父类引用指向子类对象才可以成功

　　　　　　　　DogBean dog = (DogBean)p;

　　多态应用——多态参数：

　　　　多态参数就是当方法的某个形式参数是一个引用的时候，与该引用兼容的任何对象都可以传递给方法，从而允许方法接受不同数据类型的形式参数。

　　多态应用——异构集合：

　　　　多态另一个常见应用是穿件一个不是同一类型，但是有共同父类的数据集合，不同对象的集合称为异构集合。

　

多态小结：

　　使用父类类型的引用指向子类的对象；

　　该引用只能调用父类中定义的方法，不能调用子类中独有的方法；

　　如果子类中重写了父类中的一个方法，那么在调用该方法的时候，将会调用子类中的这个方法；

　　在多态中，子类可以调用父类中的所有方法；

 

抽象类：

　　将一个方法声明为抽象方法有两个结果：

　1、类也必须声明为抽象类，如果一个类包含了一个抽象方法，那么该类也必须是抽象类；

　2、任何子类必须重写抽象方法，除非子类本身也是抽象类；

　　关键字：　abstract；用这个关键字修饰类的时候，表示这个类是抽象类；

　　　注：　抽象类不能产生对象，它只能充当父类;

　　1、有抽象方法的类一定是抽象类；

　　2、抽象类不一定有抽象方法；

　　3、抽象类除了类有abstract修饰符，它内部跟普通类一样，可以有：属性、构造、已经实现的方法；

例：

public class Boy {
	private Girl myGirl;

	public Girl getMyGirl() {
		return myGirl;
	}

	public void setMyGirl(Girl myGirl) {
		this.myGirl = myGirl;
	}
	
	public void kiss(){
		System.out.println("让我亲一个嘛~~~");
		this.myGirl.response();
	}
}

public abstract class Girl {
	
	　　　//abstract关键字表示抽象
	　　　//当它修饰方法的时候，表示类有这个方法，但是不能确定这个方法的实现，应该由它的子类去确定

	public abstract void response();

}

public class PureGirl extends Girl {

　　　　　　　　//子类在继承抽象类的时候，必须重写抽象类的抽象方法。
　　　　　　　　//否则这个子类也必须是抽象类。

	@Override
	public void response() {
		// TODO Auto-generated method stub
		System.out.println("嗯~~~你好坏~~~");
	}
	
}

public class BoldGirl extends Girl {

　　　　　　　　//子类在继承抽象类的时候，必须重写抽象类的抽象方法。
　　　　　　　　//否则这个子类也必须是抽象类。

	@Override
	public void response() {
		// TODO Auto-generated method stub
		System.out.println("老娘飞起来一脚~~~~");
	}
	
}

public class TestLove {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Boy boy = new Boy();
		System.out.println("请选择你喜欢的女孩类型：1、纯情；2、野蛮。");
		int choice = new Scanner(System.in).nextInt();
		Girl girl = null;
		switch(choice){
		case 1:
			girl = new PureGirl();break;
		case 2:
			girl = new BoldGirl();break;
		}
		
		boy.setMyGirl(girl);
		boy.kiss();
		
	}

}