第一章 Java程序设计概述
关键字：简单性、可移植性、面向对象、解释型、网络技能、高性能、安全性、动态性、体系结构中立
第二章 Java程序设计环境
2.1安装
安装时在windows版本下尽量不要在有空格的路径下安装
2.2 使用命令行工具
1、打开shell窗口
2、进入源代码目录
3、输入命令
编译命令 javac 文件名.java
运行命令 java 文件名
2.3集成开发环境
1、eclipse
2、IDEA
第三章 Java基本的程序设计结构
3.1简单的java应用程序
1.类名定义：以字母开头，后面可以是字母和数字组合，长度没有基本限制，不可使用java保留字。
标准命名规范：大写字母开头，使用驼峰命名法
3.2注释
1. java注释共有三种，注释不会出现在可执行程序中
// 表示本行注释，注释内容从//开始到本行结尾
/*和*/表示多行注释（不可嵌套）
/** 和*/可以用来自动生成文档
3.3数据类型
java是一种强类型语言，每个变量必声明类型。
java中共有8中基本类型：
1、4种整型：
int类型最常用，在java中整型范围与机器无关，不同机器的运行结果一致。且java中没有无符号类型
long类型数据有后缀L
不同进制的表现形式：
2、2种浮点类型
double类型也被称为双精度数值，大部分通用
float类型数值有后缀F
特殊浮点数：
- 负无穷大（Double.NEGATIVE_INFINITY）
- 正无穷大（Double.POSITIVE_INFINITY）
- Double.NaN（不是一个数字，正整数除以0，0/0或者负数的平方根的结果， NaN不能用'=='判断，可以用Double.isNaN()方法）
3、char类型
表示单个字符，通常用来表示字符常量，建议不要再程序中使用char类型
4、boolean类型
boolean类型有两个值：false和true，用来判断逻辑条件，整型(Integer)与boolean类型间不能相互转换
3.4变量
1、变量命名：java中变量名以字母、下划线或者$开头，不能以数字开头，后面跟字母、下划线、美元符、数字，长度没有限制.
2、变量初始化：声明变量后，可以用赋值语句对变量进行初始化。尽量不要使用未初始化的变量。变量的声明尽可能靠近第一次使用的地方
3、常量：关键字final指示常量，表示变量只能赋值一次； 关键字static final 指示类常量，可以在一个类中的多个方法使用；习惯上常量使用全大写
3.5 运算符
3.5.1 自增与自减运算符
两个运算符有两种形式：后缀式（a++）和前缀式（++a），前缀式先进行加1运算；后缀方式则先使用变量原来的值在进行加1
举例：
int a = 6;
int b = 6;
System.out.println("前缀式的值 " + (++a));
System.out.println("后缀式的值 " + (b++));
System.out.println("后缀式的值自增后的值 " + b);结果：
3.5.2 关系运算符与boolean运算符
1、关系运算符：
==（等于），!=（不等），>（大于），>=（大于等于），<（小于），<=（小于等于）
2、boolean运算符
&&表示“与”，|| 表示“或”；两个运算符按照短路方式求值，例如
expression1 && expression2
若expression1为false，则不再计算expression2
expression1 || expression2
若expression1为true，则不再计算expression2
3、三元操作符
condition ？ expression1 ：expression2 条件condition为真时计算第一个表达式，否则计算第二个表达式。
3.5.3 位运算符
1、原码、补码和反码等知识参照笔记计算机基础原理中内容
2、java位运算符
在java中，使用补码来表示二进制数，补码中，最高位表示符号位，正数符号位为0，负数符号位为1
（1）&： 按位与
按位与的运算规则：只有两个操作数对应的结果同时为1时，结果为1，其余全为0（即只要有一个操作数为0，结果就为0）
（2）按位或
运算规则：只有两个操作数对应位同时为0，结果为0，其余位1（即只要两个操作数有一个为1，结果为1）
（3）按位非
运算规则：按位取反
（4）按位异或
运算规则：相同为0，不同为1
任何数异或本身的结果为0，且有定理 a^b = b^a,异或是一个无顺序的运算符，则b^a^b=b^b^a，结果为0^a
异或遵循的数学计算法则：
① a ^ a =0
② a ^ b =b ^ a
③ a ^b ^ c = a ^ (b ^ c) = (a ^ b) ^ c;
④ d = a ^b ^ c 可以推出 a = d ^ b ^ c.
⑤ a ^ b ^a = b.
（5）左位移<<
左移规则：符号位不变，低位补0
左移一位相当于原来的数乘2 2<<2=8
m<<n = m的(n+1)次方
（6）右位移>>
右移规则： 低位溢出，符号位不变并用符号位补高位
右移一位表示原来的数除以2
（7）无符号右移>>>
低位溢出，高位补0. 无符号右移时将符号位当做普通数据位看待，用0填充高位
没有<<<运算符
3.位运算符常用操作
（1）m * (2的n次方）
m * Math.pow(2,n) = m << n
(2) 判断一个数的奇偶性
n & 1 == 1 ? "奇数" : "偶数"；
(3)不用临时变量交换两个数
int a = 3;
int b = 4;
a = a^b;
b = b^a;
a = a^b;输出 a ，b结果为 4,3
3.5.4 数学函数与常量
1.数学函数
在java中的Math类中提供了一系列的数学函数：
（1） 算数函数
Math.sqrt() // 平方根
Math.cbrt() // 立方根
Math.pow(a, b) // 计算a的b次幂 （参数和返回值均为double类型）
Math.max(a, b) // 计算最大值
Math.min(a, b) // 计算最小值
Math.abs(a, b) // 取绝对值（2）四舍五入和取整
Math.ceil() // 向上取整
Math.floor() // 向下取整
Math.round()
// 四舍五入, 返回int(参数为float时)或long(参数为double时) ，.5时向大数舍入
Math.rint() // 四舍五入, 返回double值(在 x.5 时向偶数舍入)（3）随机数
Math自带一个随机数方法Math.random(), 用来生成一个[0, 1)范围内均匀分布的double类型(伪)随机数。也可以使用它通过算数运算来组合形成各个区间的随机数
Math.randon() * 2 // [0, 2)
Math.random() + 1 // [1, 2)
Math.random() * 3 + 3 // [3, 6)在java的工具类java.util.Random中存在更多关于随机数的方法
（4）三角函数、指数函数、对数函数
// 对数运算
Math.log() // 自然对数(底数e)
Math.log10() // 常用对数(底数10)
Math.exp() //返回e的x次方
// 三角函数运算
Math.sin()
Math.cos()
Math.tan()
Math.atan()
Math.atan2()2.数学常量
Math.PI //π的近似值
Math.E //e的近似值3.5.5 数值类型转换
1.隐式转换(自动类型转换)
如果以下 2 个条件都满足，那么将一种类型的数据赋给另外一种类型变量的时，将执行自动类型转换（automatic type conversion）。
- 两种数据类型彼此兼容
- 目标类型的取值范围大于源数据类型（低级类型数据转换成高级类型数据）
当以上 2 个条件都满足时，拓宽转换（widening conversion）发生。例如 byte 类型向 short 类型转换时，由于 short 类型的取值范围较大，会自动将 byte 转换为 short 类型。
在运算过程中，由于不同的数据类型会转换成同一种数据类型，所以整型、浮点型以及字符型都可以参与混合运算。自动转换的规则是从低级类型数据转换成高级类型数据。转换规则如下：
- 数值型数据的转换：byte→short→int→long→float→double。
- 字符型转换为整型：char→int。
以上数据类型的转换遵循从左到右的转换顺序，最终转换成表达式中表示范围最大的变量的数据类型。
上图中的实线表示无信息丢失的转换，虚线表示可能存在精度丢失的转换。
2.强制类型转换（显式转换）
自动转换不能满足所有变成需要，有时也需要将double转换成int类型，，所以当两种数据类型不兼容，或目标类型的取值范围小于源类型时，自动转换将无法进行，这时就需要进行强制类型转换（cast）。
语法格式： (type)variableName type表示要转换的数据类型，varibaleName表示需要转换的变量
double b = 9.997;
int a = (int)b; //a的值为9，直接截断小数部分注： 当使用强制转换时，试图将一种类型强制转换成另一种类型，但有超出了目标类型的表示范围，就会截断程一个完全不同的值，(byte)300的实际值为44（按照300的二进制截取后8位得到44）
例题： a=a+b和a+=b的区别？
答：java语言中，a+=b和a=a+b的主要区别是在运算的精度上。类似的有“-= 、 *= 、/= 、%= ”
byte a=1;
a=a+4; //本行报错cannot convert from int to byte3.5.6 运算符优先级
3.5.7 枚举类型
当某个变量的取值在一个有限的集合内时，可以定义枚举类型，枚举类型包括有限个命名的值。
public class test {
enum Mycolor {红色, 绿色, 蓝色};
public static void main(String[] args) {
Mycolor mycolor = Mycolor.红色;
System.out.println(mycolor);
}
}结果：
3.6 字符串
3.6.1 字符串常用函数
(1) 获取
1).字符串中包含的字符数，也就是字符串的长度。
int length() //获取长度
2).根据位置获取位置上某个字符。
char charAt(int index) //返回指定位置的字符
int codePointAt(int index) //
3).根据字符获取该字符在字符串中的位置。
int indexOf(int ch) //返回的是ch在字符串中第一次出现的位置。
int indexOf(int ch,int fromIndex) //从fromIndex指定位置开始，获取ch在字符串中出现的位置。
int indexOf(String str) //返回的是str在字符串中第一次出现的位置。
int indexOf(String str，int fromIndex) //从fromIndex指定位置开始，获取str在字符串中出现的位置。
int lastIndexOf(String str)
int lastIndexOf(String str, int from index)
int lastIndexOf(int ch)
int lastIndexOf(int ch, int fromIndex)
//str在字符串最后一次出现的位置。
(2) 判断
1).字符串中是否包含某一个子串。
boolean contains(str);
特殊之处：indexOf(str):可以索引str第一次出现为止，如果返回-1，表示该str不在字符串中存在。所以，也可以用于对指定判断是否包含。
if(str.indexOf("a")!=-1)//如果不存在返回-1，否则返回字符的实际位置坐标
lastIndexOf("a") //倒序查找
而且该方法既可以判断，也可以获取出现的位置。
2).字符串中是否有内容。
boolean isEmpty() //原理就是判断长度是否为0。
3).字符串是否以指定内容开头。
boolean startsWith(str);
4).字符串是否以指定内容结尾。
boolean endsWith(str);
5).判断字符内容是否相同，复写了object类中的equals方法。
boolean equals(str);
6).判断内容是否相同，并忽略大小写。
boolean.equalsIgnorecase();
(3)转换
1).将字符数组转成字符串。
构造函数：String(char[])
String(char[],offset,count):将字符数组中的一部分转成字符串
静态方法：
static String copyValueOf(char[]);
static String copyValueOf(char[] data,int offset,int count);
static String valueOf(char[]);
2).将字符串转成字符组
char[] toCharArray();
3).将字节数组转成字符串。
String(byte[])
String(byte[],offset,count):将字节数组中的一部分转成字符串
4).将字符串转成字节数组。
byte[] getBytes()
5).将基本数据类型转成字符串，
static String valueOf(int)
static String valueOf(double)
// 3+"" 与 String.valueOf(3)的值是一样的
特殊：字符串和字节数组在转换过程中，是可以指定编码的。
(4)替换
String replace(CharSequence oldString , CharSequence newString) //用newString代替oldString，可以用string，char ，StringBuilder作为CharSequence对象
(5)切割
String[] split(regex);
(6)子串。获取字符串中的而一部分
String subString(begin);
String subString(begin,end); //begin,end都是实际的位置坐标
(7)转换，去除空格，比较。
1).将字符串转成大写或小写
String toUpperCsae() //将字符串中所有小写字母转为大写字母
String toLowerCsae() //将字符串中所有大写字母转为小写字母
2).将字符串两端的多个空格去除
String trim() //去除字符串两端空格
3).对两个字符串进行自然顺序的比较
int compareTo(String str) //按照字典顺序，若位于str之前，返回负数；位于str之后返回正数，相等返回0
3.6.2 空串与null串
空串""是长度为0的字符串,有自己的串长度（0） 和内容（空）. String变量还可以存放null值，表示目前没有任何对象与此变量有关系。
//检查字符串是否为空
if(str.length() == 0)
//或
if(str.equals(""))
//检查字符串是否为null值
if(str == null)
//检查一个字符串既不是null也不是空串
if(str != null && str.length() != 0)3.7 输入输出
3.7.1 输入
3.7.2输出
常见格式化输出标识符
举例
3.8控制流程
3.8.1 块作用域
块（block即复合语句）是指由花括号括起来的若干条简单的java语句，块确定了变量的作用域，可以嵌套。在嵌套的两个块中不可以声明同名的变量
注：C++中嵌套块重复定义变量内层中的变量会对外层进行覆盖，但java不允许这个操作
3.8.2 条件语句if
条件语句的格式：
if(condition) {
statement1;
statement2;
......
} else if (condition) {
statement1;
statement2;
......
} else {
statement1;
statement2;
......
}else if 和else都是可选的，else if部分可以有多个。
3.8.3循环while
当条件为true时 ，while循环执行一条语句（或语句块）,格式：
while(condition) {
statement;
}
while语句先检测循环条件，因此语句可能不会被执行，若希望语句至少被执行一次可以使用do-while循环
3.8.4确定循环for
for循环是支持迭代的通用结构，利用每次迭代后更新的计数器或者变量来控制迭代次数，格式：
for(初始化表达式;布尔表达式;更新表达式) {
循环体;
}
对于for循环来说，初始化表达式、布尔表达式、更新表达式都不是必须的，当布尔表达式缺失的时候，没有条件控制的前提下，会形成死循环
3.8.5多重选择：switch语句
格式：
switch(expression){
case value :
//语句
break; //可选
case value :
//语句
break; //可选
//你可以有任意数量的case语句
default : //可选
//语句
}switch语句从选项匹配的case开始执行直到遇到break，或者执行到switch语句结束，没有匹配的case时有default，则执行default语句。switch语句没有break时可执行多个case；case标签的变量类型可以是： byte、short、int 和char（或其包装类）。
3.8.6中断控制流程语句：break和continue
break的作用是跳出当前循环块（for、while、do while）或程序块（switch）。在循环块中的作用是跳出当前正在循环的循环体。在程序块中的作用是中断和下一个case条件的比较。简单来说break的作用是结束循环，执行循环下面的语句。
continue用于结束循环体中其后语句的执行，并跳回循环程序块的开头执行下一次循环，而不是立刻循环体。continue是结束本次循环，执行下一次循环
For(int i = 0;i<=5;i++){
If(i = =3)continue;
System.out.println("The number is:"+i);
}
结果为：
The number is:0
The number is:1
The number is:2
The number is:4
The number is:5
For(int i = 0;i<=6;i++){
If(i = =3)break;
System.out.println("The number is:"+i);
}
结果为：
The number is:0
The number is:1
The number is:23.9大数值
当基本类型的正数和浮点数的精度都不能满足需求时，可以使用java.math中的两个类：BigInteger（用于处理任意精度的整数运算）和BigDecimal（用于处理任意精度的浮点数运算）
使用静态方法valueOf()可以将普通数值转换成大数值
BigInteger a = BigInteger.valueOf(100);但是不能使用加(+)减(-)乘(*)除(/)进行大数值的运算，需要使用相应的方法
java.math.BigInteger
- BigInteger add(BigInteger other)--------和
- BigInteger subtract(BigInteger other)---------差
- Biginteger multiply(BigInteger other)----------积
- BigInteger divide(BigInteger other)-----------除
- BigInteger mod(BigInteger other)-----------余
- int compareTo(BigInteger other)---------如果这个大整数与另一个大整数other相等，返回0；小于返回负数；大于返回正数。
- static BigInteger valueOf(long x)----------返回值等于x的大整数
java.math.BigDecimal
- BigDecimal add(BigDecimal other)----------和
- BigDecimal substract(BigDecimal other)---------差
- BigDecimal multiply(BigDecimal other)----------积
- BigDecimal divide(BigDecimal other RoundingMode mode)--------商，想要计算商，必须给出舍入方式（roundMod）
- int compareTo(BigDecimal other)------参考整数。
- static BigDecimal valueOf(long x)
- static BigDecimal valueOf(long x, int scale)------返回值为x或x/10scale 的一个大实数。
3.10数组
数组是一种数据结构，用于存放同一类型的数据的集合。通过正式下标可以访问数组中的值
声明格式：
数据类型 [] 数组名称 = new 数据类型[长度];
· 数组长度一旦声明，不可改变不可追加，获取数组长度可以用array.length，在创建数组后，就可以给数组元素赋值。
注：在创建数组时会有默认值，创建数字数组，所有元素初始化为0；boolean数组的元素初始化为false；对象数组的元素初始化为null，表示未存放任何对象，比如在创建字符串数组时，数组中所有字符串都为null
3.10.1for each循环
foreach是增强型的for循环，格式：
for(元素类型t 元素变量x : 遍历对象obj){
引用了x的java语句;
}
foreach中的遍历对象必须是一个数组或者是一个实现了Iterable接口的类对象；foreach循环会遍历数组中的每个元素，而不需要使用下标，从而不担心数组越界的可能性，一般用来结合泛型使用
3.10.2数组初始化及匿名数组
java提供了一种创建对象同时赋予初始值的简化书写形式，例如：
int[] smallParams = {2,3,4,5,6};使用这种形式初始化数组不必调用new，甚至可以匿名初始化。
new inr[] {2,3,4,5,6};在java中，允许数组的长度为0， 数组长度为0与null是不同的含义
3.10.3 数组拷贝
可以利用for循环或者Arrays.copyOf()函数
3.10.4 命令行参数
每一个java应用程序都有一个带String args[]参数的main方法，这个方法表示main方法会接收一个字符串数组，就是命令行参数
3.10.5数组排序
想对数组进行排序，可以使用Array.sort()方法（sort使用了优化的块排算法）也可以使用其他的排序算法，比如冒泡排序，快速排序，希尔排序等
nt[] arr = {5,2,66,3,7};
Arrays.sort(arr);//Arrays是util包常用java.until.Arrays的方法
- void fill(type[] a, type v) ：给数组中所有元素设置为v。
- void sort(type [] a)：对数组中元素排序。
- String toString(type[] a): 返回a中数据元素的字符串，用逗号分隔
- boolean equals(type[] a,type[] b)：比较两个数组，若数组大小相同，所对应下标的元素相同，返回true。
- int binarySearch(type[] a, type v)方法：对排过序的数组进行二分法查找,查找成功返回下标，否则返回一个负数。
- int binarySearch(type[] a,int start, int end, type v)方法：对排过序的数组在起始下标（包括这个值）和终止下标（不包括这个值）中进行二分法查找,查找成功返回下标，否则返回一个负数。
- type copyOf(type[] a, int length): 返回与a类型相同的一个数组，长度为length
- type copyOf(type[] a, int start, int end): 返回与a类型相同的一个数组，长度为end-start
注：数组a的类型为int , long, short, char, byte, boolean, float或double的数组
3.10.6多维数组和不规则数组
多维数组将使用多个下标访问数组元素。比较常见的是二维数组
二维数组也称矩阵，声明格式如下：
//第一种方式：
int[ ][ ] arr = new int[3][4];
//上面的代码相当于定义了一个3*4的二维数组，即二维数组的长度为3，二维数组中的每个元素又是一个长度为4的数组
//第二种方式：
int[ ][ ] arr = new int[3][ ];
//第二种方式和第一种类似，只是数组中每个元素的长度不确定，
//第三种方式：
int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};
//上面的二维数组中定义了三个元素，这三个元素都是数组，分别为{1,2}、{3,4,5,6}、{7,8,9}，
在Java中实际上没有多维数组，只有一维数组，多维数组被解释为“数组的数组” ，在矩阵中，每个一维数组的长度可以不同，即为不规则数组
第四章 对象与类
OOP: 面向对象程序设计
java是完全面向对象的。
4.1面向对象程序设计
4.1.1类
类（class）是构造对象的模板或蓝图，由类构造（construt）对象的过程称为创建类的实例
封装（encapsulation，也称数据隐藏）是将数据和行为组合在一个包中，并对对象的使用者隐藏了实现方式。对象中的数据称为实例域（instance field），操纵数据的过程称为方法（method）。实现封装的关键在于绝对不让类中的方法直接访问其他类的实例域，程序仅仅通过对象的方法与对象进行交互。
4.1.2对象
同一个类的所有对象实例，由于支持相同的行为而具有家族式的相似性。对象的行为适用可调用的方法定义的。
4.1.3识别类
4.1.4类之间的关系
常见的关系有依赖、聚合、继承
4.2适用预定义类
4.2.1对象与对象变量
在java中适用对象，需要构造对象，并指定其初始状态。可以使用构造器（construct）构造新实例，构造器本身是一种特殊的方法，用来初始化对象。
构造器的名字与类名相同，以Date类为例子，Date类的构造器名为Date，在构造对象是，需要在构造器前加上new操作符，比如：
new Date()
这个表达式构造了一个新对象，这个对象被初始化为当前的日期和时间，如果希望构造的对象可以被多次使用，可以将对象赋值给一个变量中 ：
Date birthday = new Date()；
注： 一个对象变量并没有实际包含一个对象，而是仅仅引用一个对象，在Java中，任何对象变量的值都是对存储在另一个地方的一个对象的引用。new操作符的返回值也是一个引用，在上面的表达式中，birthday就是new Date()构造的Date类型的对象的值的引用
null值表示对象变量目前没有引用任何对象，局部变量不会自动初始化，必须通过调用new或者设置null进行初始化。
4.2.2Java类库中的GregorianCalendar类
java类库有两个关于时间的类，一个是用来表示时间点的Date类，另一个是用来表示日历表示法的GregorianCalendar类，这个类扩展了Calendar类，描述了日历的一般属性。
4.2.3更改器方法与访问器方法
对实例域作出修改的方法被称为更改器方法（mutator metnod），比如set方法；对实例域只进行访问而不进行修改的方法被称为访问器方法（accessor method）例如get方法。
通常在访问器方法前面加上前缀get，更改器方法加前缀set。
4.3用户自定义类
4.3.1 Employee类
在java中，最简单的类定义形式为：
class ClassName{ fieid1 field2 ... constructor1 constructor2 ... method1 method2 ... }
举例：Employee类
package java_One;
import java.util.Date;
import java.util.GregorianCalendar;
public class EmployeeTest {
public static void main(String[] args) {
Employee[] staff = new Employee[3];
staff[0] = new Employee("Carl", 75000, 1987, 12,15);
staff[1] = new Employee("Harry", 55000, 1989, 12,15);
staff[2] = new Employee("Carl", 75000, 1987, 12,15);
for (Employee e : staff){
e.raiseSalary(5);
}
}
}
class Employee{
//instance fields
private String name;
private double salary;
private Date hireDay;
//constructor
public Employee(String n, double s, int year, int month, int day){
name = n;
salary = s;
GregorianCalendar calendar = new GregorianCalendar(year,month,day);
hireDay = calendar.getTime();
}
//method
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public Date getHireDay() {
return hireDay;
}
public void setHireDay(Date hireDay) {
this.hireDay = hireDay;
}
public void raiseSalary(double byPercent){
double raise = salary * byPercent / 100;
salary += raise;
}
}4.3.2多个源文件的使用
在上面的举例代码中，一个源文件包含了两个类。
若是每个类都存放在单独的源文件中，如：Employee存在文件Employee.java,将EmployeeTest存在文件EmployeeTest.java中
编译方法有两种，第一种使用通配符调用java编译器：java Employee*.java,这样所有匹配的源文件都会被编译，或者使用javac EmployeeTest.java 虽然这种方法没有显式编译Employee，但在编译器发现两个文件之间有使用关系时会自动编译。
4.3.3剖析Employee类
在Employee类中，所有方法都被标记为public，意味着任何类的任何方法都可以调用这些方法
实例域利用关键字private修饰，确保只有类自身方法能够访问这些实例域。
4.3.4构造器
- 构造器与类同名
- 每个类可以有一个以上构造器
- 构造器可以有0个，1个或多个参数
- 构造器没有返回值
- 构造器伴随着new一起调用
4.3.5隐式参数与显示参数
举例：
public void raiseSalary（double byPercent）{
double raise = salary * byPercent / 100;
salary += raise;
}
方法raisesalary有两个参数，以一个是隐式参数salary， 第二个是显式参数byPercent，位于方法名后的括号内，在方法中可以用this关键字表示出隐私参数 如： this.salary += raise;
4.3.6封装的优点
改变内部实现，除了该类的方法，不影响其他代码
set方法可以执行错误检查，然而直接赋值不会进行这些处理
4.3.7基于类的访问呢权限
4.3.8私有方法
在实现类时由于共有数据非常危险，应将所有实例域都设置成私有化
若需要实现私有方法，将关键字public改成private
4.3.9final实例域
将实例域既成员定义为final，在构建时需进行初始化，对象一但构建，值不可被更改
如果一个类的所有对象均不可被改变，这个类就是不可变的类
