从大学课程设计、毕业设计到工作中的一些小功能调整，自己的Java水平一直是会点语法+面向搜索引擎编程级别。想要更加深入地学习Java的东西，但是Java圣经又太厚，自己也不是特别擅长看这些技术书籍的人，在别人的建议下选了《Head First Java》来看。
纵观全书，这本书的重点在Java的基础语法、对象、多态与继承等概念上的讲解（讲得挺好的），对于一些异常处理、线程、IO、网络方面更多是简单的介绍，并没有深入讲解。
原本想通过这本书学习线程方面的概念，为阅读其他更加深入讲解线程方面的文章打下基础，但是似乎无法达到目的。
尽管如此，我还是通过阅读这本书学习的到了一些新的东西。这篇笔记，就是为了整理记录这些新学到的知识，以巩固我对这些知识的掌握。

对象的声明、创建与赋值

当我们声明一个非基本数据类型的变量时，我们通常这样写：
Dog myDog = new Dog();
在这简单的一行代码中，其实包含了三个步骤：

// 1. 声明一个Dog类型的引用变量
Dog myDog
// 2. 创建Dog对象 
new Dog
// 3. 将创建的Dog对象，赋值给myDog这个引用变量
Dog myDog = new Dog(); 

所以，当我们声明对象数据的时候，实际上是声明了该对象的引用变量数据。

对象的生存空间

在Java虚拟机驱动的时候，会从底层操作系统获得一块内存来执行Java程序。在内存中，要关注这两块区域：对象的生存空间堆和方法调用及变量生存的空间栈。

• 堆又被称为可垃圾回收的堆，一旦对象失去了引用，就有可能被回收。
• 实例变量是被声明在类而不是方法中，所以实例变量存在于所属的对象中（堆中）。
• 而局部变量则是被生命在方法中，所以局部变量存在于栈中。

赋值与引用的例子

Book a = new Book();
Book b = new Book();  //这里有两个引用变量，两个对象
Book c = a;  //此时有三个引用变量，两个引用变量，c与a指向同一个对象
b = a; // 此时b也与a指向同一个对象，b原本指向的对象失去了引用，处于可回收状态 

继承与多态

• 子类会继承父类除了private的所有实例变量和方法。
• 运用多态时，引用类型可以是实际对象类的父类；参数和返回类型都可以多态。

Animal[] animals = new Animal[5];
animals[0] = new Dog();
animals[1] = new Cat();

Class Vet{
    public void giveshot(Animal a){
    a.makeNoise();
}

Vet vet = new Vet();
v.giveshot(new Dog());
}

• 父类的方法可以在子类中被覆盖，但是标记了final的方法无法被覆盖。
• 一个类只能继承一个父类。但是继承可以是多层继承。B继承A，C继承B，则C也是A的子类。
• 所有对象都是Object的子类，可以用Object来实现多态，但是一般不这样做。

Object o = new Dog();
int i = o.hashCode();  // 可行，因为Object本身有hashCode()方法
o.makeNoise(); // 不可执行，因为此时o的引用类型是Object，Object没有makeNoise()方法，无法执行。
Animal a = (Dog) o;
a.makeNoise(); // 可行，当o赋值给a时进行了类型转换，Dog是Animal的子类，所以可以赋值成功。Animal有makeNoise()方法，所以可以执行

• 当一个类执行构造函数时，会先执行完父类的构造函数。如果存在多层继承，就会一直到最初的父类执行完构造函数，才一层一层向下执行。
• 在子类的构造函数中执行父类的构造函数：

public Dog(String name){
//调用父类的构造函数
super();
}

• 当子类的构造函数中没哟调用super()时，编译器在编译时在我们编写的构造函数中添加super();
• 当我们想重载一个构造函数，但是又调用到这个构造函数时：

Class Dog{
    String name;
    public Dog(){
        // 调用了有一个String参数的构造函数
        this("myDog");
    }
    public Dog(String name){
        //调用父类的构造函数
        super();
    }
}

• 在构造函数中，this()和super()都要存在于构造函数的第一行，不得同时存在。

接口与抽象类

• 抽象类没有实体，抽象类中的方法也没有方法体。
• 接口类是抽象类，抽象类不一定是接口类。
• implements接口后，要实现该接口类的所有方法。
• extends只能extend一个父类，implements可以implement好多个接口。

