【java】快速入门：前八章内容总结

zoukankan html css js c++ 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 stub System.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 { @Override public void cut() { System.out.println("暂停"); } } class Hairdresser extends Man { @Override public void cut() { System.out.println("剪头发"); } }
重点来了，拿笔记下

多态访问成员的特点:

Father father = new Son()

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

成员变量:
1. 编译时期看左边的类型,如果左边类型中没有变量,编译报错
2. 运行时期看左边类型,左边类型的变量的值就是运行的结果
3. 编译看左边,执行看左边
成员方法:

编译看左边,执行看右边

构造方法:

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

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

静态方法:

编译看左边,执行看左边

举例代码如下：
```
package HOME9;

public class DuoTaiDemo02 {
	public static void main(String[] args) {
		Fu fu = new Zi();
		System.out.println(fu.num); // 10
		fu.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;

	@Override
	public 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 {
	@Override
	public void run() {
		System.out.println("BMW.run()");
	}
	
	public void fillOil() {
		System.out.println("加油");
	}
}

class Benz extends Car {
	@Override
	public void run() {
		System.out.println("Benz.run()");
	}
	
	public void leakOli() {
		System.out.println("漏油");
	}
}

class BYD extends Car {
	@Override
	public 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 { @Override public String getBrand() { return "iphone"; } @Override public String getColor() { return "red"; } @Override public Double getLength() { return 150.00; } @Test public 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"); 
    } 
  
    // 实现接口方法
    @Override
    public 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) throws InsufficientFundsException { 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("
Withdrawing $100...");
         c.withdraw(100.00);
         System.out.println("
Withdrawing $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项目案例开发入门》---清华出版社
查看全文

相关阅读:
python_django_分页
 python_django_中间件
 python_django_静态文件
 Django项目基础配置和基本使用
 python_django__验证码
 python_django_The requested URL /sunck/login/sunck/showmain/ was not found on this server.错误
 python_django_template_url反向解析
 python_django_template模块
 Andrew Ng机器学习算法入门(一):简介
 Vue.js 条件语句

原文地址：https://www.cnblogs.com/zhujiaozhu/p/15448882.html

【java】快速入门：前八章内容总结

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

第一章

简单了解java

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

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

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

java运算符

第1关：算数运算符

第2关：关系运算符

第3关：逻辑运算符

第5关：运算符的优先级

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

2.5练一练

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

第四章：数组

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

面向对象的基本概念

1.对象的定义

含义

组成

模板

特点

多态访问成员的特点:

向上转型（自动转换）

向下转型（强制转换）

第六章：多态与内部类

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

抽象类和抽象方法

接口

接口中的默认方法（default）

为什么需要默认方法

接口中的静态方法

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

内部类

非静态内部类

静态内部类

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

object类

String类

Math类

Random类

Calendar类和Date类和SimpleDateFormat类

枚举类

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

正则表达式

异常处理

声明自定义异常

捕获异常