20145330第五周《Java学习笔记》
这一周又是紧张的一周。
语法与继承架构
- Java中所有错误都会打包为对象可以尝试try、catch代表错误的对象后做一些处理。
- 使用try、catch语法，JVM尝试执行try区块中的程序代码。如果发生错误，执行流程会跳离错误发生点，然后比较catch括号中声明的类型，是否符合被抛出的错误对象类型，如果是，就执行catch区块的程序代码。
- 范例如下：
import java.util.*;
public class Average {
public static void main(String[] args) {
Scanner console=new Scanner(System.in);
double sum=0;
int count=0;
while(true){
try{
int number=console.nextInt();
if (number==0){
break;
}
sum+=number;
count++;
}catch(InputMismatchException ex){
System.out.printf("略过非整数输入：%s%n",console.next());
}
}
System.out.printf("平均%.2f%n",sum/count);
}
}
- 对于正确的整数输入予以加总，对于错误的则显示略过
- 异常继承架构
- 程序设计本身的错误，建议使用
Exception或其子类实例来表现，所以通常称错误处理为异常处理 - 单就语法与继承上来说，如果某个方法声明会抛出
Throwable或子类实例，只要不属于Error、java.lang.RuntimeException或其子类实例，就必须明确使用try、catch语法加以处理 - 如果父类异常对象在子类异常对象前被捕捉，则
catch子类异常对象的区块将永远不被执行，编译程序会检查出这个错误
- 程序设计本身的错误，建议使用
import java.io.*;
import java.util.Scanner;
public class FileUtil {
public static String readFile(String name) throws FileNotFoundException{
StringBuilder text=new StringBuilder();
try{
Scanner console=new Scanner(new FileInputStream(name));
while(console.hasNext()){
text.append(console.nextLine())
.append('\n');
}
}catch(FileNotFoundException ex){
ex.printStackTrace();
throw ex;
}
return text.toString();
}
}
- 在
catch区块进行完部分错误处理后，可以使用throw将异常再抛出。- 可以在任何流程中抛出异常，不一定在
catch区块中 - 在流程中抛出异常，就直接跳出原有的流程，可以抛出受检或非受检异常
- 如果使用继承时，父类某个方法声明throws某些异常，子类重新定义该方法
- 可以在任何流程中抛出异常，不一定在
- 认识堆栈追踪
- 如果要取得个别的堆栈追踪元素进行处理，则可以使用
getStackTrace() - 要善用堆栈追踪，前提是程序代码中不可有私吞异常的行为
- 如果要取得个别的堆栈追踪元素进行处理，则可以使用
-
关于assert
异常与资源管理
- 程序中因错误而抛出异常时，原本的执行流程就会中断，抛出异常处之后的程序代码就不会执行
- 使用
finally
public class FinallyDemo {
public static void main(String[] args) {
System.out.println(test(true));
}
static int test(boolean flag){
try{
if(flag){
return 1;
}
}finally {
System.out.println("finally...");
}
return 0;
}
}
- 自动尝试关闭资源
try(Scanner console=new Scanner(new FileInputStream(name)))- 使用自动尝试关闭资源语法时，并不影响你对特定异常的处理
- 自动尝试关闭资源语法也仅协助你关闭资源，而非用于处理异常
- java.lang.AutoCloseable接口
- 举例简单示范：
public class AutoCloseableDemo {
public static void main(String[] args) {
try(Resource res=new Resource()){
res.doSome();
}catch(Exception ex){
ex.printStackTrace();
}
}
}
class Resource implements AutoCloseable{
void doSome(){
System.out.println("做一些事");
}
@Override
public void close() throws Exception{
System.out.println("资源被关闭");
}
}
- 尝试关闭资源语法也可以同时关闭两个以上的对象资源，只要中间以分号分隔。
- 以下范例：
import static java.lang.System.out;
public class AutoCloseableDemo2 {
public static void main(String[] args) {
try(ResourceSome some=new ResourceSome();
ResourceOther other=new ResourceOther()) {
some.doSome();
other.doOther();
}catch (Exception ex){
ex.printStackTrace();
}
}
}
class ResourceSome implements AutoCloseable{
void doSome(){
out.println("做一些事");
}
@Override
public void close() throws Exception{
out.println("资源some已被关闭");
}
}
class ResourceOther implements AutoCloseable{
void doOther(){
out.println("做其他事");
}
@Override
public void close() throws Exception{
out.println("资源Other已被关闭");
}
}
如果父类异常对象在子类异常对象前被捕捉，则
catch子类异常对象的区块将永远不被执行，编译程序会检查出这个错误。从JDK7开始，可以使用多重捕捉语法，不过仍得注意异常的继承，catch括号中列出的异常不得有继承关系，否则会发生编译错误如果是非受检异常，原本就可以自行选择是否处理异常，因此不使用
try``catch处理时也不用特别在方法上使用throws声明，不处理非受检异常时，异常会自动往外传播。
Collection与Map
收集对象的行为，像是新增对象的
add（）方法、移除对象的remove（）方法等，都是定义在java.util.Collection中。既然可以收集对象，也要能逐一取得对象，这就是java.lang.Iterable定义的行为，它定义了iterator()方法返回java.lang.Iterable操作对象，可以让你逐一取得收集的对象。收集对象的共同行为定义在
Collection中，然而收集对象会有不同的需求。如果希望收集时记录每个对象的索引顺序，并可依索引取回对象，这样的行为定义在java.util.List接口中。如果希望收集的对象不重复，具有集合的行为，则由java.util.Set定义。如果希望收集对象时以队列方式，收集的对象加入至尾端，取得对象时从前端，则可以使用java.util.Queue。如果希望Queue的两端进行加入、移除等操作,则可以使用java.util.Deque。-
List是一种Collection,作用是收集对象，并以索引方式保留收集的对象顺序，其操作类之一是java.util.ArrayList。 例如：
import static java.lang.System.out;
public class Guest
{
public static void main(String[] args)
{
List names = new java.util.ArrayList();
collectNameTo(names);
out.println("訪客名單：");
printUpperCase(names);
}
static void collectNameTo(List names)
{
Scanner console = new Scanner(System.in);
while(true)
{
out.print("訪客名稱：");
String name = console.nextLine();
if(name.equals("quit"))
{
break;
}
names.add(name);
}
}
static void printUpperCase(List names)
{
for(int i = 0; i < names.size(); i++)
{
String name = (String) names.get(i);
out.println(name.toUpperCase());
}
}
}
- 数组在内存中会是连续的线性空间，根据索引随机存取时速度快，如果操作上有这类需求时，像是排序，就可使用ArrayList，可得到较好的速度表现。
- 若收集的对象经常会有变动索引的情况，也许考虑链接方式操作的List会比较好，像是随时会有客户端登录或注销的客户端List，使用LinkedList会有比较好的效率。
- 在收集过程中若有相同对象，则不再重复收集，如果有这类需求，可以使用Set接口的操作对象。
import java.util.*;
public class WordCount
{
public static void main(String[] args)
{
Scanner console = new Scanner(System.in);
System.out.print("請輸入英文：");
Set words = tokenSet(console.nextLine());
System.out.printf("不重複單字有 %d 個：%s%n", words.size(), words);
}
static Set tokenSet(String line)
{
String[] tokens = line.split(" ");
return new HashSet(Arrays.asList(tokens));
}
}
- HashSet的操作概念是，在内存中开设空间，每个空间会有个哈希编码。
- 如果对象有操作Queue，并打算以队列方式使用，且队列长度受限，通常建议使用offer()、poll()与peek()等方法
- LinkedList不仅操作了List接口，与操作了Queue的行为，所以可以将LinkedList当作队列来使用
- 想对队列的前端与尾端进行操作，在前端加入对象与取出对象，在尾端加入对象与取出对象，Queue的子接口Deque就定义了这类行为
- java.util.ArrayDeque操作了Deque接口，可以使用ArrayDeque来操作容量有限的堆栈。
import java.util.*;
interface Request
{
void execute();
}
public class RequestQueue
{
public static void main(String[] args)
{
Queue requests = new LinkedList();
offerRequestTo(requests);
process(requests);
}
static void offerRequestTo(Queue requests)
{
for (int i = 1; i < 6; i++)
{
Request request = new Request()
{
public void execute()
{
System.out.printf("处理资料 %f%n", Math.random());
}
};
requests.offer(request);
}
}
static void process(Queue requests)
{
while(requests.peek() != null)
{
Request request = (Request) requests.poll();
request.execute();
}
}
}相对于匿名类语法来说，Lambda表达式的语法省略了接口类型与方法名称，->左边是参数列，而右边是方法本体
在Lambda表达式中使用区块时，如果方法必须有返回值，在区块中就必须使用return
- interator()方法提升至新的java.util.Iterable父接口。
- 在java的规范中，与顺序有关的行为，通常要不对象本身是Comparable，要不就是另行指定Comparator对象告知如何排序
若要根据某个键来取得对应的值，可以事先利用java.util.Map接口的操作对象来建立键值对应数据，之后若要取得值，只要用对应的键就可以迅速取得。常用的Map操作类为java.util.HashMap与java.util.TreeMap，其继承自抽象类java.util.AbstractMap。
- 如果使用TreeMap建立键值对应，则键的部分则会排序，条件是作为键的对象必须操作Comparable接口，或者是在创建TreeMap时指定操作Comparator接口的对象。
Properties类继承自Hashtable，HashTable操作了Map接口，Properties自然也有Map的行为。虽然也可以使用put（）设定键值对应、get（）方法指定键取回值，不过一般常用Properties的setProperty（）指定字符串类型的键值，getProperty（）指定字符串类型的键，取回字符串类型的值，通常称为属性名称与属性值。
import java.util.*;
import static java.lang.System.out;
public class MapKeyValue {
public static void main(String[] args)
{
Map<String, String> map = new HashMap<>();
map.put("one", "一");
map.put("two", "二");
map.put("three", "三");
out.println("显示鍵");
map.keySet().forEach(key -> out.println(key));
out.println("显示值");
map.values().forEach(key -> out.println(key));
}
}
学习中遇到的问题
- 问题：Exception与RuntimeException的区别：
- 解决：
- Exception：在程序中必须使用try、catch进行处理。
- RuntimeException：可以不使用try、catch进行处理，但是如果有异常产生，则异常将由JVM进行处理。
感悟和思考
从每周的学习中我都能总结出一些学习Java的经验和道理，我留下的最深刻的印象就是各种类、接口、方法、行为越来越多，有些还很相似，结果经常分不清楚，看到后面的内容又忘记了前面的知识点，学习时一直前后反复翻教材，后来我就尝试做笔记，将重要的、容易混淆的知识点都记下来，发现这样在回顾知识点时很方便，也很清晰明了。希望可以灵活运用更好更熟练的掌握。
代码托管截图
学习进度表
| 代码行数（新增/累积） | 博客量（新增/累积） | 学习时间（新增/累积） | 重要成长 | |
|---|---|---|---|---|
| 目标 | 5000行 | 30篇 | 400小时 | |
| 第一周 | 200/200 | 2/2 | 20/20 | |
| 第二周 | 300/500 | 2/4 | 18/38 | |
| 第三周 | 500/1000 | 3/7 | 22/60 | |
| 第四周 | 300/1300 | 2/9 | 30/90 |
参考资料
- 《Java学习笔记》