内部类
在一个类中定义一个类，所以称为内部类。
第一种普通内部类
public class people{
class AddressP{
}
}外部类访问内部类需要创建成员内部类的对象，再通过指向对象的引用来访问。
内部类方法可以直接访问外部类的所有成员，
当外部类和内部类名字相同，就近原则访问成员，
外部类.this.成员变量
外部类.this.成员方法第二种静态内部类，在普通的内部类加上”static“关键字，
public class People{
static class Card{
}
}第三种匿名内部类
定义一个没有类名，只有对方法的具体实现，通常它依赖于实现关系（接口）或继承关系（父类）
//基于实现关系
public interface MyInterface {
// 学习
public void study();
// 工作
public void work();
}
// 创建一个匿名类(让接口的引用 指向匿名类的对象)
MyInterface person = new MyInterface() {
@Override
public void study() {
System.out.println("这个人也好好学习");
}
@Override
public void work() {
System.out.println("这个人也好好工作");
}
};
person.study();
person.work();public class MyClass {
public void service(){
System.out.println("提供服务的方法。");
}
} // 父类 new 一个 匿名类，这个匿名类是它的子类
MyClass cls = new MyClass(){
@Override //匿名类重写父类的方法 service
public void service() {
System.out.println("这是子类的方法");
}
};
cls.service();异常
异常： 在程序中，发生“不正常”的事件，导致程序无法正常运行，并使JVM中断，称为异常，
捕获异常： 当程序在运行时，发生了异常 ，为了让程序正常执行，需要对异常捕获（catch），称之为捕获异常
try:试一试，将可能发生的代码使用try包裹，try不能单独出现
catch：捕获异常，当发生指定的异常对象时，执行catch
一个try多个catch
// 抛出的异常 不能被catch捕获，会发生什么？
try {
int[] num = {1, 2, 3};
System.out.println(num[1]); // 没有捕获该异常对象，JVM依然终止运行
System.out.println(10/0);
}catch(NullPointerException ee){
System.out.println("这是空指针异常");
}catch(ArrayIndexOutOfBoundsException ee){
System.out.println("数组下标越界异常");
}catch(Exception ee){
// 输出异常 堆栈消息 方便程序员排错（尽可能避免用户看见）
ee.printStackTrace();
System.out.println("系统繁忙！"+ee.getMessage());
}
System.out.println("程序结束");finally：异常之后的最终处理（表示程序是否发生异常，程序都执行。）
try+catch+finally
try {
System.out.println("请输入两个数 ，计算两个数相除");
Scanner sc = new Scanner(System.in);
int num1 = sc.nextInt();
int num2 = sc.nextInt();
double s = num1 / num2; // 可能出错
System.out.println(" try里面结束，结果：" + s);
}catch(ArithmeticException ee){
ee.printStackTrace();
System.out.println("除数不能为0 ！！");
}catch(Exception ee){
ee.printStackTrace();
System.out.println("系统繁忙！！！");
}finally {
System.out.println("用于资源回收。");
}一、 异常机制的概述 异常机制是指当程序出现错误后，程序如何处理。具体来说，异常机制提供了程序退出的安全通道。当出现错误后，程序执行的流程发生改变，程序的控制权转移到异常处理器。
程序错误分为三种：1.编译错误；2.运行时错误；3.逻辑错误。 （1）编译错误是因为程序没有遵循语法规则，编译程序能够自己发现并且提示我们错误的原因和位置，这个也是大家在刚接触编程语言最常遇到的问题。 （2）运行时错误是因为程序在执行时，运行环境发现了不能执行的操作。 （3）逻辑错误是因为程序没有按照预期的逻辑顺序执行。异常也就是指程序运行时发生错误，而异常处理就是对这些错误进行处理和控制。
二、 异常的结构 在 Java 中，所有的异常都有一个共同的祖先 Throwable（可抛出）。Throwable 指定代码中可用异常传播机制通过 Java 应用程序传输的任何问题的共性。
Throwable： 有两个重要的子类：Exception（异常）和 Error（错误），二者都是 Java 异常处理的重要子类，各自都包含大量子类。异常和错误的区别是：异常能被程序本身可以处理，错误是无法处理。 Throwable类中常用方法如下：
1. 返回异常发生时的详细信息
public string getMessage();
2. 返回异常发生时的简要描述
public string toString();
3. 返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可以声称本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同
public string getLocalizedMessage();
4. 在控制台上打印Throwable对象封装的异常信息
public void printStackTrace();Error（错误）:是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（Virtual MachineError）、类定义错误（NoClassDefFoundError）等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在 Java中，错误通过Error的子类描述。
Exception（异常）:是程序本身可以处理的异常。Exception 类有一个重要的子类 RuntimeException。RuntimeException 类及其子类表示“JVM 常用操作”引发的错误。例如，若试图使用空值对象引用、除数为零或数组越界，则分别引发运行时异常（NullPointerException、ArithmeticException）和 ArrayIndexOutOfBoundException。 Exception（异常）分两大类：运行时异常和非运行时异常(编译异常)。程序中应当尽可能去处理这些异常。 1.运行时异常：都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。 2.非运行时异常 （编译异常）：是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。
通常，Java的异常（Throwable）分为可查的异常（checked exceptions）和不可查的异常（unchecked exceptions）。
\1. 可查异常（编译器要求必须处置的异常）：正确的程序在运行中，很容易出现的、情理可容的异常状况。除了Exception中的RuntimeException及RuntimeException的子类以外，其他的Exception类及其子类(例如：IOException和ClassNotFoundException)都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。 \2. 不可查异常(编译器不要求强制处置的异常):包括运行时异常（RuntimeException与其子类）和错误（Error）。RuntimeException表示编译器不会检查程序是否对RuntimeException作了处理，在程序中不必捕获RuntimException类型的异常，也不必在方法体声明抛出RuntimeException类。RuntimeException发生的时候，表示程序中出现了编程错误，所以应该找出错误修改程序，而不是去捕获RuntimeException。
三、 异常处理的机制 在 Java 应用程序中，异常处理机制为：抛出异常，捕捉异常。
-
抛出异常：当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统，异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。详细信息请查看《简述throw-throws异常抛出》。 捕获异常：在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器（exception handler）。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适 的异常处理器。运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适 的异常处理器，则运行时系统终止。同时，意味着Java程序的终止。详细信息请查看《Java：简述try-catch-finally异常捕获》。
对于错误、运行时异常、可查异常，Java技术所要求的异常处理方式有所不同。
-
错误：对于方法运行中可能出现的Error，当运行方法不欲捕捉时，Java允许该方法不做任何抛出声明。因为，大多数Error异常属于永远不能被允许发生的状况，也属于合理的应用程序不该捕捉的异常。 运行时异常：由于运行时异常的不可查性，为了更合理、更容易地实现应用程序，Java规定，运行时异常将由Java运行时系统自动抛出，允许应用程序忽略运行时异常。
-
可查异常：对于所有的可查异常，Java规定：一个方法必须捕捉，或者声明抛出方法之外。也就是说，当一个方法选择不捕捉可查异常时，它必须声明将抛出异常。
-
能够捕捉异常的方法，需要提供相符类型的异常处理器。所捕捉的异常，可能是由于自身语句所引发并抛出的异常，也可能是由某个调用的方法或者Java运行时 系统等抛出的异常。也就是说，一个方法所能捕捉的异常，一定是Java代码在某处所抛出的异常。简单地说，异常总是先被抛出，后被捕捉的。 异常抛出：任何Java代码都可以抛出异常，如：自己编写的代码、来自Java开发环境包中代码，或者Java运行时系统。无论是谁，都可以通过Java的throw语句抛出异常。从方法中抛出的任何异常都必须使用throws子句。 异常捕获：捕捉异常通过try-catch语句或者try-catch-finally语句实现。 总体来说，Java规定：对于可查异常必须捕捉、或者声明抛出。允许忽略不可查的RuntimeException和Error。
三、Java常见异常 1. RuntimeException子类:
| 序号 | 异常名称 | 异常描述 |
|---|---|---|
| 1 | java.lang.ArrayIndexOutOfBoundsException | 数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。 |
| 2 | java.lang.ArithmeticException | 算术条件异常。譬如：整数除零等。 |
| 3 | java.lang.SecurityException | 安全性异常 |
| 4 | java.lang.IllegalArgumentException | 非法参数异常 |
| 5 | java.lang.ArrayStoreException | 数组中包含不兼容的值抛出的异常 |
| 6 | java.lang.NegativeArraySizeException | 数组长度为负异常 |
| 7 | java.lang.NullPointerException | 空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等。 |
2.IOException
| 序号 | 异常名称 | 异常描述 |
|---|---|---|
| 1 | IOException | 操作输入流和输出流时可能出现的异常 |
| 2 | EOFException | 文件已结束异常 |
| 3 | FileNotFoundException | 文件未找到异常 |
3. 其他
| 序号 | 异常名称 | 异常描述 |
|---|---|---|
| 1 | ClassCastException | 类型转换异常类 |
| 2 | ArrayStoreException | 数组中包含不兼容的值抛出的异常 |
| 3 | SQLException | 操作数据库异常类 |
| 4 | NoSuchFieldException | 字段未找到异常 |
| 5 | NoSuchMethodException | 方法未找到抛出的异常 |
| 6 | NumberFormatException | 字符串转换为数字抛出的异常 |
| 7 | StringIndexOutOfBoundsException | 字符串索引超出范围抛出的异常 |
| 8 | IllegalAccessException | 不允许访问某类异常 |
| 9 | InstantiationException | 当应用程序试图使用Class类中的newInstance()方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常 |
| *10* | *java.lang.ClassNotFoundException* | *找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。* |
包
| 基本数据类型 | 包装类型 | 包装类的默认值 |
|---|---|---|
| byte | Byte | null |
| short | Short | null |
| int | Integer | null |
| long | Long | null |
| float | Float | null |
| double | Double | null |
| char | Character | |
| boolean | Boolean |
基本数据类型、包装类以及字符串之间的转换
public static void main(String[] args) {
// 1、byte 的包装类 Byte
// 创建包装类的对象
byte b=123;
Byte obj1 = new Byte(b);
//1、 包装类 转字符串 包装类对象.toString()
String s1 = obj1.toString();
//2、字符串转包装类 new 包装类(s) 或者 包装类.valueOf(s)
String s2="100";
Byte obj2 = new Byte(s2);
// 或者
Byte obj3 = Byte.valueOf(s2);
//3 获取包装类的数值，包装类转基本数据类型 Byte - > byte
// 包装类.valueOf(基本数据类型) 或者 byteValue()
byte b2 = obj2; // 包装类可以直接复制给基本数据类型 ，这个过程 “拆箱”过程
byte b3 = Byte.valueOf(obj2);
// 4、字符串转 基本类型 包装类.paseByte(s)
byte b4 = Byte.parseByte(s2);
byte b5=122;
String s5 = new Byte(b5).toString();
}
public static void main(String[] args) {
// 1、byte 的包装类 Byte
// 创建包装类的对象
byte b=123;
Byte obj1 = new Byte(b);
//1、 包装类 转字符串 包装类对象.toString()
String s1 = obj1.toString();
//2、字符串转包装类 new 包装类(s) 或者 包装类.valueOf(s)
String s2="100";
Byte obj2 = new Byte(s2);
// 或者
Byte obj3 = Byte.valueOf(s2);
//3 获取包装类的数值，包装类转基本数据类型 Byte - > byte
// 包装类.valueOf(基本数据类型) 或者 byteValue()
byte b2 = obj2; // 包装类可以直接复制给基本数据类型 ，这个过程 “拆箱”过程
byte b3 = Byte.valueOf(obj2);
// 4、字符串转 基本类型 包装类.paseByte(s)
byte b4 = Byte.parseByte(s2);
byte b5=122;
String s5 = new Byte(b5).toString();
}
object类
是lang包提供的，对于lang包的类不需要import，所以Object类无处不在。
getClass：返回该对象的类型 任何类都有它的 类型
equals：重写Object的方法
原生的equals比较的是地址，
public boolean equals(Object obj) {
return (this == obj);
}hashCode() ： 返回该都对象的hash值
finalize（）：资源回收调用该方法，当对象地址不在被引用时，会被GC回收，
toString() : 返回该对象的字符串表现形式 （通常会被子类重写）
wait（）：线程等待
notify（）：唤醒其中一个等待的线程
notifyAll：唤醒所有等待中的线程
字符串的常用方法
-
将此字符串与指定对象进行比较:
public boolean equals (Object anObject) -
将此字符串与指定对象进行比较，忽略大小写：
public boolean equalsIgnoreCase (String anotherString)
-
返回字符串的长度：
public int length() -
将指定的字符串连接到该字符串的末尾：
public String concat (String str) -
返回指定索引处的char值：
public char charAt (int index) -
返回指定字符串第一次出现在该字符串内的索引：
public int indexOf(String str) -
返回一个子字符串，从beginIndex开始截取字符串到字符串结尾：
public String substring (int beginIndex) -
返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex
public String substring (int beginIndex,int endIndex)
-
将字符串转换为新的字符数组：
public char[] toCharArray() -
使用平台的默认字符集将该String编码转换为新的字节数组:
public byte[] getBytes() -
将与targer匹配的字符串使用replacement字符串替换
public String rep;ace (CharSequence targer,CharSequence replacement)
将字符串按照给定的regex（规则）拆分为字符串数组：public String[] split(String regex)
StringBuffer和StringBuilder类
一、StringBuffer和StringBuilder类
1、StringBuffer 类
是一个字符串缓冲区的类，线程安全运行效率低，用户存储可变字符串
构造器：
StringBuffer sb = new StringBuffer(); // 创建空字符串的容器
StringBuffer sb = new StringBuffer(String);// 将字符串使用容器存储
StringBuffer sb = new StringBuufer(int);//声明指定容量的容器常用方法：
1.1、append（）:追加字符串
1.2、delete(int start,int end):删除指定位置的字符
1.3、insert(int start ,String):插入到指定位置
1.4、reverse（）：反转字符
1.5、capacity（）：获取初始容量
1.6、ensureCapacity(int)：设置最低所需容量
2、StringBuilder类
也是字符串缓冲区的类，它是线程不安全，且运行效率高的可变字符串缓冲类
2.1 集合的顶级接口： Collection
Collection属于单列集合的根接口，它扩展的主要子接口包括 java.util.List 和 java.util.Set接口，
List接口特点存储有序 且 可重复的元素， 而Set接口特点存储无序且不可重复的元素，其中List下扩展常用的实现类包括 java.util.ArrayList 和java.util.LinkedList 和Vector ， 其中Set接口下扩展的实现类包括 java.util.HashSet 和 java.util.TreeSet .
集合接口的常用方法：
-
public void add(E) : 把给定的元素添加到集合中
-
public void clear():清空集合中的所有元素
-
public boolean remove(E):删除集合中指定的元素，删除成功返回true
-
public boolean contains(E):判断该元素是否存在集合中
-
public boolean isEmpty():判断是否为空集合对象 null会报异常
-
public int size():获取几个元素的大小
-
publict Object toArray() : 将集合元素转成对象数组
public static void main(String[] args) {
//通过接口创建实现类 ， 可指定存储的泛型
Collection<String> collection = new ArrayList<String>();
// 集合中指定了元素的类型 String
collection.add("hello"); // 默认添加到末尾
collection.add("hi");
collection.add("哈哈");
System.out.println("元素大小："+ collection.size());
// 删除集合元素 （后面的原始往前 移动）
collection.remove("hi");
System.out.println("元素大小："+collection.size());
System.out.println("第一个元素："+((ArrayList<String>) collection).get(0));
System.out.println("第二个元素："+((ArrayList<String>) collection).get(1));
// 判断元素是否存在
System.out.println("是否存在哈哈："+collection.contains("哈哈"));
// 转成数组对象
Object [] objs = collection.toArray();
//遍历元素
for(Object obj : objs){
System.out.println("数组的元素："+obj);
}
//清空元素 clear
collection.clear();
// 大小
System.out.println("清空后元素的大小（对象依然存在，只能内容为空）"
+collection.size());
// 判断对象中是否是空集合
System.out.println(collection.isEmpty());
}Iterator 集合遍历接口
// 直接对集合元素遍历 泛型只能是包装类
Collection<Integer> scores = new ArrayList<>();
scores.add(90);
scores.add(88);
scores.add(92);
scores.add(91);
//遍历集合 使用 ，
// 再遍历集合时 不能一边遍历集合一边删除集合元素，这样会改变它的遍历的模式
Iterator<Integer> is = scores.iterator();
//判断是否有下一个元素 ，如果true ，则可以通过next获取值
while(is.hasNext()){
Integer score = is.next();
System.out.println(score);
}
-
2.2 ArrayList类
java.util.ArrayList是一个数组结构的集合，实现动态数组的功能，扩展所有Collection的方法
数组结构的本质： 线性结构的顺序结构，ArrayList中使用连续的内存空间存储， 访问时通过下标（元素所在的位置）访问
-
2.2 ArrayList类：
java.util.ArrayList是一个数组结构的集合，实现动态数组的功能，扩展所有Collection的方法
数组结构的本质： 线性结构的顺序结构，ArrayList中使用连续的内存空间存储， 访问时通过下标（元素所在的位置）访问
ArrayList的数据结构
分析一个类的时候，数据结构往往是它的灵魂所在，理解底层的数据结构其实就理解了该类的实现思路，具体的实现细节再具体分析。
ArrayList的数据结构是：
说明：底层的数据结构就是数组，数组元素类型为Object类型，即可以存放所有类型数据。我们对ArrayList类的实例的所有的操作底层都是基于数组的。
源码分析参考：https://www.cnblogs.com/zhangyinhua/p/7687377.html#_lab2_0_1
public static void main(String[] args) {
// 通过ArrayList 创建集合对象
// 还可以存储自定义对象 默认容量是 10
ArrayList<String> list = new ArrayList<String>();
// 存储有序集合
list.add("aaa");
list.add("bbb");
list.add("ccc");
// 将元素插入到指定位置
list.add(1,"ddd");
//直接 遍历元素 get（Index） 通过下标访问元素
for(int i = 0 ;i<list.size();i++){
System.out.println("集合元素："+ list.get(i));
}
// 设置集合的最小容量
list.ensureCapacity(20);
}
159
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
