内部类
在一个类中定义一个类,所以称为内部类。
第一种普通内部类
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);
}