匿名内部类、异常、常用类(String类)_匿名内部类抛出异常

内部类

匿名内部类

没有名字的一个内部类

作用：

简化代码本身，只为了重写的一些抽象方法，方便调用这个方法

简化符合需求的实现类，子类->接口|抽象父类

使用：

1、匿名对象：无引用接收匿名内部类对象地址，在匿名内部类对象的后面直接调用

public class Inner {
    public static void main(String[] args) {
        //匿名内部类
        new Run(){
            @Override
            public void running() {
                System.out.println("正在跑...");
            }
        }.running();
    }
}
//跑
interface Run{
    void running();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2、引用接收：接口多态

public class Inner {
    public static void main(String[] args) {
        //匿名内部类
        Run r = new Run(){
            @Override
            public void running() {
                System.out.println("正在跑...");
            }
        };
        r.running();
    }
}
//跑
interface Run{
    void running();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3、作为方法的实参

public class Inner {
    public static void main(String[] args) {
        //匿名内部类
        test(new Run(){
            @Override
            public void running() {
                System.out.println("正在跑...");
            }
        });
    }
    static void test(Run run){
        run.running();
    }
}
//跑
interface Run{
    void running();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

lambda表达式

为了简化匿名内部类结构

前提：

函数式接口

函数式接口：

只存在一个必须被重写的抽象方法的接口

检查一个接口是否为函数式接口:

@FunctionalInterface
1

结构：

()->{}
1

() : 重写的抽象方法的参数列表

{} : 重写抽象方法的方法体

-> : lambda符号,箭头符号,具有上下文推导的作用

写法：

public class Lambda {
    public static void main(String[] args) {
		Run r = null;
        //lambda表达式
    }
}
@FunctionalInterface
interface Run{
    int run(int i,int j);
}
1
2
3
4
5
6
7
8
9
10

1、普通写法：

r = () -> {
    System.out.println("跑步...");
};
1
2
3

2、当lambda体中的语句体只有一句,前后的{}可以省略

r = () -> System.out.println("跑步...");
1

3、参数列表的数据类型可以省略

r = (i) -> System.out.println("跑步...");
1

4、如果参数只有一个,前后的()可以省略 ,如果参数个数为2~多个,前后()不能省略

r = i -> System.out.println("跑步...");
1

r = (i,j) -> System.out.println("跑步...");
1

5、如果方法存在返回值,并且{}中语句体只有一句,为return 带出返回值语句,前后的{}与return关键字可以一起省略

s = (i,j) -> {return i+j;};
s = (i,j) -> i+j;
1
2

异常

程序中出现了问题

程序一旦遇到异，后面代码无法正常执行，并且同时控制台中展示异常的详细信息|细节问题，便于程序员的调试

异常体系

Throwable类是所有异常类的父类

​Throwable : Error、Exception

Error : 一般指由虚拟机生成并脱出的,无需程序猿解决处理

Exception : 异常，异常如果不处理,程序无法正常执行,需要程序猿在代码层面上处理异常

Exception又分为RuntimeException和CheckedException

RuntimeException

运行时异常 : 运行期间才会发生的异常

CheckedException

编译时异常|检查时异常 : 编译期间发生的异常,不处理程序无法运行

常见的运行异常

• NullPointerException 空指针异常

String s = "abc";
s = null;
System.out.println(s.length());
1
2
3

• ArithmeticException 数学异常

System.out.println(5/0);
1

• ArrayIndexOutOfBoundsException 数组索引越界异常

int[] arr = new int[3];
System.out.println(arr[3]);
1
2

• NegativeArraySizeException 数组长度负数异常

int[] arr = new int[-3];
1

• ClassCastException 类型转换异常

Object obj = "张三";
System.out.println((Exception)obj);
1
2

• NumberFormatException 转换格式异常

String str = "123abc";
System.out.println(Integer.valueOf(str));
1
2

异常处理方案

有的异常都可以通过标准异常处理方案来处理

运行时异常一般通过增强程序健壮性的代码就可以解决 -> if判断

编译时异常只能通过异常处理方案来处理

1 异常抛出 throws

把异常抛出到上一层,谁调用谁处理

2 异常捕获

异常对象当前抓住捕获,直接处理

try{
    可能会发生的异常
}catch(异常类型 异常名(变量)){
    针对异常进行处理的代码
}catch(异常类型 异常名(变量)){
    针对异常进行处理的代码
}...
[finally{
    释放资源代码;
}]
1
2
3
4
5
6
7
8
9
10

注意：

1、异常一旦处理，不影响程序的继续进行

2、try中可能出现异常，可能不会出现异常：

如果没有出现异常,try{}中的代码执行完毕,try…catch结束

如果try中代码一旦异常,try后面的代码不会执行,直接执行catch的判断

从上到下依次判断,判断当前的catch是否能够捕获出现的异常对象：

如果能,执行后面的{}中的代码；

如果不能匹配,继续向下判断,如果所有的都不能匹配,当前的异常对象没有处理,中止程序的执行

3、一个try后面可以跟1~n个catch

4、如果一个异常已经通过catch处理不影响后面代码的执行

5、接收范围较大的异常的catch,需要定义在后面：Exception > FileNotFoundException等

finally

最终的

无论try中是否会出现异常,finally中的代码肯定最后会执行一般会定义一些资源的关闭等代码

在 try块中即便有return，break，continue等改变执行流的语句，finally也会执行

finally中的return 会覆盖 try 或者catch中的返回值。

自定义异常

自己定义的异常

如果要自定义异常类，则扩展Exception类即可，因此这样的自定义异常都属于检查异常（checked exception）。如果要自定义非检查异常，则扩展自RuntimeException。

在Java中要想创建自定义异常，需要继承Throwable或者他的子类Exception。

如果是运行时期异常必须直接或者间接的继承RuntimeException

制造异常: throw

步骤：

1. 声明一个自定义异常类
2. 将自定义类继承Exception
3. 编写两个构造器，一个空的，一个有参数的构造器

public class DefineException {
	public static void main(String[] args) {
		User u = new User();
		try {
			u.setAge(10);
		}catch(AgeException e){
			System.out.println(e.getMessage());
		}
		System.out.println(u);
	}
}
class User {
	private int age;
	public User() { }
	public int getAge() {
		return age;
	}
	public void setAge(int age) throws AgeException {
		if (age < 18 || age > 70) {
			throw new AgeException("你输入的年龄不合法");
		}
		this.age = age;
	}
	@Override
	public String toString() {
		return "User [age=" + age + "]";
	}
}
public class AgeException extends Exception{
	public AgeException() { }
	public AgeException(String msg) {
		super(msg);
	}
}

//打印输出：
//你输入的年龄不合法
//User [age=0]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

常用类

经常使用到的类

String类

不可变长字符序列

String类表示字符串。 Java程序中的所有字符串文字（例如"abc" ）都实现为此类的实例。

“abc” 字符串常量 --> 字符串常量池中-> 方法区

new String() --> 堆中

底层分析:

jdk11 -> 使用字节数组存储字符串数据 private final byte[] value;

jdk8 -> 使用字符数组存储字符串数据 private final char[] value;

构造器

1、初始化新创建的 String对象，使其表示空字符序列。

String()
1

2、初始化新创建的String对象，使其表示与参数相同的字符序列

String(String original)
1

3、分配新的 String ，使其表示当前包含在字符数组参数中的字符序列。

String(char[] value)
1

4、分配一个新的 String ，其中包含字符数组参数的子数组中的字符。

String(int[] codePoints, int offset, int count)
1

string方法(常用)