面向对象（多态）

                                                    面向对象（多态——概述）

对象的多态性

class  动物

{}

class 猫  extends  动物

{}

class  狗  extends  动物

{}

 猫    x=new   猫（）；

动物  x = new  猫（）；//一个对象，两种形态

猫这类事物具备者猫的形态，又具备着动物的形态。

这就是对象的多态性

简单说：就是一个对象，对应着不同类型

多态在代码中的体现：

            父类或者接口的引用指向其子类的对象。

多态的好处：

        提高了代码的扩展性，前期定义的代码可以使用后期的内容。

多态的弊端：

         前期定义的内容不能使用(调用)后期子类特有内容

多态的前提:

        1,必须有关系，继承，实现

        2，要覆盖。

abstract  class  Animal{

        abstract  void  eat();

}

class  Dog   extends Animal{

        void  eat()//吃的功能

        {

                System.out.println("啃骨头")；

        }

        void lookHome()//看家的功能

}

class  Cat  extends  Animal{

        void eat(){

                System.out.println("吃鱼")；

        }

        void  catchMouse(){

                System.out.println("抓老鼠");

        }

}

class  DuoTaiDemo{

        public static void main(String[] args){

                Cat  c=new  Cat();

                Dog  d=new  Dog();

                method(c);

                method(d);

        }

        public static void method(Animal  a){

                a.eat();

        }

}

                                                        面向对象（多态＿转型）

abstract  class  Animal{

        abstract  void  eat();

}

class  Cat  extends  Animal{

        void  eat(){

                System.out.println("吃鱼");

        }

        void  acthMouse(){

                System.out.println("抓老鼠");

        }

}

class  DuotaiDemo1{

        public static void main(String[] args)

        {

                animal  a=new  Car();//自动类型提升，猫对象提供了动物类型，但是特有功能无法访问。

                                                    //作用就是限制对特有功能的访问。  专业讲：向上转型，   

                 a.eat();                                   //将子类型隐藏，就不用使用子类的特有方法。

                 

                //如果想用具体动物猫的特有功能。

             //你可以将该对象进行向下转型。

                Car   c=new  Car();//向下转型的目的是为了使用类中的特有方法

                c.eat();

                c.cathMouse();

                //Aminal  a1=new  Dog();//注意：对于转型，自始至终都是子类对象在做着类型的变化。

                //Car  c1=(car)a1;//ClassCastException这个是编译异常

            }

            public static void method(Animal  a){

                    a.eat();

            }

}注：Object（上帝的意思）权限最大

                                                            面向对象（多态——类型判断）

abstract  class  Animal{

        abstract   void  eat();

}

class  Dog  extends  Animal{

        void eat(){

                System.out.println("啃骨头");

        }

        void  lookHome(){

                System.out.println("看家");

        }

}

class  Cat  extends  Animal{

        void  eat(){

                System.out.println("吃鱼");

        }

        void catchMouse(){

                System.out.println("抓老鼠");

        }

}

class  DuoTaiDemo2{

        public static void main(String[] args){

                Animal  a=new  Animal();

                method(new  Cat());

        }

        public static void method(Animal   a){

                a.eat();

                if(a  instanceof  Cat)

        }//instanceof:用于判断对象的具体类型，只能用于引用数据判断

}        

//通常在向下转型前用于健壮性的判断

{

        Cat  c=(Cat)a;

        c.catchMouse();

}

else if(a  instanceof  Dog)

{

        Dog  d=(Dog)a;

        d.lookHome();

}

                                                        面向对象（多态——成员变量）

多态时，

成员的特点：

1，成员变量。

        编译时：参考引用型变量所属的类中的是否有调用的成员变量，有，编译通过，没有，编译失败。

        运行时：参考引用型变量所属的类中的是否有调用的成员变量，并运行该所属类中的成员变量。

        简单说：编译和运行都参考等号的左边。

2，成员函数（非静态）

        编译时：参考引用型变量所属的类中的是否有调用的成员变量，有，编译通过，没有，编译失败。

        运行时：参考的是对象所属的类中是否有调用的函数。

        简单说，编译看左边，运行看右边。

例：1和2一起

class Fu{

        //int  num=3;成员变量

        void  show()//成员函数

        {

                System.out.println("fu  show");//成员函数

        }

}

class    Zi  extends  Fu{

        //int  num=4;//成员变量

        void  show()//成员函数

        {

                System.out.println("zi  show");//成员函数

        }

}

class  DuoTaiDemo3{

        public static void main(String[] args){

                Fu f=new  Zi();//成员和函数共用一个对象

                f.show();//成员函数

                //System.out.println(f.num);//成员变量

        }

}

3，静态函数

        编译时：参考引用型变量所属的类中的是否有调用的静态方法。

        运行时：参考引用型变量所属的类中的是否有调用的静态方法。

        简单说，编译和运行都看左边。

其实对于静态方法，是不需要对象的，直接用类名调用即可。

例：

class  Fu{

        static void method(){

                System.out.println("fu  static method");

        }

}

class  Zi  extends  Fu  method{

        static void method(){

                System.out.println("zi  static  method");

        }

}

class  DuoTaiDemo5{

        public static void main(String[] args){

                Fu.method();

                Zi.method();

                Fu  f=new  Zi();

        }

}

                                                    面向对象（多态——概述）

