<java核心技术>读书笔记1

摘要：关键字作用调用超类方法调用超类构造器关键字作用引用隐式参数如调用该类的其他构造器在覆盖一个方法时，子类方法可见性不能低于超类方法阻止继承类和方法目的确保它们不会在子类中改变语义。但是如果将一个类声明为后面可以改变类变量的值了。

int 存储要求：4byte 取值范围：-2147483648 -- 2147483647(超过20亿)

short 存储要求：2byte 取值范围：-32768 -- 32767

long 存储要求：8byte 取值范围：-9223372036854775808 -- 9223372036854775807

byte 存储要求：1byte 取值范围：-128 -- 127
java没有任何无符号类型（unsigned）

float 存储要求：4byte 取值范围：大约+-3.40282347E+38F(有效位数为6~7位)

double 存储要求：8byte 取值范围：大约+-1.79769313486231570E+308(有效位数为15位)

double类型的精度是float的两倍

float类型的数值有一个后缀F(如3.14F),没有后缀的浮点数值（如3.14）默认为double类型。当然也可以在浮点数值后添加后缀D表示double类型

char用于表示单个字符，通常用来表示字符常量

值true,false,用来判定逻辑条件。 整型值和布尔值之间不能进行转换

变量名必须是一个以字母开头的由字母或数字构成的序列，但是+,@这样的符号不能出现在变量名中，空格也不行。变量名的长度没有限制。另外，不能将变量命名为java的保留字。可以在一行中声明多个变量，如int i,j;

声明一个变量后，必须用赋值语句对变量进行显式初始化，千万不要使用未被初始化的变量，如

int a;
System.out.println(a);//ERROR--variable not initialized

利用关键字final表示，这个变量只能被赋值一次，一旦被赋值，就不能再更改了。习惯上，常量名使用全大写。
类常量用关键字static final表示

算是运算符+,-,*,/分别表示加，减，乘，除。当参与/的两个数都是整数时，表示整数除法，否则表示浮点除法。%表示求余操作。

x+=4;
x=x+4;

两者等价。

实心箭头表示无信息丢失的转换，虚线箭头表示可能有精度损失的转换。
如果试图将一个数值从一种类型强制转换为另一种类型，而又超过了目标类型的取值范围，结果会截断成一个完全不同的值

将一个字符串与一个非字符串的值进行拼接(+)时，后者会被转换成字符串，因为任何一个java对象都可以转换成字符串.

块是由一对花括号括起来的若干简单的java语句,块确定了变量的作用域,一个块可以嵌套到另一个块中。

public static void main(String[] args)
{
    int n;
    ...
    {
        int k;
        ...
    }//变量k的作用域到这里为止
}

但是，不能在嵌套的两个块中声明相同名字的变量

public static void main(String[] args)
{
    int n;
    ...
    {
        int n;
        int k;
        ...
    }//这里不能再定义变量n了
}

在循环中，检测两个浮点数是否相等需要小心

for(double x=0;x!=10;x+=0.1)...

在for语句中声明的变量，作用域是for循环的整个循环体

for(int i=0;i<10;i++){
    ...
}//i的作用域到此为止

如果想在循环体外使用i,就要确保i在循环语句的前面且在外部声明过

int i;
for(i=0;i<10;i++){
    ...
}
//循环体外面还可以使用i

可以在各自独立的不同for循环中定义同名变量

for(int i=0;i<10;i++){
    ...
}
...
for(int i=10;i<20;i++){
    ...
}

switch(choice){
    case 1:
        ...
        break;
    ...
    default:
        ...
        break;
}

case标签可以是

类型为char,byte,short或int,以及它们包装类的常量表达式

枚举常量

字符串字面量(从java7开始)，如

switch(inputString){
    case "yes":
        ...
        break;
    ...
}

如果基本的整数和浮点数精度不能满足要求，可以使用java.math包中的BigInteger,BigDecimal.这两个类可以处理包含任意长度数字序列的数值。BigInteger实现了任意精度的整数运算，BigDecimal类实现了任意精度的浮点数运算。
使用静态的valueOf方法可以将普通的数值转换为大数值。

BigInteger a=BigInteger.valueOf(100);

大数值间的运算需要使用大数值类中的方法，而不能算术运算符。

声明数组int[] a;,实例化int[] a=new int[100];,这里创建了一个可以存储100个整数的数组，里面的所有元素都还是初始化状态(值为0)。
对象数组的元素则初始化为null,表示这些元素还没存放任何对象
一旦创建了数组，就不能再改变它的大小(尽管可以改变每个数组元素)
数组其他初始化方式int[] a={1,2,...};，int[] a=new int[]{1,2,...};

