A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© keys 中级黑马   /  2015-3-28 00:36  /  612 人查看  /  2 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

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

例如:
人:男人,女人

动物:猫,狗

猫 x = new 猫();

动物 x = new 猫();

1.多态的体现
父类的引用指向了自己的子类对象。
父类的引用也可以接受自己的对象。

2.多态的前提
(1)必须是类与类之间有关系,要么继承,要么实现
(2)通常存在覆盖
3.多态的好处
多态的出现大大的提高了程序的扩展性。

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

5.多态的应用

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

class Animal{
        abstract void eat();
}

class Cat extends Animal{
        public void eat(){
                system.out.prinln("吃鱼");
        }
       
        public void catchMouse(){
                system.out.prinln("抓老鼠");
        }
}

class Dog extends Animal{
        public void eat(){
                system.out.prinln("吃骨头");
        }
       
        public void kanJia(){
                system.out.prinln("看门");
        }
}

class Pig extends Animal{
        public void eat(){
                system.out.prinln("饲料");
        }
        public void gongDi(){
                system.out.prinln("gongDi");
        }
}

class DuoTaiDemo{
        public static void main(String[] args){
                //Cat c = new Cat();
                //c.eat();
               
        //        Dog d = new Dog();
                //d.eat();       
                /*Cat c = new Cat();
                Cat c1 = new Cat();
                function(c1);*/
               
                ///Animal c = new Cat();
                //c.eat();
               
                function(new Cat());
                function(new Dog());
                function(new Pig());
        }
       
        public static void function(Animal a){
                a.eat();
        }
}

二、多态的转型

class Animal{
        abstract void eat();
}

class Cat extends Animal{
        public void eat(){
                system.out.prinln("吃鱼");
        }
       
        public void catchMouse(){
                system.out.prinln("抓老鼠");
        }
}

class Dog extends Animal{
        public void eat(){
                system.out.prinln("吃骨头");
        }
       
        public void kanJia(){
                system.out.prinln("看门");
        }
}

class Pig extends Animal{
        public void eat(){
                system.out.prinln("饲料");
        }
        public void gongDi(){
                system.out.prinln("gongDi");
        }
}

class DuoTaiDemo{
        public static void main(String[] args){
                Animal a = new Cat();//类型提升,向上转型。
                a.eat();
                //如果想要调用猫的特有方法时,如何操作?
                //强制将父类的引用,转成子类类型,向下转型。
                Cat c = (Cat)a;
                c.catchMouse();
                //千万不要出现这样的操作,就是将父类对象转成子类类型。
                //我们能转换的是父类应用指向了自己的子类对象时,该应用可以被提升,也可以
                //被强制转换
                //Animal a = new Animal(); //这种写法就不对了,不能强制把动物转成猫
                //Cat c=(Cat)a;
               
               
        }
       
        public static void function(Animal a){
                a.eat();
        }
}

三、多态示例

基础班学生:
        学习,睡觉。
高级班学生:
        学习,睡觉。
可以将这两类事物进行抽取

abstract class Student{
        public abstract void study();
        public void sleep(){
                System.out.println("躺着睡");
        }
}

class BaseStudent extends Student{
        public void study(){
                System.out.println("study");
        }
        public void sleep(){
                System.out.println("裸睡");
        }
}

class AdvStudent extends Student{
        public void study(){
                System.out.println("adv study");
        }
}

class DoStudent{
        public void doSomething(Student stu){
                stu.study();
                stu.sleep();
        }
}

class DuoTaiDemo3{
        public static void main(String[] args){
       
                DoStudent ds = new DoStudent();
                ds.doSomething(new BaseStudent());
                ds.doSomething(new AdvStudent());
               
               
                //BaseStudent ba = new BaseStudent();
                //ba.study();
                //ba.sleep();
               
                //AvdStudent as = new AvdStudent();
                //as.study();
                //as.sleep();
        }
       
       
}

四:多态中成员(函数与变量)的特点
1.
class Fu{
        void method1(){
                System.out.println("fu method_1");
        }
        void method2(){
                System.out.println("fu method_2");
        }
}

class Zi extends Fu{
        void method1(){
                System.out.println("zi method_1");
        }
        void method3(){
                System.out.println("zi method_3");
        }
}

class Test{
        public static void main(String[] args) {
                Zi z = new Zi();
                z.method1();
                z.method2();
                z.method3();
        }
       
}

//打印结果:
zi method_1
fu method_2
zi method_3

分析:Zi复写了Fu的method1,把Fu的method2继承过来,method3是特有的

2.在多态中成员函数的特点

class Fu{
        void method1(){
                System.out.println("fu method_1");
        }
        void method2(){
                System.out.println("fu method_2");
        }
}

class Zi extends Fu{
        void method1(){
                System.out.println("zi method_1");
        }
        void method3(){
                System.out.println("zi method_3");
        }
}

class Test{
        public static void main(String[] args) {
                Fu f = new Zi();
                f.method1();
                f.method2();
                //f.method3(); //这样编译会出错
        }
       
}

//打印结果:
zi method_1
fu method_2

在多态中成员函数的特点:
在编译时期:参与引用型变量所属的类中是否有调用的方法,如果有,编译通过,
如果没有编译失败。例如:f这个引用型变量中有method1和method2,但没有method3,编译失败

在运行时期:参阅对象所属的类中是否有调用的方法。
简单总结:成员函数在多态调用时,编译看左边,运行看右边。
编译看左边:因为f这个引用型变量中有method1和method2,但没有method3,编译失败
运行看右边:Zi类中有method1,method2从Fu中继承了过来,所以运行结果为:
zi method_1
fu method_2


3.多态中成员变量的特点:
(1)
class Fu{
        int num = 5;
        void method1(){
                System.out.println("fu method_1");
        }
        void method2(){
                System.out.println("fu method_2");
        }
        static void method4(){
                System.out.println("fu method_4");
        }
}

class Zi extends Fu{
        int num = 8;
        void method1(){
                System.out.println("zi method_1");
        }
        void method3(){
                System.out.println("zi method_3");
        }
        static void method4(){
                System.out.println("zi method_4");
        }
}

class Test{
        public static void main(String[] args) {
                Fu f = new Zi();
                f.method4();
        }
       
}

//打印结果:
fu method_4

在多态中,静态成员函数的特点:
无论编译和运行,都参考左边。



(2)class Fu{
        int num = 5;
        void method1(){
                System.out.println("fu method_1");
        }
        void method2(){
                System.out.println("fu method_2");
        }
        static void method4(){
                System.out.println("fu method_4");
        }
}

class Zi extends Fu{
        int num = 8;
        void method1(){
                System.out.println("zi method_1");
        }
        void method3(){
                System.out.println("zi method_3");
        }
        static void method4(){
                System.out.println("zi method_4");
        }
}

class Test{
        public static void main(String[] args) {
                Fu f = new Zi();
                System.out.println(f.num);
        }
       
}
//打印结果:5
在多态中,成员变量的特点:
无论编译和运行,都参考左边(引用型变量所属的类)

2 个回复

倒序浏览
坚持总结!
回复 使用道具 举报
!~~~~~~~~~!
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马