Java 面向对象

一、初步理解

  • 面向对象是相对面向过程而言的。

    • 面向过程强调的是过程的行为功能。（例如：C 语言就是一门面向过程的语言）

        例：大象装进冰箱的步骤
  	1. 打开冰箱门；
  	2. 把大象装进冰箱；
  	3. 关闭冰箱门。
  注：面向过程是亲自去执行步骤

    • 面向对象强调的是具有行为功能的对象。（例如：Java 语言就是一门面向对象的语言）

        例：大象装进冰箱的步骤
  	1. 由具有打开冰箱功能的对象去打开冰箱门；
  	2. 由具有存储功能的对象去将大象装进冰箱；
  	3. 由具有关闭冰箱功能的对象去关闭冰箱门。
  注：面向对象是对象去执行步骤

  • 面向过程和面向对象都是一种思想，面向对象是基于面向过程的。

      面向对象的分析（OOA）（Object Oriented Analysis）
  面向对象的设计（OOD）（Object Oriented Design）
  面向对象的编程实现（OOP）（Object Oriented Programming）

  • 特征：

      1. 封装（encapsulation）
  2. 继承（inheritance）
  3. 多态（polymorphism）

  • 特点：

      1. 将复杂的事情简单化；
  2. 从执行者转换成指挥者；
  3. 一种符合人们思考习惯的思想。

  • 步骤：

      1. 找寻具有所需功能的对象来使用；
  2. 对象如果不存在，则创建一个具有所需功能的对象来使用。

  • Java 开发的过程，其实就是不断的创建对象、使用对象、指挥对象。

  • Java 设计的过程，其实就是管理和维护对象之间的关系。

二、类与对象

1. 关系

  • 定义：

    • 类：就是使用计算机语言不断的描述现实生活中的事物，而 Java 中描述事物通过类的形式体现，类是具体事物的抽象，概念上的定义。
      • 生活当中描述事物无非就是描述事物的属性和行为。
        • 例：人的年龄、身高等属性；人的说话、跑步等行为。
    • 对象：该类事物实实在在存在的个体称为对象。

    • 示例图理解：
      • 图纸就是类
      • 汽车就是对象

  • Java 是用类（class）来描述对象的属性和行为。

    • 定义类其实就是在定义类中的成员（成员变量和成员函数）。
      • 属性：对应类中的成员变量。
      • 行为：对应类中的成员函数。

    • 说明：以上程序就定义了一个以人为对象的类，人这个对象具有年龄的属性，还具有说话的行为功能。
      • 创建一个对象的格式：
        • Person person = new Person();//创建了一个人物对象
      • 修改属性和使用行为功能的格式：
        • person.age = 20;//修改对象的属性
        • person.speak();//使用对象的行为功能

2. 变量

  • 分类：
    • 成员变量
    • 局部变量
  • 区别：

    • 成员变量：

        1. 成员变量定义在类中，在整个类中都可以被访问。
  2. 成员变量随着对象的建立而建立。
  3. 成员变量存在于对象所在的堆内存中。
  4. 成员变量有默认初始化值。

    • 局部变量：

        1. 局部变量只定义在局部范围内。（例：函数内，语句内等）
  2. 局部变量作用的范围结束，变量空间会自动释放。
  3. 局部变量存在于栈内存中。
  4. 局部变量没有默认初始化值。

3. 匿名对象

  • 定义：匿名对象是对象的简化形式。
    • 例： new Car();
  • 匿名对象两种使用情况：
    1. 当对象方法仅需要进行一次调用的时候。
    2. 匿名对象可以作为实际参数进行传递。
  • 注：如果对一个对象进行多个成员调用，则必须给这个对象起个名字。

三、对象

1. 封装

  • 概念：隐藏对象的属性和实现细节，仅对外提供公共访问方式。
  • 优点：
    1. 便于使用。
    2. 将变化隔离。
    3. 提高重用性。
    4. 调高安全性。
  • 原则：
    1. 将不需要对外提供的内容都隐藏起来。
    2. 把属性都隐藏，提供公共方法对外，使其能够访问。
  • 封装的表现形式之一 —— private（私有）

    • private 关键字：权限修饰符，用于修饰类中的成员（成员变量、成员函数），只在本类中有效。

    • 常用场景：将成员变量私有化，对外提供对应的 set、get 方法对其进行访问，提高对数据访问的安全性。

    • 例：有一个人的对象，而年龄这一属性不想被别的对象访问，就可以将其设为 private

2. 构造函数

  • 作用：给对象进行初始化。

  • 特点：

      1. 函数名与类名相同。
  2. 不用定义返回值类型。
  3. 不可以写 return 语句。

  • 注意：

      1. 构造函数在对象一建立就运行，给对象初始化。
  2. 一般函数方法是对象调用才执行，是给对象添加对象具备的功能。
  3. 一个对象建立，构造函数只运行一次；而一般方法可以被该对象调用多次。

  • 细节：

      1. 一个类中没有定义构造函数时，系统会默认给该类加入一个空参数的构造函数。
  2. 当在类中自定义了构造函数后，默认的构造函数就没有了。

  • 什么时候需要定义构造函数？

      当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。

  • 构造代码块

    • 构造代码块中定义的是不同对象共性的初始化内容。
    • 作用：给对象进行初始化，对象一建立就运行，并且优先于构造函数运行。
    • 构造代码块与构造函数的区别：
      • 构造代码块是给所有的对象进行初始化。
      • 构造函数是给对应的对象进行初始化。

