《Java编程思想》读书笔记（1）——第一、二章面向对象

末蓝、 2023-10-09 23:47 54阅读 0赞

## 引出 ##

读一读经典的好书，《Java编程思想》

--------------------

![在这里插入图片描述][a9cc8b6acf4441218ddfd6dea1aa1213.png]

## 第一、二章 面向对象 ##

### 1.用句柄操纵对象【引用】 ###

String s;

但这里创建的只是句柄，并不是对象。若此时向s 发送一条消息，就会获得一个错误（运行期）。这是由于  
s 实际并未与任何东西连接（即“没有电视机”）。因此，一种更安全的做法是：创建一个句柄时，记住无  
论如何都进行初始化：

上述代码只是创建了一个名为s的句柄，并没有对象，如果使用s对象，会抛出运行时错误。

String s = "asdf";

然而，这里采用的是一种特殊类型：字串可用加引号的文字初始化。通常，必须为对象使用一种更通用的初始化类型。

### 2.创建对象—必须new ###

> new 的意思是：“把我变成这些对象的一种新类型”。

String s = new String("asdf");

它不仅指出“将我变成一个新字串”，也通过提供一个初始字串，指出了“如何生成这个新字串”。

从右边读，用new的方式将我“asdf”变成一个String类型的字符串，把s句柄（引用）指向刚刚new出来的String类型的“asdf”

### 3.对象的保存位置 ###

> 内存分配的问题

<table> 
 <thead> 
  <tr> 
   <th>位置</th> 
   <th>特点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>寄存器</td> 
   <td>1.处理器内部；2.由编译器分配；3.Java没有直接控制权；</td> 
  </tr> 
  <tr> 
   <td>堆栈(栈)</td> 
   <td>1.保存在常规RAM（随机访问存储器）区域；2.通过堆的指针可以控制；3.堆栈指针下移，创建新内存，如果上移，则释放内存；4.仅次于寄存器的高效存储方式；<strong>5.保存对象句柄，即引用</strong>；6.Java对象不放其中；<strong>7.需要提前分配大小byte，int，double</strong></td> 
  </tr> 
  <tr> 
   <td>堆</td> 
   <td>1.也保存在RAM区域；2.保存Java对象；3.不需要知道分配存储空间的大小；4.<strong>用new命令创建</strong>，自动在堆中进行数据保存；5.堆里分配存储空间的时间比栈长；</td> 
  </tr> 
  <tr> 
   <td>静态存储（static）</td> 
   <td>1.也在RAM区域，静态指位于固定位置；<strong>2.出现早，程序运行期间，静态存储的数据随时等候调用</strong>；3.用<strong>关键字static</strong>指出一个对象的特定元素是静态的；3.Java对象本身永远不会置入静态存储空间；</td> 
  </tr> 
  <tr> 
   <td>常数存储（常量池）</td> 
   <td>1.常量值通常直接置于程序代码内部；2.保存在只读存储器ROM中；</td> 
  </tr> 
  <tr> 
   <td>非RAM存储</td> 
   <td>1.流式对象和固定对象；2.流式对象：对象变成字节流，发送给另一台机器；3.固定对象：对象保存在磁盘，数据持久化</td> 
  </tr> 
 </tbody> 
</table>

### 4.主要类型 ###

有一系列类需特别对待；可将它们想象成“基本”、“主要”或者“主”（Primitive）类型，进行程序设计时要频繁用到它们。之所以要特别对待，是由于用new 创建对象（特别是小的、简单的变量）并不是非常有效，因为new 将对象置于“堆”里。对于这些类型，Java 采纳了与C 和C++相同的方法。也就是说，不是用new 创建变量，而是创建一个并非句柄的“自动”变量。这个变量容纳了具体的值，并置于堆栈中，能够更高效地存取。

保存在栈中，决定空间的大小；

<table> 
 <thead> 
  <tr> 
   <th>主类型（基本数据类型）</th> 
   <th>大小 (位)</th> 
   <th>最大值</th> 
   <th>最小值</th> 
   <th>主类型默认值</th> 
   <th>封装器类型（包装类）</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>boolean</td> 
   <td>1</td> 
   <td>true</td> 
   <td>false</td> 
   <td>false</td> 
   <td>Boolean</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>16</td> 
   <td>Unicode 0</td> 
   <td>Unicode 2的16次方-1</td> 
   <td>‘\u0000’(null)</td> 
   <td>Character</td> 
  </tr> 
  <tr> 
   <td>byte</td> 
   <td>8</td> 
   <td>-127</td> 
   <td>+128</td> 
   <td>(byte)0</td> 
   <td>Byte</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>16</td> 
   <td>-2^15</td> 
   <td>+2^15 - 1</td> 
   <td>(short)0</td> 
   <td>Short</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>32</td> 
   <td>-2^31</td> 
   <td>+2^31 - 1</td> 
   <td>0</td> 
   <td>Integer</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>64</td> 
   <td>-2^63</td> 
   <td>+2^63 - 1</td> 
   <td>0L</td> 
   <td>Long</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>32</td> 
   <td>IEEE754</td> 
   <td>IEEE754</td> 
   <td>0.0f</td> 
   <td>Float</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>64</td> 
   <td>IEEE754</td> 
   <td>IEEE754</td> 
   <td>0.0d</td> 
   <td>Double</td> 
  </tr> 
 </tbody> 
