目录

  • 1 C++课程概述
    • 1.1 概述
  • 2 基本编程语言
    • 2.1 编程操作提交
    • 2.2 for 循环结构
    • 2.3 变量与字符
    • 2.4 次数控制循环
    • 2.5 增量操作
    • 2.6 输出格式
    • 2.7 整型原理
    • 2.8 1!到n!的和
    • 2.9 最大公约数
  • 3 数据类型
    • 3.1 等比数列
    • 3.2 函数使用
    • 3.3 素数筛法
    • 3.4 浮点型原理
    • 3.5 浮点型表示范围
  • 4 计算表达
    • 4.1 位操作
    • 4.2 数学方法优化
  • 5 函数机制
    • 5.1 递归
    • 5.2 多重集
    • 5.3 二维数组
    • 5.4 字串与整型转换
    • 5.5 运行错误解析
    • 5.6 常规做题策略
    • 5.7 逆反
    • 5.8 数学方法运用
    • 5.9 Map
    • 5.10 结构
  • 6 性能
    • 6.1 集合
    • 6.2 空间换时间
    • 6.3 提交策略
    • 6.4 向量法
    • 6.5 转移语句
    • 6.6 字串处理
    • 6.7 计算技巧
    • 6.8 四则运算程序控制
    • 6.9 大数相加
    • 6.10 n!中的0
    • 6.11 大数相乘
    • 6.12 计算机实验解析(上)
    • 6.13 计算机实验解析(下)
  • 7 期中讲评
    • 7.1 接龙
    • 7.2 斜纹布
    • 7.3 斐波追溯数
    • 7.4 字符表
    • 7.5 少数服从多数
    • 7.6 11倍数
    • 7.7 无称售油
    • 7.8 组合数
    • 7.9 矩阵鞍点
  • 8 排序
    • 8.1 冒泡排序
    • 8.2 位数和排序
    • 8.3 “顺”序列
    • 8.4 字典序
  • 9 String搜索
    • 9.1 String搜索
    • 9.2 格式符
  • 10 期末考试习题讲解
    • 10.1 斜纹布2
    • 10.2 文件名排序
    • 10.3 Find Name Again
    • 10.4 矩阵鞍点2
    • 10.5 台阶
    • 10.6 转十进制数
    • 10.7 算菜价
    • 10.8 斜纹布3
  • 11 程序结构
    • 11.1 函数组织
    • 11.2 头文件
  • 12 类
    • 12.1 类机制的实现
    • 12.2 成员函数
      • 12.2.1 成员函数的构造方式
      • 12.2.2 成员函数的调用方式
    • 12.3 操作符两种定义方式
    • 12.4 友元
    • 12.5 错误处理
  • 13 对象生灭
    • 13.1 计算机程序的内存布局
    • 13.2 定义数据的方式
    • 13.3 维持函数框架结构占空间的合理性
    • 13.4 深拷贝应用对象产生的概念
    • 13.5 对象赋值
    • 13.6 构造函数
    • 13.7 赋值函数
    • 13.8 析构函数
    • 13.9 对象化设计的内容
    • 13.10 MyExcept的构造函数
  • 14 继承
    • 14.1 继承结构
    • 14.2 派生类的构造
    • 14.3 访问权限
    • 14.4 继承的划分
  • 15 多态
    • 15.1 继承召唤多态
    • 15.2 抽象编程的困惑
    • 15.3 虚函数
    • 15.4 避免虚函数误用
    • 15.5 精简共性的类
    • 15.6 多态编程
  • 16 归纳面向对象
    • 16.1 归纳面向对象详解
归纳面向对象详解
  • 1
  • 2 归纳面向对象


面向对象编程核心概念总结:

什么叫类?

现实中的类:是某一种事物的一般性的集合体,是相同或相似的各个事物共同特性的一种抽象。

软件中的类(class):是现实世界类的模拟,是对象的模板。

什么叫对象?

在面向对象概念中,对象是类的实例。对象与类的关系就像变量与数据类型的关系一样。类的核心特性有哪些?

类具有封装性、继承性和多态性。

封装性:类的封装性为类的成员提供公有、缺省、保护和私有等多级访问权限,目的是隐藏类中的私有变量和类中方法的实现细节。

继承性:类的继承性提供从已存在的类创建新类的机制,继承(inheritance)使一个新类自动拥有被继承类(父类)的全部成员。

多态性:类的多态性提供类中方法执行的多样性,多态性有两种表现形式:重载和覆盖。

方法:

对象中的方法表达了对象所具有的行为。方法实际上就是函数。

属性:

一个对象的属性是能够被外界或对象所处的环境所感知或操纵的数据或状态。

类的结构:

类名

属性名:

    静态属性

    实例属性:必须依赖于对象/实例

方法:

   静态方法

   实例方法

构造器:

    缺省构造器

    带参的构造器

    静态代码块

    实例代码块

参数传递:

    对于基本类型,将实际参数的值原样的复制一遍传值;

    对于引用类型,将引用类型变量的地址值复制给实参。

“this”有什么用处?

   this是一个keyword,表示对象中指向自身的一个引用,在实例方法中用来指代当前对象。

   A.实例变量于局部变量同名,用this。实例变量名来和局部变量加以区分;

   B.在构造器的重载的时候,用this来调用其他的构造器;

   C.在实例方法中,用来将当前对象的引用传递给另外的方法。

super:

调用父类的属性;调用父类的方法;子类与父类有同名的方法,子类可用super.methodname来区分是父类的方法;

方法的重载:

   A.方法名要相同;

   B.在一个类中,多个方法具有不同的方法签名(参数类型/参数个数/参数顺序),方法可以重载

   C.返回类型不作要求

构造器:

 类中提供的用于初始化对象的特殊的方法,这个方法

 与类名相同,无返回值

缺省构造器?

 A.类中没有提供构造器,JVM会提供一个不带参的缺少构造器

 B.类中有带参的构造器,JVM不会提供了。

构造器的运行:

子类的构造器默认情况下会调用父类的构造器,如果子类的构造器指定调用父类带参的构造器,则父类可以不提供缺省的构造器。

类的实例化的过程:

类的静态成员在类被加载的时候进行初始化!

  (1) 在堆中分配空间;

  (2) 给对象的属性赋默认值

      boolean=false;

      基本类型=0;

      引用类型=null;

  (3) 调用构造器

      构造器可能会初始化属性值;

  (4)进一步赋值

封装 继承 多态:

  (1) 封装

    A.将类的实现细节隐藏起来

    B.对外提供一致的接口

    C.提高系统的维护性

  (2) 继承(Inheritance)

      定义:一个类自动获得另一个类的属性或者方法的过程。

      使用:public void class A extends SubA{}

       A.单根继承

       B.所有的类都是object的子类

       C.类没有显示地继承另外一个类,则缺省继承了object

      基本规则:

      A.构造器不能被继承

      B.子类初始化时会默认情况下调用父类缺省的构造器

      C.子类调用父类的带参的构造器,则父类可以不用缺省构造器

      怎样使用继承:

      A.区分"Has-a"与"Is-a";

      B.子类要扩充父类的功能;

      C.子类需要大量置换父类的功能时,不应该使用继承;

      D.不要从工具类(一些辅助运算的方法)中继承。

      继承的优缺点

      优点:

      1.继承是最容易的复用代码的形式

      2.修改父类的功能是,子类可以自动获得新的功能

      缺点:

     打破封装,继承只是类型(静态)复用。静态类型的复用,牺牲了类的自由。

      父类的引用类型变量可以调用子类的实例,反之则不成立,即子类可当父类用。

(3)多态:

      A.编译时,编译器检查声明类型(类型/方法信息)

      B.运行时,JVM对实例方法和引用变量实际引用的对象动态绑定,对静态方法和引用变量声明的类型静态绑定。

      C.类的属性在编译阶段绑定。

instanceof:

判断某个实例是否为某个类型的实例或者其子类的实例。

           Syntax:

 <examplename> instance of <typename>

规则:

    A.只能在父子类进行比较;

    B.null可以进行比较,结果为false;

    C.判断实例的类型时,一般从子类开始,然后是父类    

重写/覆盖/override:

    方法覆盖是子类重写父类中的方法。

    子类要想override父类的方法有以下条件:

    A.方法名相同

    B.方法签名相同

    C.返回值相同

    D.子类的修饰符>=父类的修饰符

    E.子类抛出的异常要小于父类抛出的异常

    F.父类中抽象方法可以被子类通过两种途径覆盖:

    1)子类实现父类的抽象方法;

    2)子类重新声明父类中的抽象方法。

怎样使用抽象类?

(1)尽可能把可以共用的方法和逻辑放到抽象类中;

(2)属性应尽可能放到子类中。

final:

    final修饰的类不能被继承;

    final修饰的方法不能被重写

    final修饰的变量是常量,常量不可修改,但有例外:

实例常量:

    A.若定义时为赋值,则可以在构造器或者实例代码块中赋值

    B.构造器或者代码块赋值只能有一个

静态常量:

    若定义时没有赋值,可在静态代码块中赋值