3. this 关键字

  • 概述：this 代表它所在函数所属对象的引用，换而言之，哪个对象调用 this 所在的函数，this 就代表哪个对象。

  • 应用：

    • 定义类中的功能时，该函数内部要用到调用该函数的对象时，用 this 表示这个对象。
    • 本类功能内部中使用到本类对象，都用 this 表示。

  • this 语句：

    • 定义：用于构造函数之间进行互相调用。
      • 例：this(name)
    • 注意：
      • this 语句只能定义在构造函数中的第一行，因为初始化要先执行。
      • 一般函数不能直接调用构造函数，因为 this 语句不能用在一般函数中，只能用在构造函数间。

  • 应用场景：

    1. 用于区分同名变量的情况，成员变量和局部变量同名的时候。
    2. 用于构造函数间调用。

    • 说明：用于区分局部变量与成员变量同名的情况。

4. static（静态）关键字

  • 描述：static 是一个修饰符，用于修饰成员（成员变量和成员函数），成员被静态修饰后，除了可以被对象调用之外，还可以直接被类名调用。

  • 格式：类名.静态成员;

  • 特点：

      1. 随着类的加载而加载，静态会随着类的消失而消失，生命周期最长。
  2. 优先于对象存在，静态是先存在，对象是后存在。
  3. 被所有对象所共享。
  4. 可以直接被类名所调用。

  • 由于静态成员变量可以直接被类名调用，因此静态成员变量又被称为类变量；非静态成员变量又被称为实例变量。

  • 类变量和实例变量的区别：

      1. 存放位置：
  	类变量随着类的加载而存在于方法区中。
  	实例变量随着对象的建立而存在于堆内存中。
  2. 生命周期：
  	类变量生命周期最长，随着类的消失而消失。
  	实例变量生命周期随着对象的消失而消失。

  • 优势：

    1. 可以直接被类名调用。
    2. 没有必要在每一个对象中都存储一份。
    3. 对对象共享数据进行单独空间的存储，以节省空间。

  • 弊端：

    1. 生命周期过长。
    2. 访问静态有局限性。（静态只能访问静态）

  • 什么时候使用静态？（静态修饰的内容有成员变量和函数）

    1. 什么时候定义静态变量（类变量）？
      • 当对象中出现共享数据时，该数据可以被静态所修饰；当对象中的特有数据要定义为非静态时，将会存在于堆内存中。
    2. 什么时候定义静态函数？
      • 当功能内部没有访问到非静态数据（对象的特有数据）时，那么该功能可以定义为静态的。

  • 注意：

      1. 主函数是静态的。
  2. 静态方法只能访问静态；非静态方法既可以访问静态也可以访问非静态。
  3. 静态方法中不可以定义 this、super 关键字，因为静态优先于对象存在，所以静态方法中不可以出现 this、super。

  • 静态代码块：

    • 格式：

        static{
  	静态代码块中的语句;
  }

    • 特点：随着类的加载而执行，执行一次，并且优先于主函数，用于给类进行初始化操作。

  • 对象的初始化过程：

    • 定义一个新对象都做了哪些事情？

        1. 把类名.class 文件加载到内存中；
  2. 执行该类中的 static 代码块，如果有的话，给该类进行初始化；
  3. 在堆内存中开辟空间，分配内存地址给对象；
  4. 在堆内存中建立对象的特有属性，并进行默认初始化；
  5. 对属性进行显示初始化；
  6. 对对象进行构造代码块初始化；
  7. 对对象进行对应构造函数初始化；
  8. 将内存地址赋给栈内存中的对象名变量。

  • 应用 —— 文档说明书

    • 工具类：每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装，以便复用。

      • 例如：数组工具类的文档说明书制作



四、主函数

  • 主函数是一个特殊的函数，作为程序的入口，可以被 JVM 调用。

  • 主函数是固定格式的，以便作为程序的入口被 JVM 所识别。

  • 定义：

      public：代表着该函数访问权限是最大的。
  static：代表主函数随着类的加载就已经存在了。
  void：主函数没有具体的返回值。
  main：不是关键字，但是是一个特殊的单词，可以被 JVM 所识别。
  （String[] arr）：函数的参数，参数类型是一个数组，该数组中的元素是字符串，字符串类型的数组。
  args：arguments 参数，唯一可以更改的地方。

五、单例设计模式

  • 设计模式概念：解决某一问题最行之有效的方法。

    • Java 中有 23 种设计模式。

  • 单例设计模式只是其中的一种，其作用是使一个类在内存中只存在一个对象。

  • 步骤：

      1. 将构造函数初始化；
  	例如：private Single(){}
  2. 在类中创建一个本类对象；
  	例如：private static Single s = new Single();
  3. 提供一个访问方法可以获取到该对象。
  	例如：public static Single getInstance(){
  				return s;
  			}

  • 写法：

    • 饿汉式：特点是先初始化对象。（建议使用）

    • 懒汉式：特点是被调用时才进行初始化对象，也称为对象的延时加载。

posted @ 2017-10-10 17:26  陈凯冰  阅读(337)  评论(1)  编辑  收藏  举报