对象的多态性

class  动物

{}

class 猫  extends  动物

{}

class  狗  extends  动物

{}

 猫    x=new   猫（）；

动物  x = new  猫（）；//一个对象，两种形态

猫这类事物具备者猫的形态，又具备着动物的形态。

这就是对象的多态性

简单说：就是一个对象，对应着不同类型

多态在代码中的体现：

            父类或者接口的引用指向其子类的对象。

多态的好处：

        提高了代码的扩展性，前期定义的代码可以使用后期的内容。

多态的弊端：

         前期定义的内容不能使用(调用)后期子类特有内容

多态的前提:

        1,必须有关系，继承，实现

        2，要覆盖。

abstract  class  Animal{

        abstract  void  eat();

}

class  Dog   extends Animal{

        void  eat()//吃的功能

        {

                System.out.println("啃骨头")；

        }

        void lookHome()//看家的功能

}

class  Cat  extends  Animal{

        void eat(){

                System.out.println("吃鱼")；

        }

        void  catchMouse(){

                System.out.println("抓老鼠");

        }

}

class  DuoTaiDemo{

        public static void main(String[] args){

                Cat  c=new  Cat();

                Dog  d=new  Dog();

                method(c);

                method(d);

        }

        public static void method(Animal  a){

                a.eat();

        }

}

                                                        面向对象（多态＿转型）

abstract  class  Animal{

        abstract  void  eat();

}

class  Cat  extends  Animal{

        void  eat(){

                System.out.println("吃鱼");

        }

        void  acthMouse(){

                System.out.println("抓老鼠");

        }

}

class  DuotaiDemo1{

        public static void main(String[] args)

        {

                animal  a=new  Car();//自动类型提升，猫对象提供了动物类型，但是特有功能无法访问。

                                                    //作用就是限制对特有功能的访问。  专业讲：向上转型，   

                 a.eat();                                   //将子类型隐藏，就不用使用子类的特有方法。

                 

                //如果想用具体动物猫的特有功能。

             //你可以将该对象进行向下转型。

                Car   c=new  Car();//向下转型的目的是为了使用类中的特有方法

                c.eat();

                c.cathMouse();

                //Aminal  a1=new  Dog();//注意：对于转型，自始至终都是子类对象在做着类型的变化。

                //Car  c1=(car)a1;//ClassCastException这个是编译异常

            }

            public static void method(Animal  a){

                    a.eat();

            }

}注：Object（上帝的意思）权限最大

                                                            面向对象（多态——类型判断）

abstract  class  Animal{

        abstract   void  eat();

}

class  Dog  extends  Animal{

        void eat(){

                System.out.println("啃骨头");

        }

        void  lookHome(){

                System.out.println("看家");

        }

}

class  Cat  extends  Animal{

        void  eat(){

                System.out.println("吃鱼");

        }

        void catchMouse(){

                System.out.println("抓老鼠");

        }

}

class  DuoTaiDemo2{

        public static void main(String[] args){

                Animal  a=new  Animal();

                method(new  Cat());

        }

        public static void method(Animal   a){

                a.eat();

                if(a  instanceof  Cat)

        }//instanceof:用于判断对象的具体类型，只能用于引用数据判断

}        

//通常在向下转型前用于健壮性的判断

{

        Cat  c=(Cat)a;

        c.catchMouse();

}

else if(a  instanceof  Dog)

{

        Dog  d=(Dog)a;

        d.lookHome();

}

                                                        面向对象（多态——成员变量）

多态时，

成员的特点：

1，成员变量。

        编译时：参考引用型变量所属的类中的是否有调用的成员变量，有，编译通过，没有，编译失败。

        运行时：参考引用型变量所属的类中的是否有调用的成员变量，并运行该所属类中的成员变量。

        简单说：编译和运行都参考等号的左边。

2，成员函数（非静态）

        编译时：参考引用型变量所属的类中的是否有调用的成员变量，有，编译通过，没有，编译失败。

        运行时：参考的是对象所属的类中是否有调用的函数。

        简单说，编译看左边，运行看右边。

例：1和2一起

class Fu{

        //int  num=3;成员变量

        void  show()//成员函数

        {

                System.out.println("fu  show");//成员函数

        }

}

class    Zi  extends  Fu{

        //int  num=4;//成员变量

        void  show()//成员函数

        {

                System.out.println("zi  show");//成员函数

        }

}

class  DuoTaiDemo3{

        public static void main(String[] args){

                Fu f=new  Zi();//成员和函数共用一个对象

                f.show();//成员函数

                //System.out.println(f.num);//成员变量

        }

}

3，静态函数

        编译时：参考引用型变量所属的类中的是否有调用的静态方法。

        运行时：参考引用型变量所属的类中的是否有调用的静态方法。

        简单说，编译和运行都看左边。

其实对于静态方法，是不需要对象的，直接用类名调用即可。

例：

class  Fu{

        static void method(){

                System.out.println("fu  static method");

        }

}

class  Zi  extends  Fu  method{

        static void method(){

                System.out.println("zi  static  method");

        }

}

class  DuoTaiDemo5{

        public static void main(String[] args){

                Fu.method();

                Zi.method();

                Fu  f=new  Zi();

        }

}