1.访问权限修饰符 enum 枚举名{
//静态常量
常量A,常量B,常量C;
}
2.枚举只能给枚举对象赋值
枚举名 对象 = 枚举名.常量A;
对象存储的就是枚举值
3.switch...case形式
switch(对象|枚举名.常量A){
//枚举中定义的常量
case 常量A:
执行语句;
break;
........
}
通过反编译:
其实枚举即使一个特殊的类并且默认继承一个Enum的类
提供一些我们常用的方法 -->通过API中的Enum类就可以看到
两个隐藏方法values() --> 可以获取一个枚举中所有常量值的数组
valueOf("常量A")-->参数是一个字符串名就可以了 需要是枚举中常量的名字
所写的枚举常量 public static final 枚举类型 常量名;
构造方法私有化
枚举单利:
public enum 枚举名{
常量A;
}
可以在枚举中定能定义静态方法静态属性和成员方法和成员属性
枚举中可以定义抽象方法,但是若枚举中有枚举常量抽象方法需要定义在枚举常量的下面,并且必须实现这个抽象方法
常量是可以有自己的方法的形式的
public enum 枚举名{
A{
重写抽象方法
};
public abstract 返回值类型 方法名();
}
异常:
非正常发生的事情,不同于寻常
一个正常人,身体发热,去看医生,说不意思:你感冒了
ps:程序出问题了给的警告
/** * */ package com.qfedu.Day15.Exception; public class ExceptionDemo { public static void main(String[] args) { System.out.println("-----------------------begin-----------------------"); int x = 9; int y = 0; try { //这段代码可能会出现异常 int result = x/y; System.out.println("结果:"+result); //1.若能明确异常类型,就写当前异常类型 //2.不知道异常类 --> Exception }catch(ArithmeticException e) { System.out.println("除数为0,出现了问题!!!!!!"); } System.out.println("-------------------------end-------------------------"); } }
异常的种类:
编译时异常:在代码进行编译阶段,就会出现的异常信息
编译时异常必须处理,不处理程序会一直报错,若强行运行只有崩溃的结果
运行时异常:在代码执行阶段,出现异常就是运行时异常
1.在写代码时,就知道这段代码会出现一个异常进行一些处理
2.抛出异常后,在进行修改
/** * */ package com.qfedu.Day15.Exception; public class ExceptionDemo2 { public static void main(String[] args) { // String num1 = "10"; // String num2 = "0"; // try { // int i1 = Integer.parseInt(num1); // int i2 = Integer.parseInt(num2); // int result = i1/i2; // System.out.println(result); // }catch(NumberFormatException e) { // //打印异常信息 --> 打印系统所自订的异常信息 // System.out.println(e.getMessage()); // }catch (ArithmeticException e) { // /* // * java.lang.ArithmeticException: / by zero // at com.qfedu.Day15.Exception.ExceptionDemo2.main(ExceptionDemo2.java:23) // */ // //打印跟中栈信息 // e.printStackTrace(); // } //如下语法需要注意 // String num1 = "10"; // String num2 = "0"; // try { // int i1 = Integer.parseInt(num1); // int i2 = Integer.parseInt(num2); // int result = i1/i2; // System.out.println(result); // // }catch (ArithmeticException e) { // /* // * java.lang.ArithmeticException: / by zero // at com.qfedu.Day15.Exception.ExceptionDemo2.main(ExceptionDemo2.java:23) // */ // //打印跟中栈信息 // e.printStackTrace(); // //Exception是父类---> 接收所有异常,剩余的子类异常就无法接收异常信息了 // //所以父类异常需要出现在子类异常的后面 // }catch(Exception e) { // //打印异常信息 --> 打印系统所自订的异常信息 // System.out.println(e.getMessage()); // } //1.7中的新特性 String num1 = "10"; String num2 = "0"; try { int i1 = Integer.parseInt(num1); int i2 = Integer.parseInt(num2); int result = i1/i2; System.out.println(result); //平级捕获异常 需要满足 父类不能出现在子类的前面 }catch (ArithmeticException | NumberFormatException e) { //打印跟中栈信息 e.printStackTrace(); } } }
/**
*
*/
package com.qfedu.Day15.Exception;
public class ExceptionDemo3 {
public static void main(String[] args) {
System.out.println("-----------------------begin-----------------------");
int x = 9;
int y = 0;
try {
//这段代码可能会出现异常
int result = x/y;
System.out.println("结果:"+result);
//1.若能明确异常类型,就写当前异常类型
//2.不知道异常类 --> Exception
}catch(ArithmeticException e) {
System.out.println("除数为0,出现了问题!!!!!!");
//System.exit(1);
//finally优先于return执行
//finally只有使用停止JVM的方法时才不执行
}finally {
System.out.println("关闭资源,finally语句被执行了..");
}
System.out.println("-------------------------end-------------------------");
}
}
/**
*
*/
package com.qfedu.Day15.Exception;
public class ExceptionDemo4 {
public static void main(String[] args) {
System.out.println(Result1());// 3
//System.out.println((int)(Math.random()*5));
System.out.println(Result2());
}
public static int Result1() {
int x = 9;
int y = 3;
int result = 0;
try {
result = x/y;
return result;
}catch(ArithmeticException e) {
return Integer.MAX_VALUE;
}finally {
result++;
System.out.println("result="+result);// 1 / 4
}
}
public static int Result2() {
try {
return 1 ;
}finally {
//语法:只有finally当中存在return语句,永远返回的是fianlly中的结果,要避免这样发生
return 100;
}
}
}
异常的分类:
所有异常的根类Throwable
知道其两个子类 Error 和 Exception
程序猿所处理的是Exception的异常
Error程序猿不处理 --> JVM所出现的错误
Exception --> 编译时异常
RuntimeException -->运行是异常
常见异常:
--------------------------------------------------------------------------------------------
NullPointerException 空指针异常 String str = null;
str.charAt() == null.charAt();
ArrayIndexOutOfBoundsException 数组下标越界异常 int[] array ={1,2};
array[100]
StringIndexOutOfBoundsException 字符串下标越界异常 String str ="ab";
str.charAt(10);
NumberFormatException 数据类型格式化异常 new Integer("11a");
ClassCastException 强制类型转换异常 一个父类对象在进行向下转型时
Animal a = new Dog();
Cat cat =(Cat)a
IOException 流异常 流使用错误
处理异常:
异常的特点:
若某行代码在执行过程中抛出异常,那么后面的代码就会不执行了(运行时和编译时都出现这个问题)
若需要据需执行或打印其他方式-->就需要处理掉当异常了
1.try...catch...finally
1.1try...catch
try是捕获异常 catch抓取出捕获的异常
try{
编译可能出现异常的代码
}catch(异常类型 e){ --->定义了一个异常类型的变量
//记录日志
//直接打印异常信息
//继续抛出异常
ps:无论在catch代码代码段中做任何事情,都是对异常的一种补救措施
/**
*
*/
package com.qfedu.Day15.Exception.ThrowAndThrows;
public class ThrowsDemo {
//后果:main已经是最终的位置,若在main中继续抛出异常,接受者只有一个JVM
//得到的结结果就是在控制台上打印跟中栈信息
//ps:throws主要的作用就是提示调用者有异常需要处理,一般会和编译时异常一起使用
public static void main(String[] args)throws NumberFormatException {
String str = "123a";
//正确的做法就是需要处理这个异常try...catch
//但是处理异常还有一种方法继续throws
int num = getResult(str);
}
public static int getResult(String value)throws NumberFormatException {
return new Integer(value);
}
}
/** * */ package com.qfedu.Day15.Exception.ThrowAndThrows; import java.io.FileInputStream; import java.io.FileNotFoundException; import javax.management.RuntimeErrorException; public class ThrowDemo { public static void main(String[] args)throws FileNotFoundException { //效果等同于return //throw new RuntimeException(); String str = "123a"; try { int num = getNumber(str); }catch (NumberFormatException e) { System.out.println(e.getMessage()); } try { new FileInputStream("C:\test"); } catch (FileNotFoundException e) { //1.7使用throw抛出一个异常对象,throw new 异常类型() //1.7之后增强语法catch中是不是已将获知异常类型而e是不是就是异常对象 //throw可以直接在catch语句块中直接将异常对象抛出 //ps:若这样使用就无法自定义信息了 //throw new FileNotFoundException(); throw e; } // int i = 0; // while(true) { // if(i == 200000) { // //最好不要 // throw new RuntimeException("循环已经停止"); // } // i++; // // } } public static int getNumber(String value) { try { return new Integer(value); }catch(NumberFormatException e) { throw new NumberFormatException("转换错误,你输入的是什么???"); } } }
}
总结:
1.若try语句块中出现异常,那么异常代码后的代码都不会执行,会直接跳转到catch语句块中执行
2.若try语句块中没有出现异常会继续执行,catch语句块将不会执行
catch语句块中处理异常的方法:
getMessage():捕获异常信息的描述,提示用户异常信息是什么
System.out.println(e.getMessage());
toString():捕获异常信息藐视以字符串的形式返回(不用)
System.out.println(e.toString());
printStackTrace()打印异常栈跟踪信息并输出到控制台上
ps:这个方法有一个重载,参数是输出流,指定输出的位置
基本上即使在处理日志--> 雷军 --> 人们最常问的的问题10个 --> Top N
一般来说我们都会在catch语句块中进行这个方法的调用并打印信息
主要用于:看到异常类型,异常原因,异常出现的位置,在开发调用和测试的过程中来进行使用
在完成项目进行提交时会做如下操:
1.改变输出作为日志存在
2.直接删除异常跟中信息,转而使用输出语句
看ExceptionDemo
若在执行代码中出现多个异常
多种类型异常处理:
try{
编写可能出现的代码异常
}catch(异常类型 e){
进行处理异常
}catch(异常类型 e){
进行异常处理
}....
//连级判断-->异常和异常之间有一定关联性 --> 反射的时候
//1.7新特性
看ExceptionDemo2
finally代码块
finally语句开表示最终的,无论如何都会执行(异常捕获是够成功与否)
finally语句块的作用:
通过try...catch的形式可以捕捉一些异常,某些时候例如:
我们在对一些物理资源(磁盘文件/网络连接/数据库连接),fianlly会进行资源释放和关闭操作
IO流中
捕获异常终极写法
try{
编译代码可能出现的异常
}catch(异常类型 e){ --> catch可以有多个
输出异常信息
}finally{ --> 只能有一个 在没有资源释放或关闭的情况下fianlly语句块可以省略
释放资源
}
看ExceptionDemo3
面试题:
看ExceptionDemo4
final , finally ,finalize 的区别
2.throw 和 throws
throw语法:
运用于方法的内部,抛出一个具体的异常对象
throw new 异常类型("异常信息"); -->等同于 return 可以让方法结束
throw作用:
当一个方法出现不正常的情况的时候,我们不知道该方法返回什么,此时就返回一个错误.
在catch语句块中继续向上抛出异常
return 是返回一个值 throw是返回一个错误,返回给该方法的调用者
throw创建一个异常对象并定义异常信息,用于传递给调用者
看ThrowDemo
throws语法:
定义于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常
设计当前throws抛出异常,在方法体中的所有异常你都不需要处理,在调用方法时必须处理当前抛出
的异常
throws使用需要谨慎,不要大批量随意抛出异常,只要处理时机不成熟的时候,才选择抛出
ps:
若是在main方法中抛出异常是完全可以的,但是在main方法中抛出异常会失去我们程序猿的作用!!
看ThrowsDemo
throw和throws的不同
throw:运用于方法内部,用于给调用者返回一个异常对象,和return一样会结束当前方法
throws运行于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常)
若throw创建的对象是编译时异常(Exception)那么在方法中需要使用throws或try...catch来处理
throws需要在定义在方法使用
自定义异常
系统中所提供的异常不能满足所有的需求时,此时我们可以定义自己异常
分两种:
1.当前异常是在程序运行时出现异常-->继承与RuntimeException
2.当前异常是在代码书写时就出现异常-->继承Exception
异常连和异常转换
异常转换:当位于最上层子系统不需要关系底层异常的细节时,常量的做法就是当前捕获的原有异常进行一个新
包装,使之成为一个全新的异常,然后在抛出
异常链:把原始的异常包装为新的一行,从而行程多个异常的存在,并且排列,有助于我们查找异常信息
数据结构:
数据结构是计算存储,组织数据的方式
编程 = 数据结构 + 算法
数据结构存在着多种关系,一对一 一对多 多对多 等等
常见的数据结构
数组,栈,链表,哈希表,队列,堆,树,图
java中集合框架其实就是数据结构的实现与封装
java中的集合根据使用不同的数据结构各种性能是不一样
最简单的就是数组 -->线性结构
ps:大话数据结构
需求:
模拟一个球员系统你是教练
1.初始容量为5的线性列表,准备用来存储场上的5个球员的号码
2.安排5个球员上场[11,22,33,44,55];
3.查询指定位置的球员的球衣号码是多好,查询索引2号码应该333
4.根据球衣号码查询该球员在场上的索引位置 44 ---> 3
5.替换场上所以位置为2的球员,替换之后该位置的球衣编号为333
6.替换球衣号码为22的球员 ,替换之后为222
7.把场上所以位置为2的球员罚下(即没有替补)
8按照球员在场上的位置打印球衣号码风格[11,22,33,44,55]
修改需求:
健壮性和安全性的修改
1.创建数组的时候 是不是可以传入一个负数
2.查找是会出现负数和大于数组长度的值
3.若我们需要添加元素,因为我们的大小是5个元素,扩充数组
Java就提供一个类是与我们封装的类的一种
集合:存储的是对象,不能存储值类型
集合是变长
集合提供了一些常用方法,让我们来进行增删改查等操作
List(列表):集合中的对象是按照索引位置存储的(有序),并且可以存储重复数据
Set(集):集合中的对象没有特定存储方法(无序-->无序不等于随机),并且不允许重复
Map(映射):集合中每一个元素都包含一对"键值对"key和value形式,不允许key重复,value可以重复
ArrayList集合:
/** * */ package com.qfedu.Day15.ArrayList; import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class ArrayListDemo { @SuppressWarnings("rawtypes") //注解 public static void main(String[] args) { //1.无参 ArrayList al = new ArrayList(); //2.有参 --> 指定初始容量大小 ArrayList al2 = new ArrayList(20); //3.通过构造方法在ArrayList集合当中存另外一个集合的元素 ArrayList al3 = new ArrayList(al2); //常用方法: //向集合中添加元素 al.add(1); al.add(2.1243); al.add("3"); al.add('c'); al.add("我可以存储任何数据类型"); //因为ArrayList底层实现是数组,所以存在下标的概念 //第一个元素的位置是0,最后一个元素的位置是size-1 //集合可以直接打印对象-->重写了toString System.out.println(al); //向集合中添加指定元素 al.add(1, "我是插入值"); System.out.println(al); //向集合中插入另外一个集合 al2.add("2018"); al2.add(8); al2.add(17); //向集合中添加原有集合的值 al.addAll(al2); System.out.println(al); //向指定位置添加集合 //addAll(int index, Collection<? extends E> c) //清空集合-->没有数据,集合还存在 al2.clear(); System.out.println(al2); //判断集合中是否存在指定元素 //true 就是存在 false是不存在 System.out.println(al.contains("2018")); //通过下标获取集合中的元素 System.out.println(al.get(1)); //判断集合中首次出现指定元素的位置 //如果找到就返回其下标(第一次) //没有找到 -1 System.out.println(al.indexOf("七夕")); //判断集合中是否存在元素(判断集合是不是空的) //true 空 false 有元素 System.out.println(al.isEmpty()); //返回集合中最后一次出现元素的位置 //如果找到了返回值下标(最后一次) //返回-1 System.out.println(al.lastIndexOf(17)); //删除集合中的元素 //根据下标删除指定位置的元素 al.remove(1); System.out.println(al); //根据传入的指定元素删除 //若集合中存在着两个相同的元素 //删除第一次出现的,若集合中没有要删除的元素 //得到一个返回值false --> 删除失败没有这个元素 al.remove("2018"); System.out.println(al); //传入指定位置替换指定的值 al.set(0, "我是替换值"); System.out.println(al); //将ArrayLis集合转换为数组,数组必须是Object Object[] array = al.toArray(); System.out.println(Arrays.toString(array)); //将数组转换为List集合 List al4 = Arrays.asList(array); } }