<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类型

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

boolean类型

值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循环

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

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语句

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),文章说的很详细。

对象析构与finalize方法

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\theviper下，也可以编译。如果它不依赖于其他包，就不会出现编译错误。但是最终的程序将无法运行，因为虚拟机找不到类文件

继承

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

1. 调用超类方法

2. 调用超类构造器

this关键字作用

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

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

阻止继承：final类和方法

目的：确保它们不会在子类中改变语义。
类变量也可以被声明为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:对本包和所有子类可见

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