head first java读书笔记

时间 2019-11-08

标签 head java 读书笔记栏目 Java 繁體版

原文原文链接

head first java读书笔记

1. 基本信息

页数：689
阅读起止日期：20170104-20170215

2. 标签

Java入门

3. 价值

8分

4. 主题

使用面向对象的思路介绍Java的基础知识，从对象的基本概念、变量、方法，到函数库，集成与多态，静态，再到GUI，序列化，网络，数据结构，最后介绍发布和远程调用。html

5. 纲要

Java的基本介绍-第1章
对象的基本介绍（变量与方法）-第2-5章
函数库-第6章
对象的深刻-继承、多态、构造函数-第7-9章
静态的变量或方法-第10章
异常处理-第11章
GUI-第12-13章
序列化与IO-第14章
网络与线程-第15章
经常使用数据结构-第16章
包与发布程序-第17章
远程过程调用、servlets等-第18章
附录

6. 点评

本书最大的启发是创建面向对象的基本思想，万物皆在对象中，究竟是如何组成和实现的。java

7. 摘录

7.1 Java的基本介绍

Java程序包括：源代码、编译器、输出（class文件）、JVM；

最经常使用的java数据库

public class ClassName {
     public static void main(String[] args){
         System.out.println("Hello World!");
     }
 }

Java不能像C同样使用整型作测试条件
(int)(Math.random()*length)来出现随机数；api

7.2 对象的基本介绍

对象自己已知的事物被称为实例变量，对象能够执行的动做被称为方法；
类是对象的蓝图；
main的两种用途：测试真正的类，启动你的java应用程序；
Java的程序在执行期是一组会互相交谈的对象；
变量有两种类型primitive主数据类型和引用；
primitive主数据类型：boolean, char（0~65535）, byte（-128~127）, short（-32768~32767）, int, long, float, double。
没有对象变量，只有引用到对象的变量；引用变量更像是对象的遥控器；
没有引用到任何对象的引用变量的值为null；
若是堆上的对象没有任何引用变量，便会被回收；
数组就像杯架，数组变量就是数组对象的遥控器；
将实例变量标记为private，将getter和setter标记为public；
实例变量永远都会有默认值，引用变量的默认值是null；局部变量没有默认值。
程序设计的方法：找出类应该作的事情，列出实例变量和方法，编写伪码，编写测试用的程序，实现类，测试方法，排错或从新设计。
伪码描述要作什么事情，而不是如何作。
Interger.parseInt()只会在所给的String为数字时有用。

7.3 API

ArrayList listName = new ArrayList ();
Java的API中，类是包含在包中的。使用时，必须import 类全名或直接打出去全名。除非是来自于java.lang这个包中，好比System, String, Math等。

7.4 对象深刻

extends表示继承，继承搜索方法时，会从底层向祖先搜索；
继承是是一个，实例变量是有一个；
public会被继承，private不会被继承。
IS-A是单方向的；
继承的意义有二：避免了重复的代码；定义出共同的协议；
多态为声明父类的对象引用指向子类的对象；
经过多态，能够写出即便引进新型子类时，也没必要修改的程序；
继承虽然没有层次的限制，但通常不会超过2层；
标识出final的类能够确保方法都是本身须要的版本，final也能够防止特定的方法被覆盖，只要加在方法前；
覆盖父类方法须要知足两个条件：参数必需要同样，且返回类型要兼容；不能下降方法的存取权限；
abstract表示抽象，抽象类不会被初始化；
abstract能够放在方法前，直接以分号结尾。抽象方法只能放在抽象类中，全部的抽象方法在子类中必须被实现；
Java中，全部的类都继承自object。object有equals,getClass,hashCode,toString等方法。
接口是为了解决多重继承的问题出现的，它没有实例变量。像是一个100%的纯抽象类，使用interface定义，全部的方法都是抽象的。其余类用implements来实现接口的方法。类是能够实现多个借口的。
若是新的类没法对其余类经过IS-A测试，就设计不继承的类；
只有在须要某类的特殊化版本时，已覆盖或增长新的方法来继承现有的类；
当你须要定义一群子类的模板，又不想初始化此模板时，使用抽象类；
若是定义出类能够扮演的角色，使用接口；
使用super关键字执行父类的方法；
抽象类能够带有抽象和非抽象的方法；
方法调用和局部变量在栈空间，全部的对象在堆空间；
构造函数没有类型，也不会被继承。一般必定要有没有参数的构造函数。若是有了一个有参数的构造函数，则没参数的构造函数必须本身写才会有，不然建立会出错。
一般情况下，类的构造函数是public。
构造函数的调用链是自顶向下的，即先运行父类，再运行子类。
子类的构造函数若是想调用父类，使用super();一般情况下，super会被编译器默认调用没有参数的版本，显示调用的话，必需要把super();放到第一行。
可使用this(args)调用重载版的其余的构造函数，例如无参数的构造函数，加个默认值调用有参数的构造函数。this(Color.Red)

