异常
异常是程序中的一些错误,但并不是所有的错误都是异常,并且错误有时候是可以避免的。
比如说,你的代码少了一个分号,那么运行出来结果是提示是错误 java.lang.Error;如果你用System.out.println(11/0),那么你是因为你用0做了除数,会抛出 java.lang.ArithmeticException 的异常。
异常发生的原因有很多,通常包含以下几大类:
1.用户输入了非法数据。
2.要打开的文件不存在。
3.网络通信时连接中断,或者JVM内存溢出。
这些异常有的是因为用户错误引起,有的是程序错误引起的,还有其它一些是因为物理错误引起的.
要理解Java异常处理是如何工作的,你需要掌握以下三种类型的异常:
1.检查性异常:最具代表的检查性异常是用户错误或问题引起的异常,这是程序员无法预见的。例如要打开一个不存在文件时,一个异常就发生了,这些异常在编译时不能被简单地忽略。
2.运行时异常: 运行时异常是可能被程序员避免的异常。与检查性异常相反,运行时异常可以在编译时被忽略。
3.错误: 错误不是异常,而是脱离程序员控制的问题。错误在代码中通常被忽略。例如,当栈溢出时,一个错误就发生了,它们在编译也检查不到的。
异常
/**
* 异常处理 处理运行过程中出现的不可控的错误 使程序更健壮
* Exception1 -
* try{
* 执行代码
* 可能出现异常
* 一旦出现异常 系统自动为我们创建一个异常对象 并抛出
* }catch(){
* 如果需要自己处理异常就catch
* }catch(){
* 如果有多个异常 可以使用多个catch来捕获
* 如果有多个异常 catch的顺序是从小到大
* } finally{
* 不管有没有异常finally都会执行
* 处理资源回收 网络连接 数据库连接 I/O流
* }
*
*
* 如果异常出现 后面的代码将不W=会执行
* try代码块 不要抓太多代码
*
* 自定义异常类
* */
java内置异常类
异常方法
使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。
try/catch代码块中的代码称为保护代码,使用 try/catch 的语法如下:
try
{
// 程序代码
}catch(ExceptionName e1)
{
//Catch 块
}
一个 try 代码块后面跟随多个 catch 代码块的情况就叫多重捕获。
多重捕获块的语法如下所示:
try{
// 程序代码
}catch(异常类型1 异常的变量名1){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}
throws/throw 关键字:
如果一个方法没有捕获到一个检查性异常,那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。
也可以使用 throw 关键字抛出一个异常,无论它是新实例化的还是刚捕获到的。
下面方法的声明抛出一个 RemoteException 异常:
import java.io.*;
public class className
{
public void deposit(double amount) throws RemoteException
{
// Method implementation
throw new RemoteException();
}
//Remainder of class definition
}
finally关键字:
finally 关键字用来创建在 try 代码块后面执行的代码块。
无论是否发生异常,finally 代码块中的代码总会被执行。
在 finally 代码块中,可以运行清理类型等收尾善后性质的语句。
finally 代码块出现在 catch 代码块最后,语法如下:
try{
// 程序代码
}catch(异常类型1 异常的变量名1){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}finally{
// 程序代码
}
自定义异常类:
示例:
class TException {
public static void test() throws FileNotFoundException, NullPointerException {
FileReader fr = new FileReader("");
}
public static void test3() throws MYException {
//....
throw new MYException("my exception: do nothing");
}
}
class MYException extends Exception{
//1.提供一个无参构造方法
public MYException(){
}
//2.提供一个有参构造方法 参数是一个字符串
public MYException(String desc){
super(desc);
}
}
泛型
Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。
泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。
假定我们有这样一个需求:写一个排序方法,能够对整型数组、字符串数组甚至其他任何类型的数组进行排序,该如何实现?
答案是可以使用 Java 泛型。
使用 Java 泛型的概念,我们可以写一个泛型方法来对一个对象数组排序。然后,调用该泛型方法来对整型数组、浮点数数组、字符串数组等进行排序。
泛型方法:
所有泛型方法声明都有一个类型参数声明部分(由尖括号分隔),该类型参数声明部分在方法返回类型之前(在下面例子中的<E>)。
每一个类型参数声明部分包含一个或多个类型参数,参数间用逗号隔开。一个泛型参数,也被称为一个类型变量,是用于指定一个泛型类型名称的标识符。
类型参数能被用来声明返回值类型,并且能作为泛型方法得到的实际参数类型的占位符。
泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型,不能是原始类型(像int,double,char的等)。
public class GenericMethodTest
{
// 泛型方法 printArray
public static < E > void printArray( E[] inputArray )
{
// 输出数组元素
for ( E element : inputArray ){
System.out.printf( "%s ", element );
}
System.out.println();
}
public static void main( String args[] )
{
// 创建不同类型数组: Integer, Double 和 Character
Integer[] intArray = { 1, 2, 3, 4, 5 };
Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
System.out.println( "整型数组元素为:" );
printArray( intArray ); // 传递一个整型数组
System.out.println( "\n双精度型数组元素为:" );
printArray( doubleArray ); // 传递一个双精度型数组
System.out.println( "\n字符型数组元素为:" );
printArray( charArray ); // 传递一个字符型数组
}
}
HashMap
HashMap遍历
以下实例演示了如何使用 Collection 类的 iterator() 方法来遍历集合:
Main.java 文件
import java.util.*;
public class Main {
public static void main(String[] args) {
HashMap< String, String> hMap =
new HashMap< String, String>();
hMap.put("1", "1st");
hMap.put("2", "2nd");
hMap.put("3", "3rd");
Collection cl = hMap.values();
Iterator itr = cl.iterator();
while (itr.hasNext()) {
System.out.println(itr.next());
}
}
}
以上代码运行输出结果为:
1st
2nd
3rd
常用方法示例:
image.png
//1.集合里面对象不能重复 如果重复 加不进去
// 内部使用HashMap来实现 键值对 键key不能重复
// "jack":obj
//
//2.集合是无序的 添加的顺序和存储的顺序无关
// 使用了默认排序
// 哈希算法
// 如何实现HashMap里面key不相同
// 计算这个Key对应的对象的hash值
//整数:在对象的地址的基础上按照一定的算法计算出来的一个整数
// 如果两个对象相同 那么计算出来的hash值就相同
public class MyClass {
public static void main(String[] args){
//GenericTest<Integer> g1 = new GenericTest<>();
HashSet<String> names = new HashSet<>();
names.add("jack");
names.add("merry");
names.add("abc");
//可以排序的集合
TreeSet<Person> score = new TreeSet<>((Person p1,Person p2) -> p1.compareTo(p2));
Person p1 = new Person("jack",20);
Person p2 = new Person("jack",30);
Person p3 = new Person("rose",20);
score.add(p1);
score.add(p2);
score.add(p3);
System.out.println(names);
//HashMap 集合 储存数据的特点:键key - 值value
//key不能重复 可以是任意的对象类型 通常使用字符串String
HashMap<String,Integer> score = new HashMap<>();
//添加对象:键值对
score.put("chinese",89);
score.put("math",93);
score.put("English",92);
//更改某个键对应的值
score.put("chinese",91);
System.out.println(score);
//获取键值对的个数
score.size();
//获取所有的key
System.out.println(score.keySet());
//获取所有的value
System.out.println(score.values());
//获取Entry:key-value
System.out.println(score.entrySet());
//获取一个键key对应的值
System.out.println(score.get("English"));
//键值对的遍历
//1.通过遍历key来得到没一个key对应的值
for(String key:score.keySet()){
int s = score.get(key);
System.out.println("key: "+key +"value: "+s);
}
//2.通过entrySet 得到Entry对象的集合
// 一个Entry管理一个键值对 getKey getValue
Set<Map.Entry<String,Integer>> entrys = score.entrySet();
for(Map.Entry entry:entrys){
//得到Entry对应的key
String key = (String )entry.getKey();
//获取Entry对应的值
Integer value =(Integer)entry.getValue();
System.out.println("key: "+key +"value: "+value);
}
}
}
class Person implements Comparable{
String name;
int age;
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Object o ){
if(o instanceof Person){
Person o1 = (Person) o;
//自己规定比较的策略
if(this.age != o1.age){
return this.age - o1.age;
}else {
//在年龄相同的情况下 再比姓名的字母
return this.name.compareTo(o1.name);
}
}else {
return -1;
}
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
}
futher