Java白皮书学习笔记+Head First Java--用于自我复习 基础知识篇

本笔记是摘与Hava白皮书上面的内容，用来给自己做提醒的，因此大概并不适合Java的学习者作为笔记参考使用。

以我的水平现在还看不懂这个。。。

一。基础知识篇

1.常量

final关键字指示常量，只能够被赋值一次。习惯上，常量名使用全大写。

final double n=10;

1.1 类常量

在Java中，希望某个常量可以在一个类的多个方法中使用。可以使用关键字static final设置一个类常量。

例如：

public cl ass Constants〗
{
public static final double CM_PER_INCH = 2.54;//定义在main方法外部
public static void main(Stringn args)
{
double paperWidth = 8.5;
double paperHeight = 11;
System.out.println("Paper size in centimeters: "
+ paperWidth * CMJERJNCH + by " + paperHeight * CM_PER_INCH) ;
}
}

　　

1.2.数学函数与常量

1.2.1 计算平方根  Math.squart(x)

1.2.2  在Java 中，没有幂运算， 因此需要借助于Math 类的pow 方法。语句：

double y = Math.pow(x, a) ;
将y 的值设置为x 的a 次幂（ xa)。pow 方法有两个double 类型的参数， 其返回结果也为
double 类型。

1.2.3

Math 类提供了一些常用的三角函数：
Math,sin
Math.cos
Math.tan
Math.atan
Math.atan2
还有指数函数以及它的反函数—自然对数以及以10 为底的对数：
Math.exp
Math.log
Math.loglO
最后，Java 还提供了两个用于表示TC 和e 常量的近似值：
Math.PI
Math.E

1.3.1数值类型之间的转换

虚箭头会丢失精度

1.3.2   强制类型转换

强制类型转换的语法格式是在圆括号中给出想要转换的目标类型，后面紧跟待转换的变
量名。例如：

 double x * 9.997;
 int nx = (int) x;

这样， 变量nx 的值为9。强制类型转换通过截断小数部分将浮点值转换为整型。
如果想对浮点数进行舍人运算， 以便得到最接近的整数（在很多情况下， 这种操作更有
用)，
那就需要使用Math_round 方法：

double x z 9.997;
int nx = (int) Math.round(x);

　　

现在， 变量nx 的值为10。当调用round 的时候， 仍然需要使用强制类型转换（ int)。其原因
是round 方法返回的结果为long 类型，由于存在信息丢失的可能性， 所以只有使用显式的强
制类型转换才能够将long 类型转换成int 类型。

1.3.3

1.3.4   枚举类型

枚举类型包括有限个命名的值。

有关枚举类型的详细内容将在第五章中介绍。

二、字符串

String

2.1  子串

String类的substring方法可以从一个较大的字符串中提取出一个子串。

例如：

String greeting = "Hello";
String s = greeting.substring（0，3）

创建了一个由字符“ Hel” 组成的字符串。
substring 方法的第二个参数是不想复制的第一个位置。这里要复制位置为0、1 和2 ( 从
0 到2, 包括0 和2 ) 的字符。在substring 中从0 开始计数，直到3 为止， 但不包含3。

2.2 拼接

Java中的String类允许使用 + 号拼接两个字符串。

这种特性通常用在输出语句中。

如果需要把多个字符串放在一起， 用一个定界符分隔，可以使用静态join 方法：

String all = String.join(" ~ ", "S", "M", "L", "XL");
// all is the string "S ~ H ~ L ~ XL"

2.3 不可变字符串

String 类没有提供用于修改字符串的方法6 如果希望将greeting 的内容修改为“ Help!”，
不能直接地将greeting的最后两个位置的字符修改为‘ p ’ 和‘、！ 这对于C程序员来说，
将会感到无从下手。如何修改这个字符串呢？

在Java 中实现这项操作非常容易。首先提取需
要的字符， 然后再拼接上替换的字符串：
greeting = greeting.substring(0, 3) + "p!";
上面这条语句将greeting 当前值修改为“ Help ! ”