7.5 静态的变量或方法

静态方法不须要建立实例变量就能够调用，像Math.abs(-1);
若是类只有静态方法，即要限制非抽象类初始化，能够将构造函数设置为private；
静态方法不能调用非静态的变量或方法，例如在main中调用；但能够调用静态变量或方法。
类中静态变量的值，对全部实例都相同，均是共享的；即实例变量每一个实例一个，静态变量每一个类一个。
public static final double PI=3.1415public表示可供各方读取，static表示不用建立实例便可使用，final表示不变；静态final变量默认取名大写，且必须初始化。
final的变量表明不能改变，final的方法不能被覆盖，final的类不能被继承；
使用相似ArrayList 时，要用到对主类型数据的封装。由于ArrayList设计成只接受类和对象。Java5.0以前，int不能直接加入ArrayList，5.0以后能够了，由于加入了autoboxing。Integer iWarp = new Integer(i); int unWrapped = iWrap.intValue();利用上述解包装；
主数据类型的静态方法：Integer.parseInt("2"), new Boolean("true").booleanValue();Double.toString(d);
格式化输出String.format("%,d",1000);
日期的格式化输出：%tc 完整的日期和时间，%tr是时间，%tA %tB %td 分别是星期，月份和日期。若是不想重复输入参数，可使用String.format("%tA, %<tB %<td", today);

java.util.Calendar对象来操做日期数组

Calendar cal = Calendar.getInstance();
cal.set(2017,1,6,15,40);
cal.getTimeInMillis();
cal.HOUR_OF_DAY
cal.add(cal.DATE, 30);//月份滚动
cal.roll(cal.DATE, 30);//月份不动
cal.set(cal.DATE, 1);
//重要的方法
add(int field, int amount)
get(int field)
getInstance()
getTimeInMillis()
roll(int field, int amount)
set(int field, int amount)
set(year,month,day,hour,minute)
setTimeInMillis(long millis)
//关键字段
DATE / DAY_OF_MONTH
HOUR / HOUR_OF_DAY
MILLISECOND
MINUTE
MONTH
YEAR
ZONE_OFFSET

import static java.lang.System.out;静态的import能够到方法，而后直接调用out便可，不建议使用；浏览器

7.6 异常处理

Java经过throws语句来告诉你全部的异常行为；把有风险的程序放在try块中，用catch块摆放异常的处理程序；异常时Exception类型的对象；

会抛出异常的方法必需要声明它有可能会这么作。方法能够抓住其余异常，异常总会丢回给调用方；安全

public void takeRisk() throws BadException{
     if (abandonAllHope){
         throw new BadException();
     }
 }
 public void crossFingers(){
     try{
         anObject.takeRisk();
     }catch (BadException ex){
         System.out.println("Aaargh");
         ex.printStackTrace();
     }
 }

try/catch块用来处理真正的异常，而不是程序的逻辑错误。
开发与测试期间发生RuntimeException是不会受编译器关因而否声明它会抛出RuntimeException的检查的，也不会管调用方是否定识到该异常；
不管成功或者失败都要运行的放在finally中；即便try和catch都有return也同样。
throws能够抛出多个异常。throws Exception1, Exception2；catch也能够用相似switch语句同样来分别处理，可是要从小到大；
异常也能够是多态的，能够用所抛出的异常父型来catch异常。便可以用Exception ex来catch异常，可是不推荐这么作；
duck异常表示，当调用有异常的方法，也声明会抛出异常时，能够不把此方法的调用放在try/catch块中，可是不推荐这么作。服务器

