[读书笔记]java核心技术

Posted 2020-10-05 枕上轻寒

 

ps：有时间好好整理下格式。从别的编辑器拷贝过来啥都没了。

~~~~~~~~~~~~~~·

2、java程序设计环境

JDK 开发java使用的软件；
JRE 运行java使用的软件；
SE 用于桌面或简单服务器应用的java平台--废弃
EE 用于复杂服务器应用的java平台--通用。
ME 手机或其他小型设备的java平台--废弃
库源文件和文档： src.zip---包含了所有公共类库的源代码。
JDK目录结构：
bin 编译器和工具， demo演示， docs 类库文档，include 用于编译本地方法的文件，jre运行环境文件，lib 类库文件，src类库源文件。
命令行
javac程序是java的编译器，把java后缀的文件编译成.class文件，并发送到java虚拟机，虚拟机执行编译器放在class文件中的字节码。
注意大小写，编译时需要文件名，运行时需要类名。
appletviewer程序 ，jdk自带的快速测试applet，需要提供一个html文件名。可在浏览器中启用applet查看。

3、java的基本程序设计结构

System.out.println("xxxx"); //out.print输出不换行。
大小写敏感，类名已大写字母开头，文件名必须与公共类的名字相同，用.java扩展。强调main也public。
/** 这种注释可以自动生成
*文档*/ //换行时加个* 明显标识
强类型语言，8种基本类型（4整型、2浮点、1Unicode编码的字符单元char，1boolean）；
1整型 没有小数部分的数值，可负数， int 4字节 ,short 2字节,long 8字节 , byte 1字节;
与运行java代码的机器无关。长整型数值加后缀L，数字加下划线只为了让人更易读，编译器会去除。
2浮点类型 float4字节，double8字节 。float类型数值有后缀F（3.14F），没有默认是double（或加D）。
Double.NaN 不是数字？
if(x == Double.NaN) //永远false，
if(Double.isNaN(x)) //检查x
浮点型不适用于禁止出现舍入误差的金融计算。 System.out.println(2.0-1.1)将打印0.89999999。
使用BigDecimal类实现这类运算。
3char类型 单字符，
转义字符 \b退格，\t制表， \r换行=\u000a， \n回车=\u000d,
Unicode 范围从\u0000-\uffff。
JDK5.0开始， 代码点（code point）与一个编码表中的某个字符对应的代码值；看不懂喽~P52~
4boolean 类型，false和true，和整型值不能进行相互转换。
用final指示常量，
final double PI=3.14; //名称全大写
用strictfp关键字指定方法必须使用严格的浮点计算来产生理想的结果。
位运算>>>用0填充高位，>>用符号位填充高位。
Math类注重性能，如果注重结果使用StrictMath类；
对浮点数进行舍入运算，得到最接近的整数 Math.round(x);--round默认返回long类型。
枚举： enum Size{ SMALL,MEDIUM,LARGE,EXTRA_LARGE}; Size s=Size.SMALL;
字符串
s.substring(0,3);
String 类对象称为不可变字符串，
s.equals(t) //是否相等。 不区分大小写用 equalsIgnoreCase;
空串是""，长度0的字符串， if(str.length()==0) //检查空串
if(str!=null) //检查是否null；
char charAt（int index）
boolean endsWith(String suffix);
toLowerCase/toUpperCase， 小写/大写
构建字符串 StringBuilder类比拼接(+)高效；
StringBuilder sb=new StringBuilder(); sb.append(chOrStr); sb.toString();
StringBuffer效率低点，但允许多线程执行 添加或删除字符；
所在包 java.lang.StringBuilder
void setCharAt(int i, char c);将i位置设置为c；
StringBuilder insert(int offset, StrOrChar s);
StringBuilder delete(int startIndex, int endIndex);
输入输出
System.out.println ,输出
标准输入流 需要构造一个Scanner对象 // 所在包 import java.util.*;
Scanner in=new Scanner(System.in);
String name=in.nextLine();//读取一行
String aWord=in.next();//读取直到遇到空格；
int age=in.nextInt();
boolean hasNext(); hasNextInt();
Scanner类是输入可见的，不适合密码；
Console cons=System.console(); char[] passwd = cons.readPassword("Password:");
包：java.io.Console
System.out.printf("%,.2f",1000.0/3.0); //打印 3,333.33
可使用多个标志， +正负号，-左对齐，.分组分隔符，(负数加括号；
可使用String.format方法创建一个格式化的字符串但不打印；
时间日期 System.out.printf("%tc", new Date());
c 完整日期和时间， F ：2004-02-09 ,D 02/09/2004, T 24小时时间18:05:19,
文件输入输出
读入文件Scanner in=new Scanner(Paths.get("myfile.txt")); //java.util.Scanner
写入文件PrintWriter out=new PrintWriter("myfile.txt");//如果文件不存在则创建；java.io包
out.println("you can !");
写入后需调用out.flush(); 刷新流；
用户路径 String dir=System.getProperty("user.dir"); //java.nio.file.Paths
如果用不存在的文件构造一个Scanner,或不能被创建的文件名构造一个PrintWriter，会异常；
在方法中用throws子句标记， void sub() throws FileNotFoundException {};
流程控制
while(condition)statement;
do statement while(condition);
for(int i=1; i<=10; i++){}
switch(x){ case 1: break; ...}
-不建议使用switch,可在编译时加 -Xlint:fallthrough选项，强制少break警告；
-也可在外围方法加标注@SuppressWarnings("fallthrough");消除警告；
带标签的break和continue：标签是 name:， break/continue到标签后的语句块末尾，再检查是否正常退出语句块； 都不建议使用；
大数值 java.math 中的 BigInteger和 BigDecimal。可任意长度；
BigInteger a = BigInteger.valueOf(100); a.add(b);//不能用 + - * /
int compareTo(BitInteger other);//0相等，正数是大于，负数是小于；
数组
int[] a=new int[100];
System.out.println(Arrays.toString(a));//输出"[a1,a2.....]"
数组不能改变大小， 数组列表(array list)才可以。
for(variable: collection)statement; //实现了Iterable接口的类对象也可以。
初始化 int[] a={2,3,4}; //不需要new
int[] a=new int[]{2,3,4};
数组拷贝 int[] a= Arrays.copyOf(b, x * b.length); //通常用来增加数组的大小；
排序 Arrays.sort(a);//优化的快速排序算法；
Math.random() 返回0到1（包括0，但不包括1）的随机浮点数；
抽取算法：用数组最后的元素值改写抽取值，然后数组可用长度减一；
numbers[r] = numbers[n - 1]; n--;
static int binarySearch(type[] a, type v);//二分搜索算法查找值v
static void fill(type[] a, type v); //数组所有填充值v；
多维数组 int[][] x;
System.out.println(Arrays.deepToString(x));//输出"[[3,2...],[a1,a2.....]...]"

4 对象与类

三主要特性： 行为、状态、标识；
类之间的关系 依赖(uses-a)、聚合(has-a)、继承(is-a)；
对象与对象变量的区别； 一个对象变量并没有实际包含一个对象，仅仅引用；
日历类 GregorianCalender类，
表示时间点的Date类：时间是用距离一个固定时间点(纪元 1970-01-01 00：00：00)的毫秒数标识的，
GregorianCalender thisTime=new GregorianCalender(); //月份从0开始计数。
int month = thisTime.get(Calendar.MONTH); //通过常量和访问器来获取年月日等，
thisTime.set(属性，value);thisTime.add(属性,vlaue);
Date time=thisTime.getTime();//setTime(time); 转换。
int firstDayOfWeek = d.getFirstDayOfWeek();//一个星期中的第一天；
java.text.DateFormatSymbols 下面有几个格式输出方法
String[] getShortWeekdays()/ getShortMonths();
自定义类 在一个源文件中，只能有一个公有类；
警告： 不要编写返回引用可变对象的访问其方法；这个引用可能在外面被改写，破坏了类的封装。
代替用 对象的clone();
静态域与静态方法
static修饰的变量，所有实例共享一个静态域； 可用于标识实例；
private static int nextId=1; private int id;
void setId(){ id=nextId; nextId++;}
System有setOut方法，是本地方法，可设置不同的流，不是用java实现的。不推荐。
可使用对象名调用静态方法但不推荐；
工厂方法： 静态方法的常见用途，构造不同对象；
每一个类可以有个main，用作单元测试。
方法参数：java总是按值传递，没有引用调用！对象引用进行的也是值拷贝传递；
对象构造
重载，多个构造器（通过不同的方法签名-方法名和参数 实现）；
默认域初始化，没有显式的构造器。不推荐，影响代码可读性；
无参构造器，常用；
参数名
public Employee(String aName, int aAge)｛name=aName;｝//用a前缀；
public Employee(String name, int age)｛this.name=name;｝//用this访问当前对象
用this在构造器中调用另一个构造器，重用代码；
public Employee(int age){ this("NewName",age);}
初始化块
一个类的声明中，可以包含多个代码块， {xxxx; xxx; xxxxxxx;}
三种初始化数据域的方法：构造器中赋值，声明时赋值，初始化块中赋值。
初始化块先于构造器执行；
static 修饰的块只执行一次，其他的每次类实例化都执行；
调用构造器的具体步骤
a、所有数据域被初始化为默认值(0/false/null)；
b、按声明中出现的次序，依次执行初始化语句和初始化块；
c、如构造器1调用了构造器2，则先执行2，再执行1。
对象析构与 finalize方法
Java不支持析构器；但当使用了文件或另一系统资源的句柄，使用finalize方法，它在垃圾回收器清除对象之前调用。实际中，不要依赖于该方法回收任何短缺的资源——不知道何时才回收。
使用关闭勾：Runtime.addShutdownHook，可确保在Java关闭前调用finalize方法；
包package
确保类名的唯一性；嵌套的包之间没有任何关系！
调用其他包的类，可在类名之前加包名，或 用import语句；
静态导入 用import可导入静态方法和静态域；
import static java.lang.System.*； //可使用System的静态方法和静态域；
out.println("xxxx"); exit(0);
包作用域 不显示声明private的类、方法、变量，可被同一包的所有方法访问；破坏封装。
类路径 类路径必须与包名匹配；
JAR（Java归档）文件，可以用压缩文件工具打开查看JAVA文件；
共享类需要： P156的4.8类路径，暂时不懂。
文档注释
工具javadoc，由源文件生成一个HTML文档；
以专用的定界符/**开始的注释， 和代码同步；
javadoc的程序utility抽取信息（包、公有类和接口等），信息是自由格式文本，标记有@开始， 文本第一句是概要性句子；
方法注释 @param 标量描述， @return描述，@throws类描述，表示有可能抛出异常。
@author 姓名 --类注释，作者
@version 文本 --版本条目
@since 文本 始于条目，引入特性的版本
@see 引用 超级链接，可选三种
@see package.class#feature label
@see <a href="www.baidu.com">label</a>
@see "text"
包注释 需在每一个包目录中添加一个单独的文件，
以package.html命名的文件，或package-info.java命名的java文件。P162.
注释抽取 javadoc -d docDirectory nameOfPackage
类设计技巧
保证数据私有（不破坏封装）；对数据初始化；不在类中使用过多基本类型；缩减set或get访问器；分解过多的职责到其他类；类名和方法名提现职责；
java不对局部变量初始化，但对对象的实例域初始化。
比如用Address类代替 String street/city/state等。

5 继承

5.1类、超类、子类
继承是 is-A 关系，关键字extends ，（父类、超类、基类），子类；
置换法则：出现基类对象的地方都可以用子类置换。 //能置换，所以方法不能降低可见性；
调用基类方法：super.xxx(); //this是对象引用，super只指示编译器调用超类方法。
类似super();//调用超类对应构造器；放在自身构造器的第一条语句；
覆盖 override，
多态：一个对象变量可指示多种实际类型的现象，运行时自动选择调用哪个方法，称为动态绑定。
--申明为基类的引用，实际可引用基类实例，也可引用子类实例，虚拟机根据实际的引用来调用相关（公有的，非子类特有新增的）方法。 申明为基类的引用，肯定不能调用子类的方法。
subA[] aList=new subA[3]; baseA[] sList=aList; //这时aList和sList将指向同一对象；
aList.subDo(); //ok
sList.subDo()；//ERROR!虽然指向同一个对象。

方法是private /static/ final 的或构造器，调用它们是静态绑定。
虚拟机为每个类创建了一个方法表，调用时直接查表；

阻止继承： final类和方法
类的特定方法可被声明为final，这样子类不能覆盖它；final类的所有方法自动的称为final方法。
有些认为：不使用多态的都声明为final。
早期java中，避免动态绑定带来系统开销而使用final关键字。
一个方法没有被覆盖且很短，编译器优化（内联 inlining），e.getName()被转换为e.name域，提升效率；
强制类型转换
当一个基类声明中引用的确实是子类的对象实例时，可以强制类型转换为子类，或者说，用一个子类的声明去指向这个基类所引用的对象实例；
BaseA aBaseA=new SubA(); SubA a = (SubA)aBaseA;
//暂时忽视申明类型，使用对象的全部功能。
可用 instanceof 关键字 测试 if(a instanceof SubA）{dosomething;}
抽象类 ： abstract修饰，且包含一个或多个抽象方法的类本身必须被声明为抽象。
抽象类还可以包含具体数据和具体方法。
抽象类不能被实例化，但可以有构造器，在子类的构造器中 用super()调用它；
使用通配符 编译多文件 ：javac *.java； 或javac -d . A.java B.java ，生成到下一级目录。

受保护访问：protected，仅子类可访问；--修改可能影响子类，违背OOP的封装原则；--对同包其他类都可见。
控制可见性
1、仅本类-private； 2 对所有类-public； 3、对本包和所有子类可见-protected； 4、对本包--默认，不需修饰符。
5.2 Object:所有类的超类
Object obj=new Employee("name",age);//Object类型的变量可引用任何类型的对象。
只有基本类型不是对象；数组类型（哪怕基本类型的数组）都扩展于Object类。
equals 对于对象是判断俩对象是否具有相同的引用。
通常对类来说是无意义的，所以每个类要实现自己的equals。
编写一个完美equals的建议：
0、参数命名otherObject, 显式转换后为other；类型是Object，这样才能完全覆盖超类。
1、判断引用是否相同 this==otherObject; return true;
2、判断是否null otherObject==null return false;
3、判断类型一致 getClass()!=otherObject.getClass() //false
4、将otherObject强制转换为当前类的对象，判断状态。
Employee other= (Employee)otherObject;
Objects.equals(other.name,this.name);
static Objects.equals(a,b);若a,b都为null，则true，若一个null，返回false；
static Objects.equals(type[] a,type[] b); 数组长度相同，且对应位置元素也相同，则true；
子类中定义equals方法时，要先调用超类的equals。
相等测试与继承 instanceof 判断可能是继承关系，所以不适合这种判断。
如果equals的语义在子类中有所改变，则用getClass,
如果没改变，用instanceof，且将超类的eauals声明为final 。
equals 对任何非空引用，满足 自反性，对称性，传递性，一致性。对于空引用，返回false;
hashCode方法
散列码 是由对象导出的一个整型值。Object类的对象默认为其存储地址。
如果重定义equals，必须重新定义hashCode,以便用户将对象插入得到散列表中。
一般： Objects.hash(p1,p2,p3);//组合类的多个属性，生成散列码。
(java.lang.Object 1.0包) int hashCode() 返回散列码，相等的对象要求返回相等的散列码。
int Objects.hash(o1,o2,o3....) 由提供的所有对象的散列码组合得到新的散列码
int Objects.hashCode(Object a) 如果a为null则返回0，否则返回a.hashCode()。
(java.util.Arrays 包) static int hashCode(type[] a) 数组的散列码
toString方法
对象的toString可自定义。建议 类名加方括号的域值，如 java.awt.Point[x=20,y=30] ；
类名用 a.getClass().getName();获取；
技巧：在需要调用x.toString()的地方，用""+x替代。 这样x是基本类型时也能够执行。
只要对象与字符串通过"+"连接 ，Java编译就自动调用toString方法。
也可以用System.out.println(x)；//是对象时默认x.toString();
Object的toString，是输出对象的所属类名和散列码。
数组用Arrays.toString(a); 多维用Arrays.deepToString(b);
调试信息： System.out.println("Current ObjectX =" + obj); //需要对象实现自己的toString();
强烈建议为自定义的每一个类增加toString()方法；
java.lang.Object包 Class getClass() 返回包含对象信息的类对象；
java.lang.Class 包 Class getSuperclass()返回类的超类信息；
5.3泛型数组列表
Java允许在运行时确定数组大小，int size=100; Employee[] staff=new Employee[size];
泛型里面的类型参数必须是 Object 的子类。
ArrayList是采用 类型参数的泛型类， <Employee>指定类型，
ArrayList<Employee> staff=new ArrayList<>();
//Vector类是老版本的动态数组， 老版本中的ArrayList类元素是Object，没有泛型。
数组列表管理着内部数组的引用，若数组已满，则自动创建更大的数组并copy元素到新数组中。
如已清楚或能估算穿数组元素数量，可调用ensureCapacity方法，分配一个包含指定数量元素的内部数组。
也可以 ArrayList<Employee> staff=new ArrayList<>(100); //指定数量
.size()返回实际元素数目。
.add(x)添加元素， .add(index,x); .remove(n);
.trimToSize()确认元素不会再增删后，将数组列表的存储容量消减到当前尺寸，剩下的空间以便垃圾回收器回收。
new ArrayList<T>(); 构造空数组列表；
new ArrayList<T>(initialCapacity);用指定容量构造一个空数组列表。
staff.set(i,harry); //set和get 访问元素，注意实际的size；
5.4对象包装器与自动装箱
需要将基本类型转换为对象时用到。int-Integer，包装器(wrapper)是final的。
对象包装器是不可变的！不允许更改便装在其中的值。
如：ArrayList<int> aInt=new ArrayList<int>();
报错： Syntax error, insert "Dimensions" to complete ReferenceType。
泛型数组列表里面的类型参数必须是 Object 的子类，因此不能使用 int，而应该使用 int 的包装器类型 Integer。
ArrayList<Integer> aInt=new ArrayList<Integer>();
list.add(3) 自动转换为 list.add(Integer.valueOf(3)); ---自动装箱(autoboxing)。
int n=list.get(i); 自动转为list.get(i).intValue():自动拆箱；
类似：Integer n=3; n++; ---- 先拆箱，再自增，再装箱。
包装器对象比较，调用equals();
装箱和拆箱是编译器的工作，是语法糖。虚拟机执行的是编译器编译的字节码。
包装器还可以包含一些数值/字符串 转换方法。
int x=Integer.parseInt(s);
System.out.println(Integer.toString(System.out.hashCode(),16));
toString(int i, int radix) //返回数值i的给定参数进制的表示；
intValue() 返回包装器的值。
int x=Integer.parseInt(s,int radix);//radix是说明字符串s的进制表现形式。
5.5参数数量可变的方法
Java SE5.0以后提供的，
如printf，一个格式化字符串，一个Object[]
public static double max(double...values){
for(double v : values) if(x)doSomething();} //...是无限参数
5.6枚举类
public enum Size{SMALL,MEDIUM,LARGE,EXTRA_LARGE};
是有4个实例的类； Enum类的子类是Size。
比较俩枚举值时不需要调用equals，直接==；
x.toString()将返回字符串；
Enum Enum.valueOf(Size.class,"SMALL")是逆方法，
Size.values()返回包含全部枚举值的数组；
ordinal()返回枚举的位置，从0开始基数。
int compareTo(E other) 在前为负值，this==other则0，在后则正值。
5.7反射
反射库(reflection library)，JavaBeans中大量使用。
能够分析类能力的程序称为反射(reflective)。
运行中分析类的能力；运行中查看对象；---使用它的主要是工具构造者。
1、Class类)
程序运行期间，Java运行时系统为所有对象维护一个被称为运行时的类型标识。
记录着对象所属的类。
Object类的getClass()返回一个Class类型的实例；
Class.forName(className);返回类名对应的Class对象；
也可以用T.class来获取类对象；
一个Class对象实际上表示一个类型，但未必一定是类，如int.class。
可以用==比较类对象；
x.getClass().newInstance();快速创建一个类的实例；（需要一个无参的构造器）
forName和newInstance配合使用，可由字符串中的类名创建一个对象。
String s="java.util.Date";
Object m=Class.forName(s).newInstance();
2、捕获异常)
异常类型： 未检查异常和已检查异常。
try{ dosomethings();}catch(Exception e){}
Throwable类(Exception的超类)的printStackTrace()打印出栈的轨迹；
3利用反射分析类的能力)--暂忽略
java.lang.reflect包中Field/Method/Constructior分别描述类的域、方法、构造器。
还有Modifier类的静态方法；
4运行时使用反射，5使用反射编写泛型数组代码、6调用任意方法)暂忽略
5.8继承设计的技巧
1公共操作和域放在超类；
2不使用受保护的域；
（子类无限制，谁都可以写个派生类并访问protected实例域，破坏封装）
(java中，同一个包中的所有类都可以访问proteced域。）
3使用继承实现 is-a关系；（钟点工不是特殊的雇员，不是is-a关系，不能继承）
4除非所有继承的方法都有意义，否则也不要使用继承。
5覆盖方法不产生非预期行为；-覆盖基类的方法时，不偏离最初的设计想法。
6使用多态，而非类型信息；
7不过多使用反射；

6 接口和内部类 

接口interface-对象克隆-内部类inner class-代理proxy
6.1接口 对类的一组需求描述，类要遵从接口描述。
接口中所有方法自动属于public。所有域是public static final。
更重要的是知道接口不能提供哪些功能。
接口可以定义常量，但不能含有实例域，也不能有方法实现。
implements关键字。
java.lang.Comparable<T>的int compareTo(T other)； 小于则负值，相等0，大于正值。
强制的是 “实现接口”，而不是实现方法。----------一定注意。
java.util.Arrays包的 static void sort(Object[] a)
对数组a的元素排序，要求元素必须属于实现了Comparable接口的类。
如果父子类对象比较的含义不一样，那属于不同对象的非法比较。或者比较定义在超类且final。

1接口特性）不是类，不能new实例化。但能声明变量，变量引用实现了接口的类对象。
使用instance检查一个对象是否实现了某个特定接口
if(anObject instanceof XInterface){}
接口可以继承接口 interface X extnds xBase;
接口可以只定义常量，但有点偏离初衷，建议NO。
6.2对象克隆
Object类的clone方法默认是浅拷贝。
对于每一个类，进行如下判断：
1默认的clone是否满足，2默认的clone是否能通过调用子对象的clone得到修补，3是否不应该使用clone。
对于不满足1和2的， 实现Cloneable接口，使用public重新定义clone。
Cloneable接口的出现和接口的正常使用没有任何关系。clone方法是从Object类集成而来。
接口只作为标记，表明类设计者知道要进行克隆处理。
------标记接口tagging interface或者marker interface。用途是可以使用instanceof进行检查。
即便默认实现（浅拷贝）满足，也该实现Cloneable接口，且定义public并调用super.clone();
public X clone throws CloneNotSupportedException
{ return (x)super.clone();}
所有数组类型均包含clone方法，且为public，可以创建一个新数组。
int[] cloned= luckyNumbers.clone();
6.3接口与回调 callback
回调，指出某特定事件发生时采取的动作。
Java标准类库传递一个对象给定时器，定时器调用其方法；要求对象所属类实现了java.awt.event包的ActionListener接口。里面一个方法void actionPerformed(ActionEvent event);
定时器调用actionPerformed方法。
一个例子-明天运行一下。且整理笔记。
6.4内部类
已读，笔记待整理。