由于不能修改Java 字符串中的字符， 所以在Java 文档中将String 类对象称为不可变字

符串， 如同数字3 永远是数字3—样，字符串“ Hello” 永远包含字符H、e、1、1 和o 的代
码单元序列， 而不能修改其中的任何一个字符。当然， 可以修改字符串变量greeting， 让它
引用另外一个字符串， 这就如同可以将存放3 的数值变量改成存放4 一样

2.4 检测字符串是否相等

可以使用equals 方法检测两个字符串是否相等。对于表达式：
s.equal s(t)
如果字符串s 与字符串t 相等， 则返回true ; 否则， 返回false。需要注意，s 与t 可以是字符
串变量， 也可以是字符串字面量。例如， 下列表达式是合法的：
"Hello".equals(greeting)
要想检测两个字符串是否相等，而不区分大小写， 可以使用equalsIgnoreCase 方法。
"Hello".equalsIgnoreCase("hel1o")
一定不要使用=运算符检测两个字符串是否相等！ 这个运算符只能够确定两个字串
是否放置在同一个位置上。

2.5  空串与null串

空串"" 是长度为0 的字符串。可以调用以下代码检查一个字符串是否为空：
if (str.length（） = 0)
或
if (str.equals(""))
空串是一个Java 对象， 有自己的串长度（ 0 ) 和内容（空）。不过， String 变量还可以存
放一个特殊的值， 名为null , 这表示目前没有任何对象与该变量关联（关于null 的更多信息
请参见第4 章)。要检查一个字符串是否为null , 要使用以下条件：
if (str == null)

2.6 码点和代码单元

待补充知识空缺。可以单独开一个随笔说。

好像大体是说，代码单元可能不准确，而码点比较准确。

3.Java中如果整数和浮点数的精度不够使，那么可以使用java.math包中的两个很有用的类：BigInteger计二BigDecimal。这两个类可以处理包含任意长度数字序列的数值。BigInteger类实现了人已经度的整数运算，BigDecimal实现任意精度的浮点数运算。

    BigInteger a = BigInteger.valueOf(100);//value of方法将100转换成大数
    BigInteger b = BigInteger.valueOf(10);
    BigInteger c = a.add(b);//加法
    System.out.println(c);
    BigInteger d = c.multiply(b.add(BigInteger.valueOf(2)));//乘法
    System.out.println(d);

剩下的用法可以查找Java的API文档。

4.数组

4.1 数组的声明和初始化

    int[] aa;//声明了变量a  但并没有将a初始化为一个真正的数组
    aa=new int[100];//初始化了
    int[] hh=new int[10];

并且，数组的长度并不要求是常量。可以创建new int[ n ]  其中n为变量。

创建一个数字数组时， 所有元素都初始化为0。boolean 数组的元素会初始化为false   对
象数组的元素则初始化为一个特殊值null , 这表示这些元素（还）未存放任何对象。初学者
对此可能有些不解。例如，
String[]  names = new String[10] ;
会创建一个包含10 个字符串的数组， 所有字符串都为null。如果希望这个数组包含空
串， 可以为元素指定空串：就是遍历一遍，每个赋值为一个空格。

要想获得数组中的元素个数，可以使用array.length，例如：

4.2  for each 循环

    int[] aa;//
    aa=new int[100];
    for(int i=0;i<aa.length;i++)
        aa[i]=i+1;

    for(int element :aa)
        System.out.println(element);//这个就是for each循环

这个循环读作“循环a中的每一个元素”。打印的每一个元素都占一行。当然传统的for循环也是可以得到结果的，但是这个for each循环语句显得更加简洁、不宜出错。（不必为下表的起始值和中止值操心）。

    int[] aa;//
    aa=new int[100];
    for(int i=0;i<aa.length;i++)
        aa[i]=i+1;

    //Arrays.toString(aa);
    System.out.println(Arrays.toString(aa));

