=Start=

缘由：

作为一个Java编程新手，整理一下在学习《Java核心技术 卷I：基础知识》时的笔记，方便以后回顾和参考。

正文：

参考解答：

• 封装：Java中所有的代码都放在了类中，从形式上来看只是将变量和方法放在了一起，但是推荐将所有的变量都用private修饰，只允许类内部的方法进行修改，这样一层封装确保了数据不会被随意修改，使大型项目的排错更容易。
• 继承：可以通过继承这种方式在超类的基础上丰富子类的功能。同时也达到了代码复用的效果。
• 重载：同一个方法名，根据参数的不同，由编译器来决定实际该调用哪个方法。
• 多态：一个Employee类变量除了可以指代Employee对象之外，还可以指代基于Employee类派生出的Manager类的变量。

第1章 Java程序设计概述

• ……
• 1.3 Java applet与Internet
  • 在网页中运行的Java程序被称为applet
• 1.4 Java发展简史
• ……

第2章 Java程序设计环境

• ……
• 2.3 使用命令行工具
  • javac和java
• ……
• 2.6 建立并运行applet

第3章 Java的基本程序设计结构

• 3.1 一个简单的Java应用程序
  • Java对大小写敏感
• 3.2 注释
• ……
• 3.6 字符串
  • 3.6.1 子串
  • 3.6.2 拼接
  • 3.6.3 不可变字符串
  • 3.6.4 检测字符串是否相等
  • 3.6.5 空串与Null串
  • ……
  • 3.6.9 构建字符串
• 3.7 输入输出
  • 3.7.1 读取输入
  • 3.7.2 格式化输出
  • 3.7.3 文件输入与输出
• ……
• 3.10 数组
  • 3.10.1 for each循环
  • 3.10.2 数组初始化以及匿名数组
  • 3.10.3 数组拷贝
  • 3.10.4 命令行参数
• ……

第4章 对象与类

• 4.1 面向对象程序设计概述
  • 面向对象的程序是由对象组成的，每个对象包含对用户公开的特定功能部分和隐藏的实现部分。
  • 在OOP中，不必关心对象的具体实现，只要能够满足用户的需求即可。
  • 4.1.1 类
    • 用Java编写的所有代码都位于某个类的内部
    • 在扩展一个已有的类时，这个扩展后的新类具有所扩展的类的全部属性和方法
  • 4.1.2 对象
  • 4.1.3 识别类
    • 首先从设计类开始，然后再往每个类中添加方法。
    • 识别类的简单规则是：在分析问题的过程中寻找名词，而方法对应着动词。
  • 4.1.4　类之间的关系
    • 依赖（”uses-a”）：应该尽可能的将相互依赖的类减至最少！！！
    • 聚合（”has-a”）
    • 继承（”is-a”）
• 4.2 使用预定义类
  • 4.2.1 对象与对象变量
    • 构造器是一种特殊的方法，用来构造并初始化对象。构造器的名字应该与类名相同。
    • 一个对象变量并没有实际包含一个对象，而仅仅引用一个对象。
    • 在Java中，任何对象变量的值都是对存储在另外一个地方的一个对象的引用。
  • 4.2.2 Java类库中的Gregorian-Calendar类
  • 4.2.3 更改器方法与访问器方法
• 4.3 用户自定义类
  • 要想创建一个完整的程序，应该将若干类组合在一起，其中只有一个类有main方法。
  • 类文件（.java文件）名必须与public类的名字相匹配。
  • 在一个源文件中，只能有一个公有类，但可以有任意数目的非公有类。
  • 4.3.1 Employee类
    • 域（变量）
    • 构造函数
    • 方法
  • 4.3.2 多个源文件的使用
  • 4.3.3 剖析Employee类
  • 4.3.4 从构造器开始
    • 构造器与类同名；
    • 每个类可以有一个以上的构造器；
    • 构造器可以有0个、1个或多个参数；
    • 构造器没有返回值；
    • 构造器总是伴随着new操作符一起调用。
  • 4.3.5 隐式参数与显式参数
    • 第一个参数称为隐式（implicit）参数——关键字this，隐式参数没有出现在方法声明中。
  • 4.3.6 封装的优点
    • 第一：限定了可以修改内部变量的方法；
    • 第二：更改器方法可以执行错误检查。
  • 4.3.7 基于类的访问权限
  • 4.3.8 私有方法
  • 4.3.9 final实例域
