面向对象(继承,多态)

  • 二维数组的定义格式:
    第一种:直接给定了每一个一维数组中数组长度
    数据类型[][] 数组名称 = new 数据类型[m][n]
    第二种:给定了多少个一维数组,长度动态给定
    数据类型[][] 数组名称 = new 数据类型[m][] ;
    第三种:二维数组中直接给定元素值
    数据类型[][] 数组名称 = {{元素1,元素2},{元素1,元素2}…}
            如何遍历二维数组
                    int [][] arr = {{11,22},{33,44},{55,66}} ;
                    外层循环:控制的是二维数组长度,内存循环,一维数组长度
  • 代码块
    在Java中,{}括起来,统称为代码块
    局部代码块,构造代码块,静态代码块(随着类的加载而加载,只执行一次)
    构造代码块:在每次执行构造方法之前,优先执行构造代码块
    优先级:静态代码块>构造代码块>构造方法
        MYSQL数据库..  JDBC(Java连接数据库) 
  • 继承
    class Zi extends Fu{…}
    A. 继承的好处:
    1)提高代码的复用性
    2)提高代码的维护性
    3)它是多态的前提
    B. 继承的特点:
    继承不能多继承,只能单继承,但是可以多层继承..
    C.注意事项:
    1)子类继承父类,可以继承父类所有的东西(除过构造方法),私有的(private),不能直接 访问,所有需要提供公共的方法…
    2)不能继承构造方法,但是可以通过super()关键字去访问…
    3)子类继承父类,子类的构造方法(有参/无参)都会默认的访问父类的无参构造方法, 优先让父类的数据进行初始化.
    D. 假如:父类没有无参构造方法?会怎么样?如何解决?
    会出现编译错误;
    解决方法如下:
    1)可以提供无参构造
    2)通过super(父类的带参构造)..
    3)通过this(),通过本类的无参构造,再通过无参构造间接的去访问父类的代码带参构 造..

    E.成员变量,
    1) 如果子类继承父类,子类中的成员变量和父类中的成员变量名称不一致,分别输出
    2)名称一致的情况:先在子类的局部位置找,找到,就输出
    3)名称一致,还没有找到,到子类的成员位置找,有就输出,否则,到父类的成员位置 找,有就输出, 没有,就报错…
    F.成员方法
    子类继承父类,子类的成员方法名和父类的名一致,
    先子类中找,有就调用,没有就会到父类中调用
    方法重写:override
    方法重载:overload
    子类声明了一个和父类一模一样的方法声明,其目的是为覆盖父类的方法,完成自己 的功能…

  • 4.多态:
    同一时刻,体现出来的不同状态
    A.多态的前提:
    1)必须有继承关系
    2)必须有方法重写
    3)父类的引用指向子类对象(向上转型)

    B.多态的成员访问特点:
            构造方法:都是对对象进行初始化的
            成员变量:编译看左,运行看左
            成员方法(非静态):编译看左,运行看右(存在方法重写)
            静态的成员方法:不能算方法重写,和类有关系: 编译看左,运行看左
    C.多态的好处:
         提高代码复用性(由继承保证)
         提高代码的扩展性(由多态保证)
    D.多态的弊端:不能子类特有功能;
           解决方法:
           向下转型:将父类的引用强制转换为子类的引用
                Fu  f = new Zi() ;
           //向下转型
                Zi z= (Zi)f ;
    E. 向下转型容易出现的问题:
              使用不当-ClassCastException:类转换异常
                    解决方案:自己分析,内存的指向问题…          

    5.抽象类
    A.抽象类:(抽象类有抽象类多态的形式。。)
    将类中的功能抽象化,类变成抽象类
    关键字:abstract
    抽象类的特点:不能实例化 -不能创建对象
    抽象了的子类是具体类才是研究课题:由于具体类所有抽象类通过他子类进行实例化
    B.抽象类的成员特点:
    成员变量:可以是常量,也可以是变量
    构造方法:有参/无参
    成员方法:可以是抽象的,也可以是非抽象的
    (有抽象方法的类一定是抽象类,抽象类中不一定有抽象方法)

    6.接口
    A. 接口:
    给一些类提供一些额外的功能(扩展功能),定义接口
    关键字:interface
    class 子实现类(后面加impl,做到见名知意) implements(实现) 接口{.......}
    B.接口中的成员特点:
    成员变量:此变量是一个常量:public static final :默认的修饰符
    构造方法:接口没有构造方法
    成员方法:都是抽象方法

    C.抽象类和接口的区别?从三个方向去答
      1) 成员的区别
              成员变量:
                   抽象类:既可以常量,也可以是变量
                     接口:只能是常量,默认的修饰符:public static final
              构造方法:
                     抽象类:有构造方法,无参/有参 (给对象进行初始化的)
                     接口:没有构造方法
              成员方法:
                     抽象类:可以有抽象方法,也可以有非抽象方法
                     接口:只能是抽象方法 :默认的修饰符:public abstract
    
        2)类与类/类与接口关系的区别
                 类与类之间的关系:
                 继承关系,只支持单继承,不支持多继承,但是可以多层继承
            类与接口的关系:
                       实现关系,一个类继承另一个类的同时,还可以实现多个接口...
            接口与接口的关系:
                       是一种继承关系,既可以单继承,也可以多继承...
                       接口1 extends 接口2,接口3...
    
        3)设计原则的 区别
           (1)抽象类: 是有继承关系---->体现的是一种"is a"的关系   (A是B的一种或者B是A的                           一种)
           (2)接口:类和接口:实现关系--->体现的是一种" like a"的关系(扩展功能)  :跳高猫 像                       猫  
    1. 形式参数和返回值问题
      A.形式参数是引用类型的情况:
      具体类: 需要传递的是该类 对象
      抽象类:需要传递是该抽象类的子类对象
      接口:需要传递是该接口的子实现类 (还可以匿名内部类的方式)
      B.返回值的问题:
      具体类:返回该该具体类的对象
      抽象类:返回的是该抽象类的子类对象(间接的:抽象类多态…)
      接口:返回的是该接口的子实现类对象(间接:接口多态)
    2. 内部类:
      A.成员内部类和局部内部类的写法
      B.外部类访问成员内部类,局部内部类中的 成员使用的方式….
      1) 成员内部类是非静态的,外部类访问内部类的成员
      外部类名.内部类名 对象名 = 外部类对象.内部对象;
      2) 如果成员内部类是静态的,外部类访问内部类的成员
      外部类名.内部类名 对象名 = new 外部类名.内部类名() ;
      内部类访问外部类的成员变量可直接访问,静态的内部类访问外部类的数据,该数据 必须static修饰,和当前静态内部类的成员方法是否为静态还是非静态“ 没有关系”

      C.匿名内部类:
      前提:接口或者抽象类(可以抽象类也可以普通类)
      new 接口名/类名(){
      重写功能(){…}
      }
      本质:继承了该类或者是实现了该接口的子类对象..

    3. final关键字特点:
      final是一个修饰符,可以修饰类,方法和变量‘
      被final修饰的类是一个最终类不可以被继承;
      被final修饰的方法是一个最终的方法.不可以被覆盖;
      被final修饰的变量是一个常量,只能被赋值一次;

    10.面试题
    A. 方法重写和方法重载的区别?
    方法重载:Overload
    方法名相同,返回值类型相同,但是参数不同(参数类型不同,或者参数个数不同)
    方法重写:Override
    方法重写是相对于继承而言
    重写的方法名,返回类型,参数类型,参数个数都要求和父类中一样.

    B.final关键字的面试题?(final,finally,finalize有什么区别)
           final用于声明属性,方法和类,分别表示属性不可改变,方法不可覆盖,类不能继承
       finally是异常处理语句结构的一部分,表示总是执行
       finalize是object类的一个方法,在垃圾收集器执行的时候会调用被回收对象的此方法,           供垃圾收集时的其他资源回收,例如关闭文件等;

    原文地址:http://blog.51cto.com/13678296/2105666

    时间: 2024-08-01 12:36:24

    面向对象(继承,多态)的相关文章

    3、面向对象-继承-多态

    1.继承 子类可以继承父类的一切,一个子类只能有一个父类,一个父类可以有多个子类 //父类 class Ren{ public $name; public $sex; public $yuyan; function Say()    { echo $this->name."正在讲话!"; } } //美国人的子类 class America extends Ren{ public $ziben; //子类对父类的方法重写 function Say()    {    parent

    (1) 深入理解Java面向对象三大特性 封装 继承 多态

    转眼已经工作快6年了,最开始做了2年J2EE:然后整了2年的数据仓库,主要是Cognos的报表开发:现在从事4G LTE核心网的开发,用的语言任然是Java,但写代码的机会不多,基本都是看代码找BUG,偶尔做点new feature也是在比较成熟的框架上复制.粘贴.修改,大部分时间还是在理解业务,钱多.事少.离家近,当时来这家公司图的是后面2点,2年过去了,英文水平有所提升,对敏捷开放也有一定的了解,但技术方面明显退步了或者说没有进步吧,本来以前也不怎么好,因为工作上用不到,自己也没怎么学习,所

    Java面向对象㈡ -- 继承与多态

    Java的继承是通过extends和implement来实现的,Java不支持多继承,但是Java支持多层继承以及多实现(接口).Java继承有一个关键字super是用来指向父类.Java继承衍生出覆盖的概念.覆盖被用来支持多态.实际开发中Java通常继承于抽象类,实现于接口.如果不希望一个类被继承,或者一个方法被覆盖,或者一个成员变量被改变,就可以用final修饰.这里只说明两个问题:1,重载和覆盖的区别重载和覆盖的区别:重载发生在同一个类之中,重载要求函数名相同,参数不同(参数个数||参数类

    面向对象之 封装 继承 多态

    #!/usr/bin/env python # _*_ coding:utf-8 _*_ class Role(object): #继承object类 ac = None #脚本一执行跟着类一起存到了内存 类变量 #类变量和实例变量的区别: #类变量脚本执行跟着类一起存到了内存,不管是否调用都存在,实例变量是存在实例内的, def __init__(self,name,role,weapon): #初始化方法 实例化后自动执行 #self 代表实例本身.谁调用就是谁. name role,wea

    初识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("

    面向对象的三大特性---封装继承多态

    面向对象的三大特性---封装继承多态 首先我们来创建一个控制台程序 新建一个父类Person 创建一个子类继承父类Person 子类: main函数: 输出结果: 根据结果显示创建子对象,首先调用父类的构造函数在调用子类的构造函数. 继承的传递性 例如: A:B,B:C,则A:C ⅰ.继承过来之后被隐藏,有意隐藏加一个关键字"new",如果加了关键字"new",就告诉子类,父类里面的sayHi只能被隐藏,不能被覆写  ⅱ.继承过来之后被覆写/重写,覆写需要在父类里面

    类与对象 面向对象和面向过程对比 面向对象三大特征:封装 继承 多态

     初识面向对象 面向过程: 一切以事务的发展流程为中心. 面向对象: 一切以对象为中心. 一切皆为对象. 具体的某一个事务就是对象 打比方: 大象进冰箱 步骤: 第一步, 开门, 第二步, 装大象, 第三步, 关门 面向对象:大象, 你进冰箱. 此时主语是大象. 我操纵的是大象. 此时的大象就是对象 1. 面向过程: 一切以事物的流程为核心. 核心是"过程"二字, 过程是指解决问题的步骤, 即, 先?干什么, 后干什么. 基于该思想编写程序就好比在编写一套流水线. 是一种机械 式的编程

    php面向对象 封装继承多态 接口、重载、抽象类、最终类总结

    1.面向对象 封装继承多态  接口.重载.抽象类.最终类 面向对象 封装继承多态  首先,在解释面向对象之前先解释下什么是面向对象? [面向对象]1.什么是类? 具有相同属性(特征)和方法(行为)的一系列个体的集合,类是一个抽象的概念2.什么是对象?从类中拿到的具有具体属性值得个体,称为对象,对象是一个具体的个体 所以,面向对象即我们专注对象来处理问题,通过从一个个具有属性和功能的类中拿到对象来处理问题. 下面我们再来细说下面向对象的三大特征:继承/封装/多态 一.继承 在PHP中我们主要通关E

    Python 入门 之 面向对象的三大特性(封装 / 继承 / 多态)

    Python 入门 之 面向对象的三大特性(封装 / 继承 / 多态) 1.面向对象的三大特性: (1)继承 ? 继承是一种创建新类的方式,在Python中,新建的类可以继承一个或多个父类,父类又可以称为基类或超类,新建的类称为派生类或子类. ? 在Python中实现继承非常简单,在声明类的时候,在类名后面添加一个小括号,就可以完成继承关系.单纯的从代码的层面上来看当两个类具有相同的功能或者特征的时候就可以使用继承.提取一个父类,这个父类中编写者两个类相同的部分,然后两个类分别去继承这个类就可以

    面向对象三大特性(封装/继承/多态)

    引入:在面向对象思想中,有三大特性,封装  继承  多态. 思考:我们在使用类和对象实现编程的时候,到底是遵循这什么样的逻辑呢?为什么要这样规范类呢? 引入:面向对象很重要的思想就是隐藏,即外部不知道类内部是如何实现业务逻辑的,只管调用和使用结果,这个就是面向对象三大特性之一:  封装 1.封装[掌握] 定义:封装,字面意思就是将内容装到某个容器中,并进行密封保存,在面向对象思想中,封装指数据和对数据的操作捆绑到一起,形成 对外界的隐藏,同时对外提供可以操作的接口. 1.数据:即要操作的数据,在