4.3 数组初始化以及匿名数组

    int[] a= {1,2,3,4,5,5,5,5,5};//允许不初始化长度
    for(int e :a)
        System.out.println(e);
    System.out.println("after:");
    a=new int[] {1,1,1,1,1,1,1};//等于号后面这个叫做匿名数组
    for(int e: a)
        System.out.println(e);

在这里，只要暂且记住这个用法就可以了。在后面应该才会得到应用。现在还不是特别懂。

4.4数组的拷贝：

    int[] a= {1,2,3,4,5,5,5,5,5};

    int[] b= {2,2,2,2,2,2,2};
    System.out.println(a);
    System.out.println(b);

    System.out.println();

    a=b;//这样是允许的 但是打印的地址说明，这样只是把a和b指向的地址统一了而已，实际上还是指向同一个数组
    System.out.println(a);
    System.out.println(b);

想要拷贝数组，也就是两个数组指向两个地址的，那么用这个：

int[] aa=Arrays.copyOf(a,a.length);

第二个参数是新数组的长度，通常用来增加数组的大小：

int[] aa=Arrays.copyOf(a,2*a.length);

上面的这句，如果数组元素是数值型，那么多余的元素将被赋值为0；若是布尔型，将被赋值为false.....

Java与c++的不同之处见上图

4.5 数组排序

int [] a=new int[200000]
.....
Arrays.sort(a);//Arrays类中的这个算法是一个快速排序算法

5  面向对象

下面的内容摘自传智播客 学校里发的教材。

大部分概念都ok的了。

5.1  构造函数中调用其他构造函数 这个我单独出了一个博客。

5.2   static 关键字

静态变量。被这个类的所有对象共享。

静态方法。在不创建对象的基础上就可以访问的方法。可以用实例对象名. 方法访问，也可与用类名. 方法来访问。

5.3  类的继承

5.3.1  子类继承父类，并且一个子类只能由一个父类。其中，子类可以访问父类的公共变量、方法。。。

5.3.2 重写父类方法

注意 ：在重写父类的方法时，不能够添加比父类更加严格的访问权限

这样就报错了。

5.3.3 super关键字

super用来 子类调用父类的方法。

class Animal {
    String name = "动物";

    void shout() {
        System.out.println("Animal shout");
    }
}

class Dog extends Animal {
    String name = "犬类";
    void shout() {
        System.out.println("wang wang");
        super.shout();
    }
}

super还可以用来子类调用父类的构造方法。同样，用super（）调用时，只能在子类构造方法的第一行调用，只能出现一次。否则会报错。

 

并且，在实例化子类对象的时候，如果你没有在子类的构造方法里面显式调用父类构造方法，那么就会自动的隐式调用父类的无参构造方法。但是如果你没有定义这个父类的无参构造方法的话就会报错。

所以，在显式的自己定义了有参的构造方法以后，一定再显式地写一个无参构造方法。避免出错。

5.3.4  Object 类

当定义一个类时，如果没有显式指定这个类的父类，那么就全将全部继承自Object类。Object类就是父类。

5.3.5  final关键字

　　final关键字可用于修饰类、变量、方法。并且具有 “ 最终，不可更改 ” 的含义。

①final关键字修饰的类不能够被继承

　　②final关键字修饰的方法不能被重写

　　3. final 关键字修饰的变量是常量，只能赋值一次。

final修饰的局部变量，可以先声明变量，后赋值变量。分成两个语句。

但是final修饰的成员变量，必须在声明的时候同时赋值，合成一个语句。否则报错。（成员变量就是紧跟在类里面的）

5.4 抽象类和接口

5.4.1 抽象类

抽象类用abstract来修饰。即这个类中定义了这个方法却无需实现，在其子类中实现。

abstract class Animal{
    public abstract void shout();
}

class Dog extends Animal{
    public void shout() {
        System.out.println("wang wang");
    }
}

5.4.2 接口

接口中只能由抽象方法、默认方法（default）、静态方法（static）。默认方法和静态方法允许有方法体。