• 4.4 静态域与静态方法
  • 4.4.1 静态域（静态变量）
  • 4.4.2 静态常量
  • 4.4.3 静态方法
  • 4.4.4 工厂方法
  • 4.4.5 main方法
• 4.5 方法参数
  • Java总是采用按值调用（call by value）。
  • Java对对象采用的不是引用调用，实际上，对象引用进行的是值传递。
• 4.6 对象构造
  • 4.6.1 重载
    • 如果有多个方法有相同的名字、不同的参数，便产生了重载。
  • 4.6.2 默认域初始化
  • 4.6.3 无参数的构造器
  • 4.6.4 显式域初始化
  • 4.6.5 参数名
  • 4.6.6 调用另一个构造器
  • 4.6.7 初始化块
  • 4.6.8 对象析构与finalize方法
• 4.7 包
  • Java使用包（package）将类组织起来。使用包的主要原因是确保类名的唯一性。
  • 4.7.1 类的导入
  • 4.7.2 静态导入
  • 4.7.3 将类放入包中
    • 如果没有在源文件中放置package语句，这个源文件中的类就被放置在一个默认包（default package）中。
  • 4.7.4 包作用域
• 4.8 类路径
• 4.9 文档注释
  • 4.9.1 注释的插入（javadoc）
  • 4.9.2 类注释
  • 4.9.3 方法注释
  • 4.9.4 域注释
  • 4.9.5 通用注释
  • 4.9.6 包与概述注释
  • 4.9.7 注释的抽取
• 4.10 类设计技巧
  • 一定要保证数据私有（private）
  • 一定要对数据初始化

第5章 继承

• 利用继承，人们可以基于已存在的类构造一个新类。继承已存在的类就是复用（继承）这些类的方法和域。
• 5.1 类、超类和子类
  • 关键字extends表示继承。已存在的类称为 超类（super class）、基类（base class）或父类（parent class）；新类称为 子类（sub class）、派生类（derived class）或孩子类（child class）。
  • 一个对象变量可以指示多种实际类型的现象被称为多态（polymorphism）。
  • 在运行时能够自动的选择调用哪个方法的现象被称为动态绑定（dynamic binding）。
  • 5.1.1 继承层次
  • 5.1.2 多态
    • 在Java中，对象变量是多态的。一个Employee变量既可以引用一个Employee类对象，也可以引用一个Employee类的任何一个子类的对象（例如：Manager、Executive等）
  • 5.1.3 动态绑定
  • 5.1.4 阻止继承：final类和方法
    • 不允许扩展的类被称为final类。
    • 类中的特定方法也可以被声明为final。如果这样做，子类就不能覆盖这个方法（final类中的所有方法自动地成为final方法）。
    • 将方法或类声明为final的主要目的是：确保它们不会在子类中改变语义。
  • 5.1.5 强制类型转换
  • 5.1.6 抽象类
    • 为了提高程序的清晰度，包含一个或多个抽象方法的类本身必须被声明为抽象的。
    • 抽象方法充当着占位的角色，它们的具体实现在子类中。
    • 类即使不含抽象方法，也可以将类声明为抽象类。抽象类不能被实例化。（实例化可以简单的认为是用new关键字进行的）
  • 5.1.7 受保护访问
• 5.2 Object：所有类的超类
  • Object类是Java中所有类的始祖，在Java中每个类都是由它扩展而来的。
  • 5.2.1 equals方法
  • 5.2.2 相等测试与继承
  • 5.2.3 hashCode方法
    • equals与hashCode的定义必须一致：如果 x.equals(y) 返回 true ，那么 x.hashCode() 就必须与 y.hashCode() 具有相同的值。
  • 5.2.4 toString方法
