20145240 《Java程序设计》第五周学习总结

20145240 《Java程序设计》第五周学习总结

教材学习内容总结

语法与继承结构

8.1.1使用try、catch

• java中所有的错误都会被打包为对象，并提供了特有的语句进行处理。使用了try、catch语法，JVM会尝试执行try区块中的程序代码，如果发生错误，执行流程会跳离错误发生点，然后对比catch括号中声明的类型，是否符合被抛出的错误对象类型，如果是的话，就执行catch区块中的程序代码。

• 1.try

    	{
    		需要被检测的代码；
    	}
  

• 2.cathy(异常类 变量)

    	{
    		处理异常的代码（处理方式）；
    	}
  

• 3.finally

    	{
    		一定会执行的语句；
    	}
  

eg:运用try、catch在错误被捕捉处理后、尝试恢复程序正常的执行流程。

	import java.util.*;
	public class Average3{
	    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);
	    }
	
	}

• 运行结果
  

8.1.2异常继承构架

• 设计错误对象都集成自java.lang.Throwable类，Throwable类定义了取得错误信息、堆栈追踪等方法，他有两个子类：java.lang.Errow、java.lang.Exception。
• 程序设计本身的错误，建议使用Exception或其子类实例来表现，所以通常诚错误处理为异常处理。
• 使用try、catch语法加以处理，或者用throws声明这个方法会抛出异常，否则会编译失败。

eg：取得用户的字符串输入之后，检查时候位数字格式，若是在转换为int整数，若格式不对就提醒用户做正确格式输入。

import java.util.Scanner;
public class Average4{
    public static void main(String[] args){
        double sum=0;
        int count=0;
        while(true){
            int number=console.nextInt();
            if(number==0){
                break;
            }
            sum+=number;
            count++;
        }
        System.out.printf("平均 %.2f%n",sum/count);
    }
    static Scanner console=new Scanner(System.in);
    static int nextInt(){
        String input=console.next();
        while(!input.matches("\\d*")){
            System.out.println("请输入数字");
            input=console.next();
        }
        return Integer.parseInt(input);
    }
}

8.1.3要抓还是要抛

• 编译时被检测异常 ：该异常在编译时，如果没有处理（没有抛也没有try）,编译失败。该异常被表示，代表可以被处理。
• 运行时异常（编译时不检测）：在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止，需要对代码进行修正。

eg：在异常发生时，可以使用try、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();
	}
}

8.1.4贴心还是造成麻烦

• 异常处理的本意：在程序错误发生时能有有明确的方式通知API客户端。
• java是唯一采用受检异常的语言的目的：文件化和提供编译程序信息。

8.1.5认识堆栈追踪

