一 集合的总结
package com.lanou3g;
import java.util.HashMap;
import java.util.Hashtable;
/*
* HashMap 与Hashtable 的区别?
* *HashMap与Hashtable区别?
* HashMap
* JDK1.2
* 线程不安全的
* HashMap可以保存null值
*
*
* Hasntable
* JDK1.0
* 线程安全
* Hashtable不能保存null值
*
*
* ArrayList
* JDK1.2
* 线程不安全的
* 查找快,增删慢
*
* linkList
* 线程不安全
* 查询慢,增删快
*
* Vector
* JDK1.0
* 线程安全
*
*
*
* HashSet 去重
* 线程不安全
* TreeSet 排序
* 线程不安全
* linkedHashSet 有序怎么存怎么取.
* 线程不安全
*
*/
public class Demo01 {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
map.put("代号", null);
map.put(null, null);
Hashtable<String, String> table = new Hashtable<>();
table.put(null, "大海");
}
}
二 异常
1.异常的分类
异常处理的类
-- throwable(所有异常的父类) 两个子类
-- Error (系统崩溃,数据库崩溃)
-- Exception 编译时异常(程序员的错误)
未雨绸缪(为你可能发生的异常,做一个准备)
特点:强制你去处理这个异常,不处理就报错.
-- RuntimeException(运行时异常)
通常在main函数中产生的异常由main函数自己处理,但是main函数没做处理的话,就会向上级抛出异常由JVM处理.
JVM默认的处理方式:
1.打印错误所在位置
2.打印错误信息
3.停止程序
2.发生异常的处理方法
try // catch // finally
try :指的是要测试的代码部分.(有可能发生异常的代码)
catch :指的是要捕获的异常
finally :指的是异常处理后要执行的代码.
异常处理步骤:
class TextException{
public int fun(int a, int b) {
//发生异常时会创建一个异常对象
//new ArithmeticException("异常信息/ by zero")
//这时会把创建的异常对象返回 给它的上级去处理(谁调用这个方法上级就是谁)
//这个异常对象就返回给main函数
//main函数接到异常没有处理传给JVM处理.
//JVM打印错误信息.
return a/b;
}
public static void main(String[] args) {
TextException text =new TextException();
try {
//放可能发生异常的代码
//返回ArithmeticException 对象.
int num = text.fun(10, 0);
System.out.println(num+"32541654");
}catch (ArithmeticException e) {
//ArithmeticException e = new ArithmeticException();
// 捕获的异常对象
//捕获成功 会执行catch中代码
//程序不会被终止
System.out.println("/ by zero");
}catch ( IndexOutOfBoundsException e) {
System.out.println("越界异常");
}catch (Exception e) {
System.out.println("Exception异常");
}
}
多catch处理异常:
由上至下进行匹配,匹配上一个就不运行了
catch捕获时使用的类 要由小到大 书写
需求:
创建一个人类 有name 和 age
要求 人类的年龄赋值时 要在 0 到 120岁之前
public static void main(String[] args) throws Exception {
Person person = new Person();
person.setName("萧峰");
//自己处理
/*try {
person.setAge(10000);
//调用该方法可能接受到异常对象,需要你来处理.
System.out.println(person);
} catch (Exception e) {
//打印错误信息
System.out.println(e.getMessage());
}*/
//把异常抛给上级处理
//在main方法上标识该方法有异常
person.setAge(10000);
System.out.println(person);
}
定义一个person类
class Person{
private String name;
private int age;
public Person() {
super();
// TODO Auto-generated constructor stub
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) throws Exception {
//判断年龄
if (age>0 && age<120) {
this.age = age;
}else {
//抛出一个异常
//创建一个异常
// Exception exception = new Exception("你超出标准人类年龄范围请前往地狱");
//使用throw关键词抛出异常
//报错原因: 该方法不支持抛出异常,需要在方法中标识一下本方法可以抛出一个异常对象
//使用throws 来标识方法是个带异常的方法
// throw exception;
//抛出自定义异常
AgeOutOfBoundsException e =
new AgeOutOfBoundsException("你超出标准人类年龄范围请前往地狱");
throw e;
}
}
@Override
public String toString() {
return "person [name=" + name + ", age=" + age + "]";
}
}
自定义异常类:类名要见名知意.
class AgeOutOfBoundsException extends Exception {
/**
* 序列化ID
*/
private static final long serialVersionUID = 1L;
// //无参构造方法
// public AgeOutOfBoundsException() {
// // TODO Auto-generated constructor stub
// }
// //有参构造方法,传入的是异常信息
// public AgeOutOfBoundsException(String message) {
// super(message);
// }
}
public static void main(String[] args) throws FileNotFoundException {
//读取文件 传入要读取文件的路径
//系统不知道 你有没有这个文件
//未雨绸缪 强制出一下 没有这个文件 怎么办
//相当于 要为可能发生的异常 提前做准备
//自己处理 编译时异常
/*try {
FileInputStream fis = new FileInputStream("wl.tet");
} catch (FileNotFoundException e) {
System.out.println("你没有这个文件");
}*/
//抛出去处理
FileInputStream fis = new FileInputStream("wl.tet");
}
继承中的异常
public class Demo03 {
}
class Father{
public void fun() {
}
}
class son extends Father{
//重写父类方法
@Override
public void fun() {
// 调用带异常的方法
//不能把异常抛出去处理
//这时只能使用try catch 处理
try {
method();
} catch (Exception e) {
// TODO: handle exception
}
super.fun();
}
public void method() throws Exception {
throw new Exception();
}
}
另外在父类中的方法没有抛出异常 那么子类在重写父类的这个方法的时候 也不能抛出异常. 如果父类抛出异常,子类也可以抛出异常并且可以try catch 处理.
为了更好的理解异常的运行进制看下面一个例子
完成两个数的加法 和 除法的功能(设计完成 要求分装方法和异常处理)
分析: 把两个数分装成一个对象
MyNum类 : 把两个数分装成一个对象 类中属性就是这两个数
用户输入数字类: 接收用户输入的数字(异常处理)
循环 递归
操作类
1.获取封装好的MyNum对象 :让用户输入俩数
2.获取用户输入要做的运算(输入 1 和 2 1是加法 2是 除法 异常处理)
除法方法 (有可能出现异常 出现异常 重新输入 数据) 加法方法
根据用户要做的运算 和 那两个数 计算出结果
测试类:
测试..
/*
* 封装数字的类
*/
public class MyName {
private int num1;
private int num2;
public MyName() {
super();
// TODO Auto-generated constructor stub
}
public MyName(int num1, int num2) {
super();
this.num1 = num1;
this.num2 = num2;
}
public int getNum1() {
return num1;
}
public void setNum1(int num1) {
this.num1 = num1;
}
public int getNum2() {
return num2;
}
public void setNum2(int num2) {
this.num2 = num2;
}
@Override
public String toString() {
return "MyName [num1=" + num1 + ", num2=" + num2 + "]";
}
}
/*
* 提供用户输入数字的类
*/
import java.util.Scanner;
public class IntTool {
//构造方法私有化
private IntTool() {}
/*public static int getNum() {
Scanner scanner = new Scanner(System.in);
String string = scanner.nextLine();
//转数字
try {
int num = Integer.parseInt(string);
return num;
} catch (Exception e) {
System.out.println("请你输入数字");
//再调用一次本方法
return getNum();
}
}*/
public static int getNum1(){
System.out.println("请你输入数字");
while (true) {
Scanner scanner = new Scanner(System.in);
String string = scanner.nextLine();
try {
int num = Integer.parseInt(string);
return num;
} catch (Exception e) {
System.out.println("请你输入数字");
}
}
}
}
/*
* 操作运算的类
*/
public class Operact {
//获取Myname对象
public MyName getNumt() {
int num1=IntTool.getNum1();
int num2 =IntTool.getNum1();
//构建MyName 对象
MyName myName = new MyName(num1, num2);
return myName;
}
//获取哦用户输入的 运算复合
public String getMethod() {
System.out.println("请输入数字 1 为加法 2 是除法");
int num = IntTool.getNum1();
if (num==1) {
return "+";
}else if (num==2) {
return "/";
}else {
System.out.println("请从新输入1或2");
//再次调用本方法 实现重新输入
return getMethod();
}
}
//加法
public int sum(MyName myName) {
return myName.getNum1() + myName.getNum2();
}
//除法(可能出现除以 0 的异常 处理一下)
public int div(MyName myName) throws DivNotZeroExcception {
try {
return myName.getNum1()/myName.getNum2();
} catch (ArithmeticException e) {
//捕获这个异常
// 直接抛出去 让调用者去处理
throw new DivNotZeroExcception("0不可以做除数");
}
}
//根据运算符 和数字 计算结果
public int getRelsult(String operact,MyName myName) {
if (operact.equals("+")) {
return sum(myName);
}
//除法
try {
return div(myName);
} catch (DivNotZeroExcception e) {
// JVM 默认打印的信息 位置和异常类
// e.printStackTrace();
System.out.println(e.getMessage());
//重新调用getnum
MyName m = getNumt();
//重新计算结果
return getRelsult(operact, m);
}
}
}
class DivNotZeroExcception extends Exception{
/**
*
*/
private static final long serialVersionUID = 1L;
public DivNotZeroExcception() {
super();
}
public DivNotZeroExcception(String message) {
super(message);
}
}
public class Test {
public static void main(String[] args) {
//测试
Operact operact = new Operact();
//获取两个数的对象
MyName numt = operact.getNumt();
//获取操作符
String method = operact.getMethod();
//计算
int result = operact.getRelsult(method, numt);
System.out.println(result);
}
}
运算加法时
请你输入数字 1 请你输入数字 2 请输入数字 1 为加法 2 是除法 请你输入数字 1 3
运算除法时
请你输入数字 1 请你输入数字 2 请输入数字 1 为加法 2 是除法 请你输入数字 2 0
输入非数字的异常反馈
请你输入数字 1 请你输入数字 2 请输入数字 1 为加法 2 是除法 请你输入数字 呜呜 请你输入数字
除零的异常反馈
请你输入数字 5 请你输入数字 0 请输入数字 1 为加法 2 是除法 请你输入数字 2 0不可以做除数 请你输入数字