【java】前八章：快速回忆

本文主要是介绍【java】前八章：快速回忆，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

不知不觉，Java已近学了接近两个月。课本也慢慢的翻到了第八章，总感觉什么都没学到，一直想停下来整理一下，那就今天

2021-10-23 09:38:03 星期六

java前八章复习总结（理论内容）

~~学的糊里糊涂的，没有代码经验，整理摘抄一些理论的东西，供自己参考，一定会有错误~~

第一章

简单了解java

java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点 [2] 。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等

工作原理
由四方面组成：
（1）Java编程语言
（2）Java类文件格式
（3）Java虚拟机
（4）Java应用程序接口（4）Java应用程序接口
具体一点，百度java简介

搭建java开发环境的基本步骤：

点击->百度搭建java开发环境的基本步骤
自己去看吧；一步一步跟着来还是很简单的。

第二章：基本数据类型及运算

java中一共有8中基本数据类型，并且每种数据类型所占的存储空间是固定的，这种特性也增加了java的可移植性，这一点和c语言c++是不同的，因为java是在**虚拟机（jvm）**上运行的，数据类型和操作系统以及硬件间的适配是通过虚拟机来实现的。

Java中的8中基本数据类型：byte short int long float double boolean char

byte short int long都表示有符号数，即最高位是用来表示正负的，0表示正，1表示负；
byte占一个字节，表示范围：-~2^7-1 即-128~127
short 占两个字节，表示范围：–~2^15-1
int 占四个字节，表示范围：-~2^31-1
long 占八个字节，表示范围：-~2^63-1
float 占四个字节， double占八个字节
char 占两个字节，一个char代表一个unicode码,范围：0~2^16
boolean 占一个字节，只有true和false两个值

其中使用和用法注意和c语言差不多包括但不限于（类型转换与运算、隐式类型转换、显式类型转换）等。

java运算符

第1关：算数运算符

点击查看代码

package step1;
import java.util.Scanner;
public class Cal {public static void main(String[] args) {/*********start*********/System.out.println("请输入第一个整数");System.out.println("请输入第二个整数");Scanner sc=new Scanner(System.in);int a=sc.nextInt();int b=sc.nextInt();int c,d,e,f,g;c=a+b;d=a-b;e=a*b;f=a/b;g=a%b;System.out.println("两数相加的结果为："+c);System.out.println("两数相减的结果为："+d);System.out.println("两数相乘的结果为："+e);System.out.println("两数相除的结果为："+f);System.out.println("两数取余数的结果为："+g);/*********end*********/}}

测试用例：

第2关：关系运算符

点击查看代码

package step2;
import java.util.Scanner;
public class Relative {public static void main(String[] args) {Scanner sc=new Scanner(System.in);int a=sc.nextInt();int b=sc.nextInt();/*********start*********/System.out.println("a==b="+(a==b));System.out.println("a!=b="+(a!=b));System.out.println("a>b="+(a>b));System.out.println("a<b="+(a<b));System.out.println("b>=a="+(b>=a));System.out.println("b<=a="+(b<=a));/*********end*********/}}

第一次测试会输入数据：20,34；
需要你的程序输出：

a==b=false
a!=b=true
a>b=false
a<b=true
b>=a=true
b<=a=false

第3关：逻辑运算符

什么是逻辑运算符
逻辑运算符用于测试两个操作数之间的逻辑关系，且这两个操作数必须是布尔类型的（如关系表达式），得到的结果也是布尔类型的，通过逻辑运算符连接的结果为boolean类型的变量或表达式叫做逻辑表达式

我们可以从“投票选举”的角度理解逻辑运算符：
与：要求所有人都投票同意，才能通过某议题；
或：只要求一个人投票同意就可以通过某议题；
非：某人原本投票同意，通过非运算符，可以使其投票无效；
异或：有且只能有一个人投票同意，才可以通过某议题

点击查看代码