7.7 GUI相关

GUI的流程是建立frame，建立widget，加在widget，显示出来。

监听和事件源之间的沟统统过程序代码调用button.addActionListener(this)来向按钮注册。按钮会在事件发生时，调用注册该接口的方法actionPerformed(theEvent)；网络

import javax.swing.*;
 import java.awt.event.*;

 public class SimpleGui1B implements ActionListener{
     JButton button;

     public static void main(String[] args){
         SimpleGui1B gui = new SimpleGui1B();
         gui.go();
     }
     public void go(){
         JFrame frame = new JFrame();
         button = new JButton("click me");

         button.addAcitonListener(this);

         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

         frame.getContentPane().add(button);

         frame.setSize(300,300);
         frame.setVisible(true);
     }

     public void actionPerformed(ActionEvent event){
         button.setText("I've been clicked!");
     }
 }

frame默认有东西南北中五个位置来放置widget；

当有多个widget须要监听事件时，用内部类来解决；数据结构

public void go(){
     //...
     labelButton.addActionListener(new LaberlListener());
     colorButton.addActionListener(new ColorListener());
     label = new JLabel("I'm a label")
     //...
 }
 class LaberListener implements ActionListener {
     public void actionPerformed(ActionEvent event){
         labnel.setText("Ouch!")
     }
 }

不一样的事件有不一样的对应回调函数，ActionListener对应的回调函数是actionPerformed，经过addActionListener添加。
每一个背景组件均可以有自定义规则的布局管理器。BorderLayout表示五个区域，是frame默认的，FlowLayout表示从左至右，有必要时换行，是panel默认的；BoxLayout以垂直排列；
```
panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
 panel.add(button);
 frame.getContentPane().add(BorderLayout.North, panel);
```
JTextField文本框组件，JTextArea可滚动的文本框组件，JCheckBox组件，JList组件均为经常使用组件。

7.8 序列化与IO

储存对象的状态能够有两种办法，序列化（本身的Java程序读），纯文本文件（公共格式，其余程序可读）。
序列化写入的步骤：建立FileOutputStream对应一个文件xxx.ser，有FileStream建立ObjectOutputStream，由ObjectOutputStream写入object，关闭ObjectOutputStream。其中须要注意，可以写入ObjectOutputStream的object必须implements Serializable，可是不须要实现任何方法。
```
FileOutputStream fileStream = new FileOutputStream("MyGame.ser");
 ObjectOutputStream os = new ObjectOutputStream(fileStream);
 os.writeObject(characterOne);
 os.close();
```
当一个类能够序列化时，必须全部的实例变量都能被序列化，若是某个变量不须要序列化，须要标记transient，例如transient String currentID;

解序列化步骤，建立FileInputStream读取一个文件，建立ObjectInputStream，读取对象，转换对象类型，关闭。

FileInputStream fileStream = new FileInputStream("MyGame.ser");
 ObjectInputStream os = new ObjectInputStream(fileStream);
 Object one = os.readObject();
 GameCharacter elf = (GameCharacter) one;
 os.close()

读写文本文件。注意可使用缓冲区的方法来减小磁盘IO。使用writer.flush()强制缓冲区内容写入磁盘。

import java.io.*;
 class WriteAFile{
     public static void main(String[] args){
         try {
             FileWriter writer = new FileWriter("Foo.txt");
             writer.write("hello, foo!");
             //BufferedWriter bWriter = new BufferedWriter(writer);
             //bWriter.flush();
             writer.close();
             File myFile = new File("Foo.txt");
             FileReader fileReader = new FileReader(myFile);

             BufferedReader reader = new BufferedReader(fileReader);
             String line = null;
             while((line = reader.readLine()) != null){
                 System.out.println(line);
             }
             reader.close();
         } catch(IOException ex){
             ex.printStackTrace();
         }
     }
 }

java.io.File类的操做

//建立出File对象
 File f = new File("MyCode.txt");
 //建目录
 File dir = new File("Chapter_8");
 dir.mkdir()
 //列出目录内容
 if (dir.isDirectory()){
     String[] dirContents = dit.list();
 }
 //取得绝对路径
 dit.getAbsolutePath();
 //删除文件
 boolean isDeleted = f.delete()

