Java基础---多态

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

多态：可以理解为事物存在的多种体现形态。

1、多态的体现

    父类的引用指向了自己的子类对象。

    父类的引用也可以接受自己的子类对象。

2、多态的前提

    必须是类与类之间有关系。要么继承，要么接口实现。

    通常还有一个前提：存在覆盖。（前期定义一个功能，后期子类进行重写，实现，这叫后期扩展性）

3、多态的好处

    多态的出现大大的提高了程序的扩展性。

4、多态的弊端：

    提高了扩展性，但是只能使用父类的引用访问父类中的成员。（不能预先去使用子类的成员）

例子：

人： 男人，女人   来了个人，不管男人女人你都可以称之为人。

动物：猫，狗    他们都是动物，称为猫行，成为动物也行。

猫 x = new 猫();

动物 x = new 猫();

猫可以具备其他类型，这个事物可以成为多种形态，称之为多态。

/*
动物，
猫，狗。
*/
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("吃骨头");
 }
 public void kanJia()
 {
  System.out.println("看家");
 }
}

class Pig extends Animal
{
 public void eat()
 {
  System.out.println("饲料");
 }
 public void gongDi()
 {
  System.out.println("拱地");
 }
}

class DuoTaiDemo
{
 public static void main(String[] args)
 {
  function(new Cat());
  function(new Pig());
  function(new Dog());
 }

 public static void function(Animal a)
 {
  a.eat();
 }
}


class DuoTaiDemo2
{
 public static void main(String[] args)
 {
  /*
  Animal a = new Cat();//类型提升。 向上转型。
  a.eat();

  //如果想要调用猫的特有方法是，如何操作？
  //强制将父类的引用。转成子类类型。向下转型
  Cat c = (Cat)a;
  c.catchMouse();
  */
  function(new Dog());
 }

 public static void function(Animal a)
 {
  a.eat();
  if(a instanceof Cat)
  {
   Cat c = (Cat)a;
   c.catchMouse();
  }
  if(a instanceof Dog)
  {
   Dog d = (Dog)a;
   d.kanJia();
  }
 }
}

多态：可以理解为事物存在的多种体现形态。

左为：向下转型   右为：向上转型

    Animal a = new Animal();

    Cat c = (Cat)a;

    千万不要出现这样的操作，就是讲父类对象转成子类类型。

    我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。

    多态自始至终都是子类对象在作者变化。

    父类对象不能强制转换为子类

    为了避免这种情况可以使用 instanceof 进行类型判断

    语法：if(对象 instanceof 对象类型){}

    判断玩之后就可以进行向下转型，使用子类对象特有的方法

5、多态的应用

    父类的方法被子类重写后，编译时会调用子类的方法。
 

    例：
    /*
基础班学生：
 学习，睡觉。
就业班学生:
 学习，睡觉。
可以将这两类事物进行抽取。
*/
abstract class Student
{
 public abstract void study();
 public void sleep()
 {
  System.out.println("躺着睡");
 }
}
class BaseStudent extends Student
{
 public void study()
 {
  System.out.println("base study");
 }
 public void sleep()
 {
  System.out.println("坐着睡");
 }
}
class AdvStudent extends Student
{
 public void study()
 {
  System.out.println("adv study");
 }
}
class DoStudent
{
 public void doSome(Student stu)
 {
  stu.study();
  stu.sleep();
 }
}
class DuoTaiDemo3
{
 public static void main(String[] args)
 {
  DoStudent ds = new DoStudent();
  ds.doSome(new BaseStudent());
  ds.doSome(new AdvStudent());
  //BaseStudent bs = new BaseStudent();
  //bs.sleep();
  //bs.study();
  //AdvStudent as = new AdvStudent();
  //as.sleep();
  //as.study();

'' }
}

    多态的核心思想：

    多态将对象调用变简单了，以前是指挥每一个对象去做事情，现在是可以指挥一批对象做事情，

    那是因为找到了这批对象的共同所属类型，把对象不停的往上抽取，就可以找到对象的共同点     

    对类型进行抽取，导致了多态的产生，操作同一个大类型，对大类型里的所有小类型都可以进行操作

 

6、多态使用的注意事项

例：

    

    class Fu
{
 int num = 5;
 void method1()
 {
  System.out.println("fu method1");
 }
 void method2()
 {
  System.out.println("fu method2");
 }
 static void method4()
 {
  System.out.println("fu method4");
 }
}
class Zi extends Fu
{
 int num = 8;
 void method1()
 {
  System.out.println("zi method1");
 }
 void method3()
 {
  System.out.println("zi method3");
 }
 static void method4()
 {
  System.out.println("zi method4");
 }
}
class  DuoTaiDemo4
{
 public static void main(String[] args) 
 {
  //Fu f = new Zi();
  //System.out.println(f.num);
  //Zi z = new Zi();
  //System.out.println(z.num);
  //f.method1();
  //f.method2();
  //f.method3();
 
  /*
  Zi z = new Zi();
  z.method1();
  z.method2();
  z.method3();
  */
  Fu f = new Zi();
  f.method4();
 }
}

    在多态中成员函数的特点：

    在编译时期：参阅引用性变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。

    在运行时期：参阅对象所属的类中是否有调用的方法。

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

    在多态中，成员变量的特点：

    无论编译和运行，都参考左边（引用性变量所属的类）。

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

    无论编译和运行，都参考左边。

例：

    /*
需求：
电脑运行实例，
电脑运行基于主板。
*/

interface PCI
{
 public void open();
 public void close();
}

class MainBoard
{
 public void run()
 {
  System.out.println("mainboard run");
 }
 public void usePCI(PCI p)//PCI p = new NetCard() 多态的实现
 {
  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 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 DuoTaiDemo5 
{
 public static void main(String[] args) 
 {
  //Mainboard mb = new Mainboard();
  //mb.run();
  //mb.useNetCard(new NetCard());

  MainBoard mb = new MainBoard();
  mb.run();
  mb.usePCI(null);
  mb.usePCI(new NetCard());
  mb.usePCI(new SoundCard());
 }
}

例：

/*
需求：数据库的操作。
数据是：用户信息。
1、连接数据库。 JDBC	Hibernate
2、操作数据库。
 c create  r read  u update  d delete
3、关闭数据库连接。
*/

interface UserInfoDao
{
 public void add(User user);

 public void delete(User user);
}

class UserInfoByJDBC implements UserDao
{
 public void add(User user)
 {
  1，JDBC连接数据库。
  2，使用sql添加语句添加数据。
  3，关闭连接。
 }
 public void delete(User user)
 {
  1，JDBC连接数据库。
  2，使用sql添加语句删除数据。
  3，关闭连接。
 }
}

class UserInfoByHibernate implements UserInfoDao
{
 public void add(User user)
 {
  1，Hibernate连接数据库。
  2，使用sql添加语句添加数据。
  3，关闭连接。
 }
 public void delete(User user)
 {
  1，Hibernate连接数据库。
  2，使用sql添加语句删除数据。
  3，关闭连接。
 }
}


class DBOperate
{
 public static void main(String[] args) 
 {
  //UserInfoByJDBC ui = new UserInfoByJDBC();
  UserInfoDao ui = UserInfoByHibernate
  ui.add(user);
  ui.delete(user);
 }
}

多态总结：

多态就是将对象当做参数使用进行数据的传参。

同时也可以作为返回类型，

这样做减少了代码的耦合性，增强了代码的复用性，以及利于以后的维护。