1、Day 01；JVM - Java 虚拟机JRE - Java 运行环境JDK - Java 开发包 ，其中包含 JREJava 的跨平台性JDK 的下载，安装，环境变量的配置HELLO WORLD 第一个程序编写Classpath 环境变量配置，虚拟机先行在环境变量目录下找寻 class 文件然后才在当前目录下找，也就是说 classpath 环境变量的优先级大于当前目录。当配置临时 classpath 路径时，在路径末加上分号时 classpath 路径没有对应的 class 文件，会在当前目录找寻相应的class，反之，若末尾没有分号，则仅在 classpath 配置路径找寻对应的 cl
2、ass 文件，不再在当前目录下找寻。Path 环境变量配置时与 classpath 相反，它会先在当前目录下寻找，然后才找配置的路径。PS：我们在配置 classpath 路径时，以不加分号为好。如果需要在当前目录下寻找，可以在配置时参照：classpath=.;c:;d: 前边.代表当前目录。HelloWorld 程序组成部分：class Demo() /定义一个类public static void main(String args) /主函数System.out.println(“Hello World”); /输出语句class： 关键字，用于专门定义类。Demo：类名规范（首字母大写
3、，如果由多个字母组成，每个单词首字母大写）一般定义有意义的名称，加强易读性。: 一对大括号类区间。主函数：public static void main(String args) 保证类能独立运行，程序的入口。注释：/ -单行注释/* */ -多行注释/* */ -文档注释（开发者使用）javadoc.exe注解说明程序，调试程序，一边写代码，一边写注释，方便后期维护。需求分析设计：需求思路步骤代码需求：定义一个 Hello World 小程序；思路：（解决问题的思想，可以不涉及代码）1.2.步骤：1. 通过 class 关键字定义一个类，将代码都编写到该类中；2. 为了保证该类的独立运行，在
4、类中定义一个主函数；3. 保存成一个扩展名为 JAVA 的文件；4. 在 DOS 控制台中通过 javac 工具对 java 文件进行编译；5. 再通过 java 命令对生成的 class 文件进行执行。一个源文件只能有一个 public 类；被 public 修饰的类存储源文件时源文件名要与类名保持一致，如果一个源文件出现多个被 public 修饰的类，源文件不确定存储为什么名字。Day 02；数据类型：基本数据类型：（简单数据类型 语言所内置的类型）布尔型：Boolean(true/false) *：纯粹的 java 中数值不能给 Boolean 赋值字符型：char 16bit 0 个符
5、号位，全部都是数值位char c1 = a； /直接指定字面值char c2 = 97； /ASCIIchar c3 = u4e2d； /i18n native2asciichar c4 = t； /转义字符整数型：byte short int long 符号(1)+数值位(n-1)8 16 32 64int num1 = 25； /10 进制赋值 DECint num2 = 025； /8 进制赋值 OCTint num3 = 0x25； /16 进制赋值 HEXint num4 = 0b1011； /2 进制赋值 JDK7.0 BIN*:十进制二进制的转换76 = 64+8+4 = 010
6、011001 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384 *：long 定义结束之后可以加 L，超出 int 范围必须加 L.浮点型：符号位+ 幂指位+ 数值位float32(1+8+23) F/fdouble64(1+11+52) D/d67.25 =得到符号位：0整数部分：64+2+1 = 1000011小数部分：0.011000011.01 = 科学计数法：1.00001101*2(6)0.25*2 = 0.5；0.5*2 = 1.0；0.0*2 = 0.0；幂指位 8 位：127+6 = 01111111 + 0110 =
7、133 = 10000101数值位(科学计数法中小数点后面部分 )：000011010 10000101 00001101000000000000000*：IEEE754 浮点单精度和双精度的存储规范*：计算机当中 2.0 1.1 等于多少？为什么？怎么解决？引用数据类型：(自定义类型 自己写的类型 Object)PS：负数的二进制表现形式：就是负数的绝对值取反+1，负数的最高位都是 1.字符型和整型相加字符型提升为整型再行相加.三元运算符,可做简易 if else 语句的简化：变量 = (条件表达式)?表达式 1：表达式 2；因为是一个运算符，所以运算完必须要有一个结果。进制转换：二进制 =
8、 十六进制 1.最低四位/ price = (int)(price *0.7);price = price*7/10;/：Java 当中整数除以整数 结果一定为整数%：最终结果的符号位取决于参与运算的第一个数字的符号：5%2 = 1；5%-2 =1；-5%2 = -1；-5%-2 = -1；2.+= -= /= %=能够自动保持运算符左侧数据类型不发生任何变化int num = 3；num += 1.5；3. = = =区别 = 判断等，= 赋值等 4.b = a b;a = a b;一个数与另一个数异或两次等于它本身7. 位移运算符*2 *4 *8 *16 右移,高位补符号位” 右移一位表示
9、除 2 “ 无符号右移,高位补 0”;*：结合按位运算符和位移运算符能够进行简单的图形图像处理PS：1 st: 如何不借助第三块空间交换两个变量的值2nd：计算机如何最高效的求出 2 的 3 次方3rd：计算 144 237 之间所有数字累加的和，禁用循环Day 03；流程控制：分支：if else 利用其排他特性简化判断条件switch case 注意利用 break 机制实现相邻分支的代码共享*： while:先判断条件，只有条件满足才执行循环体。do while: 先执行循环体,再判断条件 ,条件满足,执行循环体。break 语句：应用范围：选择结构和循环结构。continue 语句：应
10、用于循环结构。这两个语句离开应用范围，存在是没有意义的。这个两个语句单独存在下面都不可以有语句，因为执行不到。continue 语句是结束本次循环继续下次循环。标号的出现，可以让这两个语句作用于指定的范围。PS：JDK7.0 switch 语句支持对字符串的判断。Day 04；数组：数组的定义方式：元素类型 数组名 = new 元素类型元素个数或数组长度;数组常见操作：遍历 获取最值 排序(选择/冒泡) 折半查找编译的时候没有开辟数组空间，只有在运行才开辟.Day 05；面向对象：1. 三个基本特征：封装，继承，多态2. 类和对象的关系：类就是对现实生活中事物的描述；对象就是这类事物实实在在存
11、在的个体。类是对象的抽象，对象的类的具体。3. 成员变量和局部变量：成员变量作用于整个类中；局部变量变量作用于函数中，或者语句中。成员变量：存在堆内存中，因为对象的存在，才在内存中存在；局部变量：存在栈内存中。如果局部变量的名字和成员变量的名字相同，则成员变量被隐藏，即这个成员变量在这个方法内暂时失效。这时如果想在该方法内使用成员变量，必须使用关键字 this。4. 匿名对象使用：方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。方式二：可以将匿名对象作为实际参数进行传递。PS：如果对一个对象进行多个成员调用，必须给这个对象起个名字，即不再使用匿名对象。5. 封装概述：
12、Encapsulation 用 private 将不想被外界访问的属性和方法隐藏起来，private 私有成员只有在本类中可以使用；封装对于类的开发者和使用者都有好处：对于类的开发者：能够让数据得到保密 得到隐藏 从而更加安全对于类的使用者：能够让使用者将精力 全部集中在核心业务逻辑上类的开发应当高内聚 低耦合内聚：独立完成功能的能力耦合：模块与模块之间的依赖关系，“耦合“无处不在所有的属性应当使用 private 修饰 并且提供两个 public 的方法 setters getters用于设置属性的 用于得到属性*：可以给设置和得到属性一种统一的方式 有助于代码的解耦*：可以让程序员重新拿回
13、主动权 让程序员来决定 是否需要用户设置和得到属性所有的方法应当考虑：一个方法究竟是给外界提供的核心方法还是给核心方法服务的方法核心方法用 public 修饰给核心方法服务的方法应当使用 private 对外屏蔽注意：私有仅仅是封装的一种表现形式。6. 构造函数：特点：a.函数名与类名相同 b.不用定义返回值类型 c.不可以写 return 语句.作用：给对象进行初始化.a.对象一建立就会调用与之相对应的构造函数(构造函数也可以重载)；b.当一个类中没有定义构造函数时 ,那么系统会默认给该类加入一个空参数的构造函数。c.当在类中自定义了构造函数后，默认的构造函数就没有了。构造函数和一般函数在写
14、法上有不同，在运行上也有不同：构造函数是在对象一建立就运行，给对象初始化。而一般方法是对象调用才执行，给是对象添加对象具备的功能。一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次。*：什么时候定义构造函数呢？当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。7. 构造代码块：作用：给对象进行初始化。对象一建立就运行，而且优先于构造函数执行。和构造函数的区别：构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化。构造代码块中定义的是不同对象共性的初始化内容。8. this 关键字：this 用于区分局部变量和成员变量同名情况。this
15、代表它所在函数所属对象的引用。即哪个对象在调用 this 所在的函数，this 就代表哪个对象。this 的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用 this来表示这个对象。但凡本类功能内部使用了了本类对象，都用 this 表示。9. this 关键字在构造函数间调用：this 语句用于构造函数之间进行互相调用时只能定义在构造函数的第一行，因为初始化要先执行。Day 06；1.Static 关键字：成员修饰符(成员变量，成员函数 )，static 静态修饰内容被对象所共享。当成员被 static修饰后，除了可以被对象调用，还可以直接被类名调用(类名 .静态成员)sta
16、tic 特点：1：随着类的加载而加载。也就说：静态会随着类的消失而消失,说明它的生命周期最长。2：优先于的对象存在，明确一点：静态是先存在。对象是后存在的。3：被所有对象所共享4：可以直接被类名所调用。实例变量和类变量的区别：1，存放位置：类变量(静态成员变量)随着类的加载而存在于方法区中。实例变量(成员变量)随着对象的建立而存在于堆内存中。2，生命周期：类变量生命周期最长，随着类的消失而消失。实例变量生命周期随着对象的消失而消失。静态使用注意事项：1，静态方法只能访问静态成员。非静态方法既可以访问静态也可以访问非静态。2，静态方法中不可以定义 this，super 关键字。因为静态优先于对象
17、存在。所以静态方法中不可以出现 this。3，主函数是静态的。静态有利有弊：利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份，可以直接被类名调用。弊端：生命周期过长。访问出现局限性。(静态虽好，只能访问静态。 )2.main 函数：public static void main(String args) 主函数：是一个特殊的函数。作为程序的入口，可以被 jvm 调用。主函数的定义：public：代表着该函数访问权限是最大的。static：代表主函数随着类的加载就已经存在了。void：主函数没有具体的返回值。main：不是关键字，但是是一个特殊的单词，可以被 j
18、vm 识别。(String arr):函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。主函数是固定格式的：jvm 识别。jvm 在调用主函数时，传入的是 new String0;3.静态什么时候使用：要从两方面下手：因为静态修饰的内容有成员变量和成员函数。什么时候定义静态变量(类变量 )呢？当对象中出现共享数据时，该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。什么时候定义静态函数呢？当功能内部没有访问到非静态数据(对象的特有数据) ，那么该功能可以定义成静态的。4.帮助文档(API)的制作 javadoc：author version param
19、return 默认构造构造函数的权限是随着的类的变化而变化的5.静态代码块：特点：随着类的加载而执行，只执行一次,并优先于主函数。用于给类进行初始化的。6.对象的初始化过程：Person p = new Person(“zhangsan“,20);该句话都做了什么事情？1. 因为 new 用到了 Person.class.所以会先找到 Person.class 文件并加载到内存中。2. 执行该类中的 static 代码块，如果有的话，给 Person.class 类进行初始化。3. 在堆内存中开辟空间，分配内存地址。4. 在堆内存中建立对象的特有属性。并进行默认初始化。5. 对属性进行显示初始
20、化。6. 对对象进行构造代码块初始化。7. 对对象进行对应的构造函数初始化。8. 将内存地址付给栈内存中的 p 变量。7.对象调用成员过程：堆 栈 方法区8.单例设计模式：设计模式：解决某一类问题最行之有效的方法，java 中有 23 种设计模式：单例设计模式：解决一个类在内存只存在一个对象。想要保证对象唯一。1，为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。这三部怎么用代码体现呢？1，将构造函数私有化。2，在类中创建一个本类对象。3，提供一个方
21、法可以获取到该对象。对于事物该怎么描述，还怎么描述。当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可。饿汉式：Single 类一进内存，就已经创建好了对象。class Singleprivate static Single s = new Single();private Single()public static Single getInstance()return s;懒汉式：对象是方法被调用时，才初始化，也叫做对象的延时加载。Single 类进内存，对象还没有存在，只有调用了 getInstance 方法时，才建立对象。class Singleprivate static
22、Single s = null;private Single()public static Single getInstance()if(s=null)synchronized(Single.class)if(s=null)s = new Single();return s;原则：定义单例，建议使用饿汉式。Day 07；1.继承概述：继承(extends)：1，提高了代码的复用性。2，让类与类之间产生了关系,有了这个关系，才有了多态的特性。注意：千万不要为了获取其他类的功能，简化代码而继承。必须是类与类之间有所属关系才可以继承, 所属关系 is a。从对象抽取出共性得到子类，再抽取子类共性得到
23、父类，接着由父类衍生各种子类。(父类先存在，自然界每天都有新事物出现，例如疾病，继承了之前父类某疾病)Java 语言中： java 只支持单继承，不支持多继承。因为多继承容易带来安全隐患:当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个。但是 java 保留这种机制。并用另一种体现形式(接口) 多实现来完成表示。 。java 支持多层继承，也就是一个继承体系；如何使用一个继承体系中的功能呢？想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。通过了解共性功能，就可以知道该体系的基本功能。那么这个体系已经可以基本使用了。那么在具体调用时，要创建最子类的
24、对象，为什么呢？一是因为有可能父类不能创建对象，二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。简单一句话：查阅父类功能，创建子类对象使用功能。依赖(“uses-a”) dependance 聚合(“has-a”) aggregation 继承(“is-a”) inheritance2. 子父类中变量和函数的特点：类中成员：1. 变量。2. 函数。3. 构造函数。如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用 this；子类要访问父类中的同名变量，用 super。super 的使用和 this 的使用几乎一致；this 代表的是本类对象的引用，super 代表的是
25、父类对象的引用。当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容。如同父类的函数被覆盖一样。这种情况是函数的另一个特性：重写(覆盖) 。即当子类继承父类，沿袭父类的功能到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致，这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。1，子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。2，静态只能覆盖静态。重载：只看同名函数的参数列表。重写：子父类方法要一模一样。3. 子父类中构造函数的特点：在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数默
26、认第一行有一条隐式的语句 super();super()会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是 super();为什么子类一定要访问父类中的构造函数？因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时，要先访问一下父类中的构造函数。如果要访问父类中指定的构造函数，可以通过手动定义 super 语句的方式来指定。注意：super 语句一定定义在子类构造函数的第一行。结论(子类的实例化过程)：子类的所有的构造函数，默认都会访问父类中空参数的构造函数。因为子类每一个构造函数内的第一行都有一句隐式 s
27、uper();当父类中没有空参数的构造函数时，子类必须手动通过 super 语句形式来指定要访问父类中的构造函数。对于父类含参数的构造方法，子类可以通过在自己的构造方法中使用 super 关键字来调用它，但这个调用语句必须是子类构造方法的第一个可执行语句。当然：子类的构造函数第一行也可以手动指定 this 语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。4. final 关键字：final : 最终。作为一个修饰符，1，可以修饰类，函数，变量。2，被 final 修饰的类不可以被继承。为了避免被继承，被子类复写功能。3，被 final 修饰的方法不可以被复写。4，
28、被 final 修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，有可以修饰局部变量。当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。方便于阅读。而这个值不需要改变，所以加上 final 修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成，单词间通过_连接。5，内部类定义在类中的局部位置上时，只能访问该局部被 final 修饰的局部变量。5. 抽象类：抽象类的特点：1，抽象方法一定在抽象类中。2，抽象方法和抽象类都必须被 abstract 关键字修饰。3，抽象类不可以用 new 创建对象。因为调用抽象方法没意义。4，抽象类中的抽象方法要被
29、使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。抽象类和一般类没有太大的不同。该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。这些不确定的部分，也是该事物的功能，需要明确出现，但是无法定义主体，通过抽象方法来表示。抽象类比一般类多了抽象函数，就是在类中可以定义抽象方法。抽象类不可以实例化。抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。6. 模板方法模式：需求：获取一段程序运行的时间。原理：获取程序开始和结束的时间并相减即可。获取时间：System.currentTimeMillis();当代码完
30、成优化后，就可以解决这类问题，这种方式，模版方法设计模式。什么是模版方法呢？在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去，由该类的子类去完成。7. 接口(interface) ：接口：初期理解，可以认为是一个特殊的抽象类当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。class 用于定义类，interface 用于定义接口。接口定义时，格式特点：1，接口中常见定义：常量，抽象方法。2，接口中的成员都有固定修饰符。常量：public static final方法：public abstract 接口中的成
31、员都是 public 的，接口是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。接口可以被类多实现，也是对多继承不支持的转换形式，java 支持多实现。类在继承类的同时可以实现接口。同时接口之间可以多继承。基本功能定义在类中，扩展功能定义在接口中，不同体系中基本功能和扩展功能可能不同，在体系中用继承来实现，体系外用接口来实现。Day 08；1. 多态概述：多态：可以理解为事物存在的多种体现形态。人：男人，女人 动物：猫，狗。 猫 x = new 猫(); 动物 x = new 猫();1，多态的体现父类的引用指向了自己
32、的子类对象。父类的引用也可以接收自己的子类对象。2，多态的前提必须是类与类之间有关系。要么继承，要么实现。通常还有一个前提：存在覆盖。3，多态的好处多态的出现大大的提高程序的扩展性。4，多态的弊端：只能使用父类的引用访问父类中的成员。5，多态的应用6，多态的出现代码中的特点( 多态使用的注意事项)如何使用子类特有方法，强制将父类的引用转成子类类型，向下转型。多态自始至终都是子类对象在做着变化。instanceof : 用于判断对象的类型。 对象 intanceof 类型( 类类型 接口类型)2. 多态中成员的特点：在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有
33、编译失败。在运行时期：参阅对象所属的类中是否有调用的方法。简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。多态中成员变量的特点：无论编译和运行，都参考左边(引用型变量所属的类 )。多态中静态成员函数的特点：无论编译和运行，都参考做左边。3. 多态的主板示例：电脑运行实例：电脑有使用 PCI 卡槽的方法接口 Interface 扩展功能，后期加入网卡，声卡，显卡等，接口型引用指向自己的子类对象。4. Object 类 equals()：Object:是所有对象的直接或者间接父类，传说中的上帝。该类中定义的肯定是所有对象都具备的功能。Object 类中已经提供了对对象是否相同的比较方法
34、(equals) 。如果自定义类中也有比较相同的功能，没有必要重新定义。只要沿袭父类中的功能(覆盖) ，建立自己特有比较内容即可。Day 09；1. 内部类访问规则：将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类） 。1，内部类可以直接访问外部类中的成员，包括私有。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this.成员名2，外部类要访问内部类，必须建立内部类对象。/ 直接访问内部类中的成员。/ Outer.Inner in = new Outer().new Inner();/ in.function();2. 静态内部类
35、：访问格式：1,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。直接建立内部类对象。格式：外部类名.内部类名 变量名 = 外部类对象.内部类对象;Outer.Inner in = new Outer().new Inner();2,当内部类在成员位置上，就可以被成员修饰符所修饰。比如，private：将内部类在外部类中进行封装。static:内部类就具备 static 的特性。当内部类被 static 修饰后，只能直接访问外部类中的 static 成员。出现了访问局限。在外部其他类中，如何直接访问 static 内部类的非静态成员呢？new Outer.Inner().fun
36、ction();在外部其他类中，如何直接访问 static 内部类的静态成员呢？Outer.Inner.function();注意：当内部类中定义了静态成员，该内部类必须是 static 的。当外部类中的静态方法访问内部类时，内部类也必须是 static 的。当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事物在使用外部事物的内容。内部类定义在局部时，1，不可以被成员修饰符修饰2，可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量。只能访问被 final 修饰的局部变量。3. 匿名内部类：匿名内部类:1，匿名内部类其实就是内部类的简写格式。
37、2，定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。3，匿名内部类的格式： new 父类或者接口()定义子类的内容4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。5，匿名内部类中定义的方法最好不要超过 3 个。4. 异常概述：1. 异常：就是程序在运行时出现不正常情况。异常由来：问题也是现实生活中一个具体的事物，也可以通过 java 的类的形式进行描述，并封装成对象。其实就是 java 对不正常情况进行描述后的对象体现。对于问题的划分：两种：一种是严重的问题，一种非严重的问题。对于严重的，java 通过 Error 类进行描述。对于 Error 一
38、般不编写针对性的代码对其进行处理。对与非严重的，java 通过 Exception 类进行描述。对于 Exception 可以使用针对性的处理方式进行处理。无论 Error 或者 Exception都具有一些共性内容。比如：不正常情况的信息，引发原因等。Throwable |-Error |-Exception2. 异常的处理java 提供了特有的语句进行处理。try需要被检测的代码；catch(异常类 变量)处理异常的代码；(处理方式 )finally一定会执行的语句；3. 对捕获到的异常对象进行常见方法操作。toString getMessage()：获取异常信息。在函数上声明异常(tho
39、ws Exception)，便于提高安全性，让调用去进行处理，不处理编译失败。4. 对多异常的处理。a. 声明异常时，建议声明更为具体的异常。这样处理的可以更具体。b. 对方声明几个异常，就对应有几个 catch 块。不要定义多余的 catch 块。如果多个 catch 块中的异常出现继承关系，父类异常 catch 块放在最下面。建议在进行 catch 处理时，catch 中一定要定义具体处理方式。不要简单定义一句 e.printStackTrace(),也不要简单的就书写一条输出语句。5. 自定义异常：因为项目中会出现特有的问题，而这些问题并未被 java 所描述并封装对象。所以对于这些特有
40、的问题可以按照 java 的对问题封装的思想。将特有的问题。进行自定义的异常封装。自定义异常：需求：在本程序中，对于除数是-1，也视为是错误的是无法进行运算的。那么就需要对这个问题进行自定义的描述。当在函数内部出现了 throw 抛出异常对象，那么就必须要给对应的处理动作。要么在内部 try catch 处理，要么在函数上声明让调用者处理。一般情况在，函数内出现异常，函数上需要声明。发现打印的结果中只有异常的名称，却没有异常的信息。因为自定义的异常并未定义信息。如何定义异常信息呢？因为父类中已经把异常信息的操作都完成了。所以子类只要在构造时，将异常信息传递给父类通过 super 语句。那么就可
41、以直接通过 getMessage 方法获取自定义的异常信息。自定义异常必须是自定义类继承 Exception。继承 Exception 原因：异常体系有一个特点：因为异常类和异常对象都被抛出。他们都具备可抛性。这个可抛性是 Throwable 这个体系中独有特点。只有这个体系中的类和对象才可以被 throws 和throw 操作。throws 和 throw 的区别throws 使用在函数上，throw 使用在函数内。throws 后面跟的异常类，可以跟多个，用逗号隔开。throw 后跟的是异常对象。6. RuntimeException：Exceptoin 中有一个特殊的子类异常 Runti
42、meException 运行时异常。如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过；之所以不用在函数声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。自定义异常时：如果该异常的发生无法再继续进行运算，就让自定义异常继承RuntimeException。对于异常分两种：1，编译时被检测的异常。2，编译时不被检测的异常(运行时异常：RuntimeException 以及其子类)Day 10；1. 异常-finally：finally 代码块：
43、定义一定执行的代码，通常用于关闭资源。2. 处理语句其他格式：try catchtry finallytry catch finallycatch 是用于处理异常。如果没有 catch 就代表异常没有被处理过，如果该异常是检测时异常。那么必须声明。3. 覆盖时异常的特点：异常在子父类覆盖中的体现；1. 子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。2. 如果父类方法抛出多个异常，子类在覆盖该方法时，只能抛出父类异常的子集。3. 如果父类或者接口的方法中没有异常抛出, 子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常。就必须要进行 t
44、ry 处理。绝对不能抛。原则就是子类在复写父类方法时，后续调用子类方法时只能处理父类有的异常。4. 异常总结：异常：是什么？是对问题的描述。将问题进行对象的封装。-异常体系：Throwable|-Error|-Exception|-RuntimeException异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性。也就是说可以被 throw 和 throws 关键字所操作。只有异常体系具备这个特点。-throw 和 throws 的用法：throw 定义在函数内，用于抛出异常对象。throws 定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。当函数内容有 throw 抛出异常对
45、象，并未进行 try 处理。必须要在函数上声明，都在编译失败。注意，RuntimeException 除外。也就说，函数内如果抛出的 RuntimeExcpetion 异常，函数上可以不用声明。-如果函数声明了异常，调用者需要进行处理。处理方法可以 throws 可以 try。异常有两种：编译时被检测异常该异常在编译时，如果没有处理(没有抛也没有 try)，编译失败。该异常被标识，代表这可以被处理。运行时异常(编译时不检测 )在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止。需要对代码进行修正。-异常处理语句：try需要被检测的代码；catch ()处理异常的代码；fi
46、nally一定会执行的代码；有三个结合格式：1. try catch ()2. try finally3. trycatch ()finally注意：1， finally 中定义的通常是 关闭资源代码。因为资源必须释放。2， finally 只有一种情况不会执行。当执行到 System.exit(0);fianlly 不会执行。-自定义异常：定义类继承 Exception 或者 RuntimeException1,为了让该自定义类具备可抛性。2，让该类具备操作异常的共性方法。当要定义自定义异常的信息时，可以使用父类已经定义好的功能。将异常信息传递给父类的构造函数。class MyExcepti
47、on extends ExceptionMyException(String message)super(message);自定义异常：按照 java 的面向对象思想，将程序中出现的特有问题进行封装。-异常的好处：1，将问题进行封装。2，将正常流程代码和问题处理代码相分离，方便于阅读。异常的处理原则：1，处理方式有两种：try 或者 throws。2，调用到抛出异常的功能时，抛出几个，就处理几个，一个 try 对应多个catch。3，多个 catch，父类的 catch 放到最下面。4，catch 内，需要定义针对性的处理方式。不要简单的定义 printStackTrace，输出语句。也不要不
48、写。当捕获到的异常，本功能处理不了时，可以继续在 catch 中抛出。trythrow new AException();catch (AException e)throw e;如果该异常处理不了，但并不属于该功能出现的异常。可以将异常转换后，再抛出和该功能相关的异常。或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，让调用者知道。并处理。也可以将捕获异常处理后，转换新的异常。trythrow new AException();catch (AException e)/ 对 AException 处理。throw new BException();比如，汇款的例子。异常的注意事项
49、：在子父类覆盖时：1，子类抛出的异常必须是父类的异常的子类或者子集。2，如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能 try 不能抛。参阅ExceptionTest.java 老师用电脑上课ExceptionTest1.java 图形面积。5. 包 package：包写在程序的第一行 package pack;1. 编译时包中的类要带包名走，格式：包名.类名2. 编译时设置 classpath 路径，告诉 jvm 去哪里找指定的 package 包3. 要访问包中的类，类的权限必须足够大，被访问的类要被 public 修饰4. 类公有后，被访问的成员也要共有后才可以被访问注意：一个源文件中只能有一个公有类，其他类封装起来为公有类服务为了简