package step3;
import java.util.Scanner;
public class testLogic {public static void main(String[] args) {Scanner sc=new Scanner(System.in);boolean a=sc.nextBoolean();boolean b=sc.nextBoolean();boolean c=sc.nextBoolean();     /*********start  *********/  System.out.println(!a);      System.out.println(a && b &&c);          System.out.println( c || b );	       System.out.println( !b  );        /*********end  *********/}
}

测试说明按照相关要求编写程序后，我会对你的程序进行测试。预期输入：

true，false，true

预期输出：
false
false
true
true

第5关：运算符的优先级

java特有的运算符（instancceof）<不知道是不是特有的，反正对一次见>

双目运算实例运算符，用于判断指定对象是否是一个特定的类型（类类型或接口类型<第5章内容>）
例如：

		obj instanceof String其中，obj是一对像实例，若obj是string类型实例，则运算结果是true，否则为false。

String，java类，存储字符串类型，第七章

2.5练一练

1.输出java基本数据类型的取值范围

提示：java语言为基本数据类型提供了相应的包装类，分别是Boolean，Byte，Character，Short。Integer，Long，Float，Double。包装类中封装了静态成员变量MIN_VALUE与MAX_VALLUE，分别表达基本的数据类型所能表示的最小值和最大值。

点击查看代码


public class HOME {public static void main(String[] args) {// TODO Auto-generated method stubSystem.out.println("Boolean最大值：true" +"最小值：flase");    //这里好像不是这么写的，管他呢，知道就行 ，不太会写代码System.out.println("byte的取值范围：");System.out.println(Byte.MIN_VALUE+"~"+Byte.MAX_VALUE);System.out.println("Character的取值范围：");System.out.println((int)Character.MIN_VALUE+"~"+(int)Character.MAX_VALUE);System.out.println("short的取值范围：");System.out.println(Short.MIN_VALUE+"~"+Short.MAX_VALUE);System.out.println("Integer的取值范围：");System.out.println(Integer.MIN_VALUE+"~"+Integer.MAX_VALUE);System.out.println("Long的取值范围：");System.out.println(Long.MIN_VALUE+"~"+Long.MAX_VALUE);System.out.println("Float的取值范围：");System.out.println(Float.MIN_VALUE+"~"+Float.MAX_VALUE);System.out.println("Double的取值范围：");System.out.println(Double.MIN_VALUE+"~"+Double.MAX_VALUE);}}

第三章：结构化程序设计（面向过程程序化设计）

顺序结构
分支结构
循环结构

和c一样，不写了

练一练：求π的近似值

点击查看代码


public class HOME4 {public static void main(String[] args) {System.out.println("PI = ");float k = 1;float b = 1;float c = 0;while((1/b)>1e-6) {c += k*1/b;b +=2;k = -k;}System.out.println(4*c);}}

第四章：数组

了解并学会使用下图所有内容即可

具体在这Java基础语法（六）——数组的定义与使用，，非常具体 c语言同样适用

第五章：类与类的继承（应该是非常重要的一章）

面向对象的基本概念

面向对象: 把涉及到的对象抽离出来，然后考虑对象之间的关系构建整个项目，面向对象的设计是一种提供符号设计系统的面向对象的实现过程。，面向对象是以领域对象开发为指导。

举例说明（可能不太正确）:
把大象装进冰箱

面向过程的思维:

打开冰箱
装进大象
关闭冰箱

面向对象的思想：

冰箱打开
冰箱存储
冰箱关闭

下面，我们从对象，开始了解上图所有内容，

1.对象的定义

含义

对象是类的实例，拥有具体的状态行为。例如Student是类（描述同类对象共同的状态和行为），而对象是指一个具体的Student个体，对象是动态的，每个对象都拥有一个从创建，运行到消亡的动态过程。同时对象也同样占内存空间，存储对象的状态数据，即成员变量。（比如文海同学<对象>的身高<成员变量>）

