面向对象的简单理解三

发布时间：2024-03-25 00:50:57 来源：互联网

.

对象的多态性：方法的重载，根据方法传入参数的不同，而调用的不同对象的多态性建议永远不要继承一个普通类。对象多态性是对继承的扩展，所以程序必须先有继承关系才

对象的多态性：

方法的重载，根据方法传入参数的不同，而调用的不同

对象的多态性
建议永远不要继承一个普通类。
对象多态性是对继承的扩展，所以程序必须先有继承关系才能使用多态性
如果一个方法被覆写了，则子类与父类之间发生转换时，调用的是子类中覆写的方法。

Code
class A
{
    public void fun1()
    {
        System.out.println("1、A --> public void fun1()") ;
    }
    public void fun2()
    {
        this.fun1() ;
    }
};
class B extends A
{
    // 覆写了fun1()方法
    public void fun1()
    {
        System.out.println("2、B --> public void fun1()") ;
    }
    // 增加了一个fun3()方法
    public void fun3()
    {
        System.out.println("3、B --> public void fun3()") ;
    }
};
public class OODemo01
{
    public static void main(String args[])
    {

　　　// a是A型的，子类对象为父类实例化,向上转型，子类对象向父类对象转型
　　　A a = null ;
        a = new B() ;
　　　　
        // fun1方法被子类覆写了

            B b = null ;
              b = (B)a ;(向下转型，父类为子类实例化)
        a.fun2() ;
　　　//输出的是B的fun1方法
        a.fun3() ;//已经转型的a类对象已经不能访问fun3方法了，主要是a是又A定义的是属于A类的
        // b.fun2() ;
    }
};

子类对象向父类对象的转换（向上）

　　　　　　父类对象=子类对象（自动）如：A a=null;a=new B();

父类对象向子类转换（向下）

　　　　　　子类对象=（子类）父类对象（强制）　

Code
public class OODemo02
{
    public static void main(String args[])
    {
        A a = new A() ;
        a.fun2() ;
        B b = (B)a ;
　　//此会产生类转换异常ClassCastException,上面的不会发生是
　　//因为 A a = null ;
        //a = new B() ;子类先为父类实例化，子类extends父类当然知道父类是谁了，这样A知道有B这个子类了，才能进行向下转型
       //但在A a = new A() ;
        //a.fun2() ;
       // B b = (B)a ;之中父类并不知道和子类的关系
    }
};

　两个常见错误：ClassCastException(两个对象之间没有任何关系而进行的转换),NullPointException
对象多态性的用处

Code
class A
{
    public void fun1()
    {
        System.out.println("1、A --> public void fun1()") ;
    }
    public void fun2()
    {
        this.fun1() ;
    }
};
class B extends A
{
    // 覆写了fun1()方法
    public void fun1()
    {
        System.out.println("2、B --> public void fun1()") ;
    }
    // 增加了一个fun3()方法
    public void fun3()
    {
        System.out.println("3、B --> public void fun3()") ;
    }
};
class C extends A
{
    // 覆写了fun1()方法
    public void fun1()
    {
        System.out.println("4、C --> public void fun1()") ;
    }
    // 增加了一个fun3()方法
    public void fun4()
    {
        System.out.println("5、C --> public void fun4()") ;
    }
};
public class OODemo03
{
    public static void main(String args[])
    {
        // 对象都态性到底该怎么用？
        // 一个print方法，此方法可以接收A和B类的对象，并调用方法打印
        // 如果是A类对象，则调用fun2()方法
        // 如果是B类对象，则调用fun2()和fun3()两个方法
        print(new C()) ;
        // 如果A类还有20个子类，会怎么样？
        // 则此方法还要再写20遍
    }
    public static void print(A a)
//对此程序的理解传的是new C(),传给 A a 即相当于 A a=new C(),这样就是向上转型了，A知道了和子类的关系，因//为用new实例化了再判断是谁的实例，再进行向下转型，这样就可调用各自的方法了。
    {
        a.fun2() ;
        // 缺少一个对象是否是某一个类的实例的判断
        if(a instanceof B)
        {　　
            B b = (B)a ;
            b.fun3() ;
        }
        if(a instanceof C)
        {
            C c = (C)a ;
            c.fun4() ;
        }
    }

};