• JavaSE复习日记 : 多态


    /**
     *  里氏替换原则 : 
     *      能使用父类的地方,一定可以使用子类
     *  什么是多态 : 
     *          父类的引用,指向子类的对象
     *  多态的前提条件 : 
     *          有继承关系的两个类
     *  多态的目的 : 
     *        ☆☆☆  代码的重用
     *  多态发什么在什么时候 : 
     *          赋值的时候
     *  
     * !!!!!!!!! 多态中的 ☆☆☆  覆写 是特指的 成员方法!!!!!!!!!
     *  什么是覆写 : 
     *          就是在子类有个和父类相同的方法 : 方法名 , 参数列表 , 返回值类型 (和修饰符列表没关系)
     *              1 方法名相同 : 不相同,就是两个不一样的方法了  不是覆写
     *              2 参数列表相同 : 参数列表不同,就是方法的重载了,也不是覆写
     *                               参数列表的 个数 和 数据类型 都相同 才叫相同吧
     *              3 返回值类型相同 ; 返回值代表函数(方法)的功能,覆写是为了功能更强大,不能降低功能,所以必须相同
     *          覆写之后 不能比原有的方法有更低的访问权限 ( 权限的降低 就意味着 功能的降低 )
     *          覆写之后 不能比原有的方法有更宽泛的异常 ( 只能异常越来越低 )
     *
     *!!!!! ☆☆☆ 父类的属性列表是在编译的时候就生成了 : 就是javac的时候☆☆☆ 
     *!!!!! ☆☆☆ 子类的属性列表是在运行时才生成 : 就是java运行的时候☆☆☆ 
     *
     *  父类和子类的调用有两种形式 : 
     *          1 多态 父类引用指向子类的对象  父类型 变量名 = new 子类构造方法();
     *              静态变量,静态方法,成员变量 :
     *                                         当这样用引用变量名去调用方法或者变量时 , 先去父类找,如果有这个变量(方法).就会直接执行,不会再去子类中找,如果父类没有这个变量(方法),直接报错( 错误 : 找不到符号 ),不会去子类中找,因为现在子类的属性列表还没有,现在是编译期报错,所以没法去子类找
     *              成员方法 : 
     *                       当调用成员方法的时候,先去父类中找,父类如果有,再去子类中找,如果子类覆写了成员方法,就执行子类的成员方法,如果子类没有覆写,就还执行父类的,但是如果父类没有的成员方法,但是子类有,直接报错( 错误 : 找不到符号 ),不会去子类找(不会执行子类特有的成员方法),因为子类现在还没有属性列表,现在只是在编译期报错.
     *          2 直接实例化  子类型 变量名 = new 子类构造方法();
     *              静态变量,静态方法,成员变量 :
     *                                         先去子类找,如果子类有这个变量(方法),就执行,不会再去父类找,如果子类没有这个变量(方法),就会去父类找,执行父类,但是如果子类和父类都没有,就报错( 错误 : 找不到符号 )
     *              成员方法 : 
     *                       如果子类有,父类也有,就按子类的执行,那是方法的覆写  ,如果子类没有,就去父类找,执行父类的,如果子类有,父类没有,就执行子类的(用于执行子类特有的方法,是父类没有的),如果都没有,就报错( 错误 : 找不到符号 )
     *
     */
    public class Duo_Tai{
        public static void main(String[] args){
            //第一种 多态 父类引用 指向子类的对象
            Fu_Lei f = new Zi_Lei();
    
             //--------------------变量------------------------------
    
                //父类有的 子类没有的 静态变量 
                int i = f.i;
                System.out.println( i ); // 输出100  是 父类的 静态变量
    
                //父类有的 子类也有的 静态变量
                int a = f.a; //这里的两个变量 不会冲突 因为前面那个int a 是局部变量  后面那个f.a 是类中的静态变量 
                System.out.println( a ); //输出1  是 父类的 静态变量 为什么输出的不是子类的 111
    
                //父类有的 子类没有的 成员变量
                int j = f.j;
                System.out.println( j );//输出200 是 父类的 成员变量
    
                //父类有的 子类也有的 成员变量
                int b = f.b;
                System.out.println( b );//输出2 是 父类的 成员变量 为什么输出的不是子类的 2222
                /*
                //父类没有 子类有的 静态变量  为什么?为什么不去调用子类的?
               int m = f.m;  //Duo_Tai.java:48: 错误: 找不到符号
                System.out.println( m );
    
                //父类没有 子类有的 成员变量  为什么?为什么不去调用子类的?
                int n = f.n;  //Duo_Tai.java:52: 错误: 找不到符号
                System.out.println( n );
                */
            //--------------------方法------------------------------
    
                //父类有的 子类没有的 静态方法
                    f.m6();  //输出 父类的 静态方法
    
                //父类有的 子类也有的 静态方法
                    f.m3();  //输出 父类的 静态方法
    
                //父类有的 子类没有的 成员方法
                    f.m2();  //输出 父类的 成员方法
    
                //父类有的 子类也有的 成员方法
                    f.m1();  //输出 父类的 成员方法
                /*
                //父类没有 子类有的 静态方法   为什么报错?为什么不去调用子类的?
                    f.m5();  //Duo_Tai.java:68: 错误: 找不到符号
    
                //父类没有 子类有的 成员方法   为什么报错?为什么不去调用子类的?
                    f.m4();  //Duo_Tai.java:71: 错误: 找不到符号
                */
    //----------------------------------------------------------------------           
    
            //第二种 直接实例化多态 子类引用 是子类的对象
            Zi_Lei z = new Zi_Lei();
    
             //--------------------变量------------------------------
    
                //父类有的 子类没有的 静态变量
                    int i1 = z.i;  // 输出 父类 的 静态变量
                    System.out.println( i1 ); // 为什么子类没有 不会报错?而是去调用父类的
    
                //父类有的 子类也有的 静态变量
                    int a1 = z.a;  // 输出 子类 的 静态变量
                    System.out.println( a1 );
    
                //父类有的 子类没有的 成员变量
                    int j1 = z.j;  // 输出 父类 的 成员变量
                    System.out.println( j1 );
    
                //父类有的 子类也有的 成员变量
                    int b1 = z.b;  // 输出 子类 的 成员变量
                    System.out.println( b1 );
                //父类没有 子类有的 静态变量
                    int m1 = z.m;  // 输出 子类 的 静态变量
                    System.out.println( m1 ); //为什么父类没有 不会报错?
    
                //父类没有 子类有的 成员变量
                    int n1 = z.n;  // 输出 子类 的 成员变量
                    System.out.println( n1 );
    
            //--------------------方法------------------------------
    
                //父类有的 子类没有的 静态方法
                    z.m6();  //输出 父类的 静态方法 为什么没有报错?而且去调用父类的了静态方法
    
                //父类有的 子类也有的 静态方法
                    z.m3();  //输出 子类的 静态方法
    
                //父类有的 子类没有的 成员方法
                    z.m2();  // 输出 父类的 成员方法 为什么没有报错?而且去调用父类的成员方法
    
                //父类有的 子类也有的 成员方法
                    z.m1();  //输出 子类的 成员方法 为什么?!!!!☆☆☆ 
    
                //父类没有 子类有的 静态方法
                    z.m5();  //输出 子类的 静态方法
    
                //父类没有 子类有的 成员方法
                    z.m4();  //输出 子类的 成员方法
        }
    }
    class Fu_Lei{//声明一个父类
        static int i = 100;//静态变量 父类的 子类没有的
    
        static int a = 1;//静态变量 子类也有的
    
        int j = 200;//成员变量 父类的 子类没有的
    
        int b = 2;//父类的 子类也有的
    
        public void m1(){//被覆写的成员变量(子类有的)
            System.out.println( "我是父类的成员方法," );
        }
        public void m2(){//没有被覆写的成员变量 (子类没有的)
            System.out.println( "我是父类的成员方法,没有被覆写的" );
        }
        public static void m3(){//静态方法 子类也有
            System.out.println( "我是父类的静态变量" );
        }
        public static void m6(){//子类没有的静态方法
            System.out.println( "子类没有的静态方法" );
        }
    }
    
    class Zi_Lei extends Fu_Lei{//声明一个子类  继承( extends )父类
    
        static int m = 3;//父类没有的静态变量
    
        int n = 8;//父类没有的成员变量
    
        static int a = 111;//父类也有的
    
        int b = 2222;//父类也有的
    
        public void m1(){//父类有的成员方法
             System.out.println( "我是子类,我覆写了父类的m1()成员方法" );
        }
        public void m4(){//父类没有的成员方法
             System.out.println( "我是子类,我这个方法,父类没有,是我自己的" );
        }
        public static void m3(){//父类有的静态方法
             System.out.println( "我是子类的静态方法,父类也有哦" );
        }
        public static void m5(){//父类没有的静态方法
             System.out.println( "我是子类的静态方法 , 父类没有," );
        }
    }
  • 相关阅读:
    OpenCV2.4.4 图像旋转和缩放
    Python+OpenCV:图片无损旋转90°且无黑边的处理方法
    python 怎样去除图片中的多余物体
    goland 无法解析符号
    go mod init 报错
    比较有用的
    Gorm 学习笔记
    Gorm 更新 0 值
    Java Lambda 表达式,Java Lambda 函数接口
    Java 单例模式,Java Singleton单例模式
  • 原文地址:https://www.cnblogs.com/yizhimichong/p/4779532.html
Copyright © 2020-2023  润新知