多态,面向对象

/**
 *  里氏替换原则 :
 *      能使用父类的地方,一定可以使用子类
 *  什么是多态 :
 *          父类的引用,指向子类的对象
 *  多态的前提条件 :
 *          有继承关系的两个类
 *  多态的目的 :
 *        ☆☆☆  代码的重用
 *  多态发什么在什么时候 :
 *          赋值的时候
 *  
 * !!!!!!!!! 多态中的 ☆☆☆  覆写 是特指的 成员方法!!!!!!!!!
 *  什么是覆写 :
 *          就是在子类有个和父类相同的方法 : 方法名 , 参数列表 , 返回值类型 (和修饰符列表没关系)
 *              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( "我是子类的静态方法 , 父类没有," );
    }
}

时间: 2024-10-09 04:49:29

多态,面向对象的相关文章

面向对象【day07】:多态-面向对象使用场景--知识点回顾

本节内容 多态 面向对象使用场景 知识点回顾 一.多态 一.概述 多态性(polymorphisn)是允许你将父对象设置成为和一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作.简单的说,就是一句话:允许将子类类型的指针赋值给父类类型的指针. 那么,多态的作用是什么呢?我们知道,封装可以隐藏实现细节,使得代码模块化:继承可以扩展已存在的代码模块(类):它们的目的都是为了--代码重用.而多态则是为了实现另一个目的--接口重用!多态的作用,就是为了

python的面向对象的特性(继承、封装、多态)

创建自已对象就python非常核心的概念,事实上,python被称为面向对象语言,本章会介绍如何创建对象.以及面向对象的概念:继承.封装.多态. 多态: 可对不同类的对象使用同样的操作. 封装:对外部世界隐藏对象的工作细节. 继承:以普通的类为基础建立专门的类对象. 多态 面向对象程序设计最有趣的特性是多太,它是是让大多数人犯晕的特性.所以,先来介绍这个. 多态意思是"有多种形式".多态意味着就算不知道变量所引用的对象类是什么,还是能对它进行操作,而它也会根据对象(或类)类型的不同而表

初识JAVA(【面向对象】:pub/fri/pro/pri、封装/继承/多态、接口/抽象类、静态方法和抽象方法;泛型、垃圾回收机制、反射和RTTI)

JAVA特点: 语法简单,学习容易 功能强大,适合各种应用开发:J2SE/J2ME/J2EE 面向对象,易扩展,易维护 容错机制好,在内存不够时仍能不崩溃.不死机 强大的网络应用功能 跨平台:JVM,字节码 两个命令: javac helloworld.java:将Java文件编译为字节码的.class文件 java helloworld:运行Java程序...??暂时这么认为 数据类型: 普通数据类型:int a=3; 对象数据类型:使用关键字new,String s=new String("

面向对象封装、继承、多态

一.面向对象封装 01. 封装 封装 是面向对象编程的一大特点 面向对象编程的 第一步 —— 将 属性 和 方法 封装 到一个抽象的 类 中 外界 使用 类 创建 对象,然后 让对象调用方法 对象方法的细节 都被 封装 在 类的内部 02. 小明跑步案例 需求: 小明 体重 50公斤 小明每次 跑步 会减肥 1公斤 小明每次 吃东西 体重增加 0.5 公斤 class Person(object): def __init__(self, name, weight): self.name = na

面向对象的5个基本设计原则

面向对象的3个基本要素:封装.继承.多态 面向对象的5个基本设计原则: 单一职责原则(Single-Resposibility Principle) 其核心思想为:一个类,最好仅仅做一件事,仅仅有一个引起它的变化.单一职责原则能够看做是低耦合.高内聚在面向对象原则上的引申,将职责定义为引起变化的原因,以提高内聚性来降低引起变化的原因.职责过多,可能引起它变化的原因就越多,这将导致职责依赖,相互之间就产生影响,从而大大损伤其内聚性和耦合度.通常意义下的单一职责,就是指仅仅有一种单一功能,不要为类实

Java继承,多态,组合应用

继承:  面向对象的三大特征之一:    是类和类之间的一种拓展关系,是一种从一般到特殊的关系;    格式: sub   extends Super,  我们把sub称为子类或者拓展类, 把super称为父类或者基类(超类)   泛化: 把子类中的共性抽取到父类的过程; 特化: 子类在父类的基础之上,拓展自己特有的状态和特征;    Object: 是所有类的直接父类后间接父类;      class  Student{} 等价于  class  Student extends Object{

python学习笔记-Day8 上(pickle补充、字段、面向对象成员、成员修饰符、特殊方法)

pickle 序列化补充 # pickle load # 现在有两个python程序,调用关系如下 # s1.py class foo: …. Obj = foo(x,y) Pickle.dump(obj, open(‘db’,’wb’)) S2.py # s2.py from s1 import foo pickle.load(db) # s2.py 反序列化加载包含对象,一定要先导入对象对应的类,否则Pickle load将会报错 类多继承关系 有共同父类的继承关系如下 如图,如果我们有两个

05面向对象基础

总结一下这两天的学习笔记,正所谓温故而知新嘛,希望能够更好的学习后面的新知识 1.面向对象概念面向对象三大特征:封装.继承.多态 2.类对象是引用传递把一个对象传递到方法中,传递的也是这个对象本身的引用,修改这个对象会影响外面的对象 3.null表示变量没有指向任何对象值类型(ValueType):数值类型(int.long.double等).boolean等基本类型,枚举.结构体的值是复制传递,不能为null;String不是值类型 4.局部变量和成员变量(1)局部变量必须初始化,成员变量声明

Java实验二实验报告:java面向对象程序设计

java实验二实验报告 实验内容 1. 初步掌握单元测试和TDD 2. 理解并掌握面向对象三要素:封装.继承.多态 3. 初步掌握UML建模 4. 熟悉S.O.L.I.D原则 5. 了解设计模式 实验要求 1.没有Linux基础的同学建议先学习<Linux基础入门(新版)><Vim编辑器> 课程 2.完成实验.撰写实验报告,实验报告以博客方式发表在博客园,注意实验报告重点是运行结果,遇到的问题(工具查找,安装,使用,程序的编辑,调试,运行等).解决办法(空洞的方法如“查网络”.“问