• 5.3 泛型数组列表
  • ArrayList是一个采用类型参数（type parameter）的泛型类（generic class）。
  • 5.3.1 访问数组列表元素
  • 5.3.2 类型化与原始数组列表的兼容性
• 5.4 对象包装器与自动装箱
  • 有时，需要将 int 这样的基本类型转换为对象。所有的基本类型都有一个与之对应的类。例如，Integer类对应基本类型int。通常，这些类被称为包装器（wrapper）。
  • 比如 list.add(3) 这个调用将自动的变换成 list.add(Integer.valueOf(3)) ，这种变换被称为自动装箱（auto boxing）。
• 5.5 参数数量可变的方法
  • System.out.printf()
• 5.6 枚举类
• 5.7 反射
  • 反射是指在程序运行期间发现更多的类及其属性的能力。
  • 5.7.1 Class类
    • Employee e; Class cl = e.getClass();
  • 5.7.2 捕获异常
  • 5.7.3 利用反射分析类的能力
  • 5.7.4 在运行时使用反射分析对象
  • 5.7.5 使用反射编写泛型数组代码
  • 5.7.6 调用任意方法
• 5.8 继承设计的技巧
  • 将公共操作和域放在超类
  • 不要使用受保护的域
  • 使用继承实现 “is-a” 关系
  • 使用多态，而非类型信息
  • 不要过多的使用反射

第6章 接口与内部类

• 首先，接口是一种技术；其次，这种技术主要用来描述类具有什么功能，而并不给出每个功能的具体实现。
• 6.1 接口
  • 在Java中，接口不是类，而是对类的一组需求描述，这些类要遵从接口描述的统一格式进行定义。
  • 6.1.1 接口的特性
    • 接口不是类，尤其不能使用new运算符实例化一个接口！
    • 尽管每个类只能够拥有一个超类，但却可以实现多个接口。这就位定义类的行为提供了极大的灵活性。
  • 6.1.2 接口与抽象类
    • 为什么有了抽象类之后还要有接口？因为用抽象类表示通用属性存在这样一个问题：每个类只能扩展于一个类。尽管每个类只能够拥有一个超类，但却可以实现多个接口，这样类的定义就比较灵活。
• 6.2 对象克隆
• 6.3 接口与回调
  • 回调（callback）是一种常见的程序设计模式。在这种模式中，可以指出某个特定事件发生时该采取的动作。
• 6.4 内部类
  • 6.4.1 使用内部类访问对象状态
  • 6.4.2 内部类的特殊语法规则
  • 6.4.3 内部类是否有用、必要和安全
  • 6.4.4 局部内部类
  • 6.4.5 由外部方法访问final变量
  • 6.4.6 匿名内部类
  • 6.4.7 静态内部类
• 6.5 代理
  • 利用代理可以在运行时创建一个实现了一组给定接口的新类。这种功能只有在编译时无法确定需要实现哪个接口时才有必要使用。
  • 所有的代理类都扩展于Proxy类。
  • 代理类一定是public和final。

第10章 部署应用程序和applet

• 10.1 JAR文件
  • 10.1.1 清单文件
    • 除了类文件、图像和其它资源外，每个jar文件还包含一个用于描述归档特征的清单文件
    • 清单文件被命名为MANIFEST.MF，它位于jar文件的一个特殊 META-INF 子目录中
  • 10.1.2 可运行JAR文件
  • 10.1.3 资源
  • 10.1.4 密封
• 10.2 Java Web Start
  • 10.2.1 沙箱
  • 10.2.2 签名代码
  • 10.2.3 JNLP API
• 10.3 applet
  • 10.3.1 一个简单的applet
    • applet是一种包含在HTML网页中的Java应用程序
  • 10.3.2 applet的HTML标记和属性
  • 10.3.3 object标记
  • 10.3.4 使用参数向applet传递信息
  • 10.3.5 访问图像和音频文件
  • 10.3.6 applet上下文
• 10.4 应用程序首选项存储
  • 10.4.1 属性映射
  • 10.4.2 Preferences API