• 定义：若想得知异常发生的根源，以及多重方法调用下异常的堆栈传播，可以利用一场对象自动收集的对堆栈追踪来获取相关信息。
• 查看堆栈追踪最简单的方法是直接调用异常对象的printStackTrace()。
• 在使用```throw``重抛异常时，异常的追踪堆栈起点，仍是异常的发生根源，而不是重抛异常的地方。

eg：使用fillInStrackTrace（）方法，让异常堆栈起点为重抛异常的地方。

public class StackTraceDemo3{
    public static void main(String[] args){
        try{
            c();
        }catch(NullPointerException ex){
            ex.printStackTrace();
        }
    }
    static void c(){
        try{
            b();
        }catch(NullPointerException ex){
            ex.printStackTrace();
            Throwable t=ex.fillInStackTrace();
            throw (NullPointerException) t;
        }
    }
    static void b(){
        a();
    }
    static String a(){
        String text=null;
        return text.toUpperCase();
    }
}

• 运行结果
  

8.1.6关于assert

• assert的两种使用语法：
  1.assert boolean_expression
2.assert boolean_expression : detail_expression
• boolean_expression 若为true则什么事都不会发生，若为false则会发生java.lang.Assertionerror。
• 何时该使用断言？1.断言客户端调用方法前，已经准备好某些前置条件。2.断言客户端调用方法后名具有方法承诺的结果。3.断言对象某个时间点下的状态。4.使用断言取代批注。5.断言程序流程中绝对不会执行到的程序代码部分。

8.2异常与资源管理

8.2.1使用finally

• finally代码块：定义一定执行的代码。
• 用常用于关闭资源。

eg：程序撰写的流程中先return了，而且也有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;
    }
}

• 运行结果
  

8.2.2自动尝试关闭资源

• 想要尝试自动关闭资源的对象，是撰写在try之后的括号中，如果无需catch处理任何异常，可以不用撰写，也不用撰写fianlly自行尝试关闭资源。
• 使用自动尝试关闭资源语法时，并不影响你对特定异常的处理。
• 实际上，自动尝试关闭资源语法也仅协助你关闭资源，而非用与处理异常。

8.2.3java.lang.AutoCloseable接口

• JDK7的尝试关闭资源语法可套用的对象，必须操作java.lang.AutoCloseable接口。
• AutoCloseable是JDK7新增的接口，仅定义了close（）语法。

eg：在try括号中，越后面撰写的对象资源会越早被关闭。

import static java.lang.System.out;

public class AutoClosableDemo2{
	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 AutoClosable{
	void doSome(){
		out.println("做一些事");
	}
	@Override
	public void close() throws Exception{
		out.println("资源Some被关闭");
	}
}

class ResourceOther implements AutoClosable{
	void doOther(){
		out.println("做其他事");
	}
	@Override
	public void close() throws Exception{
		out.println("资源Other被关闭");
	}
}

9.1使用Collection收集对象

9.1.1认识Collection

• 针对收集对象的需求，java SE提供了Collection API。
• 收集对象的行为，像是新增对象的add（）方法、移除对象的remove（）方法等，都是定义在java.lang.Collection中。
• 既可以收集对象，也能逐一取得对象，这就是java.lang.Iterable定义的行为。

9.1.2具有索引的List

• List是一种Collection，作用是收集对象，并以索引方式保留收集的对象顺序，其操作之一是java.util.ArrayList。
• ArrayList特性：数组在内存中会是连续的线性空间，根据索引随机存取时速度快。有可指定容量的构造函数。
• LinkedList特性：若收集的对象经常会有变动索引的情况。

9.1.3内容不重复的Set

• 在收集过程中，若有相同对象，则不再重复收集，可用set接口的操作对象。

eg：操作了hashcode（）与equal（）方法，重复的student不会被收集。

import java.util.*;

class Student2 {
    private String name;
    private String number;

    Student2(String name, String number) {
        this.name = name;
        this.number = number;
    }


    @Override
    public int hashCode()
    {
        int hash = 7;
        hash = 47 * hash + Objects.hashCode(this.name);
        hash = 47 * hash + Objects.hashCode(this.number);
        return hash;
    }

    @Override
    public boolean equals(Objects obj) {
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final Student2 other = (Student2) obj;
        if (!Objects.equals(this.name, other.name)) {
            return false;
        }
        if (!Objects.equals(this.number, other.number)) {
            return false;
        }
        return true;
    }

    @Override
    public String toString()
    {
        return String.format("(%s,%s)", name, number);
    }
}
public class Students2
{
    public static void main(String[] args)
    {
        Set students = new HashSet();
        students.add(new Student2("Justin","B835031"));
        students.add(new Student2("Monica","B835032"));
        students.add(new Student2("Justin","B835031"));
        System.out.println(students);
    }
}

9.1.4支持队列操作的Queue

• 希望收集对象时以队列方式，收集的对象加至尾端，取得对象时从前端，则可用Quene接口的操作对象。

eg：使用ArrayDeque来操作容量有限的堆栈。

import java.util.*;
import static java.lang.System.out;

public class Stack
{
    private Deque elems = new ArrayDeque();
    private int capacity ;

    public Stack(int capacity)
    {
        this.capacity = capacity;
    }

    public boolean push(Object elem)
    {
        if(isFull())
        {
            return false;
        }
        return elems.offerLast(elem);
    }

    private boolean ifFull()
    {
        return elems.size() + 1 > capacity;
    }

    public Object pop()
    {
        return elems.pollLast();
    }

    public Object peek()
    {
        return elems.size();
    }

    public static  void main (String[] agrs)
    {
        Stack stack = new Stack(5);
        stack.push("Justin");
        stack.push("Monica");
        stack.push("Irene");
        out.println(stack.pop());
        out.println(stack.pop());
        out.println(stack.pop());
    }
}

• 运行结果

9.1.5使用泛型

• 使我们在设计API时可以指定类或方法支持泛型，而使API的客户端在语法上会更为简洁，并得到编译时期检查。

eg：ArrayList为例，加入泛型语法。

import java.util.Arrays;
import java.util.Objects;

public class ArrayList<E>
{
    private Object[] elems;
    private int next;

    public ArrayList(int capacity)
    {
        elems = new Object [capacity];
    }

    public ArrayList()
    {
        this(16);
    }

    public void add(E e)
    {
        if(next == elems.length)
        {
            elems = Arrays.copyOf(elems,elems.length * 2);
        }
        elems[next++] = e;
    }

    public E get (int index)
    {
        return (E) elems[index];
    }

    public int size()
    {
        return next;
    }
}

9.1.6简介Lambda表达式

• Lambda表达式的语法省略了接口类型与方法名称，->左边是参数列，右边是方法本体。

eg：简化以下代码。

IntegerFunction doubleFunction = new IntegerFunction()
{
    public Integer apply(Integer i)
	{
        return i*2;    
	}
    
}

• 简化后

IntegerFunction doubleFunction = (Integer i) -> i * 2;

9.2键值对应的Map

9.2.1常用Map操作类

• 常用的Map操作类为java.util.HashMap与java.util.TreeMap。

9.2.2访问Map键值

• 如果想取得Map中所有的键，可以调用Map的keySet（）返回Set对象。

本周代码托管截图

其他（感悟、思考等，可选）

代码太多就没有往博客上粘贴了，选取了几个比较有代表性的。即使在清明假期也没有放下java的学习，多积累就会有更多的收获。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	200/200	1/2	20/20
第二周	300/500	1/3	30/50
第三周	500/1000	1/4	35/85
第四周	1225/2225	1/5	40/125
第五周	993/3218	1/5	35/160