[置顶] JavaSE学习笔记_5：Java多态
Java多态
一、多态（面向对象的第三个特征）
1、多态—概念
多态：可以理解为事物存在的多种体现形式。
人：男人，女人
动物：猫，狗
猫 x=new 猫（）；
动物 x=new 动物（）；//实体x既具备猫的类型也具备动物的类型。
多态的前提：必须是类与类之间有关系。要么继承，要么实现。
多态的体现：父类引用指向子类对象。父类引用也可以接收子类对象。
多态的好处：大大的提高程序的扩展性和代码的复用性。
多态的弊端：只能使用父类的引用去访问被子类复写的父类功能。可以转型。（创建对象时是向上转型，如：Animal a=new Cat（），想调用子类中特有的功能向下转型（强转），如：Cat c=（Cat）a）
2、多态—扩展性
3、多态—转型
用实例来讲解：
/*
动物
猫，狗
*/
一开始：
abstract class Animal
{
public abstract void eat();//吃啥不确定，每个动物 //的事物都不一样。
}
//定义子类
class Cat extends Animal
{
//由子类来实现未知的内容
public void eat()
{
System.out.println(“吃鱼”);
}
//子类自己独有的功能
public void catMouse()
{
System.out.println(“抓老鼠”);
}
}
class Dog extends Animal
{
public void eat()
{
System.ou.println(“吃骨头”);
}
public void kangjia()
{
System.out.println(“看家”);
}
}
class Pig extends Animal
{
public void eat()
{
System.ou.println(“吃饲料”);
}
public void gongdi()
{
System.out.println(“拱地”);
}
}
class DuoTaiDemo
{
public static void main(String[] args)
{
Cat c=new Cat();
c.eat();
Cat c2=new Cat();
c2.eat();
Dog d=new Dog();
d.eat();
Dog d1=new Dog();
d1.eat();
Pig p=new Pig();
p.eat();
Pig p1=new Pig();
p1.eat();
}
}
发现以上主函数中的代码好死板，我们可以：
abstract class Animal
{
public abstract void eat();//吃啥不确定，每个动物 //的事物都不一样。
}
//定义子类
class Cat extends Animal
{
//由子类来实现未知的内容
public void eat()
{
System.out.println(“吃鱼”);
}
//子类自己独有的功能
public void catMouse()
{
System.out.println(“抓老鼠”);
}
}
class Dog extends Animal
{
public void eat()
{
System.ou.println(“吃骨头”);
}
public void kangjia()
{
System.out.println(“看家”);
}
}
class Pig extends Animal
{
public void eat()
{
System.ou.println(“吃饲料”);
}
public void gongdi()
{
System.out.println(“拱地”);
}
}
class DuoTaiDemo
{
public static void main(String[] args)
{
function(new Cat());
function(new Cat());
function(new Dog());
function(new Dog());
function(new Pig());
function(new Pig());
}
pubic static void function(Cat c)
{
c.eat();
}
pubic static void function(Dog d)
{
d.eat();
}
pubic static void function(Pig c)
{
p.eat();
}
}
发现这样的话，如果再来一个动物鸡，那么主类中还需写一个function（）以重载形式出现。动物越多，function（）重载越多。因此另辟蹊径：
abstract class Animal
{
public abstract void eat();//吃啥不确定，每个动物 //的事物都不一样。
}
//定义子类
class Cat extends Animal
{
//由子类来实现未知的内容
public void eat()
{
System.out.println(“吃鱼”);
}
//子类自己独有的功能
public void catMouse()
{
System.out.println(“抓老鼠”);
}
}
class Dog extends Animal
{
public void eat()
{
System.ou.println(“吃骨头”);
}
public void kangjia()
{
System.out.println(“看家”);
}
}
class Pig extends Animal
{
public void eat()
{
System.ou.println(“吃饲料”);
}
public void gongdi()
{
System.out.println(“拱地”);
}
}
class DuoTaiDemo
{
public static void main(String[] args)
{
function(new Cat());
function(new Cat());
function(new Dog());
function(new Dog());
function(new Pig());
function(new Pig());
}
pubic static void function(Animal a)
{
c.eat();
}
}
但是，这样虽好，却只能调用子类中重写的方法。因此可以向下转型：
abstract class Animal
{
public abstract void eat();//吃啥不确定，每个动物 //的事物都不一样。
}
//定义子类
class Cat extends Animal
{
//由子类来实现未知的内容
public void eat()
{
System.out.println(“吃鱼”);
}
//子类自己独有的功能
public void catMouse()
{
System.out.println(“抓老鼠”);
}
}
class Dog extends Animal
{
public void eat()
{
System.ou.println(“吃骨头”);
}
public void kangjia()
{
System.out.println(“看家”);
}
}
class Pig extends Animal
{
public void eat()
{
System.ou.println(“吃饲料”);
}
public void gongdi()
{
System.out.println(“拱地”);
}
}
class DuoTaiDemo
{
public static void main(String[] args)
{
function(new Cat());
function(new Cat());
function(new Dog());
function(new Dog());
function(new Pig());
function(new Pig());
}
pubic static void function(Animal a)
{
a.eat();
Cat c=(cat)a;
c.catchMouse();//调用了子类自己特有的内容。
}
}
但是，如果传入的是new Dog（），则编译通过，运行失败，发生类型转化异常：ClassCastException。则：
abstract class Animal
{
public abstract void eat();//吃啥不确定，每个动物 //的事物都不一样。
}
//定义子类
class Cat extends Animal
{
//由子类来实现未知的内容
public void eat()
{
System.out.println(“吃鱼”);
}
//子类自己独有的功能
public void catMouse()
{
System.out.println(“抓老鼠”);
}
}
class Dog extends Animal
{
public void eat()
{
System.ou.println(“吃骨头”);
}
public void kangjia()
{
System.out.println(“看家”);
}
}
class Pig extends Animal
{
public void eat()
{
System.ou.println(“吃饲料”);
}
public void gongdi()
{
System.out.println(“拱地”);
}
}
class DuoTaiDemo
{
public static void main(String[] args)
{
function(new Cat());
function(new Cat());
function(new Dog());
function(new Dog());
function(new Pig());
function(new Pig());
}
pubic static void function(Animal a)
{
b.eat();
if(a instanceof Cat)
{
Cat c=(Cat)a;
a.catchMouse();
}
else if(a instanceof Dog)
{
Dog d=(Dog)a;
d.kangjia();
}
else if(a instanceof Pig)
{
Pig p=(Pig)a;
p.gongDi();
}
}
}
上述代码，如果动物越多，判断也就越多，也不是好办法。待留。还有就是不建议在function（）中首先对Animal类型做判断，因为无论如何也都成立。
还有就是，将function（）单独放在一个类中，这个类与Animal类共同成为一个体系。
4、多态中成员的特点
Fu f=new Zi（）；（Fu可以是一个类，也可以是一个接口）
（1）在多态中成员函数的特点
1）在编译时期，参阅引用型变量所属的类是否有调用的方法。如果有，编译通过；如果没有，编译失败。
2）在运行时期，参阅对象所属的类中是否有调用的方法。如果有，运行通过；如果没有，运行失败。
简单总结：编译看左边，运行看右边。
（2）在多态中成员变量的特点
无论编译和运行，都参考左边（引用型变量所属的类）
（3）在多态中静态成员变量的特点
无论编译和运行，都参考左边（引用型变量所属的类）
（4）在多态中静态成员函数的特点
无论编译和运行，都参考左边（引用型变量所属的类）
示例1：
/*电脑主板*/
//功能单一的主板逐渐增添多个功能。
一开始
class MainBoard
{
public void run()
{
System.out.println(“mainboard run”);
}
}
class DuoTaiDemo
{
public static void main(String[] args)
{
MainBoard mb=new MainBoard();
mb.run();
}
}
主板功能太单一。现在想上网,买来网卡
class MainBoard
{
public void run()
{
System.out.println(“mainboard run”);
}
public void useNetCard(netCard c)
{
c.open（）；
c.close();
}
}
//定义网卡
class NetCard
{
public void open()
{
System.out.println(“netcard open”);
}
public void close()
{
System.out.println(“netcard close”);
}
}
class DuoTaiDemo
{
public static void main(String[] args)
{
MainBoard mb=new MainBoard();
mb.run();
mb.useNetcard(new NetCard());
}
}
现在又想听音乐，又买来一个声卡，则还得修改主板，耦合性强。发现主板毫无扩展性可言。现在利用多态的思想：
interface PCI
{
Public abstract void open();
Public abstract void close();
}
class MainBoard
{
public void run()
{
System.out.println(“mainboard run”);
}
public void usePCI(PCI p)
{
if(p!==null)
{
p.open（）；
p.close();
}
}
}
//定义网卡
class NetCard implements PCI
{
public void open()
{
System.out.println(“netcard open”);
}
public void close()
{
System.out.println(“netcard close”);
}
}
//定义声卡
class SoundCard implements PCI
{
public void open()
{
System.out.println(“Soundcard open”);
}
public void close()
{
System.out.println(“Soundcard close”);
}
}
class DuoTaiDemo
{
public static void main(String[] args)
{
MainBoard mb=new MainBoard();
mb.run();
mb.usePCI(new NetCard());
mb.usePCI（new SoundCard()）;
}
}
实例2：
/*
数据库的操作：
1、连接数据库。JDBC、Hibernate两种方式
2、操作数据库。c：creat r：read u：update d：delete
3、关闭数据库。
*/
一开始：我们用jdbc的方式连接数据库：
class UserInfoByJDBC
{
public void add(User user)
{
1、JDBC连接数据库。
2、使用sql添加语句添加数据。
3、关闭数据库。
}
public void delete(User user)
{
1．JDBC连接数据库。
2．使用sql删除语句删除数据。
3．关闭数据库。
}
}
class DBOperate
{
public static void main(String[] args)
{
UserInfoByJDBC ui=new UserInfoByJDBC();
ui.add(user);
ui.add(user);
}
}
后来，我们又想通过Hibernate方式连接。则：
class UserInfoHibernate
{
public void add(User user)
{
4、Hibernate连接数据库。
5、使用sql添加语句添加数据。
6、关闭数据库。
}
public void delete(User user)
{
4．Hibernate连接数据库。
5．使用sql删除语句删除数据。
6．关闭数据库。
}
}
class DBOperate
{
public static void main(String[] args)
{
UserInfoByHibernate ui=new
UserInfoByHibernate();
ui.add(user);
ui.add(user);
}
}
发现连接方式和主程序的耦合性非常强。因此利用多态的思想：
interface UserInfoDao
{
public void add();
public void delete();
}
class UserInfoByJDBC implements UserInfoDao
{
public void add(User user)
{
7、JDBC连接数据库。
8、使用sql添加语句添加数据。
9、关闭数据库。
}
public void delete(User user)
{
7．JDBC连接数据库。
8．使用sql删除语句删除数据。
9．关闭数据库。
}
}
Class UserInfoByHibernate implements UserInfoDao
{
public void add(User user)
{
10、Hibernate连接数据库。
11、使用sql添加语句添加数据。
12、关闭数据库。
}
public void delete(User user)
{
10．Hibernate连接数据库。
11．使用sql删除语句删除数据。
12．关闭数据库。
}
}
class DBOperate
{
Public static void main(String[] args)
{
UserInfoDao ui=new UserInfoByJDBC()/
UserInfoByHibernate();
ui.add(user);
ui.delete(user);
}
}
这样，主程序只和interface有关系，与UserInfoByJDBC/UserInfoByHibernate无关。当主程序中还有一个地方需要改，想让它也不用改，则涉及到以后的反射。
2015-11-20至2015-11-20著