基础知识
常用快捷键
Ctrl+A：全选
Ctrl+X：剪切
Ctrl+Z：撤销
Ctrl+Z：撤销
Ctrl+S：保存
Alt+F4：关闭窗口
Shift+Delete：永久删除
win+E：文件资源管理器
Alt+Alt：切换界面
Win+R cmd：控制台（若以管理员身份运行，则右击）
Ctrl+D：复制当前行到下一行
常用Dos命令(cmd)
#盘符切换
#查看当前目录下的所有文件 dir
#切换目录 cd
#清理屏幕 cls(clear screen)
#退出终端 exit
#查看电脑ip ipconfig
#查看ip ping 网址
#回到上一级目录 cd..
#文件操作
md 创建目录
rd 移除目录
del 删除文件
cd> 创建文件
Java基础
标识符
所有标识符都以字母、美元符、下划线开始
标识符是大小写敏感的
数据类型
强类型语言：变量必须先定义后使用
基本数据类型(Primitive Type)
数值类型
整数类型：byte(1个字节-128127)、short(2个字节-3276832767)、int(4个字节-2147483648~9223372036854775807)、
long(8个字节)
浮点类型：float(4字节)、double(8字节) 注意：最好完全避免浮点数进行比较
float d1 = 23131312312312313f;
float d2 = d1+1;
得到结果d1==d2
那么银行业务怎么表示?
数据工具类 BigDecimal
字符类型：char(2字节) 注意：string不是关键字，而是类
boolean类型
占1位，其值只有true和false 注意：1B(byte，字节)=8bit(位)，位是内部数据存储的最小单位，字节是数据处理的基本单位，字符是计
算机中使用的字母、数字、字和符号
引用数据类型(Reference Type)
类
接口
数组
类型转换
所有字符的本质是数字
char c1 = "A";
char c2 = "中";
System.out.println(c1); A
System.out.println(int(c1));//强制转换 65
System.out.println(c2); 中
System.out.println(int(c2));//强制转换 20013
溢出问题
int money = 10_0000_0000;
int years = 20;
int total = money*years；//-147483648，计算的时候溢出了
long total2 = money*years；//默认是int，转换之前己经存在问题了
long total3 = money*((long)years)；//先把一个数转换为Long，输出正确
变量与常量
类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词以外，后面的单词首字母大写 lastname lastName
类变量static：static 变量名 = 值
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
常量final：final 变量名 = 值
类名：首字母大写和驼峰原则: Man, GoodMan
方法名：首字母小写和驼峰原则:run(),runRun()
运算符
算术运算符
int a= 3;
int b=a++； //执行完这行代码后，先给b赋值，再自增
int c = ++a；//执行完这行代码前，先自增，再给b赋值
System.out.println(a); 5
System.out.println(b); 3
System.out.println(c); 5
幂运算
2^3 2*2*2 =8
double pow = Math.pow(2,3);
System.out.println(pow); 8.0
短路运算
int c= 5;
boolean d =(c<4)&&(c++<4);
System.out.println(d); false
System.out.println(c); 5//c<4为错，C++不运行，所以c不加1
位运算
A = 0011 1100
B = 0000 1101
A&B = 0000 1100
A/B = 0011 1101
A^B = 0011 0001
~B = 1111 0010
//<< 与 >>
<<: *2
>>: /2
2<<3 = 2*2*2*2 = 16
条件运算符
//x ? y：z
//如果x==true，则结果为y，否则结果为z
int score = 50;
String type = score <60 ? "不及格":“及格";
用户交互Scanner
通过Scanner 类来获取用户的输入。
基本语法：Scanner s = new Scanner(System.in)；注意：使用之前需要导包 import java.util.Scanner;
通过 Scanner 类的next()与nextLine()方法获取输入的字符串，读取前需要使用hasNextO与hasNextLine()判断是否还有输入的数据。
next()与nextLine()的区别：
next():
1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白，next()方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
4、next() 不能得到带有空格的字符串。
//创建一个扫描器对象，用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用next方式接收：“);
//判断用户有没有输入字符串
if(scanner.hasNext()){
// 使用next方式接收
String str = scanner.next();
System.out.println("输出的内容为："+str);
}
//凡是属于IO流的类如果不关闭会一直占用资源.要养成好习惯用完就关掉
scanner.close();
nextLine():
1、以Enter为结束符，也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。
注意：另外还有nextInt和hasNextInt、nextDouble和hasNextDouble、nextFloat和hasNextFloat等等
//nextInt和hasNextInt
int i =0;
System.out.println(“请输入整数：“);
//如果...那么
if (scanner.hasNextInt()){
i = scanner.nextInt();
System.out.println("整数数据："+ i);
}else {
System.out.println("输入的不是整数数据！");
}
小练习：输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入
Scanner scanner = new Scanner(System.in);
//和
double sum = 0;
//计算输入了多少个数字
int m = 0;
//通过循环判断是否还有输入，并在里面对每一次进行求和和统计
while (scanner.hasNextDouble()){
double x = scanner.nextDouble();
m =m+ 1;//m++
sum =sum + x;
System.out.println("你输入了第"+m+"个数据，然后当前结果sum="+sum);
}
System.out.println(m +“个数的和为”+ sum);
System.out.println(m +“个数的平均值是”+（sum / m));
scanner.close();
switch多选择结构
switch 语句中的变量类型可以是: byte、 short、 int 或者 char。
从 Java SE7开始，switch 支持字符串(String)类型
同时case 标签必须为字符串常串或字变量。
switch(expression){
case value :
//语句
break；//可选
case value :
//语句
break;//可选
//可以有任意数量的case语句
default ：//可选
//语句
}
do...while 循环
对于while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
While和do-While的区别:
while先判断后执行。do...while是先执行后判断!
do...while总是保证循环体会被至少执行一次！
练习：用for循环输出1-1000之间能被5整除的数，并且每行输出3个
for (int i = 0; i <= 1000; i++){
if (i%5==0){
System.out.print(i+"\t");
}
if(i%(5*3)==0){//每行
System.out.println();
//System.out.print("\n");
}
}
练习：九九乘法表打印
1.先打印第一列
2.把固定的1再用一个循环包起
3.去掉重复项，i<=j
4.调整样式
for (int j = 1; j <= 9; j++) {
for (int i = 1; i <= j; i++) {
System.out.print(j+"*"+i+"="+(j*i）+ "\t");
}
System.out.println();
增强for循环
用于数组或集合的增强型for 循环。Java 增强 for 循环语法格式如下:
for（声明语句：表达式）
//代码句子
例如：遍历数组并打印
for(int array:arrays){
System.out.printlnz(array)
}
声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型相匹配，其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
参数
函数重载
定义：在一个类中，有相同的函数名称，但形参不同的函数
方法的重载的规则：
1.方法名称必须相同。
2.参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。
3.方法的返回类型可以相同也可以不相同。
4.仅仅返回类型不同不足以成为方法的重载。
可变参数
方法中传递同类型的可变参数：在方法声明中，指定参数类型后加一个省略号(···）
注意：一个方法中只能指定一个可变参数，并且它必须是方法的最后一个参数，任何普通的参数必须在它之前声明。
public static void printMax(double... numbers) {
if (numbers.length == 0) {
System.out.println("No argument passed");
return;
}
double result = numbers[e];
//排序！
for (int i可；i< numbers.length;i++){
if (numbêrs[i] > result) {
result = numbers[i];
}
}
System.out.println("The max value is " + result);
}
递归
调用次数过多影响性能
//求10!
public static void main(String[] args) {
System.out.println(f(10));
}
public static int f(int n){
if (n==1){
return 1;
}else{
return n*f(n-1);
}
}
数组
arrays包
用于操作数组的各种方法（排序、搜索等），数组为空则抛出异常。
数组的工具类java.util.Arrays。
Arrays类中的方法都是static修饰的静态方法，可以直接使用类名进行调用，而”不用“使用对象来调用（注意：是“不用”而不是“不能”）。
具有以下常用功能：
给数组赋值：通过 fill 方法。
对数组排序：通过sort方法，按升序。
比较数组：通过equals方法比较数组中元素值是否相等。
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
//打印输出数组toString
public static void main(String[] args) {
int[l a = {1,2,3,4,9090,31231,543,21,3,23];
System.out.println(a);// [I@4554617c]
//打印数组元素Arrays.toString
System.out.println(Arrays.toString(a));//数组必须toString转化为字符才能输出
}
//数组排序sort
public static void main(String[] args) {
int[l a = {1,2,3,4,9090,31231,543,21,3,23};
//打印数组元素Arrays.tostring
//System.out.printLn(Arrays.toString(a));
Arrays.sort(a)；//数组进行排序
System.out.println(Arrays.toString(a));
}
面向对象
面向过程与面向对象的区别：
面向过程思想：步骤清晰简单，第一步做什么，第二步做什么....适合处理一些较为简单的问题。
面向对象思想：分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。
最后，才对某个分类下的细节进行面向过程的思索。
适合处理复杂的问题，适合处理需要多人协作的问题。
注意：对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观
操作，仍然需要面向过程的思路去处理。
面向对象编程的本质：以类的方式组织代码，以对象的组织(封装)数据。
三大特性:封装、继承、多态
从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板。
类与对象
关系
类：类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
动物、植物、手机、电脑.…...Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为。
对象：对象是抽象概念的具体实例
张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。
能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。
创建与初始化对象
new关键字创建对象：使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的
调用。
属性：静态的属性
方法：动态的行为
//学生类
public class Student {
//属性：字段
String name; //null
int age; //0
//方法
public void study(){
System.out.println(this.name+"在学习");
}
}
public class Application {
public static void main(String[] args) {
//类：抽象的，实例化
//类实例化后会返回一个自己的对象！
//student对象就是一个Student类的具体实例！
Student xiaoming = new Student();
Student xh = new Student();
xiaoming.name ="小明";
xiaoming.age = 3;
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
}
}
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:
1.必须和类的名字相同
2.必须没有返回类型,也不能写void
//java ---> class
public class Person (
//一个类即使什么都不写，它也会存在一个方法
//显示的定义构造器
String name;
//1、按用new关键字，本质是在调用构造器
//2、用来初始化值
public Person(){
}
//有参构造：一旦定义了有参构造，无参就必须显示定义
public Person(String name){
this.name = name;
}
//有参构造使用举例
//一个项目应该只存一个main方法
public class Application {
public static void main(String[] args){
//new实例化了一个对象
Person person = new Person("张三");
System.out.println(person.name);
}
}
构造器：
1.和类名相同
2.没有返回值
作用：
1.new 本质在调用构造方法
2.初始化对象的值
注意点：
1.定义有参构造之后，如果想使用无参构造，定义一个无参的构造
Alt + Insert 构造器快捷键
方法
方法的定义
修饰符 返回值类型 方法名 （···）{
// 方法体
return 返回值；
}
public String sayHello(){
return "hello,world";
}
public int max(int a, int b)
public int max(int a,int b){
return a>b?a：b；//三元运算符!
}
break和return的区别：
break：跳出switch，结束循环（continue结束一次循环）
return：方法结束，返回一个结果
抛出异常
public void readFile(String file) throws IOExceptidn{}
方法的调用
静态与非静态
静态方法： 和类一起加载的
返回类型之前加上static
//两个Java类
//学生类
public class Student {
//非静态方法
public static void say(){
System.out.println("学生说话了");
}
public class Demo02 {
public static void main(String[] args) {
Student.say();
}
}
非静态方法：类实例化 之后才存在
//两个Java类
//学生类
public class Student {
//静态方法
public void say(){
System.out.println("学生说话了");
}
public class Demo02 {
public static void main(String[] args) {
//实例化这个类 new
//对象类型对象名= 对象值;
Student student = new Student();
student.say();
}
}
值传递与地址传递
值传递
public class Demo04 {
public static void main(String[] args) {
int a = l;
System.out.println(a);//1
Demo04.change(a);
System.out.println(a);//1
}
//返回值为空
public static void change(int a){
a = 10;
}
}
地址传递：对象，本质还是值传递
public class Demoes {
public static void main(String[] args) {
Perosn perosn = new Perosn();
System.out.println(perosn.name)；//null
Demoe5.change(perosn);
System.out.println(perosn.name)；//张三
}
public static void change(Perosn perosn){
//peresn是一个对象：指向的--->Perosn perosn= new Perosn()；这是一个具体的人，可以改变属性！
perosn.name ="张三";
}
}
//定义了一个Perosn类，有一个属性：name
class Rerosn{
String name; //null
}
封装
程序设计追求“高内聚，低耦合”。
高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）：禁止直接访问一个对象中的数据，而是通过操作接口来访问，这称为信息隐藏。 属性私有，编写方法get/set得
到。
//类 private：私有
public class Student {
//属性私有
private String name;//名字
private int id;//学号
private char sex;//性别
//提供一些可以操作这个属性的方法！
// 提供一些public 的get、set方法
//get 获得这个数据
public String getName(){
return this.name;
}
//set 给这个数据设置值
public void setName(String name){
this.name = name;
}
}
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("张三");
System.out.println(s1.getName());
}
}
此外，还可避免设置一些不合法的数据
public void setAge(int age) {
if (age>12e 11 agece){//不合汹
this.age = 3;
}else {
this.age = age;
}
}
封装的好处：
提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
增加系统可维护
继承
继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类，子类是父类的扩展，使用关键字extends来表示。
java中类只有单继承，没有多继承！
object
在java中，所有的类，都默认直接或者间接继承object。
//Person 父类
public class Person /*extends Object*/ {
protected String name = "zhangsan";
//私有的东西无法被继承！
public void print(){
System.out.println("Person");
}
}
//Student 子类
public class Student extends Person {
private String name = "zhangsan";
public void print(){
System.out.println("Student");
}
public void test1(){
print();//Student
this.print();//Student
super.print(); //Person
}
}
public class Application {
public static void main(String[] args){
Student student = new Student();
student.test1();
}
}
this与super
this调用本体的构造，super调用父类的构造
//子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person {
public Student(){
//隐藏代码；调用了父类的无参构造
super();//调用父类的构造器，必须要在子类构造器的第一行
this();//标红报错
System.out.println("Student无参执行了");
}
}
super注意点：
1.super调用父类的构造方法，必在构造方法的第一个。
2.super 必须只能出现在子类的方法或者构造方法中！
3.super和 this不能同时调用构造方法！
super Vs this:
代表的对象不同：this：本身调用者这个对象
super：代表父类对象的应用
前提：this：没有继承也可以使用
super：只能在继承条件才可以使用
构造方法：this(）；本类的构造
super(）：父类的构造
方法重写
//重写都是方法的重写，和属性无关
public class B {
public static void test(){
System.out.println(“B=>test()");
}
}
//继承
public class A extends B{
//Override重写
@Override //注解：有功能的注释！
public void test() {
System.out.println("A=>test()");
}
}
public class Application {
public static void main(String[] args) {
//方法的调用只和左边，定义的数据类型有关
A a= new A():
a.test();//A
//父类的引用指向了子类
B b= new A();//子类重写了父类的方法
b.test();//B
}
}
//输出：
A=>test()
A=>test()
重写：需要有继承关系，子类重写父类的方法
1.方法名必须相同
2.参数列表列表必须相同
3.修饰符：范围可以扩大但不能缩小：public>Protected>Default>private
4.抛出的异常：范围，可以被缩小，但不能扩大； ClassNotFoundException -->Exception（大)
重写，子类的方法和父类必要一致；方法体不同。
为什么需要重写：
1.父类的功能，子类不一定需要，或者不一定满足。
Alt + Insert ：override;
多态
同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件：有继承关系
子类重写父类方法
父类引用指向子类对象
注意：多态是方法的多态，属性没有多态性。
//Student 能调用的方法都是自己的或者继承父类的！
Student s1 = new Student();
//Person 父类型，可以指向子类，但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
instanceof
(类型转换）引用类型，判断一个对象是什么类型
//0bject > String
//0bject > Person > Teacher
//0bject > Person > Student
Object object = new Student();
System.out.println(object instanceof Student); //true
System.out.println(object instanceof Person); //true
System.out.println(object instanceof Object); //true
System.out.println(object instanceof Teacher); //False
System.out.println(object instanceof String); //False
System.out.println("=========================");
Person person = new Student();
System.out.println(person instanceof Student); //true
System.out.println(person instanceof Person); //true
System.out.println(person instanceof Object); //true
System.out.println(person instanceof Teacher); //False
//System.out.println(person instanceof String)；//编译报错!
System.out.println("====================");
Student student = new Student();
System.out.println(student instanceof Student); //true
System.out.println(student instanceof Person); //true
System.out.println(student instanceof Object); //true
//System.out.println(student instanceof Teacher)；//编译报错!
//System.out.println(student instanceof String)； //编译报错！
类型转换
//类型之间的转化：父子
//高-->低
Person obj = new Student();
//student将这个对象转换为Student类型，就可以使用Student类型的方法了！
((Student) obj).go();
//子类转换为父类，可能丢失自己的本来的一些方法！
Student student = new Student();
student.go();
Person person = student;
1.父类引用指向子类的对象
2.把子类转换为父类，向上转型;
3.把父类转换为子类，向下转型；强制转换
4.方便方法的调用，减少重复的代码！
static
public class Person {
//2：赋初值~
{
System.out.println("匿名代码块");
}
//1：只执行一次~
static {
System.out.println("静态代码块");
}
//3
public Person(){
System.out.println("构造方法");
}
public static void main(String[] args) {
Person personl = new Person();
System.out.println("==============");
Person person2 = new Person();
}
}
输出结果：
静态代码块
匿名代码块
构造方法
==============
匿名代码块
构造方法
//静态导入包~
import static java.lang.Math.random;
public class Test {
public static void main(String[] args) {
System.out.println(random());
}
}
抽象类
abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类,那么该类就是抽象类。
抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。
接口
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范！自己无法写方法~专业的约束。约束和实现分离：面向接口编程
声明类的关键字是class，声明接口的关键字是interface。
接口中的常量类型为 public static final
//interface 定义的关键字
public interface UserService {
//接口中的所有定义其实都是抽象的 public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
//抽象类： extends~
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法
public class UserServiceImpl implements UserServiceI{
@Override
public void add(String name){
}
@Override
public void delete(String name){
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
}
//多继承
public interface TimeService{
void timer();
}
//多继承~利用接口实现多继承~
public class UserServiceImpl implements UserService, TimeService{
···
@Override
public void timer() {
}
}
异常
分类
检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就
发生了，这些异常在编译时不能被简单地忽略。
运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也
检查不到的。
Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。
Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception。
Error
Error类对象由Java 虑拟机生成并抛出出，大多数错误与代码编写者所执行的操作无关。
Java虚拟机运行错误（Virtual MachineError），当JVM不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。
这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。
Exception
在Exception分支中有一个重要的子类RuntimeException（运行时异常)
ArraylndexOutOfBoundsException（数组下标越界)
NullPointerException（空指针异常)
ArithmeticException（算术异常)
MissingResourceException （丢失资源)
ClassNotFoundException(找不到类）等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。
这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生;
Error和Exception的区别：
Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程；
Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。
异常处理机制
抛出异常
捕获异常
异常处理五个关键字
try, catch, finally, throw,throws
public class Test (
public static void main(String[] args) {
int a = 1;
int b = 0;
try { //try监控区域
System.out.println(a/b);
}catch (ArithmeticException e){
//catch 捕获异常
System.out.println("程序出现异常，变量b不能为0");
}finally { //处理善后工作
System.out.println("finally");//finaLly可以不要finalLy，假设IO，资源，关闭
}
}
}
public static void main(String[] args) {
int a= 1;
int b =0;
//假设要捕获多个异常：从小到大！
try {//try监控区域
System.out.println(a/b);
} catch (Error e){ //catch(想要捕获的异常类型！）捕获异常
System.out.println("Error");
} catch (Exception e){
System.out.println("Exception");
} catch (Throwable t){
System.out.println("Throwable");
} finally { //处理善后工作
System.out.println("finally");
}
}
//Ctrl + Alt + T异常快捷键
public class Test {
public static void main(String[] args) {
try {
new Test().test(1,0);
}catch (ArithmeticException e) {
e.printStackTrace();
}
}
//假设这方法中，处理不了这个异常。方法上抛出异常
public void test(int a,int b) throws ArithmeticException{
if(b==e){//throw throws
throw new ArithmeticException()；//主动的抛出异常，一般在方法中使用
}
}
}