每一个对象被序列化的同时，都会带上一个类的版本的识别ID，即serialVersionUID。所以要注意版本。

7.9 网络与线程

网络接收消息的步骤：创建socket链接，输入到底层的InputStreamReader上，转换到缓冲区字符BufferedReader，读取数据；

Socket chatSocket = new Socket("127.0.0.1", 5000);
 InputStreamReader stream = new InputStreamReader(chatSocket.getInputStream());
 BufferedReader reader = new BufferedReader(stream);
 String message = reader.readline();
 reader.close();

写消息的流程是：创建socket，getOutputSream并创建PrintWriter，写入数据；

Socket chatSocket = new Socket("127.0.0.1", 5000);
 PrintWriter writer = new PringWriter(chatSocket.getOutputStream());
 writer.println("haha");
 writer.close();

服务器端创建服务的流程为：创建ServerSocket，等待客户端链接，客户链接后，调用accept方法创建新的socket。

ServerSocket serverSock = new ServerSocket(5000);
 while(true){
     Socket sock = serverSock.accept();
     PrintWriter writer = new PrintWriter(sock.getOutputStream());
     writer.println("haha");
     writer.close();
 }

Thread类用于建立线程，它有void join();void start();static void sleep();等方法。
启动新线程的流程是：创建Runnable对象，创建Thread对象，并赋值Runnable任务；启动Thread。

Runnable是一个接口，它只有一个方法public void run()。它就是线程要执行的工做。

public class MyRunnable implements Runnable {
     public void run(){
         go();
     }
     public void go(){
         System.out.println("top o' the stack");
     }
 }

 class ThreadTestDrive{
     public static void main(String[] args){
         Runnable threadJob = new MyRunnable();
         Thread myThread = new Thread(threadJob);
         myThread.start();
         System.out.println("back in main");
     }
 }

新建线程线程有新建(new)，可执行(start)，执行中，三个状态，可执行和执行中两个状态是来回切换的，由JVM调度决定，是随机不可控的。最多只能靠sleep来影响最小保证时间。
线程不可重复启动。
线程的名字能够经过myThread.setName("Solon's Thread")来设定，并可经过调用Thread.currentThread().getName()来获取。
线程会产生并发性问题(concurrency)，并发性问题会引起竞争状态(race condition)，竞争状态会引起数据损毁。举个例子，两个线程共用一个余额，每次用钱时，先检查余额，再扣钱。这样会因为竞争缘由出现负数。因此须要一把锁，来保证一个方法一次只能被一个线程调用，即用synchronized关键字。
```
private synchronized void makeWithDrawa(int amount){
    //...
}
```
要注意锁是锁在对象上的，只有对象包含同步化方法时才起做用。对象就算有多个同步化方法，也仍是只有一个锁。

同步化能够只修饰几行，这样能够减少原子操做的范围，提升效率。

private void makeWithDrawa(int amount){
    //...
    synchronized(this){
        //...
    }
}

两个线程和两个对象就能够引发死锁，各自占有一个资源，又须要调用彼此的资源。
静态的方法是运行在类上的，当要对静态的方法作同步化是，会使用类自己的锁。

7.10 经常使用数据结构与泛型

TreeSet一有序状态保持并可防止重复；
HashMap-KV来存储；
LinkedList-针对常常插入和删除的集合；没有ArrayList经常使用；
HashSet-防重复的集合，快速查找；
LinkedHashMap-相似HashMap，但可记住元素的插入顺序，可按照存取顺序来排序；
可用java.util下的Collections.sort(List list)来给ArrayList排序，此函数会直接改变list的顺序。
不用泛型时，任何object对象均可以加入ArrayList，形成混乱。使用泛型，只有任一单一类型可加入；

泛型有三件事是重要的：

new ArrayList<Song>(); //建立实例
 ArrayList<Song> songList = new ArrayList<song>(); //声明指定泛型类型的变量
 void foo(ArrayList<Song> list); //声明或调用指定泛型的方法

在说明文件中，通常用E表示指定类型；

