一、初步理解

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

  • 面向过程强调的是过程的行为功能。（例如：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;
                }
  

• 写法：

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

    

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