黑马程序员：Java基础总结----多态

黑马程序员：Java基础总结

---

多态

  ASP.Net+Android+IO开发 、 .Net培训 、期待与您交流！

---

多态：

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


例如：
人：男人，女人

动物：猫，狗。

猫 x = new 猫();

动物 x = new 猫();





1，多态的体现
     父类的引用指向了自己的子类对象。
     父类的引用也可以接收自己的子类对象。
2，多态的前提
     必须是类与类之间有关系。要么继承，要么实现。
     通常还有一个前提：存在覆盖。

3，多态的好处
     多态的出现大大的提高程序的扩展性。

4，多态的弊端：
     提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5，多态的应用

6，多态的出现代码中的特点(多态使用的注意事项)

7， instanceof : 用于判断对象的类型。 对象 intanceof 类型(类类型 接口类型)

              if (a  instanceof  Cat)

            {

                  Cat c = (Cat)a;

                  c.catchMouse();

            }

              else  if (a  instanceof  Dog)

            {

                  Dog c = (Dog)a;

                  c.kanJia();

        public  boolean  equals(Object obj) //Object obj = new Demo();

      {

              if (!(obj  instanceof  Demo))

                    return  false ;

            Demo d = (Demo)obj;

              return  this .num == d.num;

      }

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

在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
在运行时期：参阅对象所属的类中是否有调用的方法。
简单总结就是：

成员函数:

编译看左边，运行看右边。

成员变量:
无论编译和运行，都参考左边(引用型变量所属的类)。


静态成员函数:
无论编译和运行，都参考做左边

class  Fu {

        static  int  num  = 5;

        void  method1() {

            System.  out .println( "fu method_1"  );

      }

        static  void  method2() {

            System.  out .println( "fu method_2"  );

      }

        void  method3()

      {

            System.  out .println( "fu method_3"  );

      }

}

class  Zi  extends  Fu {

        static  int  num  = 8;

        void  method1() {

            System.  out .println( "zi method_1"  );

      }

        static  void  method2() {

            System.  out .println( "zi method_2"  );

      }

        void  method3()

      {

            System.  out .println( "fu method_3"  );

      }

}

public  class  Test01 {

        public  static  void  main(String[] args) {

            Fu a =  new  Zi();

            Zi b =  new  Zi();

            Zi c = (Zi)  new  Fu();

              // 基础数据类型测试

              int  n = a.  num ;  // fu 的 num

            n = Zi.  num ;  // zi 的 num

            n = b.  num ; // Zi

            n = Fu.  num ; // fu

            n = c.  num ; // Zi ..注意！

              // 引用数据类型测试

            a.method1();  //fu

            b.method1();  //zi

            c.method1();  //zi

             a.method2(); // fu

             b.method2(); // zi

             c.method2(); // zi

            a.method3();  //fu

            b.method3();  //zi

            c.method3();  //zi

      }

}

用于实例接口：

interface  A{

      

}

class  B  implements  A{

      

}

class  test {

      A  a  =  new  B();

} 

总结：

一。表现：
父类或者接口的引用指向了或者接收了自己的子类对象。

二。前提：
1，类与类之间要有关系。继承，实现。
2，通常都会有覆盖。

三。好处：
预先定义的程序可以运行后期程序的内容。
增强了程序的扩展性。

四。弊端：
虽然可以预先使用，但是只能访问父类中已有的功能，运行的是后期子类的功能内容。
不能预先使用子类中定义的特有功能。

五。多态的注意事项：
在代码中。
对于成员函数：Fu f = new Zi(); f.method();
编译时期：看左边。
运行时期：看右边。
因为成员函数有一个覆盖操作。
     毕姥爷和毕老师的故事。

    
对于非私有的实例变量，
静态变量，静态方法。

编译和运行都看左边。

老师要求记住结论。有空闲时间，就想想为什么？

六。转型。
子类对象被父类引用：子类对象在向上转型。
将指向子类对象的父类应用转换成子类类型引用：向下转型。

毕姥爷和毕老师的故事。
class 毕姥爷
{}

class 毕老师 extends 毕姥爷
{}

毕姥爷 ly = new 毕老师();//毕老师向上转型为了毕姥爷。向上转型

毕老师 ls = (毕老师)ly; //将代表毕老师对象的父类引用ly强制转换成了毕老师类型。向下转型。



七。应用
电脑使用。主板运行。

class MainBoard
{
     public void run()
     {
          //主板运行;
     }
     public void usePCI(PCI p)//PCI p = new NetCard();
     {
          if(p!=null)
          {
               p.open();
               p.close();
          }
     }
}


//为了提高主板功能的扩展性。
//定义了规则。让后期的出现的功能板块，只要覆盖该规则，就可以被这个主板使用。
interface PCI
{
     void open();
     void close();
}




class MainDemo
{
     public static void main(String[] args)
     {
          MainBoard mb = new MainBoard();
          mb.run();
          mb.usePCI(null);
          mb.usePCI(new NetCard());



     }
}


class NetCard implements PCI
{
     public void open(){}
     public void close(){}
}


Object:是java中所有对象的直接或者间接的父类。
     它里面的方法都所有对象都具备的。
     常见方法：
     boolean equals(Object obj):用于比较两个对象是否相同。
     String toString(): 获取对象的字符串表现形式 类名@哈希值 
          getClass().getName()+"@"+Integer.toHexString(hashCode());
     Class getClass():获取正在运行的对象所属的字节码文件的对象。也就是说如果Demo d = new Demo();
                    d.getClass():获取的就是d执行的对象所属的字节码文件Demo.class对象。
    
     通常在自定义对象时，因为对象中都有自己特有的描述，
     所以都会建立对象自身的特有比较方法，或者字符串表现形式。
     也就是说，会覆盖Object中的方法。

---

  ASP.Net+Android+IO开发 、 .Net培训 、期待与您交流！