【java】前八章：快速回忆

最新推荐文章于 2024-05-16 10:23:10 发布

烂尾主教

最新推荐文章于 2024-05-16 10:23:10 发布

阅读量315

点赞数 6

分类专栏： java 文章标签： java 1024程序员节

本文链接：https://blog.csdn.net/qq_25218219/article/details/120938674

版权

java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

不知不觉，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.帮助子类初始化父类继承过来的成员

静态方法:

编译看左边,执行看左边

举例代码如下：

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("\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项目案例开发入门》—清华出版社

烂尾主教

关注

6
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
【java】前八章：快速回忆

不知不觉，Java已近学了接近两个月。课本也慢慢的翻到了第八章，总感觉什么都没学到，一直想停下来整理一下，那就今天2021-10-23 09:38:03 星期六java前八章复习总结（理论内容）学的糊里糊涂的，没有代码经验，整理摘抄一些理论的东西，供自己参考，一定会有错误第一章简单了解javajava具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点 [2] 。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等工作原理由四
复制链接

扫一扫