java笔记-面向对象-多态

多态：

（含类的向上和向下转换）

/*
** 多态：事物存在的多种形态；
** 1.多态的体现：
** 使用父类的引用指向自己子类的对象；
** 2.多态的前提：
** 必须是类与类之间的关系，要么继承，要么实现，
** 另外，子类需能覆盖父类的方法；
** 3.多态的优点：
** 大大提高了程序的扩展性；
** 4.多态的弊端：
** 只能访问父类中的成员；
*/
abstract class Animal{		//抽象的父类；
public abstract void Eat();
}
class Cat extends Animal{
//重写继承而来的抽象类中的方法；
public void Eat(){
System.out.println("吃鱼");
}
public void CatchMouse(){
System.out.println("捉老鼠");
}
}
class Dog extends Animal{
//重写继承而来的抽象类中的方法；
public void Eat(){
System.out.println("啃骨头");
}
}
class Pig extends Animal{
//重写继承而来的抽象类中的方法；
public void Eat(){
System.out.println("饲料");
}
}
class PolymorphicDemo{
public static void main(String[] args){
/* 该部分语句可以用下面的代替
Cat c=new Cat();
c.Eat();
*/
// 父类的引用Animal A指向子类的对象new Cat()
Polymorphic(new Cat());
Polymorphic(new Dog());
Polymorphic(new Pig());
System.out.println("类型向上转换。");
Animal c=new Cat();			//类型提升，向上转换；
c.Eat();
//对象c中不具有CatchMouse()方法，若要具有该方法，则：
System.out.println("对象的强制类型转换。");
//类型转换之前需先判断；
if(c instanceof Cat){		//instance: 判断所属类型；
Cat a=(Cat)c;			//强制类型转换；只能将之转换为原子类；
a.CatchMouse();
}

}
/*
** 以下语句中Animal A的语句按照之前的方法是用Cat C
** 这样的话,每添加一个动物类都需要再添加一个函数；
** 而使用Animal A的方式却只需要写如下函数即可。
** 原理：不管是添加的何种动物类，
** 它们都继承自“动物”这一大父类，子类均对Eat()函数重写，
** 覆盖了父类中的Eat();
*/
// Animal A是多态的体现；
// 父类的引用Animal A指向子类的对象new Cat()
public static void Polymorphic(Animal A){
A.Eat();
}
}

多态实例：

abstract class Student{
int num=3;
public abstract void Study();
public void Sleep(){
System.out.println("Student:12点入睡。");
}
}
class BaseStudent extends Student{
int num=4;
public void Study(){
System.out.println("Base study.");
}
//部分同学休息时间不定，重写休息时间，覆盖父类休息方法；
public void Sleep(){
System.out.println("base student:11点入睡。");
}
}
class AdvStudent extends Student{
//重写抽象类中的抽象方法；
public void Study(){
System.out.println("Adv student study.");
}
}
//将多态的调用直接封装到一类类中：工具类；
class DoStudent{
//父类引用指向子类对象；
public void doSome(Student s){
s.Study();
s.Sleep();
}
}
class duotai{
public static void main(String[] args){
/*
** 未使用多态的调用；
*/
System.out.println("未使用多态调用。");
BaseStudent bs=new BaseStudent();
bs.Study();
bs.Sleep();

/*
** 使用多态的调用；
*/
System.out.println("使用多态调用。");
DoStudent ds= new DoStudent();
ds.doSome(new BaseStudent());
ds.doSome(new AdvStudent());
//多态中的成员变量；
Student Stu=new BaseStudent();
System.out.println(Stu.num);	//该值输出为3；
BaseStudent Bstu= new BaseStudent();
System.out.println(Bstu.num);	//该值输出为4；
}
}

多态中非静态成员函数的特点：

编译时期：审查引用型变量所属的类中是否有调用的方法；若有，则通过，反之则不通过；

运行时期：审查对象所属的类中是否有调用的方法，若有则通过，反之则不通过。

总结：成员函数在多态调用时，编译看左边，运行看右边；

多态中成员变量的特点：

无论编译和运行，都参看引用型变量；

对于静态成员函数，无论编译和运行，都参看左边（引用型变量）。

多态主板实例：

/*
** 主板实例：
** 功能：可向该主板中添加插件，如网卡，声卡...
*/

//定义同一的接口，添加的插件，如网卡，声卡等，
//通过该接口连接到主板；
interface PCI{
public void open();
public void close();
}
//主板中提供接口的使用方法；
class mBoard{
public void run(){
System.out.println("Main board run!");
}
//主板符合接口的标准；
//表示插件通过该接口可以连接到主板；
public void usePci(PCI P){
P.open();
P.close();
}
}
//要连接的插件符合接口的标准；
class netCard implements PCI{
public void open(){
System.out.println("net card open.");
}
public void close(){
System.out.println("net card close.");
}
}
//......后续有N多的插件都可以通过该方式添加
//而无需更改主板相关信息；
class soundCard implements PCI{
public void open(){
System.out.println("sound card open.");
}
public void close(){
System.out.println("sound card close.");
}
}
class MainBoard{
public static void main(String[] args){
mBoard mb= new mBoard();
mb.run();
//父类引用，指向子类对象；
mb.usePci(new netCard() );
mb.usePci(new soundCard() );
}
}

复写Object类中的equals方法

/*
** 复写object类中的equals方法；
** Object 类是所有类的上帝；
*/
class Demo{
int num;
Demo(int num){	//构造函数无返回；
this.num=num;
}
//复写equals方法；
/*
** 由于Object类中已经有了equals方法，在使用相同的功能比较不同的类型
** 时，可以采用复写的方式；
*/
public boolean equals(Object obj){
//只有同类型才能相比，先判断是否同类型；不同则直接返回false
if(!(obj instanceof Demo)){
return false;
}
//由于父类中无num变量，且obj为父类引用（多态），为了访问子类
//中的变量，需要使用强类型转换；
Demo d= (Demo)obj;
return this.num==d.num;
}
}
class objectDemo{
public static void main(String[] args){
Demo de_1=new Demo(3);
Demo de_2=new Demo(3);
System.out.println("Compare result is :"+de_1.equals(de_2));
}
}