《Thinking in Java》读书笔记（一）

最新推荐文章于 2019-03-10 15:12:38 发布

swpu_ocean

最新推荐文章于 2019-03-10 15:12:38 发布

阅读量308

点赞数

CC 4.0 BY-SA版权

文章标签： Java

本文链接：https://blog.youkuaiyun.com/swpu_ocean/article/details/80205791

本文深入讲解Java的基础概念，包括关键字作用范围、面向对象特性、数据类型、操作符、控制执行流程等核心内容，并介绍了垃圾回收机制及枚举类型。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

第1章对象导论

1.1 Java中的三个关键字及其作用范围

① public：表示紧随其后的元素对任何人都是可用的。
② private：表示除类型创建者和类型的内部方法之外的任何人都不能访问。
③ protected：与private作用相当，差别仅在于继承的类可以访问protected成员，但不能访问private成员。

1.2 面向对象三要素

封装、继承、多态

第2章一切都是对象

2.1 String s

创建一个String的引用。

2.2 存储

堆栈：某些Java数据存储于堆栈中—特别是对象的引用
堆：用于存放所有的Java对象

2.3 Java中定义的数据类型

基本类型
① 数值类型
② 布尔类型
③ 指针类型
引用类型
① 类
② 数组
③ 接口

2.4 基本类型

基本类型	大小	包装类型
boolean	———	Boolean
byte	1个字节	Character
char	2个字节	Byte
short	2个字节	Short
int	4个字节	Integer
float	4个字节	Long
long	8个字节	Float
double	8个字节	Double
void	———	Void

boolean类型所占存储空间的大小没有明确指定，仅定义为能够取字面值true和false

第3章操作符

3.1 引用

A a1 = new A();
A a2 = new A();
a1 = a2; //修改的是a1的引用

在堆上new了两个对象并将这两个对象的分别指向a1、a2，即a1、a2拥有堆上这两个对象的引用，当进行a1 = a2操作时，会将原先指向a2对象的引用指向a1，原先指向a1的引用被覆盖，并且随后垃圾回收器会清理a2对象。

3.2 Random类

//47 为随机数种子，即相同种子总是产生相同的随机数序列
Random rand = new Random(47);
//nextInt()传入的参数设置了所产生的随机数的上限，下限为0。即产生0~10之间的数
int i = rand.nextInt(10);

第4章控制执行流程

4.1 print家族

① println()：打印并换行
② printnb()：打印不换行

第5章初始化与清理

5.1 重载

5.1.1 构造器重载：具有相同的构造器名字，但形式参数不同

class Tree{
    int height;

    Tree(){
    }

    Tree(int height){
        this.height = height;
    }
}

5.1.2 方法重载：具有相同的方法名字，但形式参数不同

class Tree{
    int height;

    void tree(){
        System.out.println("I don't have height");
    }

    void tree(int height){
        System.out.println("I have height");
    }
}

如何区分两个不同方法：
① 参数的数量或类型不同
② 参数的顺序不同
注意：不能通过返回值来区分重载方法！！！

5.2 this关键字

this关键字只能在方法内部使用，表示对“调用方法的那个对象”的引用。

class Leaf{
    int i = 0;
    Leaf increment(){
        i++
        return this; //返回当前对象的引用
    }
}

5.3 static关键字

在static方法的内部不能调用非静态方法，反过来是可以的。

5.4 垃圾回收机制

垃圾回收只会释放那些经由new分配的内存，但并不是绝对的会释放。

垃圾回收方式：
① 停止-复制：先暂停程序的运行，然后将所有存活的对象从当前堆复制到另一个堆，没有被复制的全部都是垃圾
② 标记-清扫：从堆栈和静态存储区出发，遍历所有的引用，进而找出所有存活的对象。每当它找到一个存活对象，就会给对象设一个标记，这个过程中不会回收任何对象。只有全部标记工作完成的时候，清理动作才会开始。

5.5 成员初始化

在类的内部，不管变量定义散布与类的何处，它们都会在任何方法以及构造器被调用之前得到初始化。

初始化的顺序：
① 无父类
静态变量 > 静态初始化块 > 变量 > 初始化块 > 构造函数

② 有父类
父类静态变量 > 父类静态初始化块 > 子类静态变量 > 子类静态初始化块 > 父类变量 > 父类初始化块 > 父类构造函数 > 子类变量 > 子类初始化块 > 子类构造函数

总结对象创建的过程，假设有个名为Dog的类：
① 即使没有显式地使用static关键字，构造器实际上也是静态方法。因此，当首次创建类型为Dog的对象时，或者Dog类的静态方法/静态域首次被访问时，Java解释器必须查找类路径，以定义Dog.class文件。
② 然后载入Dog.class，有关静态初始化的所有动作都会执行。因此，静态初始化只在Class对象首次加载的时候进行一次。
③ 当用到new Dog()创建对象的时候，首先将在堆上为Dog对象分配足够的存储空间。
④ 自动地将Dog对象中的所有基本类型都设置成默认值，而引用则被设置成了null。
⑤ 执行所有出现于字段定义处的初始化动作。
⑥ 执行构造器。

5.6 显示的静态初始化（静态块）

静态块实际上只是一段跟在static关键字后面的代码。与其他静态初始化动作一样，当首先生成这个类的一个对象时，或者首次访问属于这个类的静态数据成员时，这段代码仅执行一次。

public class Spoon{
    static int i;
    static {
        i = 47;
    }
}

5.7 枚举类型

public enum Enum {
    HOT,COLD,WEARM
}
——————————————————————————
public class Main {

    public static void main(String[] args) {
        Enum enums = Enum.HOT;
        System.out.println(enums);

        for(Enum e : Enum.values()){
            System.out.println("enum is " + e + ",ordinal is " + e.ordinal());
        }
    }

}
——————————————————————————
//output
HOT
enum is HOT,ordinal is 0
enum is COLD,ordinal is 1
enum is WEARM,ordinal is 2