定义接口时，不用class  用 interface 关键字。

接口可以继承别的接口，继承的时候可以有多个父类。（special）

接口继承接口用 extends     接口要被一个实现它的类继承的时候用 implements

接口的实现类，必须实现接口的所有抽象方法。默认和静态不用。

interface Animal{
    int ID = 1;
    void breathe();
    default void getType(String type) {
        System.out.println(type);
    }
    static int getID() {
        return ID;
    }
}

class Dog implements Animal{
    public void breathe() {
        System.out.println("Dog Breathe");
    }
}

interface Animal{
    int ID = 1;
    void breathe();
    default void getType(String type) {
        System.out.println(type);
    }
    static int getID() {
        return ID;
    }
}

interface LandAnimal extends Animal{
    void run();
}

class Dog implements LandAnimal{
    public void breathe() {
        System.out.println("Dog breathe");
    }
    public void run() {
        System.out.println("Dog run");
    }
}

5. 5   多态

多态是指，当把子类的对象直接赋值给父类引用变量时，调用相同方法将呈现多种形态。

abstract class Animal{
    abstract void shout();
}
class Cat extends Animal{
    public void shout() {
        System.out.println("miao miao");
    }
}
class Dog extends Animal{
    public void shout() {
        System.out.println("wang wang");
    }
}

public class Hello {
    public static void main(String[] args) {
        Animal an1 = new Cat();//cat类对象指向父类对象
        Animal an2 = new Dog();
        an1.shout();
        an2.shout();

    }
}

5.5.2  类型转换

interface Animal{
    void shout();
}
class Cat implements Animal{
    public void shout() {
        System.out.println("miao miao");
    }
    public void catchMouse() {
        System.out.println("Cat Catch Mouse");
    }
}

public class Hello {
    public static void main(String[] args) {
        Animal an1 = new Cat();//Cat向上转型
        an1.shout();
        //an1.catchMouse(); 不能用
        Cat cat = (Cat) an1;
        cat.catchMouse();

    }
}

在上面的代码中，第一次， an1指向了Animal，但是它的本质是Cat类型。被注释的那块语句不能用，因为指向了Animal。此时

然后强制类型转换，向下转型。一定要用 instanceof 判断一下本质类。一个被向上转型的类只能再向下转型为它的本质类。

例子：

interface Animal{
    void shout();
}
class Cat implements Animal{
    public void shout() {
        System.out.println("miao miao");
    }
    public void catchMouse() {
        System.out.println("Cat Catch Mouse");
    }
}
class Dog implements Animal{
    public void shout() {
        System.out.println("wang wang");
    }

}

public class Hello {
    public static void main(String[] args) {
        Animal an1 = new Cat();
        Animal an2 = new Dog();
        if(an1 instanceof Cat) {
            Cat cat = (Cat)an1;
        }
        else {
            Dog dog = (Dog)an2;
        }

    }
}

5.5.3 外部类和内部类

1，成员内部类

就是从一个类里面再定义一个类。

都可以互相访问对方的类内所有内容。

内部类可以无条件访问外部类的所有成员、方法   ； 但是从外部类访问内部类的时候需要先定义一个内部类的对象，通过对象来访问。

（这块不是特别清楚）

2.局部内部类

就是在一个类的方法中再定义一个内部类。在这个方法中，可以从局部内部类访问外部类的所有东西，但是内部类只能在这个方法中用。

3.匿名内部类

interface Animal{
    void shout();
}

public class Hello {
    public static void main(String[] args) {
        String name = "xiao hua ";
        animalshout(new Animal() {
            public void shout() {
                System.out.println(name +"miao miao");
            }
        });
    }
    public static void animalshout(Animal ani) {
        ani.shout();
    }

调用animalshout的时候需要一个接口类型的参数，这个时候我们：

在main主函数中写了个   animalshout（  new animal (  ) {   ....  }  ）;

大括号内实现抽象方法。

5.6   异常