匿名内部类、异常、常用类(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();
}

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();
}

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();
}

lambda表达式

为了简化匿名内部类结构

前提：

函数式接口

函数式接口：

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

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

@FunctionalInterface

结构：

()->{}

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

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

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

写法：

public class Lambda {
    public static void main(String[] args) {
		Run r = null;
        //lambda表达式
    }
}
@FunctionalInterface
interface Run{
    int run(int i,int j);
}

1、普通写法：

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

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

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

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

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

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

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

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

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

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

异常

程序中出现了问题

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

异常体系

Throwable类是所有异常类的父类

​Throwable : Error、Exception

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

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

Exception又分为RuntimeException和CheckedException

RuntimeException

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

CheckedException

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

常见的运行异常

• NullPointerException 空指针异常

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

• ArithmeticException 数学异常

System.out.println(5/0);

• ArrayIndexOutOfBoundsException 数组索引越界异常

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

• NegativeArraySizeException 数组长度负数异常

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

• ClassCastException 类型转换异常

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

• NumberFormatException 转换格式异常

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

异常处理方案

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

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

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

1 异常抛出 throws

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

2 异常捕获

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

try{
    可能会发生的异常
}catch(异常类型 异常名(变量)){
    针对异常进行处理的代码
}catch(异常类型 异常名(变量)){
    针对异常进行处理的代码
}...
[finally{
    释放资源代码;
}]

注意：

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]

常用类

经常使用到的类

String类

不可变长字符序列

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

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

new String() --> 堆中

底层分析:

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

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

构造器

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

String()

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

String(String original)

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

String(char[] value)

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

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

string方法(常用)

方法	变量和类型	描述
charAt(int index)	char	返回指定索引处的char值
codePointAt(int index)	int	返回指定索引处的字符(Unicode代码点)
compareTo(String anotherString)	int	按字典顺序比较两个字符串
concat(String str)	String	将指定的字符串连接到此字符串的末尾
contains(CharSequence s)	boolean	当且仅当此字符串包含指定的char值序列时，才返回true
copyValueOf(char[] data)	static String	将字符数组拼接成字符串
endsWith(String suffix)	boolean	测试此字符串是否以指定的后缀结尾
equals(Object anObject)	boolean	将此字符串与指定的对象进行比较
indexOf(int ch)	int	定字符第一次出现的字符串中的索引
indexOf(int ch, int fromIndex)	int	返回指定字符第一次出现的此字符串中的索引，从指定索引处开始搜索。
indexOf(String str)	int	返回指定子字符串第一次出现的字符串中的索引
indexOf(String str, int fromIndex)	int	从指定的索引处开始，返回指定子字符串第一次出现的字符串中的索引
lastIndexOf(int ch)	int	返回指定字符最后一次出现的字符串中的索引
lastIndexOf(int ch, int fromIndex)	int	返回指定字符最后一次出现的字符串中的索引，从指定的索引开始向后搜索
length	int	返回此字符串的长度