321学习日记（contain：异常处理、throw和throws具体作用和区别、内部类、lambda表达式、函数式接口实现）

异常处理

写throws Exception的方法调用它的时候就必须写异常处理语句（try...catch...finally），不然无法编译。

如果主方法throws Exception，就说明，主方法也不想处理异常，如果主方法中有异常，直接交给JVM处理（输出异常信息，中止执行）。

try捕获是处理异常语句，throw是抛出异常，如果你写了throws Exception定义本方法，就不用处理异常语句处理本方法中调用的其他有异常的方法（build），也不用处理本方法中throw出来的异常：throw new Exception("消息不能为空！");（抛给调用本方法的方法去处理）。

示例代码：

class Message {
    public void send(String s) throws Exception {
        try {


            if (this.build()) {
                if (s == null) {
                    throw new Exception("消息不能为空！");
                }
            }
            System.out.println("发送信息：" + s);
        } finally {
            this.close();
        }
    }
    public boolean build() throws Exception {
        System.out.println("建立服务器连接...");
        if(false){
            throw new Exception("连接服务器失败！");
        }
        System.out.println("连接服务器成功！");
        return true;
    }
    public void close(){
        System.out.println("关闭连接成功。");
    }
}
public class demo320 {

    public static void main(String[] args) throws Exception {
        new Message().send(null);
    }
}

throws Exception表示的是本方法不处理异常，交给被调用处处理(如果你不希望异常层层往上抛，你就要用throws Exception) ，而且被调用处必须处理。

异常处理流程图：

throw关键字：

 内部类

 内部类特点：内部类和外部类的私有成员都可互相访问。

lambda表达式：

Lambda表达式超详细总结_Code0cean的博客-CSDN博客_lambda表达式

@FunctionalInterface//注解作用：此接口只能有一个抽象方法，有多个抽象方法就不是函数式编程
interface IMessage{
    public String echo(String s);
}
public class demo321{
    public static void main(String[] args) {
// IMessage message=new IMessage(){
//    public String echo(String str){
//    return ("[echo]"+str)
//    };
//    }
    IMessage message=(str)->"[echo]"+str;//lambda表达式 接口中只有一个抽象方法 等价于上面注释代码。
    System.out.println(message.echo("hxw"));
    }
}

函数式接口实现

静态方法实现具体函数：类名称::static 方法名称

@FunctionalInterface
interface IFunction<T>{
    public String convert(T value);
}

public class demo321{
    public static void main(String[] args) {
        IFunction<Integer> function=String::valueOf;//public static String valueOf(数据类型 变量)
        String str=function.convert(24668);
        System.out.println(str.length());
    }
}

 引用某个类的方法：实例化对象::普通方法

@FunctionalInterface
interface IFunction{
    public String upper();
}

public class demo321{
    public static void main(String[] args) {
        IFunction function="hxw"::toUpperCase;
        System.out.println(function.upper());

    }
}

引用特定类普通方法： 特定类::普通方法

@FunctionalInterface
interface IFunction<T>{
    public int compare(T p1,T p2);
}

public class demo321{
    public static void main(String[] args) {
        IFunction<String> function=String::compareTo;
        System.out.println(function.compare("aaa","SSS"));
    }
}

引用构造方法：

class Book{
    private String name;
    private String author;
    private double price;
    public Book(String name,String author,double price){
        this.author=author;
        this.name=name;
        this.price=price;
    }
    public String toString(){
        return this.price+this.name+this.author;
    }
}
@FunctionalInterface
interface IFunction{
    public Book create(String n,String a,double p);
}

public class demo321{
    public static void main(String[] args) {
        IFunction function=Book::new;
        System.out.println(function.create("program","hxw",98.8));
    }
}