try{

}catch{

}finally{ //一定会执行

}

try{

一些可能会引起错误的代码

}catch(捕获错误){  //从小到大。先写子类再写父类

执行一些代码

}finally{

//最终要执行的一些代码

}

运行时异常（非检查异常）

ArrayList

java中的集合类：是一种工具类，就像是容器，储存任意数量的具有共同属性的对象。

作用：

在类的内部，对数据进行组织；

简单而快速的搜索大数量的条目；

有的集合接口，提供了一系列排列有序的元素，并且可以在序列中间快速的插入或者删除有关元素；

1、List接口：序列，存储元素排列有序且可重复。实现类:ArrayList，数组序列。实现类：LinkedList，链表。
2、Queue接口：队列，存储元素排列有序且可重复。实现类：LinkedList，链表。
3、Set接口：集，存储元素无序且不可重复。实现类：HashSet，哈希集。
Map接口：内部以<Key,Value>两个对象（任意类型）为一个映射去存储数据，这一个映射就是Entry类（Map的内部类）的实例。包括：实现类：HashMap，哈希表。

其中ArrayList  HashSet HashMap使用频率最高

/**

* 对泛型为String的List进行排序版本2

*/

public void testSort3(){

List<String> stringList2 = new ArrayList<String>();

//插入十条随机字符串

Random random = new Random();

String all = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

int sbLength;

for(int i = 0; i < 10; i++ ){

StringBuilder sb = new StringBuilder();

sbLength = random.nextInt(11);

do{

for(int j = 0; j < sbLength; j++){

sb.append(all.charAt(random.nextInt(61)));

}

}while(stringList2.contains(sb.toString()));

if(sbLength==0){

i--;

}else{

stringList2.add(sb.toString());

System.out.println("添加字符串：" + sb.toString());

}

}

System.out.println("-----------------------排序前-------------------------");

for (String string : stringList2) {

System.out.println("元素：" + string);

}

Collections.sort(stringList2);

System.out.println("-----------------------排序后-------------------------");

for (String string : stringList2) {

System.out.println("元素：" + string);

}

装箱：把基本类型转换成包装类，使其具有对象的性质，又可分为手动装箱和自动装箱

拆箱：和装箱相反，把包装类对象转换成基本类型的值，又可分为手动拆箱和自动拆箱

import java.text.SimpleDateFoemat;
import java.util.Calendar;
import java.util.Date;
public class HelloWorld{
public static void main(String[]args){
//创建calendar对象
Calendar c=Calendar.getInstance();
//将calendar对象转换为date对象
Date date=nc.getTime();
//创建SimpleDateFormat对象，指定目标格式
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//将日期转换为指定格式的字符串
String now=sdf.format(date);
System.out.println("当前时间:"+now);

}}

import java.text.parseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class HelloWorld{
public static void main(String[]args)throws ParseException{
//使用format（）方法将日期转换为指定格式的文本
SimpleDateFormat sdf1=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
SimpleDateFormat sdf2=new SimpleDateFormat("yyyy/MM/dd HH:mm");
SimpleDateFormat sdf3=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//创建date对象，表示当前时间
Date now=new Date();
//调用format（）豆豆，将日期转换为字符串并输出
System.out.println(sdf1.format(now));
System.out.println(sdf2.format(now));
System.out.println(sdf3.format(now));
//使用parse()方法将文本转换为日期
String d="2014-6-1 21:05:36";
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//调用parse（）方法，将字符串转化为日期
Date date=sdf.parse(d);
System.out.println(date);}}

“==” 和 equals() 有什么区别呢？

==: 判断两个字符串在内存中首地址是否相同，即判断是否是同一个字符串对象

equals(): 比较存储在两个字符串对象中的内容是否一致

运行结果： 2014-06-11  09:55:48

其中，基本类型转换为字符串有三种方法：

1. 使用包装类的 toString() 方法

2. 使用String类的 valueOf() 方法

3. 用一个空字符串加上基本类型，得到的就是基本类型数据对应的字符串

再来看，将字符串转换成基本类型有两种方法：

1. 调用包装类的 parseXxx 静态方法

2. 调用包装类的 valueOf() 方法转换为基本类型的包装类，会自动拆箱

package com.imooc;

import java.util.Scanner;

public class SearchBook {
    private static Scanner console= new Scanner(System.in);
    public static void main(String[] agrs){
        String[] books={"喜羊羊与灰太狼","葫芦娃娃","金刚狼","金碧池"};
        String book;
        while(true){
            System.out.println("请输入命令：1-按照名称查询图书；2-按照序号查询图书");
            try{
                int command =inputCoummand();
                switch (command){
                    case 1:
                        book =getBookByName(books);
                        System.out.println("已为您找到《"+book+"》");
                        break;
                    case 2:
                        book =getBookByNum(books);
                        System.out.println("已为您找到《"+book+"》");
                        break;
                    default:
                        System.out.println("命令输入错误");
                        continue;
                }
                break;

            }catch (Exception e){
                System.out.println(e.getMessage());
                continue;
            }
        }
    }
    private static String getBookByName(String[] books) throws Exception{
        System.out.println("请输入图书名称");
        String name=console.next();
        for (int i=0;i<books.length;i++){
            if(name.equals(books[i])){
                return books[i];
            }
        }
        throw new Exception("图书不存在");
    }

    private static String getBookByNum(String[] books) throws Exception{
        while(true){
            System.out.println("请输入图书序号");
            try {
                int index=inputCoummand();
                if(index==-1){
                    System.out.println("命令输入错误，请根据提示输入数字命令");
                    continue;
                }
                String book=books[index];
                return book;
            }catch (Exception e){
              throw new Exception("不存在该书本");
//                Exception bookNotExists = new Exception("图书不存在！");
//                bookNotExists.initCause(e);
//                throw bookNotExists;
            }
        }
    }
    private static int inputCoummand(){
        int command;
        try{
            command=console.nextInt();
            return command;
        }catch (Exception e){
            console=new Scanner(System.in);
            return -1;
        }
    }
}

“==” 和 equals() 有什么区别呢？

==: 判断两个字符串在内存中首地址是否相同，即判断是否是同一个字符串对象

equals(): 比较存储在两个字符串对象中的内容是否一致

装饰者模式

1、Decorator抽象类中，持有Human接口，方法全部委托给该接口调用，目的是交给该接口的实现类即子类进行调用。
2、Decorator抽象类的子类（具体装饰者），里面都有一个构造方法调用super(human),这一句就体现了抽象类依赖于子类实现即抽象依赖于实现的原则。因为构造里面参数都是Human接口，只要是该Human的实现类都可以传递进去，即表现出Decorator dt = new Decorator_second(new Decorator_first(new Decorator_zero(human)));这种结构的样子。所以当调用dt.wearClothes();dt.walkToWhere()的时候，又因为每个具体装饰者类中，都先调用super.wearClothes和super.walkToWhere()方法，而该super已经由构造传递并指向了具体的某一个装饰者类（这个可以根据需要调换顺序），那么调用的即为装饰类的方法，然后才调用自身的装饰方法，即表现出一种装饰、链式的类似于过滤的行为。
3、具体被装饰者类，可以定义初始的状态或者初始的自己的装饰，后面的装饰行为都在此基础上一步一步进行点缀、装饰。
4、装饰者模式的设计原则为：对扩展开放、对修改关闭，这句话体现在我如果想扩展被装饰者类的行为，无须修改装饰者抽象类，只需继承装饰者抽象类，实现额外的一些装饰或者叫行为即可对被装饰者进行包装。所以：扩展体现在继承、修改体现在子类中，而不是具体的抽象类，这充分体现了依赖倒置原则，这是自己理解的装饰者模式。

说的不清楚，有些只可意会不可言传的感觉，多看几遍代码，然后自己敲出来运行一下，基本上就领悟了。

下面这个例子也有助于理解 装饰的流程和作用

现在需要一个汉堡，主体是鸡腿堡，可以选择添加生菜、酱、辣椒等等许多其他的配料，这种情况下就可以使用装饰者模式。

汉堡基类（被装饰者，相当于上面的Human）

package decorator;public abstract class Humburger {protected  String name ;public String getName(){return name;}public abstract double getPrice();}

鸡腿堡类（被装饰者的初始状态，有些自己的简单装饰，相当于上面的Person）

package decorator;public class ChickenBurger extends Humburger {public ChickenBurger(){name = "鸡腿堡";}@Override  public double getPrice() {return 10;}}

配料的基类（装饰者，用来对汉堡进行多层装饰，每层装饰增加一些配料，相当于上面Decorator）

package decorator;public abstract class Condiment extends Humburger {public abstract String getName();}

生菜（装饰者的第一层，相当于上面的decorator_zero）

package decorator;public class Lettuce extends Condiment {Humburger humburger;public Lettuce(Humburger humburger){this.humburger = humburger;}@Override  public String getName() {return humburger.getName()+" 加生菜";}@Override  public double getPrice() {return humburger.getPrice()+1.5;}}

辣椒（装饰者的第二层，相当于上面的decorator_first）

package decorator;public class Chilli extends Condiment {Humburger humburger;public Chilli(Humburger humburger){this.humburger = humburger;}@Override  public String getName() {return humburger.getName()+" 加辣椒";}@Override  public double getPrice() {return humburger.getPrice();  //辣椒是免费的哦  }}

测试类

package decorator;public class Test {/**      * @param args      */  public static void main(String[] args) {Humburger humburger = new ChickenBurger();System.out.println(humburger.getName()+"  价钱："+humburger.getPrice());Lettuce lettuce = new Lettuce(humburger);System.out.println(lettuce.getName()+"  价钱："+lettuce.getPrice());Chilli chilli = new Chilli(humburger);System.out.println(chilli.getName()+"  价钱："+chilli.getPrice());Chilli chilli2 = new Chilli(lettuce);System.out.println(chilli2.getName()+"  价钱："+chilli2.getPrice());}}

输出

鸡腿堡  价钱：10.0  鸡腿堡 加生菜  价钱：11.5  鸡腿堡 加辣椒  价钱：10.0  鸡腿堡 加生菜 加辣椒  价钱：11.5