按值调用：方法接收的是调用者提供的值

按引用调用：方法接收的是调用者提供的变量地址

java总是采用按值调用，也就是说，方法得到的是所有参数值的一个拷贝，结果就是方法不能修改传递给它的任何参数变量。
但是方法参数有两种类型
1.基本数据类型(int,boolean,...)
2.对象引用
对象引用作为参数可以通过调用对象里的方法改变对象里的类变量,但是这并不说明java的方法参数是对象引用

public class Employer {
    String name=null;
    Employer(String name){
        this.name=name;
    }
    static void swap(Employer a,Employer b){
        Employer temp=a;
        a=b;
        b=temp;
    }
    void print(){
        System.out.println(this.name);
    }
    public static void main(String[] args){
        Employer employer1=new Employer("aaa");
        Employer employer2=new Employer("bbb");
        swap(employer1,employer2);
        employer1.print();//aaa
        employer2.print();//bbb
    }
}

可以看到，尽管swap方法将两个Emplyer实例交换，但实际上交换的仅仅是两个对象引用的拷贝.

如果构造器的第一行语句形如this(...),这个构造器将调用同一类的另一个构造器。

public class TestCons {
    String name;
    public TestCons(){
        this("default1");
        //this.name="default";
    }
    public TestCons(String name){
        this.name=name;
    }
    public static void main(String[] args){
        TestCons testCons=new TestCons();
        System.out.println(testCons.name);//default1
    }
}

在一个类的声明中，可以包含多个代码块，只要构造类的对象，这些块就会被执行。
具体参见一道面试题引发的思考:(1),文章说的很详细。

java有自动的垃圾回收器，不需要人工回收内存，所以java不支持析构器。
finalize方法在垃圾回收器清除对象前调用。实际应用中，不要依赖于使用finalize方法回收任何短缺资源，因为很难知道这个方法什么时候调用。
如果某个资源需要在使用完毕后立刻被关闭，就需要由人来管理。对象使用完，可以用close方法（如果有）完成相应的清理操作。

只能使用(*)导入一个包，而不能使用import java.*或import java.*.*导入以java为前缀的所有包。
大多数时候，只导入所需的包就可以了。但发生命名冲突的时候，就需要变成具体的包名。例如
java.util和java.sql包里都有Date类

import java.util.*;
import java.sql.*;
...
Date today;//ERROR!--java.util.Date or java.sql.Date?
...

import static java.lang.System.*;
...
out.println("gwegwe");//不用加类名前缀
exit(0);

警告
编译器在编译源文件时，不检查目录结构。
package com.theviper;,即使源文件没有在目录com heviper下，也可以编译。如果它不依赖于其他包，就不会出现编译错误。但是最终的程序将无法运行，因为虚拟机找不到类文件

使用super调用构造器的语句必须是子类构造器的第一条语句。
如果子类构造器没有显式调用超类构造器，则将自动调用超类默认(没有参数)的构造器。
如果子类没有不带参数的构造器，并且在子类构造器中没有显式调用超类的其他构造器，则编译器将报错。
super关键字作用

调用超类方法

调用超类构造器

this关键字作用

引用隐式参数(如this.name=name)

调用该类的其他构造器
在覆盖一个方法时，子类方法可见性不能低于超类方法

目的：确保它们不会在子类中改变语义。
类变量也可以被声明为final,但是构造对象后就不允许再改变类变量的值了。

public class Parent {
    final String name="aaa";
    void setName(String name){
        this.name=name;
    }
    public static void main(String[] args){
        Parent parent=new Parent();
        parent.setName("bbb");//The final field Parent.name cannot be assigned
    }
}

但是如果将一个类声明为final,后面可以改变类变量的值了。

public final class Parent {
    String name="aaa";
    public static void main(String[] args){
        Parent parent=new Parent();
        parent.name="bbb";
        System.out.println(parent.name);//bbb
    }
}

类即使不含抽象方法，也可以声明为抽象类

抽象类不能被实例化，但可以创建抽象类的具体子类对象

可以定义抽象类的对象变量，但只能引用非抽象子类的对象。

AbstractClass a=new AbstractConcrete();

private:仅对本类可见

public:对所有类可见

protected:对本包和所有子类可见

默认（不需要修饰符）：对本包可见