		//定义方法：类名 对象名；//或者类名 对象名 = new 类名( 参数列表 )；Student a；Student a = new Student（）；

组成

和类中成员变量以及方法有关（好比一个人，有多种属性：姓名、性别、年龄、体重等，都有多种行为：吃饭、走路等）对象=属性+行为

模板

没啥好说的，模板就是类，那么介绍一下类

什么是类：类不是一个实体的存在,比如手机这个类,手机并不是实体,如iPhone7 才是一个实体,手机并不是,类只是一个模子,确定对象将会有的特征(属性)和行为(方法)
类的组成: 属性和方法（如果你是从上看到这，就不会有对此处的疑问）
类的定义方法：

		定义类名 public class 类名{//[初始化模块](https://www.cnblogs.com/wp456/p/3233186.html "初始化模块")的定义【初始化模块首先被执行】//定义属性（成员变量）的部分编写类的属性 属性1的类型 属性1;属性2的类型 属性2;..........属性n的类型 属性n;//定义方法（行为）的部分;编写类的方法 方法1;方法2;........方法n;}

例如：手机类的定义：

点击查看代码

public class Telphone {//1.定义一个类//2.定义属性(成员变量)float screen;//屏幕float cpu;//cpu大小float mem;//内存大小//3.定义方法
void call(){System.out.println("Telphone有打电话的功能!");
}
void sendMessage(){System.out.println("screen:"+ screen + "cpu:"+ cpu + "mem:"+ mem +"Telphone有发短信的功能");
}
}

成员变量与局部变量的区别和c差不多，就不过多赘述了，但是修饰符需要重点掌握

特点

封装：封装是一种信息屏蔽技术，通过封装讲对象的状态和行为结合成一个独立的模块，尽可能隐藏对象的内部细节（包括对象内部的私有状态以及行为的具体实现）。封装的目的在于把对象的设计者和使用者分开，作为使用者不需要了解对象内部的实现细节，只需要使用设计者提供的行为方法实现功能即可。

private 关键字
是一个权限修饰符。
用于修饰成员(成员变量和成员函数)
被私有化的成员只在本类中有效。

常用之一：
将成员变量私有化，对外提供对应的set ,get方法对其进行访问。提高对数据访问的安全性。

private ：私有，是一个权限修饰符。用于修饰成员。
私有的内容只在本类中有效。
注意：私有仅仅是封装的一种体现。

继承：继承表示类之间的层次关系。继承关系使得子类的对象可以共享父类对象的状态（属性<非私有成员变量>）和行为（方法<除构造方法外>）

例如：
父类：Telphone

点击查看代码

package HOME9;public class Telphone {//2.定义属性(成员变量)float screen;//屏幕private float cpu;//cpu大小float mem;//内存大小//3.定义方法void call(){System.out.println("Telphone有打电话的功能!");}void sendMessage(){System.out.println("screen:"+ screen + "cpu:"+ cpu + "mem:"+ mem +"Telphone有发短信的功能");}}

子类：iPhone 点击查看代码

package HOME9;public class iPhone extends Telphone {}

测试：

public static void main(String[] args) {iPhone apple = new iPhone();//子类可以继承父类非private属性（成员变量）和方法（非构造方法）//apple.cpu =5;如果有此行，则报错‘The field Telphone.cpu is not visible’apple.mem = 6;apple.screen = 7;apple.call();apple.sendMessage();}

结果：

多态：多态性是指同名的行为方法可在不同类中具有不同的实现。在子类继承父类的同时，类的方法实现可以进行扩充或者修改，使子类的同名方法更适合子类的对象

多态的实现的必要条件:(重点要记下)

存在继承关系
存在方法重写
父类引用指向子类对象

多态的优点：

简化了代码
提高了维护性和扩展性

例如：

点击查看代码

public class DuoTaiDemo01 {public static void main(String[] args) {Man m = new Doctor();m.cut();m = new Director();m.cut();m = new Hairdresser();m.cut();}
}class Man {public void cut() {System.out.println("我是man, 我也不知道怎么cut");}
}class Doctor extends Man {public void cut() {System.out.println("动手术");}
}class Director extends Man {@Overridepublic void cut() {System.out.println("暂停");}
}class Hairdresser extends Man {@Overridepublic void cut() {System.out.println("剪头发");}
}

重点来了，拿笔记下

多态访问成员的特点:

Father father = new Son()

左边类型 ————右边类型

成员变量:

编译时期看左边的类型,如果左边类型中没有变量,编译报错
运行时期看左边类型,左边类型的变量的值就是运行的结果
编译看左边,执行看左边

成员方法:

编译看左边,执行看右边

构造方法:

1.多态访问子类构造方法会先访问父类构造方法

2.帮助子类初始化父类继承过来的成员

静态方法:

编译看左边,执行看左边

举例代码如下：

package HOME9;public class DuoTaiDemo02 {public static void main(String[] args) {Fu fu = new Zi();System.out.println(fu.num); // 10fu.method();fu.show();}
}class Fu {int num = 10;public void method() {System.out.println("Fu.method()");}public static void show() {System.out.println("Fu.show");}
}class Zi extends Fu {int num = 20;@Overridepublic void method() {System.out.println("Zi.method()");}public static void show() {System.out.println("Zi.show");}}

结果：

向上转型（自动转换）

格式：<父类型> <引用变量名> = new <子类型>();
特点：
子类转为父类父类的引用指向子类对象。可以理解为自动进行类型转换(和自动类型转换完全是两个概念)
此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法
此时通过父类引用变量无法调用子类特有的属性和方法
解决方法（instanceof + 向下转型）

向下转型（强制转换）

格式：<子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;
特点：
父类转为子类，父类引用转为子类对象。可以理解为强制类型转换
在向下转型的过程中，如果没有转换为真实子类类型，会出现类型转换异常

异常名称: 类型转换异常 java.lang.ClassCastException
产生原因: 在向下转型的过程中,没有转换成真实的类型
解决办法: 在每次向下转型之前做一个类型的判断

类型判断的语法: instanceof
左边对象 instanceof 类名这个表达式的结果是boolean类型
测试它左边的对象是否是它右边的类的实例

多态的弊端可以使用instanceof关键字+向下转型来解决
我们知道我们需要对父类的所有子类做逐一判断,违背了开闭原则
为了开闭原则我们还是可以继续开发,但是如果这个父类引用是Object呢?
无法做逐一个判断,安全隐患一致存在,可以考虑是泛型。

举例1代码如下所示：

package HOME9;public class DuoTaiDemo02 {public static void main(String[] args) {Car c = new Benz();c.run();c = new BYD();c.run();if (c instanceof Benz) {Benz benz = (Benz) c;benz.leakOli();} else if (c instanceof BMW) {BMW b = (BMW) c;b.fillOil();} else  if (c instanceof BYD) {BYD byd = (BYD) c;byd.electric();}Object obj = new BMW();}
}class Car {public void run() {System.out.println("Car.run()");}
}class BMW extends Car {@Overridepublic void run() {System.out.println("BMW.run()");}public void fillOil() {System.out.println("加油");}
}class Benz extends Car {@Overridepublic void run() {System.out.println("Benz.run()");}public void leakOli() {System.out.println("漏油");}
}class BYD extends Car {@Overridepublic void run() {System.out.println("BYD.run()");}、*------*、public void electric() {System.out.println("充电");}
}

结果：

第六章：多态与内部类

多态（第五章写的有点多了，这章就不写了）：

主要内容（向上转型，向下转型，instanceof运算符）

抽象类和抽象方法

抽象类：是对具体类的抽象，用来完成类框架的共享的公共设计，具体子类继承并扩展公共设计（~~自认为像多态~~），
抽象类不能实例化对象
一、抽象（abstract）的使用

当父类的某些方法不确定时，可以用abstract关键字来修饰该方法[抽象方法]，用abstract来修饰该类[抽象类]。

我们都知道，父类是将子类所共同拥有的属性和方法进行抽取，这些属性和方法中，有的是已经明确实现了的，有的还无法确定，那么我们就可以将其定义成抽象，在后日子类进行重用，进行具体化。这样，抽象类也就诞生了。

例如，定义了“动物”父类，其中“动物名称”和“动物年龄”属性已经明确了，但是“动物叫”的方法没有明确，此时就可以将“动物叫”定义为抽象方法。

所以，抽象类是为了把相同的但不确定的东西的提取出来，为了以后的重用。定义成抽象类的目的，就是为了在子类中实现抽象类。
例子：

package javastudy;public class AbstractDemo1 {public static void main(String[] args) {// TODO Auto-generated method stub}
}// 这就是一个抽象类
abstract class Animal {String name;int age;// 动物会叫public abstract void cry(); // 不确定动物怎么叫的。定义成抽象方法，来解决父类方法的不确定性。抽象方法在父类中不能实现，所以没有函数体。但在后续在继承时，要具体实现此方法。
}// 抽象类可以被继承
// 当继承的父类是抽象类时，需要将抽象类中的所有抽象方法全部实现。
class cat extends Animal {// 实现父类的cry抽象方法public void cry() {System.out.println("猫叫:");}
}

接口

接口与抽象类似，是对类的一种抽象，指明了类所具备的功能，接口描述的是一种能力。例如组织一次会议有接待参与人员的需求。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口与类的区别和接口的特性

点这->Java 接口（~~我没看明白~~）

课本上的解释：抽象类更主要的是体现了类模板的设计思想，定义其子类的通用特性及部分已近实现的共有功能。抽象类与子类实现了“一般到特殊”之间的关系（~~多态是不是一种方法，而抽象类就是实现此方法的手段，包括接口也是？？~~）

接口中的默认方法（default）

public interface MyInterface {// 普通接口方法default void defaultMethod() {// 默认方法}
}

为什么需要默认方法

在Java8之前，接口只能有抽象方法。如果不强制所有实现类创建新方法的实现，就不能向现有接口添加新功能。

Java8新增默认方法的原因非常明显。

在一个典型的基于抽象的设计中，一个接口有一个或多个实现类。接口要新增方法，所有的实现都要新增这个方法的实现。否则就不满足接口的约束。

默认接口方法是处理此问题的解决方案。在接口添加默认方法不需要修改实现类，接口新增的默认方法在实现类中直接可用。
例如：

点击查看代码

interface MobilePhone {/*** 获取手机品牌*/String getBrand();/*** 获取手机颜色*/String getColor();/*** 获取手机长度(毫米)*/Double getLength();/*** 设置手机时间*/default String setTime(String newTime) {return "time set to " + newTime;}/*** 对getLength方法进行拓展，返回厘米为单位的长度*/default String getLengthInCm() {return getLength() / 10 + "cm";}
}

点击查看代码

public class DefaultTests implements MobilePhone {@Overridepublic String getBrand() {return "iphone";}@Overridepublic String getColor() {return "red";}@Overridepublic Double getLength() {return 150.00;}@Testpublic void defaultTest() {System.out.println(setTime("8:00 am"));System.out.println(getLengthInCm());}
}

结果：

接口中的静态方法

接口中的静态方法和类中定义的静态方法一样，不属于特定对象，所以它们不是实现接口的api的一部分，必须使用InterfaceName.staticMethod来调用它们。

为了理解静态方法如何在接口中工作，让我们看一个实例:

interface NewInterface { // 静态方法static void hello() { System.out.println("Hello, New Static Method Here"); } // 抽象方法 void overrideMethod(String str); 
} // 实现类
public class InterfaceDemo implements NewInterface { public static void main(String[] args) { InterfaceDemo interfaceDemo = new InterfaceDemo(); // 调用接口静态方法 NewInterface.hello(); // 调用被覆写后抽象方法 interfaceDemo.overrideMethod("Hello, Override Method here"); } // 实现接口方法@Overridepublic void overrideMethod(String str) { System.out.println(str); }

为什么接口要支持静态方法

接口中的静态方法背后的思想是提供一种简单的机制，允许通过将相关的方法内聚在接口中，而不必创建新的对象。

抽象类也可以做同样的事情。主要的区别在于抽象类可以有构造函数、成员变量和方法。

推荐把和只和接口相关的静态utility方法放在接口中（提高内聚性），而不需要额外创建一些utility类专门去放置这些方法。

内部类

Java 一个类中可以嵌套另外一个类，语法格式如下：

class OuterClass {   // 外部类// ...class NestedClass { // 嵌套类，或称为内部类// ...}
}

要访问内部类，可以通过创建外部类的对象，然后创建内部类的对象来实现。

嵌套类有两种类型：

非静态内部类
静态内部类

非静态内部类

非静态内部类是一个类中嵌套着另外一个类。它有访问外部类成员的权限，通常被称为内部类。

由于内部类嵌套在外部类中，因此必须首先实例化外部类，然后创建内部类的对象来实现。
实例：

点击查看代码

class OuterClass {int x = 10;class InnerClass {int y = 5;}
}public class MyMainClass {public static void main(String[] args) {OuterClass myOuter = new OuterClass();OuterClass.InnerClass myInner = myOuter.new InnerClass();System.out.println(myInner.y + myOuter.x);}
}

以上实例执行输出结果为：

私有的内部类
内部类可以使用 private 或 protected 来修饰，如果你不希望内部类被外部类访问可以使用 private 修饰符：

实例：

点击查看代码

class OuterClass {int x = 10;private class InnerClass {int y = 5;}
}public class MyMainClass {public static void main(String[] args) {OuterClass myOuter = new OuterClass();OuterClass.InnerClass myInner = myOuter.new InnerClass();System.out.println(myInner.y + myOuter.x);}
}

报错：

错误提示信息’The type OuterClass.InnerClass is not visible‘

静态内部类

静态内部类可以使用 static 关键字定义，静态内部类我们不需要创建外部类来访问，可以直接访问它：
实例：

点击查看代码

class OuterClass {int x = 10;static class InnerClass {int y = 5;}
}public class MyMainClass {public static void main(String[] args) {OuterClass.InnerClass myInner = new OuterClass.InnerClass();System.out.println(myInner.y);}
}

以上实例执行输出结果为：

~~好像还有一个匿名内部类，看不懂~~

第七章：java常用类与枚举类

常用类：object类、String类、StringBuilder类、StringBuffer类、Math类、Random类、Calendar类、SimpleDateFormat类、枚举类

object类

String类

StringBuilder和StringBuffer类

Math类

Random类

Calendar类和Date类和SimpleDateFormat类

枚举类

第八章：正则表达式与异常处理

正则表达式

正则表达式定义了字符串的模式。

正则表达式可以用来搜索、编辑或处理文本。

正则表达式并不仅限于某一种语言，但是在每种语言中有细微的差别。

异常处理

声明自定义异常

在 Java 中你可以自定义异常。编写自己的异常类时需要记住下面的几点。

所有异常都必须是 Throwable 的子类。
如果希望写一个检查性异常类，则需要继承 Exception 类。
如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。

可以像下面这样定义自己的异常类：

		class MyException extends Exception{}

继承Exception 类来创建的异常类是检查性异常类。
下面的 InsufficientFundsException 类是用户定义的异常类，它继承自 Exception。
一个异常类和其它任何类一样，包含有变量和方法。

**实例：**以下实例是一个银行账户的模拟，通过银行卡的号码完成识别，可以进行存钱和取钱的操作。

InsufficientFundsException.java 文件代码

点击查看代码

// 文件名InsufficientFundsException.java
import java.io.*;//自定义异常类，继承Exception类
public class InsufficientFundsException extends Exception
{//此处的amount用来储存当出现异常（取出钱多于余额时）所缺乏的钱private double amount;public InsufficientFundsException(double amount){this.amount = amount;} public double getAmount(){return amount;}
}

为了展示如何使用我们自定义的异常类，

在下面的 CheckingAccount 类中包含一个 withdraw() 方法抛出一个 InsufficientFundsException 异常。

CheckingAccount.java 文件代码：

点击查看代码

// 文件名称 CheckingAccount.java
import java.io.*;//此类模拟银行账户
public class CheckingAccount
{//balance为余额，number为卡号private double balance;private int number;public CheckingAccount(int number){this.number = number;}//方法：存钱public void deposit(double amount){balance += amount;}//方法：取钱public void withdraw(double amount) throwsInsufficientFundsException{if(amount <= balance){balance -= amount;}else{double needs = amount - balance;throw new InsufficientFundsException(needs);}}//方法：返回余额public double getBalance(){return balance;}//方法：返回卡号public int getNumber(){return number;}
}

下面的 BankDemo 程序示范了如何调用 CheckingAccount 类的 deposit() 和 withdraw() 方法。

BankDemo.java 文件代码：

//文件名称 BankDemo.java
public class BankDemo
{public static void main(String [] args){CheckingAccount c = new CheckingAccount(101);System.out.println("Depositing $500...");c.deposit(500.00);try{System.out.println("\nWithdrawing $100...");c.withdraw(100.00);System.out.println("\nWithdrawing $600...");c.withdraw(600.00);}catch(InsufficientFundsException e){System.out.println("Sorry, but you are short $"+ e.getAmount());e.printStackTrace();//将错误行打印出来，exception中的一个方法}}
}

编译上面三个文件，并运行程序 BankDemo，得到结果如下所示：

捕获异常

使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。

try/catch代码块中的代码称为保护代码，使用 try/catch 的语法如下：

		try{// 程序代码}catch(ExceptionName e1){//Catch 块}或者 多重捕获：异常子类在上，父类在下
try{
// 程序代码
}catch(异常类型1 异常的变量名1){// 程序代码
}catch(异常类型2 异常的变量名2){// 程序代码
}catch(异常类型3 异常的变量名3){// 程序代码
}

实例：

点击查看代码

public class ExcepTest{public static void main(String args[]){int a[] = new int[2];try{System.out.println("Access element three :" + a[3]);}catch(ArrayIndexOutOfBoundsException e){System.out.println("Exception thrown  :" + e);}finally{a[0] = 6;System.out.println("First element value: " +a[0]);System.out.println("The finally statement is executed");}}
}

结果：

注意下面事项：

catch 不能独立于 try 存在。
在 try/catch 后面添加 finally 块并非强制性要求的。
try 代码后不能既没 catch 块也没 finally 块。
try, catch, finally 块之间不能添加任何代码。

完！太耗时间了，希望以后能用到吧随笔中有许多采用（~~其实大多都是抄的~~），写这篇随笔目的之一也是为了整理一下网上真正我现阶段所需要的！现在问题是我代码经验太少了不会用这些东西，希望上完实践课之后会有更深的理解和运用，毕竟没使用过，就没有底气写一些真正自己所认为的东西

2021-10-24 19:04:39 星期日 > 本文主要内容来自，

菜鸟教程，
W3SCHOOL.COM
https://blog.csdn.net/zhouym_/article/details/89421577
https://www.cnblogs.com/ibelieve618/p/6410910.html
https://www.cnblogs.com/wuhenzhidu/p/anonymous.html
https://blog.csdn.net/qq_39754721/article/details/94736251
https://www.cnblogs.com/weink1215/p/4433790.html
https://blog.csdn.net/weixin_42110638/article/details/85467987
《java项目案例开发入门》—清华出版社

这篇关于【java】前八章：快速回忆的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！