最好给个程序示范着讲。:kiss:

以下是我做的笔记希望对你有用哦、、
多态：
　　多态的体现
　　父类的引用指向自己的子类对象；
　　父类的引用也可以接收自己的子类对象；
　　多态的前提
　　必须是类与类之间有关系，要么继承，要么实现；
　　通常有个前提：存在覆盖；
　　多态的好处
　　多态的出现提高了程序的扩展性；
　　多态的弊端
　　提高了扩展性，但是只能使用父类的引用访问父类中的成员；
　　小知识点：判断一个类型的引用是指向的对象是否符合该类型用关键字instanceof
　　如：if(a instanceof b) a为一个引用对象，b为类名；
　　转型：强制将父类的引用转成子类的对象
　　父类 f = new 子类（）；
　　1、在多态中非静态成员函数的特点：（简单总结：编译看左边，运行看右边）
　　在编译时期：参阅的引用型变量所属类中是否有调用方法，如果有编译通过，如果没有，编译        失败； 如：父类 父类引用f  = new 子类（）
　　f . method1();                //method1()为方法；
　　如果父类中含有method1()方法，则编译成功；否则失败；
　　在运行时期：参阅对象所属类中是否有调用方法；
　　运行时：调用的方法为 子类中的method1()方法；
　　2、在多态静态成员函数的特点：无论编译和运行，都参考左边；
　　3、在多态中成员变量的特点：无论在编译和运行都参考左边（引用变量所属的类）；

父类引用指向子类对象，也就是向上转型，向上转型体现了面向对象的特点，也增加了程序的扩展性。下面是我写的一个小例子，你可以看看

先定义一个父类
public class Father {
        
        public String speak(){
                return "我是父类";
        }
        
        public String teach(){
                return "我会教育子女";
        }
}
然后两个子类
public class Son extends Father{
        public String speak(){
                return "我是子类";
        }
}

public class Daughter extends Father{
        public String speak(){
                return "我是女子类";
        }
}
然后测试类
public class Text_01 {
   
    public static void main(String args[]){
            Father son = new Son();
            Father daughter = new Daughter();
            System.out.println(son.teach());
            System.out.println(son.speak());
            System.out.println(text(son));
            System.out.println(text(daughter));
            
    }
   
    public static String text(Father fa){
            return fa.speak();
    }
}

在测试类中就可以看到向上转型的特点和作用了
text（）方法传进的是Father的引用，实际上你传什么对象，它就调用谁的方法，所以这个程序的输出结果是
我会教育子女
我是子类
我是子类
我是女子类

我的理解，看是不是你需要的。

子类继承父类，所以子类就相当于有两个对象类型，一个是父类对象类型，一个是子类对象类型。
也就是说  父类能干的事，它的子类也能干。   所以子类的引用可以赋给父类。
所以：Fu f = new Zi（）；右边其实就是相当于既能代表父类类型，也能代表子类类型。

反过来，子类能干的，父类不一定能干了。

403383221 发表于 2013-4-13 08:28
父类引用指向子类对象，也就是向上转型，向上转型体现了面向对象的特点，也增加了程序的扩展性。下面是我写 ...

:kiss:  不错幺~

林声荣 发表于 2013-4-13 08:11
以下是我做的笔记希望对你有用哦、、
多态：
　　多态的体现

:handshake   我也要好好做笔记。！

黑马伍哲沂 发表于 2013-4-13 08:29
我的理解，看是不是你需要的。

子类继承父类，所以子类就相当于有两个对象类型，一个是父类对象类型，一个 ...

3Q  :handshake

父类引用指向子类对象，是多态的一种形式，就是将子类对象的堆内存地址，赋给父类引用类型的变量。
这种形式称为向上转型。向上转型是自动的。
还有另一种形式，子类引用指向父类的对象， 就是想父类对象的堆内存地址，赋给子类引用类型的变量。这种形式称为向下转型。向下转型要进行强制转换。
多态有个非常重要的特点：就是在程序编译的时候使用是引用变量的特征，程序在运行的时候，使用的是实际对象的特征。
实例：
//定义一个类，将这个类作为Son的父类。
class Father{
       //
       int age;
       //定义父类中的方法
       public void eat(){
        System.out.println("年龄大了，吃的少");
}
}

//定义一个类，将该类做为Father的子类
class Son extend Father{
        int age;
      //复写父类中的方法
        public void eat(){
        System.out.println("年龄小，吃得多");
}
}
//编写测试类

public class Test{
       public static void main(String[] args){
        //使用向上转型；
       Father fa = new Son();
        //通过fa应用变量调用eat()方法
        fa.eat();//猜猜控制台打印的是什么？程序在编译时使用的是引用变量fa的特征，绑定的是Father中的eat()方法。到了程序运行的时变成了使用对象Son的特性，绑定的是Son中的eat()方法。所以程序运行的结果是"年龄小，吃得多"。
      总结：多态的前提，要有继承关系，子类中复写父类的方法。这样才会有多态。
}
}