</table>

### 5.新建数据类型：类 ###

class ATypeName \{/\*类主体置于这里\}  
这样就引入了一种新类型，接下来便可用new 创建这种类型的一个新对象：  
ATypeName a = new ATypeName();

#### **（1）属性和方法（数据成员和成员函数）** ####

定义一个类时（我们在Java 里的全部工作就是定义类、制作那些类的对象以及将消息发给那些对象），可在自己的类里设置两种类型的元素：数据成员（有时也叫“字段”）以及成员函数（通常叫“方法”）。其中，数据成员是一种对象（通过它的句柄与其通信），可以为任何类型。它也可以是主类型（并不是句柄）之一。

> 每个对象都为自己的数据成员保有存储空间；数据成员不会在对象之间共享

class DataOnly {
        
    int i;
    float f;
    boolean b;
    }

这个类并没有做任何实质性的事情，但我们可创建一个对象：

DataOnly d = new DataOnly();

可将值赋给数据成员，但首先必须知道如何引用一个对象的成员。为达到引用对象成员的目的，首先要写上对象句柄的名字，再跟随一个点号（句点），再跟随对象内部成员的名字。即“对象句柄.成员”。例如：

d.i = 47;
    d.f = 1.1f;
    d.b = false;

一个对象也可能包含了另一个对象，而另一个对象里则包含了我们想修改的数据。对于这个问题，只需保持“连接句点”即可。例如：

myPlane.leftTank.capacity = 100;

#### **（2）方法、自变量和返回值** ####

迄今为止，我们一直用“函数”（Function）这个词指代一个已命名的子例程。但在Java 里，更常用的一个词却是“方法”（Method），代表“完成某事的途径”。

方法的基本组成部分包括名字、自变量、返回类型以及主体。形式如下：

> 返回类型 方法名( /\* 自变量列表\*/ ) \{/\* 方法主体 \*/\}

**return关键字**

return 关键字的运用。它主要做两件事情。首先，它意味着“离开方法，我已完工了”。其次，假设方法生成了一个值，则那个值紧接在return 语句的后面。

#### **（3）类的导入** ####

import java.util.Vector;

它的作用是告诉编译器我们想使用Java 的Vector 类。然而，util 包含了数量众多的类，我们有时希望使用其中的几个，同时不想全部明确地声明它们。为达到这个目的，可使用“*”通配符。如下所示：*

import java.util.*;

需导入一系列类时，采用的通常是这个办法。应尽量避免一个一个地导入类。

#### **（4）static关键字** ####

另一种情形是我们需要一个特殊的方法，它没有与这个类的任何对象关联。也就是说，即使没有创建对象，也需要一个能调用的方法。为满足这两方面的要求，可使用static（静态）关键字。一旦将什么东西设为static，数据或方法就不会同那个类的任何对象实例联系到一起。所以尽管从未创建那个类的一个对象，仍能调用一个static 方法，或访问一些static 数据。

对于非static 数据和方法，我们必须创建一个对象，并用那个对象访问数据或方法。这是由于非static 数据和方法必须知道它们操作的具体对象。

**1）作用于属性**

例如，下述代码能生成一个static数据成员，并对其初始化：

class StaticTest {
        
    Static int i = 47;
    }

StaticTest st1 = new StaticTest();
    StaticTest st2 = new StaticTest();

此时，无论st1.i 还是st2.i 都有同样的值47，因为它们引用的是同样的内存区域。  
有两个办法可引用一个static 变量。正如上面展示的那样，可通过一个对象命名它，如st2.i。亦可直接用它的类名引用，而这在非静态成员里是行不通的（最好用这个办法引用static 变量，因为它强调了那个变量的“静态”本质）。

StaticTest.i++;

其中，++运算符会使变量增值。此时，无论st1.i 还是st2.i 的值都是48。

**2）作用于方法**

类似的逻辑也适用于静态方法。既可象对其他任何方法那样通过一个对象引用静态方法，亦可用特殊的语法格式“类名.方法()”加以引用。静态方法的定义是类似的：

class StaticFun {
        
    static void incr() {
         StaticTest.i++; }
    }

从中可看出，StaticFun 的方法incr()使静态数据i 增值。通过对象，可用典型的方法调用incr()：

StaticFun sf = new StaticFun();
    sf.incr();