public class ArrayList<E> extends AbstractList<E> implements List<E> ...{
     public boolean add(E o)
 }

运用泛型的方法可使用未定义在类声明的类型参数。

public <T extends Animal> void takeThing(ArrayList<T> list)
//与后续的万用字符相同
public void takeThing(ArrayList<? extends Animal>)
//与下面不同,下面的只能使用Animal，不能使用其子类
public void takeThing(ArrayList<Animal> list)

以泛型的观点来讲extends能够表明extend或implement，表示是一个。
若是要对自定义类实现排序，有两种方法，一是实现该类的Comparable接口，这个接口有compareTo方法。能够调用已有的类型来辅助实现该方法；二是增长Comparator类的参数来比较。
能够调用HashSet的addAll方法，来生成ArrayList对应的队列；

一样若是要使用HashSet去除重复，针对自定义类，要覆盖equals方法和hashCode方法。它的比较过程是先比较hashCode()，若是相同，再比较equals。

class Song implements Comparable<Song>{
    ...
    public boolean equals(Object aSong){
        Song s = (Song)aSong;
        return getTitle().equals(s.getTitle());
    }
    public int hashCode(){
        return title.hashCode();
    }
}

HashMap适合用KV场景存储数据

HashMap<String, Integer> scores = new HashMap<String, Integer>();
scores.put("Bert", 43);
System.out.println(scores.get("Bert"));

泛型参数和数组参数的区别

public void takeAnimals1(ArrayList<Animal> animals)
public void takeAnimals2(Animal[] animals)
//takeAnimals1(new ArrayList<Dog> dogs)会出错，编译错误
//takeAnimals2(new Dog[] dogs)不会出错
//前者能够防止在函数中进行Dog的特有相关操做，后者在执行期若是运行相关操做，会抛出异常

为了解决上述前者的问题，可使用万用字符

public void takeAnimals3(ArrayList<? extends Animal> animals)
//为了防止此时，将ArrayList<Dog>中加入Cat，当用万用字符时，不能对队列作加入操做

7.11 包与发布程序

可使用-d class_path来将源代码与类文件相分离，实现对源码的保护；
```
javac -d ../classes *.java
```
jar相似tar命令，它有本身的规则。首先要肯定全部的类文件都在classes目录下，其次要有manifest.txt文件来描述哪一个类带有main()方法，最后执行命令打jar包
```
cat manifest.txt
 Main-Class:MyApp
 cd MiniProject/classes
 jar -cvmf manifest.txt app1.jar *.class
```
若是jar包指定了manifest，则能够执行java -jar app1.jar。
除非类是包的一部分，不然Java虚拟机不会深刻其余目录去找。
用包防止类名冲突，能够把类放到各个包里。就像java.util.ArrayList。
而为了防止包命名冲突，通常反向使用domain做为包名称。
```
com.headfirstbooks.Book
 com.headfirstjava.projects.Chart
```
选定包名称后，须要再类的源代码的第一行将类加入包中package com.headfirstjava;。而后要设定对应的目录结构。
通常Java程序的路径为项目根目录下有source和classes两个文件，source目录下为包路径和源代码，这样用-d ../classes编译后，-d会在classes目录下创建对应的目录和class文件。
按照上述约定时，manifest文件也放在class目录下，通常为Main-Class:com.headfirstjava.PackageExcise。
在classes目录下执行jar语句打包，这里只要指定com路径就行。
```
jar -cvmf manifest.txt packEx.jar com
```
使用jar -xf packEx.jar解压后会发现有META-INF目录，其下有MANIFEST.MF文件，即为写入的对应文件。
JWS即Java Web Start，用户能经过网页上的某个链接来启动Java程序，一旦程序下载后，下次就能独立于浏览器来运行，它是经过网络来发布程序的一种手段。jnlp文件是个描述应用程序可执行JAR文件的XML文件。
制做可执行jar程序；编写jnlp文件；二者均放入Web服务器；Web服务器设定新类型application/x-java-jnlp-file；设定网页连接到jnlp文件<a href="MyApp.jnlp">Launch My App</a>

7.12 远程过程调用、servlets等

