Java异常处理：
5个关键字：
try（尝试）、catch（捕获）、 finally（最终的）、throw（抛出）、throws
使用方法：
finally ：一般写的是资源释放代码，无论是否发生异常代码总能执行。
try{}catch(异常类型){}
try{}catch(异常类型){} finally{}
public class TestThrows {
//除法
public double div() throws ArithmeticException{
int a=1;
int b=0;
if(b==0){
throw new ArithmeticException("aaaaaa");
}
return a/b;
}
public static void main(String[] args) {
TestThrows tt = new TestThrows();
try {
tt.div();
} catch (Exception e) {
e.printStackTrace();
System.out.println(e.getMessage());
}
}
}
//如果有finally的话，finally中的代码是在return之前执行的
子类抛出的异常范围，不能宽于父类；
异常类关系：
java.lang.Object
继承者 java.lang.Throwable
继承者 java.lang.Exception
继承者 java.lang.RuntimeException
继承者 java.lang.NullPointerException
并不是所有的错误都是异常
异常的体系：
|——Throwable （实现类描述java的错误和异常）
|——Error （错误）一般不通过代码去处理。
|——Exception （异常）
|——RuntimeException （运行时异常）
|——非运行时异常
编译时异常和运行时异常
1. 编译时异常：Java程序必须显示处理，否则程序就会发生错误，无法通过编译
2. 运行时异常：无需显示处理，也可以和编译时异常一样处理
注意：
在安排catch语句的顺序时，首先应该捕获最特殊的异常，
然后在逐渐一般化。即先子类后父类
抛出异常：
throw:方法中抛出一个异常对象
throws：在方法定义中，抛出一个或多个异常；
Throwable中提供的方法：
1. getMessage()
获取异常信息，返回字符串。
2. toString()
获取异常类名和异常信息，返回字符串。
3. printStackTrace()
获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。
4. printStackTrace(PrintStream s)
通常用该方法将异常内容保存在日志文件中，以便查阅
throws和throw的区别：
throws格式是：方法名（参数）throws 异常类1，异常类2，.....
throws是用来声明一个方法可能抛出的所有异常信息，throws是将异常声明但是不处理，而是将异常往上传，谁调用我就交给谁处理。而throw则是指抛出的一个具体的异常类型
public class hoemwork73 {
//在方法中需要声明抛出异常
public static void throws_test() throws Exception{
throw new Exception("test");
};
public static void main(String[] args){
//必须在try的范围内使用
try{
throws_test();
}catch (Exception e){
System.out.println(e.getMessage());
}
}
}
自定义异常：
package com.jy.myexc;
/**
* 自定义异常
* @author bo
*
*/
public class MyException extends Exception{
public MyException() {
super();
}
public MyException(String message) {
super(message);
}
}
public class Div {
//除法
public void d() throws MyException{
int a=0;
int b=12;
if(a==0){
throw new MyException("分母不能为零！"); //大数据，Jee view controller service dao
}
int c =b/a;
System.out.println(c);
}
public static void main(String[] args) {
Div d = new Div();
try {
d.d();
} catch (MyException e) {
System.out.println(e.getMessage());
//e.printStackTrace();
}
}
}
包
注意事项：
1. package语句必须在文件（java）中的第一条有效语句
2. 一个java文件中，只能有一个package
3. 如果没有package，默认就是无包名
包的导入
1. import 包名...类名; 导入包内具体的文件
2. import 包名...*; 导入包内所有文件，不建议
权限修饰符种类
- private
- 默认friendly
- protected
- public
不同权限修饰符的区别
本类中 同一个包中 不同包中的子类中 不同包中
private OK
默认friedly OK Ok
protected OK Ok OK
public OK Ok OK Ok
对象数组：
public class Person {
private int age;
private String name;
// 手臂
private Arm[] arm;
// 腿
private Leg[] leg;
public Person() {
super();
}
public Person(int age, String name) {
super();
this.age = age;
this.name = name;
}
public Arm[] getArm() {
return arm;
}
public void setArm(Arm[] arm) {
this.arm = arm;
}
public Leg[] getLeg() {
return leg;
}
public void setLeg(Leg[] leg) {
this.leg = leg;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person [age=" + age + ", name=" + name + ", arm=" + arm + ", leg=" + leg + "]";
}
}
Arrays 和System常用方法：
public static void main(String[] args) {
int[] arr={10,12,5,6,9,20,8};
Arrays.sort(arr);//排序
int[] copyOf = Arrays.copyOf(arr, 6);//拷贝数组
System.out.println(Arrays.toString(arr));//排序后
int[] aa=new int[3];
System.arraycopy(arr, 2, aa, 0, 3);//拷贝数组
System.out.println(Arrays.toString(aa));
System.out.println(Arrays.toString(copyOf));
/*String str = Arrays.toString(arr);
System.out.println(str);*/
System.out.println(Arrays.toString(arr));
}
枚举类型简介：
在JDK 1.5之前，JAVA可以有两种方式定义新类型：类和接口。对于大部分面向对象编程来说，这两种方法看起来似乎足够了。但是在一些特殊情况下，这些方法就不适合。例如，想定义一个Color类，它只能有 Red、Green、Blue三种值，其他的任何值都是非法的，那么JDK 1.5之前虽然可以构造这样的代码，但是要做很多的工作，也有可能带来各种不安全的问题。而JDK 1.5之后引入的枚举类型（Enum）就能避免这些问题。
枚举：能够穷尽的列举出来的数据；
每周天数：周一，二，三，四，五，六 日
四季：春夏秋冬
在JDK 1.5之后，引入了一个新的关键字类型 —— enum，可以直接定义枚举类型，格式如下：
[public] enum 枚举类型名称{
枚举对象1,枚举对象2,…,枚举对象n ;
}
泛型：
泛型可以解决数据类型的安全性问题，它主要的原理，是在类声明的时候通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这样在类声明或实例化的时候只要指定好需要的类型即可。
泛型类定义格式：
[访问权限] class 类名称<泛型类型1,泛型类型2,…泛型类型3>{
[访问权限] 泛型类型标识 变量名称 ;
[访问权限] 泛型类型标识 方法名称(){} ;
[访问权限] 返回值类型声明 方法名称(泛型类型标识 变量名称){} ;}
泛型对象定义
类名称<具体类> 对象名称 = new 类名称<具体类>() ;
public class fanxing<A,B> {
private A age;
private B name;
private B address;
public fanxing(A age, B name, B address) {
super();
this.age = age;
this.name = name;
this.address = address;
}
@Override
public String toString() {
return "Person [age="+age+"name="+name+"address="+address+"]";
}
public static void main(String[] args) {
fanxing<Integer, String> fanxing = new fanxing<>(20, "zym", "haicheng");
System.out.println(fanxing);
}
}
通配符
public class Test {
public void show(Info<?> i){//？通配符
System.out.println(i);
}
public static void main(String[] args) {
Test t = new Test();
// Info<String> i = new Info<>();
// i.setName("张三");
Info<Integer> i = new Info<>();
i.setName(10);
t.show(i);
}
}
受限泛型：
在引用传递中，泛型操作中也可以设置一个泛型对象的范围上限和范围下限。范围上限使用extends关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类，而范围下限使用super进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至Object类。
设置上限：
声明对象：类名称<? extends 类> 对象名称 《=类
定义类：[访问权限] 类名称<泛型标识 extends 类>{}
设置下限：
声明对象：类名称<? super 类> 对象名称 》=类
定义类：[访问权限] 类名称<泛型标识 extends 类>{}
public class Info<T>{
private T name;
public Info() {
super();
}
public Info(T name) {
super();
this.name = name;
}
public T getName() {
return name;
}
public void setName(T name) {
this.name = name;
}
@Override
public String toString() {
return "Info [name=" + name + "]";
}
}
public class TestInfo {
//打印Info
public void show(Info<? extends String> i){
System.out.println(i);
}
//打印Info
public void show1(Info<? super String> i){
System.out.println(i);
}
public static void main(String[] args) {
//上限 <=String
Info<String> in = new Info<>();
in.setName("张三");
/* Info<Object> io = new Info<>();
in.setName(new Object());*/
System.out.println(in);
//下限 >=String
Info<String> in1 = new Info<>();
in1.setName("aa");
Info<Object> io1 = new Info<>();
io1.setName(new Object());
}
}
来源：https://www.cnblogs.com/taozizainali/p/10767046.html