类与对象

/* 过段时间疫情结束返校后 再来精读 《JAVA核心技术》 */

0. OOP思想概述

• 不必关心对象的具体实现，只要能 够满足用户的需求即可

• 对于一些规模较小的问题， 将其分解为过程的开发方式比较理想。而面向对象更加适用 于解决规模较大的问题

  充分理解 分解 + 抽象 的内涵

  ——67大帝

1. 定义类与对象

• 对象 = 数据 + 方法

• 对象 = 属性 + 服务

  一个对象 有什么东西 可以做那些事情

• 封装： 将数据 和 对数据的操作 组合在一个包中

• 实现封装的关键：绝对不能让类中的方法直接访问其它类的实例域，程序仅通过对象的方法与对象数据进行交互

• 对象状态的改变必须通过就、调用方法实现（否则说明封装性遭到破坏）

• 类是规范 定义了该类的实例（对象）的属性和行为 （一种规范）

• 对象是实体 是一个类的具体实现 需要被创建 可以为我们做事情

• 对象变量和普通变量的不同，对象变量是对象的管理者而非所有者

  一个对象变量并没有实际包含一个对象，而仅仅引用一个对象

  • 任何对象变量的值都是对存储在另外一个地方的一个对象的引用

  • new 操作符的返回值也是一个引用

  • java 的对象变量 可以看作 C++的对象指针

• 通过 new + 构造器来创建新对象： new Date()

• 当数组的元素的类型是类的时候，数组的每一个元素其实只是对象的管理者而不是对象本身。因此，仅仅创建数组并没有创建其中的每一个对象！

  • 通过 for each 循环来 创建数组中的每个对象

2. 成员变量 成员函数 本地变量

• 一个类由两种东西组成：表示对象有什么的成员变量和表示对象能做什么的成员函数

  • 关键是理解类的定义和对象的关系，理解对象中的成员变量是怎么来的，怎么就能让成员函数明白自己在和哪个对象打交道。

  • 一个对象的成员变量在对象创建时就被确定（即确定一个状态）

  • 对象一旦被创建，该对象会有唯一的id，可以通过该对象的变量名来引用，对该对象进行操作（通过成员函数进行服务打交道）

  • 成员函数 即方法 有访问器方法 有更改器方法

    • 访问器方法：只访问对象 而不修改对象（对象状态不变） 如 getValue() 或者返回新对象的 toUpperCase()
    • 更改器方法：调用该方法后 对象的状态会改变 如 setValue()
    • 生成器方法：

  • this 是一个对象变量（管理者）/对象引用 ：

    • 成员函数的一个特殊的固有的本地变量，表达了调用这个函数的那个对象

      void setPrice(int prive) {
          this.price = price;
      }
      

    • 在成员函数内部调用另外一个成员函数，可以不使用this

• 区别 本地变量：

  • 本地变量：定义在函数内部的变量
  • 生存期 和 作用域 都是函数内部
  • 而成员变量 生存期是对象的生存期 作用域是类的内部的成员函数

3. 对象初始化

变量的初始化是程序安全很重要的一环。一旦创建了一个对象，有什么手段可以保证其中的每一个成员变量都有确定的初始值呢？

• 给每个成员变量默认的“0”值/NULL

• 定义构造函数

  • 特殊的成员函数，无返回类型，名称与类名一定相同
  • 执行顺序： 创建（构造）对象时，先声明成员变量，再执行构造函数，再返回Main

  public class VendingMachine{
      private int prive;
      private int balance;
      private int total;
      
      VendingMachine(int price) { //构造函数
          this.price = price;
      }
      
      VendingMachine(int price, int total) {  //重载 overload
          this.price = price;
          this.total = total;
      }
  }
  

• 函数重载

  • 类中的成员函数 名称相同，参数表不同 -> 构成重载关系

4. 识别对象 与 对象交互

抽象出对象 设计类 然后再往每个类中添加方法

• 识别类的简单规则是在分析问题的过程中寻找名词，而方法对应着动词

  例子; 数字时钟 11:03 看成两个两位数的Display的对象

对象交互

当一个对象里有多个对象的时候，那些对象之间是如何交互的，对象和对象之间的联系是如何建立的，对象如何和其他对象交流???

对象和对象之间的联系紧密程度叫做耦合。

对象和对象的耦合程度越紧，表现在源代码上，就是它们的代码是互相依赖、互相牵制的。

• 我们理想的模型，是对象和对象之间的耦合要尽可能的松，平行的对象要尽量减少直接联系，让更高层次的对象来提供通信服务

public class Display {
   private int value;
   private int limit;

   Display (int limit) {
       this.limit = limit;
   }

   public void incease() {
       value = value + 1;
       if (value==limit){
           value = 0;
       }
   }

   public int getValue() {
       return value;
   }
}

public class Clock {
   private Display minute = new Display(60);
   private Display hour = new Display(24);

   public void start() {
       while(true) {
           minute.incease();
           if (minute.getValue() == 0) {
               hour.incease();
           }
           System.out.printf("%02d : %02d\n", hour.getValue(), minute.getValue());
       }
   }
}

5. 封装

封装，就是把数据和对这些数据的操作放在一起，并且用这些操作把数据掩盖起来，是面向对象的基本概念之一，也是最核心的概念。

• 所有的成员变量必须是private的，这样就避免别人任意使用你的内部数据，保护作用

  • 只有在这个类的内部 才能访问 private 的成员变量

    比如 构造函数 或成员函数

    不可在其他的class中比如Main（在其他class中的Main）中 直接访问对象的成员变量

  • 这个限制是对类的，而不是针对对象的

• 所有的成员函数基本上都是public的

  • public 任何人都可以访问
  • 任何人指的是 任何类的定义初始化或者成员函数都可以使用
  • 使用指的是 调用、访问、或 定义变量
  • 一个类是public 那么任何类都可以定义该类的对象，public class 必须定义在自己的文件里（文件名与类名相同），一个编译单元（.java)只能有一个public class，虽然可以有很多个class（只能在这个package内使用）

• friednly(如果不加限定词 那么默认为friendly)

  • 仅仅同一个package内才能访问

6. 包 Package

包就是Java的类库管理机制，它借助文件系统的目录来管理类库，

一个包就是一个目录，一个包内的所有的类必须放在一个目录下，那个目录的名字必须是包的名字

• Project -> Source File (src) -> Package -> class

• src 只能一个 Package 可以多级 可以多个

• 例如 com.google.demo （包的名字可以带. 表示多级)

• 如果需要另外一个Package里的class，那么需要 import

  import package.class

7. 类变量 与 类方法 static （静态变量 与 静态方法）

类是描述，对象是实体。在类里所描述的成员变量，是位于这个类的每一个对象中的。

而如果某个成员有static关键字做修饰，它就不再属于每一个对象，而是属于整个类的了。

通过每个对象都可以访问到这些类变量和类函数，但是也可以通过类的名字来访问它们。类函数由于不属于任何对象，因此也没有办法建立与调用它们的对象的关系，就不能访问任何非static的成员变量和成员函数了。

例如 String.join ( CharSequence delimiter, CharSequence... elements )

@author : nju_zzp
@date : 2020/3/12