或者，由于incr()是一种静态方法，所以可通过它的类直接调用：

StaticFun.incr();

### 6.第一个Java程序 ###

package com.tianju.book.test;
    
    import java.util.*;
    
    // 打印出与当前运行的系统有关的资料，使用System库的方法
    public class PropertyDemo {
        
        public static void main(String[] args) {
        
            System.out.println(new Date());
            Properties p = System.getProperties();
            p.list(System.out);
            System.out.println("---Memory Usage: ");
            Runtime rt = Runtime.getRuntime();
            System.out.println("Total Memory = " + rt.totalMemory()+
                            " Free Memory = " + rt.freeMemory()
            );
        }
    }

要点

（1）类名与文件是一样的；

（2）类里必须包含一个名为main()的方法，形式如下：

public static void main(String[] args) {

其中，关键字“public”意味着方法可由外部世界调用；

main()的自变量是包含了String 对象的一个数组；

args 不会在本程序中用到，但需要在这个地方列出，因为它们保存了在命令行调用的自变量。\[Ljava.lang.String;@4554617c

（2）System.out.println(new Date());

创建Date 对象唯一的目的就是将它的值发送给println()。一旦这个语句执行完毕，Date 就不再需要。随之而来的“垃圾收集器”会发现这一情况，并在任何可能的时候将其回收。

（3）System.getProperties()：System 类的一个static 方法

由于它是“静态”的，所以不必创建任何对象便可调用该方法。无论是否存在该类的一个对象，static 方法随时都可使用。调用getProperties()时，它会将系统属性作为Properties类的一个对象生成（注意Properties 是“属性”的意思）。随后的的句柄保存在一个名为p 的Properties句柄里。

（4）list()方法

Properties 对象有一个名为list()的方法，它将自己的全部内容都发给一个我们作为自变量传递的PrintStream 对象。

### 7.注释文档 ###

（1）@version

格式如下：@version 版本信息；

其中，“版本信息”代表任何适合作为版本说明的资料。

（2）@author

格式如下：@author 作者信息：  
其中，“作者信息”包括您的姓名、电子函件地址或者其他任何适宜的资料。

（3）@param

格式如下：@param 参数名 说明  
其中，“参数名”是指参数列表内的标识符，而“说明”代表一些可延续到后续行内的说明文字。

（4）@return

格式如下：@return 说明  
其中，“说明”是指返回值的含义。它可延续到后面的行内。

（5）@exception  
有关“违例”（Exception）的详细情况，

格式如下：@exception 完整类名 说明  
其中，“完整类名”明确指定了一个违例类的名字，它是在其他某个地方定义好的。而“说明”（同样可以  
延续到下面的行）告诉我们为什么这种特殊类型的违例会在方法调用中出现。

（6）@deprecated

该标记的作用是建议用户不必再使用一种特定的功能，因为未来改版时可能摒弃这一功能。

若将一个方法标记为@deprecated，则使用该方法时会收到编译器的警告。

#### 带有注释的第一个Java程序 ####

package com.tianju.book.test;
    
    import java.util.*;
    
    /** 第一个 Java程序示例
     *  作用是列出当前机器的系统信息
     * @author Peter
     * @author http://t.csdn.cn/HSlDv
     * @version 1.0
     */
    public class PropertyDemo {
        
        /**
         * 类的应用初步
         * @param args String类型的args数组
         * @return 无返回值
         * @exception Exception 无异常值
         */
        public static void main(String[] args) {
        
            System.out.println(new Date());
            Properties p = System.getProperties();
            p.list(System.out);
            System.out.println("---Memory Usage: ");
            Runtime rt = Runtime.getRuntime();
            System.out.println("Total Memory = " + rt.totalMemory()+
                            " Free Memory = " + rt.freeMemory()
            );
        }
    }

### 8.编码样式初步 ###

一个非正式的Java 编程标准是大写一个类名的首字母。若类名由几个单词构成，那么把它们紧靠到一起（也就是说，不要用下划线来分隔名字）。此外，每个嵌入单词的首字母都采用大写形式。例如：

class AllTheColorsOfTheRainbow {
         // ...}

对于其他几乎所有内容：方法、字段（成员变量）以及对象句柄名称，可接受的样式与类样式差不多，只是标识符的第一个字母采用小写。例如：

class AllTheColorsOfTheRainbow {
        
    int anIntegerRepresentingColors;
    void changeTheHueOfTheColor(int newHue) {
        
    // ...
    }
    // ...
    }

--------------------

### 总结 ###

1.创建对象的方式；  
2.主要数据类型，范围，包装类，初始化值；  
3.认识Java的类，类的属性，变量；  
4.第一个Java程序，编码规范；

[a9cc8b6acf4441218ddfd6dea1aa1213.png]: https://img-blog.csdnimg.cn/a9cc8b6acf4441218ddfd6dea1aa1213.png