静态方法

• 非静态方法需要有实例才能调用，静态方法不需要实例，直接以类名就可以调用。

// 非静态方法
Dog d = new Dog();
d.makeNoise();
// 静态方法
Math.min(3,7);

• 静态方法中没有实例变量，也不允许调用非静态的变量。
• 静态方法不允许调用费静态的方法。
• 静态变量是同一个类所有实例共享的。每一个实例都有一个属于自己的实例变量。但静态变量是每个类一个。这里可能会有多个实例对同一个静态变量同时进行修改的问题。
• 静态变量会在该类有任何静态方法执行之前就初始化。
• final的变量代表值无法被改变，final的方法代表无法被覆盖，final的类代表无法被继承。以下例子来自java提高篇(十五)-----关键字final

public class Person {
    private String name;

    Person(String name){
        this.name = name;
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class FinalTest {
    private final String final_01 = "chenssy";    //编译期常量，必须要进行初始化，且不可更改
    private final String final_02;                //构造器常量，在实例化一个对象时被初始化
    
    private static Random random = new Random();
    private final int final_03 = random.nextInt(50);    //使用随机数来进行初始化
    
    //引用
    public final Person final_04 = new Person("chen_ssy");    //final指向引用数据类型
    
    FinalTest(String final_02){
        this.final_02 = final_02;
    }
    
    public String toString(){
        return "final_01 = " + final_01 +"   final_02 = " + final_02 + "   final_03 = " + final_03 +
               "   final_04 = " + final_04.getName();
    }
    
    public static void main(String[] args) {
        System.out.println("------------第一次创建对象------------");
        FinalTest final1 = new FinalTest("cm");
        System.out.println(final1);
        System.out.println("------------第二次创建对象------------");
        FinalTest final2 = new FinalTest("zj");
        System.out.println(final2);
        System.out.println("------------修改引用对象--------------");
        final2.final_04.setName("chenssy");
        System.out.println(final2);
    }
}

------------------
Output:
------------第一次创建对象------------
final_01 = chenssy   final_02 = cm   final_03 = 34   final_04 = chen_ssy
------------第二次创建对象------------
final_01 = chenssy   final_02 = zj   final_03 = 46   final_04 = chen_ssy
------------修改引用对象--------------
final_01 = chenssy   final_02 = zj   final_03 = 46   final_04 = chenssy

异常处理

• finally块中的代码无论有无异常都会执行。
• 异常也是多态的，Exception是所有异常的父类。
• 异常可以throws 也可以 try/catch。
• 可以为每个不同的异常编写不同的catch块，但是要注意子类要放在父类之前catch

try{
 // do somethings
} catch (DogException de){
  //deal DogException
} catch (AnimalException ae){
  //deal AnimalException
}
// 如果AnimalException的catch块在DogException之前，那么DogException也会被AnimalException的catch块捕获，就不会落到后面的DogException的catch块了。

内部类

• 内部类可以使用外部类的所有方法和变量，包括标记为private的。
• 内部类的实例一定会绑定在外部类的实例上。
• 内部类的其中一个适用场景：一个界面，需要监听多个按钮点击事件并且不同按钮的点击事件有不同的响应。

IO

IO这一章简单地讲了一下文件操作，着重讲了序列化的内容。
其实这章序列化说得不好，建议看这里Java 序列化的高级认识

• 序列化程序会对象相关的所有东西都存储起来，被对象的实例变量所引用的所有对象都会被实例化。
• 如果要让类能够被序列化，必须实现Serializable
• 如果某实例变量不能/不应该被序列化，就把他标记为瞬时的(transient)，这样序列化时候，程序会将它跳过。到了解序列化的时候这个引用变量会被置为null。
• 解序列化的时候，所有的类都必须让JVM找到。
• 解序列化时，新的对象会被分配到堆上，但构造函数不会执行。
• 如果对象在继承树上的有不可序列化的祖先类，则该不可序列化类以及在它之上的类的构造函数（就算是可序列化的类）就会执行。从第一个不可序列化的父类开始，之上的类都会回到初始状态。
• 静态文件不会被序列化。
• 序列化标志：如果在解序列化之前，类已经发生了修改，可能会导致解序列化失败。

会损害序列化的修改：

• 删除实例变量
• 改变实例变量的类型
• 将非瞬时的实例变量改为瞬时的
• 改变继承的继承层次
• 将类从可序列化改为不可序列化
• 将实例变量变成静态的

较为安全的修改：

• 加入新的实例变量（还原时取默认值）
• 在继承层次中加入新的类
• 在继承层次中删除类
• 将实例变量从瞬时改为非瞬时

• 一致的序列化ID有利于保证反序列化的成功。

网络通信与多线程

• 服务器与客户端通过socket连接来沟通。
• 当ServerSocket接收到请求时，会在另外的一个端口做一个socket连接来处理客户端的请求。
• 线程代表独立的执行空间。
• 多线程同时执行时，实际上是多个线程随机轮流执行的。
• 线程进入可执行状态时，会在执行中和可执行这两种状态中切换。但是也可能进入堵塞状态。堵塞状态可能是闲置、等待其他县城完成、等待串流数据、等待被占用的对象等原因引起的。
• 构造线程时需要传入一个任务对象，这个任务对象需要实现Runnable接口。
• 并发：不同线程对同一个对象同时进行处理，可能引起问题。
• 锁：要让对象在线程上有足够的安全性，就要对不可分割执行的指令上锁（同步化）。
• 如果线程尝试进入同步化的方法，必须取得对象的钥匙如果钥匙被别的线程拿走了，线程只能等待。

• 如果两个线程互相持有对方正在等待执行的方法的钥匙，就会发生死锁。

  
  
  死锁

集合与排序

• 常见的集合类型，有序的集合中的元素必须是可比较的，Comparable的：

• TreeSet：有序且防止重复的集合。
• HashMap：Key-Value集合，Key不可重复
• HashSet：防止重复的集合，可快速找到相符元素
• LinkedList：针对经常插入或者删除中间元素所涉及的高效率集合（不如ArrayList实用）
• LinkedHashMap：可记住元素插入顺序，可设定依照原宿上次存储先后来排序的HashMap。

• ArrayList中的sort()方法，可进行已实现了Comparable接口的类的排序，也可以使用实现了Comparator接口的内部类来进行排序。

// 实现Comparable接口
class Song inplements Comparable<Song>{
    public int compareTo(Song s){
       return title. compareTo(s.getTitle());
   }
}

// 实现Comparator
class Song{
class ArtistCompare implements Comparator<Song>{
    public int Compare (Song one, Song two){
          return one.getArtist().compareTo(two.getArtist());
    }


ArtistCompare artistCompare = new ArtistCompare();
    Collections.sort(songList, artistCompare);
}

}

• 如果equal()被覆盖过，hashCode()方法也应该相应覆盖。
• equal()默认行为是执行==的比较，即判断两个引用变量是否引用堆中的同一个对象。如果equals()没有被覆盖过，那么两个对象永远不会被视为相等的。
• a.equals(b)必须与a.hashCode()==b.hashCode()等值，但a.hashCode()==b.hashCode() 不一定与a.equals(b)等值。

泛型

//这里的list仅接受ArrayList<Animal>
public void takeThing(ArrayList<Animal> list) 

 //这里的list对象可以接受ArrayList<Dog>、ArrayList<Cat>等继承Animal的对象的ArrayList
// 泛型的extends等价于实体类的extends或者implements
public <T extends Animal> void takeThing(ArrayList<T> list)

//万用字符也可以让ArrayList接受Animal的子类
// 使用万用字符，能够调用list中任何元素的方法，但是不能增加元素。
public void takeAnimals(ArrayList<? extends Animal> animals){
    for(Animal a:animals){
        a.eat();  //合法
    }
    animals.add(new Dog());  //不合法的操作
}

// 第二、第三种写法执行起来是一样的，但是在一般用第二种，因为需要传入多个对象时，第二种方法不需要多次声明
public <T extends Animal> void takeThing(ArrayList<T> one, ArrayList<T> two)

远端过程调用

远端过程调用

远端过程调用的过程：

1. 启动RMI registry
2. 远程服务被初始化（生成stub和skeleton）
3. 远程服务向RMI registry注册
4. 客户端查询RMI registry
5. 客户端从RMI registry获取stub
6. 客户端调用stub上的方法
7. stub将方法的调用送到服务器上

• 启动服务前应先启动注册器
• 远程服务的参数和返回都需要做成可序列化

• Jini--adaptive discovery：自动注册、知道接口名称就可以自动适配下发stub
• Jini--self-healing networks：通过续约的方式确定服务的状态，超过续约时间不进行续约就会任务该服务已离线。

碎片知识

• 数据隐藏：将成员变量标记为private，将getters、setters标记为public。
• 实例变量总会有默认值：无论有没有明确赋值或者调用setter，实例变量总会有默认值。

integer --- 0
floating point --- 0.0
boolean --- false
reference --- null

• ==：使用==来比较两个基本数据类型或判断两个引用变量是否指向同一个对象。==可以用来比较任何类型的两个变量，因为它只是比较其中的字节组合。
• equals()：使用equals()来判断两个对象是否在意义上向相等

int a = 3;
byte b =3;
if(a == b){ 
// true
}
Foo c = new Foo();
Foo d = new Foo();
Foo e = c;
if(c == d){
// false
}
if(c == e){
// true
}
if(c.equals(d)){
// true
}

• x++与++x：x++先执行x+1，再执行赋值；++x先执行赋值，再执行x+1
• 长运算符(| &)与短运算符(|| &&)：

• 在&&表达式中，左右两边都为true这个表达式返回true，当左边返回false时，JVM不会执行右边的计算就直接返回false；
• 在||表达式中，左右两边都为false这个表达式返回false，当左边返回true时，JVM不会执行右边的计算就直接返回true；
• & 和 | 在boolean表达式会强制JVM执行两边的运算，但一般长表达是用在位运算中。

• 当一个类没有构造方法时，编译器再编译时会默认加上一个无参的构造方法。但是如果一个类已有一个构造方法，则编译器不会再加上无参的构造方法。

• 格式化说明

  
  
  格式化说明

需要拓展的知识点

• 位运算：移位运算参考：JAVA移位操作符你真的懂吗？

// 位非 ~
int x = 10;  //00001010
x = ~x;  //11110101

// 位与 & 、位或 |、位异或 ^
int x = 10;  //00001010
int x = 6;    //00000110
// 位与 &： 两位都是1返回1，否则返回0
int a =x&y;  //00000010
// 位或 |： 有一位为1就返回1，否则返回0
int a =x&y;  //00001110
// 位异或 ^： 位相同返回1，否则返回0
int a =x&y;  //11110010

// 移位运算 左移<<，右移>>，无符号右移>>>，需要结合数据类型来看。
int x = -11;  //11111011
// 左移 1位，等于值*2，向左边移动，并且在低位补0.
int a= x<<1; //11110110
// 右移1位，等于值/2，带符号右移，若左操作数是正数，则高位补“0”，若左操作数是负数，则高位补“1”.
int a= x>>1; //1111101
// 无符号右移，无论左操作数是正数还是负数，在高位都补“0”
int a= x>>>1; //0111101

• 不变性：String类型和包装类都是不可变的。创建后就值就不可以改变。JVM中有一个String Pool，不受GC的影响。如果新建的String引用变量的值在String Pool中有相同值的对象，会直接引用这个对象，而不是新建一个String对象。
• 断言：执行时没有特殊设置JVM会自动忽略断言，运行时打开JVM的断言设置，则可以在不影响任意代码的前提下进行除错。
• 静态嵌套类：可以在没有外层实例的情况下使用的类。

public class Outer{
    static class Inner{
        void do(){
        // do somethings
        }
    }
   class Test{
        public static void main (String args[]){
          Outer.Inner a = new Outer.Inner();
          a.do();
        }
    }
}

• 非静态的嵌套类是通常成为内部类。
• 匿名内部类：

button.addActionListen(new ActionListen{
    public void actionPerformed(ActionEvent e){
    //  do somethings
    }
})

• default与protected：default-同一个包内可存取，protected-允许不同包的子类继承它的成员。

• 多维数组：int[][] a2d = new int[4][2]>>这里由5个数组组成。

  
  
  多维数组
• 枚举ENUM：Java 枚举(enum) 详解7种常见的用法