远程过程调用最先是为了利用Server端的强大处理能力。RMI全称Remote Method Invocation；
RMI须要服务器与服务器helper和客户端与客户端helper。helper伪装成服务，但其实只是真实服务的代理；
使用RMI时要肯定协议，两端都是Java可以使用JRMP协议，IIOP能够调用Java对象或其余类型的远程方法。
在RMI中客户端的helper称为stub，客户端的helper成为skeleton
建立远程服务的流程是建立接口(extends Remote)，实现类(extends UnicastRemoteObject impements MyRemote)，rmic产生stub与skeleton(rmic MyRemoteImpl)，启动RMI registry(rmiregistry)，启动远程服务(Naming.rebind("Remote Hello", serviceMyRemote))。
客户端查询RMIregistry((MyRemote)Naming.lookup("rmi://127.0.0.1/Remote Hello"))，RMIregistry返回stub对象，客户端调用stub上的方法；
注意点：启动远程服务前启动registry；参数和返回类型可序列化；
servlet至关于Java的CGI，能够处理用户提交的请求，并将结果返回给浏览器的网页；
建立并执行serverlet的步骤：找到网页服务器能够存放servlet的地方；取得servlet.jar并添加到classpath上（其不是标准函数库的一部分）；extends HttpServlet来编写servlet的类；编写html来调用servlet；给服务器配置html和servlet；
servlet通常经过覆盖HttpServlet的doGet和doPost来建立；它输出带有完整标识的HTML网页；
EJB是Enterprise JavaBeans，它具备一组光靠RMI不会有的服务，好比交易管理、安全性、并发性、数据库和网络功能等；EJB服务器做用于RMI调用和服务层之间。service helper调用EJB object，object调用Enterprise bean，后者再调用DB等操做；
Jini也使用RMI，但具备自适应探索（接收服务注册和客户端调用查询）和自恢复网络（用心跳检查服务）的功能；

7.13 附录
按位非~，按位与&，按位或|，按位异或^；
右移>>，无符号右移>>>;
String具备不变性，放在String pool中，不受Garbage Collector管理。
包装类没有setter，其具备不变性。例如new Integer(42)，永远都是42。

断言能够用来测试，它比println的好处是没有特别设定的话，它会自动被JVM忽略，也可专门打开断言调试程序。

assert (height > 0) : "height = " + height + " weight = " + weight;
 //冒号后面的语句能够是任何返回非null值得语句，但必定要注意不要在这里改变对象的状态
 //断言的编译和普通编译没差异，执行时有差别。
 javac TestDriveGame.java
 java -ea TestDriveGame

new Foo().go()是一个调用go方法，但又不须要维持对Foo引用的方式；
静态嵌套类，和普通类很像，可经过new Outer.Inner()来建立。可存取外层静态私有变量；
非静态的嵌套类，一般被称为内部类。

匿名内部类。

//button.addActionListener(quitListener); //一般是传递一个内部类的实例
 //虽然ActionListener是个接口，并且咱们不能声明一个接口的实例，但匿名内部类是个例外
 button.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent ev){
         System.exit(0);
     }
 });

public任何程序代码均可公开存取；default只在统一包中的默认事物可以存取；protected可容许不在同一包的子类，继承该部分；
对于经常使用的可变String，通常使用StringBuilder，Thread安全环境中，采用StringBuffer；
二维数组是指数组的数组，new int [4][2]实际上是建立一个包含四个元素的数组，每一个元素是一个长度为2的数组。
枚举相对于普一般量的优点是限定了范围，其实际是继承了java.lang.Enum。声明时使用public enum Members {JERRY, BOBBY, PHIL};
每一个枚举都内置values()能够用于遍历操做；
能够在enum中加入构造函数，方法、变量和特定常量的内容；

8. 相关

暂无

head first java读书笔记

head first java读书笔记

1. 基本信息

2. 标签

3. 价值

4. 主题

5. 纲要

6. 点评

7. 摘录

7.1 Java的基本介绍

7.2 对象的基本介绍

7.3 API

7.4 对象深刻

7.5 静态的变量或方法

7.6 异常处理

7.7 GUI相关

7.8 序列化与IO

7.9 网络与线程

7.10 经常使用数据结构与泛型

7.11 包与发布程序

7.12 远程过程调用、servlets等

7.13 附录

8. 相关