第11章 异常、断言、日志和调试

• 11.1 处理错误
  • 11.1.1 异常分类
    • 在Java中，异常对象都是派生于Throwable类的一个实例
    • 所有的异常都是由Throwable继承而来，但在下一层立即分解为两个分支：Error和Exception
    • Error类层次结构描述了Java运行时系统的内部错误和资源耗尽错误，应用程序不应该抛出这种类型的对象，如果遇到了，除了通告给用户，并尽力使程序安全地终止之外，再也无能为力了；
    • Exception层次结构是在编码时需要重点关注的，它又分为两个分支：一个是RuntimeException（如果出现RuntimeException异常，那么就一定是你的问题），另一个是其它异常；
    • 由程序错误导致的异常属于RuntimeException，包含下面几种情况：
      • 错误的类型转换
      • 数组访问越界
      • 访问空指针
    • Java语言规范将派生于Error类或RuntimeException类的所有异常称为「未检查异常」，所有其它的异常称为已检查异常。
  • 11.1.2 声明已检查异常
    • 一个方法不仅需要告诉编译器将要返回什么值，还要告诉编译器有可能发生什么错误。
    • 方法应该在其首部声明所有可能抛出的异常。这样可以从首部反映出这个方法可能抛出哪类已检查异常。
      • public FileInputStream(String name) throws FileNotFoundException, EOFException
      • public FileInputStream(String name) throws Exception
    • 总之，一个方法必须声明所有可能抛出的「已检查异常」，而「未检查异常」要么不可控制（Error），要么就应该避免发生（RuntimeException）。
  • 11.1.3 如何抛出异常
    • throw new EOFException();
    • EOFException e = new EOFException(); throw e;
  • 11.1.4 创建异常类
    • 定义一个派生于Exception的类，或者派生于Exception子类的类。
• 11.2 捕获异常
  • 如果某个异常发生的时候没有在任何地方进行捕获，那程序就会终止执行，并在控制台上打印出异常信息，其中包括异常的类型和堆栈的内容。
  • 如果调用了一个抛出已检查异常的方法，就必须对它进行处理，或者将它继续进行传递。
  • 11.2.1 捕获多个异常
  • 11.2.2 再次抛出异常与异常链
  • 11.2.3 finally子句
  • 11.2.4 带资源的try语句
  • 11.2.5 分析堆栈跟踪元素
• 11.3 使用异常机制的技巧
  • 异常处理不能替代简单的测试
  • 不要过分的细化异常
  • 利用异常层次结构
  • 不要压制异常
  • 在检测错误时，「苛刻」要比放任更好
  • 不要羞于传递异常
• 11.4 使用断言
  • 11.4.1 启用和禁用断言
  • 11.4.2 使用断言完成参数检查
  • 11.4.3 为文档假设使用断言
• 11.5 记录日志（Logger）
  • 11.5.1 基本日志
  • 11.5.2 高级日志
  • 11.5.3 修改日志管理器配置
  • 11.5.4 本地化
  • 11.5.5 处理器
  • 11.5.6 过滤器
  • 11.5.7 格式化器
  • 11.5.8 日志记录说明
• 11.6 调试技巧
  • 打印变量的内容System.out.println()
  • 在每一个类中放置一个main方法，这样就可以对每一个类进行单元测试
  • JUnit
  • 日志代理（logging proxy）
  • 利用Throwable类提供的printStackTrace方法，可以从任何一个异常对象中获得堆栈情况
  • 利用printStackTrace(PrintWriter s)将堆栈跟踪发送到一个文件中
  • 将错误信息单独保存在一个文件在（java myprogram 2>errors.txt）
  • 观察类的加载过程（在启动时添加 -verbose 选项）
  • 使用-Xlint选项对代码问题进行检查
  • 使用jconsole
  • 使用jmap
  • 使用-Xprof选项
• 11.7 GUI程序排错技巧
• 11.8 使用调试器
  • 断点
  • 单步跟踪

参考链接：

• 《Java核心技术 卷1 基础知识（原书第9版）》

=END=