JavaSe-学习知识点汇总

发布于:2022-11-09 ⋅ 阅读:(14) ⋅ 点赞:(0) ⋅ 评论:(0)

一、学习体会

这么多天第一阶段的JavaSe学习结束了,针对自己所学的知识点作如下总结与汇总。复习之后进入数据结构与算法的学习。

对于JavaSe的学习来说,个人觉得弄清楚这些基本的知识与理解是最为重要的,你拿到相关的代码一定要能看得懂并且理解其中的意思,自己动手写代码的代码量不需要太多,可以尝试写一写,相关的代码题可以先想思路,代码实现不了可以看别人的答案,要能看懂就可以。我学习的JavaSe这些内容大约是Java核心卷1的前一半的内容。多看,多写(看懂的代码自己在IDEA写一遍)多总结,出问题的查一查具体问题,不要死磕。

个人总结的JavaSe学习路径:有条件可以预习 —> 上课:培训or自学的课 —> 总结当日知识点 —> 看相关代码 对着知识点理解并消化 —> IDEA写一遍当日代码 —> 有问题百度或者询问朋友一起解决—> 直到代码正确 —> 自己照着代码再写一份 —> 阶段性总结与复习 —> 阶段性学习的相关知识点一些经典问题的解决与代码的查看和理解。

以下内容中红色标亮部分为个人认为的重点内容,务必理解与消化。其中橙色字体为本人的个人理解,蓝色字体为语法结构。此文章只总结个人认为比较重要的知识点,不包含代码实现与具体题目。


二 、JavaSe具体知识点汇总

1  Java的基本了解

*.java   java源文件 该文件中存储所有的java源代码

在java中一切皆对象,所以一切属性和方法必须定义在类中(Java中的一个个类,就是一个个对象,没有对象你设定的属性以及方法就没有意义,因为Java是面向对象的编程语言,例如你设定一个属性:年龄等于10,那么如果不在一个类中。那这个年龄等于10,是谁的年龄等于10?在代码中的体现就是。你必须创建类之后,才能创建其他的东西,否则你创建的其他的所有东西没有意义)

源文件名称必须与主类名称一致,主方法存储在主类中。每一个程序的开始执行入口都是主方法,你在该源文件内创立的所有的东西。如果你想要执行都必须放入主方法中。主方法就是一个执行器。

javac编译器 ——将源文件编译成字节码文件也就是class文件,然后class文件通过java解释器翻译为具体操作的机器码给机器执行。

JDK——java开发工具包,包括jre开发环境以及开发工具,比如javac编译器

JRE——java运行时环境,包括jvm与javase标准类库

JVM——java虚拟机,保证java 做到 write once,run everywhere的关键

另外添加的注释在编译后是不存在的,只存在于源文件中。

Tips:IDEA注释的快捷键:选中需要注释的内容ctrl+/

2  标识符与基本数据类型

标识符:在程序中给类、方法、变量取的名字都叫标识符,取名规则为:可以包含字母、数字、下划线以及美元符$(不推荐)。不能以数字开头,不能使用java中的关键字,区别大小写(java中一切都区分大小写)(标识符其实就是给你想创建的对象起个名字,无论是属性也好方法也好,总要有个名字来代表它)

关于标识符的命名:驼峰命名法:类名用大驼峰,每个单词首字母都大写。方法和变量使用小驼峰:第一个单词首字母小写,其他都大写。

class TextStudent{ //类名大驼峰
    int myAge = 10;//变量小驼峰
}

八大基本数据类型分别为:数值型:byte short int long (整型)float double (浮点型)                

字符型:char   布尔型:boolean    其中数值型整型的默认值为0,浮点型默认值为0.0,字符型默认值为\u0000,boolean型默认值为false。

所有的数据类型只有在类中定义时才具备默认值,在方法中的局部变量是不具备默认值的。你在类中定义时可以写 int a而不赋值不会报错,但是你在方法中调用时或创建局部变量时写 int  a 就不行,必须在使用前赋值。(因为类中的东西可以不被操作,但是方法内部必须是要对其内部的东西进行操作的,你不赋值就无法操作,所以不行)

程序中有两种类型的数值,一种为变量,定义后可以修改该变量的具体数值,另一种为常量,数值无法改变,用final修饰。

变量语法:数据类型   变量名称 = 初始值   eg:int a = 10

一行中可以定义多个对象:int a = 10,b = 20 ,c;特别的 如果为int a,b,c=10;此时只有c为10,a和b为默认值,要特别注意

因为java中一切皆对象,所以一切都可以用类来描述,但八大基础数据类型不属于类,为了满足一切皆对象原则,为八大基础数据类型创建了包装类,这样它们也就能成为对象了。包装类除了int的为Integer,char为Character之外,其他的均首字母大写即可。

在进行数据处理时,得出的最终结果要与数据类型匹配,如果不匹配就会出现精度损失。如果int / int 那么得到的还是int ,如果结果是小数那么会舍去小数点后的数字以此来输出int的结果。

字面量:直接展示出来的就是字面量,比如10 (整型字面量),abc(字符串字面量),他们都是常量,因为10只能指代10,abc只能指代abc,在使用时,int a = 10相当于把一个10的字面量常量赋值给了变量a。另外,整型字面量默认为int类型,浮点型字面量默认为double。

关于类型转换与类型提升:小类型转为大类型自动转换,大类型转小类型需要强制转换。因此

float = 10.1F(大转小强转)   long b = 10(小转大自动),并且在运算时,小数据类型与大数据类型一起计算,自动将小类型提升为大类型再计算。

另外,存储byte short char的时候看它本身大小,但是调用时默认将其调为int类型进行处理。

java中任何数据类型与字符串(string类)进行+操作,都会变成拼接结果。

string类中有一个valueOf方法可以将纯数字字符串转换为数值型,接收该数值的数据类型必须比转换过来的数值要大,否则放不进去。


3 运算符

算术运算符:+ - * / %(取余)+=  -=   *=  %= (先进行=前的运算再得出结果,例如 1 +=2,就为3)

关系运算符:==    !=   <    >   <=     >=  计算结果为布尔值,该运算符的意思为:判断数据怎么怎么样(根据具体运算符来决定, ==就是判断两个数据相等,相等为true不相等为false,!=为判断不相等)

逻辑运算符:&& (逻辑与)并且关系   ;   ||  (逻辑或)或者关系     ;   它们运算结果也为布尔值     特别的!为逻辑取反

位运算符:在二进制位进行操作  &(按位与)  |(按位或)   ^(按位异或)   ~(按位取反)

&:二进制位(后同)都为1返回1否则0    |  :都为0返回0否则1  ^ :相同返回1不同返回0  ~:1变为0 ,0变为1

>> 与<<分别是在二进制位右移和左移,空出的位置补0。当一个数<<1(二进制位左移一位)相当于*2,>>1相当于/2.

条件运算符:三目运算符(条件判断的一个简化写法):语法:表达式1?表达式2:表达式3(1true执行2false执行3)


4 逻辑结构(代码中体现为在方法中的语句展现出来的逻辑结构)

分支结构 if

if (布尔表达式){
                //满足条件时执行的语句
}//第一种
if (布尔表达式){
                //满足条件时执行的语句
}else{
                //不满足时执行的语句
}//第二种
if (布尔表达式1){
               //满足布尔表达式1时执行的语句
}else if(布尔表达式2){
                //满足布尔表达式2时执行的语句
}else{
                //都不满足执行的语句
}//第三种

分支结构switch

switch(){ //括号内表达式:int以及小于int的char short  byte,string,枚举

        case字面量1:{
                //匹配字面量1时的语句
        }
        case字面量2:{
                //匹配字面量2时的语句
                [break];
        }
        default:{
                //以上case都不匹配时执行的语句
                [break];
                          // break表示switch语句到此为止,不加则会往下跑,case1没加就会往下到case2
        }

}

循环结构while(知道终止条件选用)


while(){ //括号内循环满足的条件:必须为布尔表达式
                //满足时执行的循环语句
                //tips:记得更新循环条件
}

循环结构 for

for(表达式1;布尔表达式;表达式3){
                //循环语句
}

 加强for循环(用于数组元素的遍历)

for(数据类型 变量名 :遍历的目标){
                        //数据类型 变量名:声明一个变量用来接收遍历目标遍历后的元素
}  

5 方法(定义在类中的实际操作语句)

public static void text(int a){ //修饰符 返回值类型 方法名称(参数类型   形参名称)
                //方法体代码
                [return返回值];   //当反回值类型为void时,没有返回值,不写return语句
}

调用方法:方法名称(参数);

形参为定义方法时定义的,此时并没有具体的数值,而实参则为调用方法时赋的具体的值,执行的操作为实参数据拷贝,赋值给形参。

实参和形参储存在不同的栈帧中,在对形参的数值进行操作时,不会影响到实参的数据。

方法重载(overload):在同一个类中,定义了若干方法名称相同,参数列表不同(参数类型或个数),与返回值无关的一组方法。是一种静态绑定,根据传参不同来调用方法。方法覆写则是动态绑定。

根据方法的定义语法,如果方法一和二是重载方法,那么应该是这样的:

public static void c(int a,String b){
    //方法体代码
}
public static void c(double c){
    //方法体代码
}

方法递归:方法在执行过程中又调用自身的过程,称为递归。使用递归要满足以下三个条件:

1 一个大问题可以拆分为若干个小问题

2拆分后的子问题与原问题除了数据规模不同之外,解决的思路完全相同

3存在递归终止条件,即分到什么时候不用分也能得出结果

递归实质运行起来就是一个往下一层一层递下去再一层一层返回处理的过程(有些不用返回,没有返回值的可以理解为一个循环,因为上层执行语句的时候不需要返回值参与)


6 引用数据类型

三大引用类型分别为:类、数组与接口,他们的默认值为null。所有引用数据类型的变量,保存的都是存储内容的地址,并非实际的内容。另外,当引用数据类型的值为默认值null时,表示不指向任何对象,无法通过该引用数据类型进行任何操作,操作的话会产生NPE错误。

A 数组

数组:一种引用数据类型相同数据类型数据的集合,数组存储在内存中连续空间。数组为引用数据类型,存储在堆中。一旦创建长度确定不可更改

语法:数组的静态初始化(元素已确定):数据类型 [ ] 数组名称 = { 元素值1 ,元素值2,……}

静态初始化在编译时会产生new关键字,此处为Java语法糖,舍去了。

数组的动态初始化(元素未确定):数据类型 [ ] 数组名称 = new 数据类型 [数组长度]

new关键字在任何地方出现都是指在内存堆中开辟空间存放东西

数组内的元素下标从0开始,表示对首元素的偏移量,数组内元素个数为N则下标最多为N-1.

访问数组中的元素使用   数组名称   [ 下标 ]

得到数组长度用   数组名称.length

数组的元素遍历(不更改数据):for - each循环(上文中的增强for循环)  for (int i ,num1){}

数组的冒泡排序:当前一个元素大于后一个元素,交换两个元素的位置,然后比较后面两个,一直走到底。

数组的拷贝:Arrays.copyOf(原数组名称 , 新数组长度)//数组工具类Arrays中的copyOf方法

数组问题的双引用解法:通过设定左边界与右边界的方式,通过一些操作加边界移动来达到解决问题的解法。

B 类

类的定义:使用关键字class来定义,类只是一个模板,没有具体意义,不是具体实例。

class  类名称 {

                属性:成员属性,对象属性

                方法:成员方法,对象方法

}
一个源文件只能存在一个主类,主类名与源文件名相同。

类的实例化:类的实例化其实就是创建一个该种类的对象出来

类名称  引用名称(实例对象的名称)  =  new  类名称();//此处的    类名称()括号内内容要根据具体构造方法填入,例如构造方法中为 类名称 (int a ,int b )那么在使用实例化创建对象时也要存入相应的参数。

通过该实例对象就可以使用  “ . ”操作符访问成员属性和成员方法。

引用名称 . 成员属性/成员方法名称

构造方法:初始化对象要用构造方法,其就是为了产生对象,给对象做初始化操作。(创建对象的第一步)

构造方法的特点:

1 构造方法与类名称相同,无法自定义方法名称

2 构造方法没有返回值类型声明,void

3 构造方法在产生对象时由编译器自动调用并且只在产生对象时调用一次。

语法:

类名称 (参数){

                构造语句

}

如果没有构造语句和参数则为无参构造。在你创建一个类时,如果你不写构造方法,编译器会自动生成一个无参构造,如果你写了,那么该无参构造就不会生成。

成员变量的所有赋值操作都在构造方法中进行。

构造方法也是可以重载的,此时只是参数个数不同,因为类型已经定义过了。

C 接口(在看完继承与多态之后学习)

java中三大引用数据类型之一,可以看作是多个类的共同规范。

使用关键字 interface定义接口,JDK8之前,接口中只有全局常量和抽象方法,他是更加纯粹的抽象类。

子类使用implements实现接口,子类若是普通类,则必须覆写父类接口中所有的抽象方法。

 一般来说,子类名称中用Impl结尾,表示是接口的实现子类。接口的子类没有 is  a原则。

注意点:

1 接口是更纯粹的抽象类,因此接口中只有全局常量和抽象方法,没有构造方法和普通方法,因此其无法直接实例化对象,只能通过具体子类向上转型来被父类引用接收。

2 接口的子类是可以允许多实现的,一个类可以使用多个implements实现多个父接口。(避免了单继承局限)。

3 因为接口中只有全局常量和抽象方法,因此在接口中以下关键字全都可以省略不写:public abstract  static  final  

4 子类如果继承一个抽象类实现多个接口,那么先使用extends继承一个类,然后用implements实现多个接口

5 接口和接口之间可以用extends继承多个父接口。但是不能用来继承多个类!

6 JDK8之后,接口中允许存在普通方法,接口中的普通方法用default定义。定义的为成员方法,必须通过具体的子类对象来使用。


7 this 与 static 关键字
 

this关键字的使用:

1 this修饰成员变量  :this.属性名称    表示直接从类中寻找同名变量,防止编译器的就近匹配原则产生bug。 

2 this修饰方法:修饰成员方法:表示调用类中的成员方法。 this.方法名称

当有继承关系后,明确调用的是当前类的成员方法,加上this

调用构造方法: this(参数);(构造方法之间才能相互调用)这种调用体现在,当一个构造方法是另一个构造方法的一部分时,可以调用this(参数)直接调用那部分构造方法,然后再写其他的语句。

3 this表示当前对象的引用:在语句中出现this时,当前方法或属性是哪个实例对象调用的,那么这个this就指代那个实例对象。


static关键字的使用:

static与具体实例对象无关,是静态的,与类有关。

staitc修饰属性,称为类属性,静态属性,存放在JVM的方法区,类属性在没有对象时(即指代值为null时也可以使用,但是成员方法和成员变量不可以)也能使用。

java中不支持在方法中定义静态变量,方法中定义的都是局部变量。

静态属性通过类名称直接调用:  类名称.静态属性名称

static修饰方法:类方法,直接通过类名称调用: 类名称.类方法名称

static无法修饰外部类,但是可以修饰内部类。

static变量的初始化:就地初始化(定义静态变量时就直接初始化)或在静态代码块中初始化。


8 代码块

四种代码块:

普通代码块:直接定义在方法内部,不加任何修饰符定义的代码块  { } ;代码块内部就是各个变量的作用域

构造块:直接定义在类中,{ }内的代码块  特别的 构造块优先于构造方法执行

静态代码块:一般用于初始化静态变量  使用static修饰,直接定义在类中的代码块。在类加载时执行一次。特别的,主类中的静态代码块会优先于主方法执行。

同步代码块:使用synchronized(){}包裹起来的代码块,在多线程环境下,对共享数据的读写操作是需要互斥进行的,否则会导致数据的不一致性。同步代码块需要写在方法中。(多线程后学习)


9 面向对象的三大特性

三大特性:封装、继承与多态

A 封装:对外隐藏内部实现细节

权限修饰符:

private  default  protected  public 

需要注意的是,权限修饰符指的是在哪些类中可见,与具体对象无关。

private 修饰符:私有属性,只在当前类内部可见。当属性方法被封装之后,外部只能通过设定的getter  与 setter (必须满足设定的条件)来获取和修改私有属性。

default 修饰符:包访问权限,当前包内部可见(子包不行)。什么都没写就默认是包访问权限,包就是文件夹。包的命名:全小写,单词之间用_分割使用 import关键字来导入某个包下的某个类使用 import java. 包名,类名 导入另外不确定导入的是一个包中的哪个类时,可以使用通配符:import java. 包名,*  ,这样它就会自动根据调用的类来导入该包下相对应的类。特别的,这种通配符有重名的隐患,因此还是建议写全名。

静态导入::将一个类1的所有静态域导入到当前类2中,和之前唯一的区别就是在类2中调用类1的方法属性不需要加类1前缀。

protected修饰符:在不同包的具有继承关系的类中可见。

public:公开权限,都可见。

B 继承

类和类之间的关系有继承和组合。

继承的使用要满足 is - a原则:子类 is a 父类。

组合关系:has -a 原则 父类 has a子类。

继承的语法:使用extends表示继承父类:访问修饰符  class 子类名称 extends 父类名称

当在子类中访问变量,访问的变量在子类中存在时,优先调用子类的,不存在时,调用父类的。

特别的,父类中存在私有域属性与方法,只能被隐式继承,无法在外部被调用。

当通过子类对象调用方法时,子类中存在则调用子类的,否则调用父类的(私有域无法被调用)。

要注意的点为:要根据方法名称+参数来确定是调用的方法

当用构造方法产生子类对象时,默认先用父类构造方法产生父类对象。

子类中若想直接跳过子类属性和普通方法调用,则使用super关键字直接在父类中寻找对象。

特别的,我们知道用构造方法产生子类对象时,默认先用父类构造方法产生父类对象。在父类中构造方法为无参构造时,不需要在子类的构造方法首行写上super(参数);来表示调用父类的构造方法,但是父类构造方法如果不是无参构造,那么必须在子类构造方法首行写上super(参数);来表示调用了父类的构造方法。

Java的单继承局限:不允许多重继承,即一个子类继承多个父类(但是接口可以!)。

java继承支持的几种方式: 单继承(a继承b)多层继承(a继承b,b继承c)不同类继承同一个类(a继承c  b继承c)

C 多态

多态:同样的方法,不同的对象,展现出不同的行为结果。

要实现多态,必须满足以下三个条件:

1多态的实现依赖于继承,只有在继承体系下才有多态

2子类必须覆写父类的方法

3通过父类引用调用子类覆写的方法

方法覆写:在有继承关系的类之间,子类定义了和父类除了权限不同以外,其他(方法名称,参数列表,返回值(向上转型除外))完全相同的方法,称为子类覆写了父类的方法。特别的,子类的权限>=父类的权限。

方法覆写是一种动态绑定:编译时不确定用哪个对象的方法,只有在运行时,根据具体传入方法的对象,才能知道到底调用的是哪个方法。

D 向上转型与向下转型

向上转型:天然发生的,也是产生对象的主要使用方式

语法:父类名称  父类引用  = new 子类实例(参数)

这里非常重要的点是 产生该向上转型的对象,通过该父类引用该能调用哪些方法和属性,是父类决定的,而至于调用这个方法到底表现出什么行为是new的子类对象决定的。如果子类覆写了则调用子类中覆写的方法,如果没有则执行父类中的。并且子类中独有的属性方法无法调用。

向上转型的优势是参数统一化,缺点是子类中独有的无法调用。

想调用则使用向下转型(必须先发生向上转型,否则实现不了):

子类名称 子类引用 = (子类名称)父类引用

可以使用java中instanceof关键字来判断一个父类引用是否指向一个子类对象(向上转型)

语法:引用名称  instanceof 类  ( 返回布尔值)


JDK中三大特殊类:Object类,String类,包装类

10 Object类与抽象类

Object是java中所有类的父类,不需要使用extends明确写出继承。只要是class声明的类,就都有一个父类Object。

1  因此Object是参数的最高统一化,所有类的对象都可以通过Object引用进行接收

2 Object中的所有方法都可以在子类中进行覆写。

我们的子类可以选择覆写或者不覆写父类中的方法,在编译运行是不会出错的,但是要是想要强制子类覆写父类中的方法,则需要使用到抽象类和抽象方法。

抽象类:使用abstract定义,抽象类只是普通类的超集,只是比普通类躲了一些抽象方法而已。普通类具有的,抽象类也有。

使用abstract定义抽象方法,抽象方法没有方法体,只有方法声明。(没有方法体就看有没有 { } )。除了abstract方法以外还有本地方法native也没有方法体。 没有加访问修饰符时,抽象方法默认为包权限。

抽象类和抽象方法使用的原则

 抽象类和抽象方法的使用原则:

1 抽象类不能实例化对象,即使抽象类中没有任何抽象方法,也无法直接实例化对象。只能通过向上转型进行赋值

2 抽象类的子类如果是普通类则必须覆写其父类抽象类的方法————强制覆写,保证多态的运行

如果是抽象类则不覆写也行

3 abstract的使用  不能与private / final  /static 一起使用

4 抽象类中仍然可以定义普通类中的构造方法和普通方法,也仍然满足对象的实例化流程。
 


11 String类与String类常量池

String类,字符串,它有相当多的常用方法:例如构造String类的方法,String类内部的比较方法,截取方法等等。

此处阐述字符串常量池:

Java中 “  ”为字符串常量,为了提高程序的运行速度,节省空间,JVM会维护一个字符串常量池。

当字符串第一次出现,则产生新对象并将该对象置入常量池中,后续若继续出现该字符串常量,不会产生新对象,直接复用常量池中已有的对象,直接赋值法会默认从常量池中取对象。

我们在这里特别要注意的几个概念是:

1 String类是引用数据类型,那么它所创建的String类的对象,保存的是指向内容的地址(栈中保存该对象的地址)。

String s1 = “ abc” -------这代表,我创建了一个字符串常量“abc”放在堆中,同时创建了一个String类对象s1,该对象指向的内容是字符串常量“abc”,实际内容为“abc”存放的地址,在s1对象的内部有一个value来接收该地址,而s1的值为s1保存的地址。特别提醒:在栈中进行操作的直接对象是s1的值。也就是说栈中存在s1 = 0x223.

因为该字符串常量为第一次创建, 所以要将其置入字符串常量池中,需要注意的是,置入常量池中的是字符串创建的对象,并非其指向的实际对象。此处为s1置入常量池。

而当第二次使用直接赋值创建新的String类对象s2时,String s2 = “ abc”;如果赋的值仍为“abc”,java发现此时字符串常量“abc”的地址已经存在了常量池中,那么此时s2便不会产生相同的字符串常量“abc”,回直接在常量池中返回已经存好的“abc”地址的s1的地址,也就是s1的值。此时s2  ==  s1 。

如果使用构造方法来创建String类,那么其实质就是把常量池中s1保存的内容(value)复制一份,再放入刚开辟的新空间s3中。

比如 String s3 = new String (“abc”);第一步发现常量池中存在,返回该指向对象“abc”的地址,即value = 0xf43,然后将其放入刚开辟的新空间s3中,此时s3的地址假设为0x211,那么s3=0x211会进入栈中等待被操作。此时s3 !== s1的。

所以综上所述,常量池中存储的是什么?实质就是存储了第一次出现的字符串常量的对象,该对象内存储的是字符串常量的地址。

intern方法:入池方法,也是本地方法(native)

将手动创建的字符串对象置入常量池,并返回置入常量池后的地址。

若池中本身就存在该字符串常量的对象,则返回已经存在的对象的地址。如上文中如果我使用

s3.intern(); 那么返回的就是s1的值,需要特别注意的是,返回值为s1的值,但是s3的值此时并未改变,仍指向的是原本s3的地址0x211,若想让此时s1==s3则必须用s3接收该返回值即可,这样s3就不再指向0x211而是s1的地址。


12 包装类

包装类:将基本类型封装到具体的类之中

1 包装类和基本类型的互相转换:

基本类型到包装类对象,称之为装箱,通过包装类的构造方法或valueOf方法。

包装类对象到基本类型,称之为拆箱,使用相应包装类的xxValue方法实现拆箱。

2 自动拆装箱:与基本数据类型相同写法即可。另外阿里编码规约:对于基本的POJO类(自定义类),成员变量统一使用包装类,方法中局部变量可以使用基本类型。


13 异常

异常:程序执行过程中发生的不正常行为。重点为:程序执行过程中发生的,导致程序无法继续执行下去。编译时产生的语法错误不叫异常,因为它还没运行,可以直接解决。

在Java中,异常也是类。其实程序抛出的异常就是一个异常对象,是JVM产生并返回程序。

A 异常的分类

异常体系核心的两个父类:

Error:JVM无法解决的重大问题,程序无法解决只能退出。

Exceprtion:异常处理后可以通过异常的处理流程来解决此类问题,使得程序继续执行。

所以异常处理流程只针对Exception类

另外异常还有另一种分类:

受查异常:又称编译时异常,在程序编译的时候必须显示处理的异常。个人理解为与编译阶段的语法错误差不多,不显示处理就报错运行不了。包括Exception内的IOEException  SQLException等。

非受查异常:又称运行时异常,程序编译时没有产生任何错误,但是在运行时发生的异常。包括Erroe类与Exception类里的RuntimeException类。

B 异常的处理

Java对异常的处理方式为先执行再处理

处理异常的五个关键字:try catch finally throw throws

异常的捕获并处理: try - catch - finally 代码块

一些注意的地方:

a 没有异常产生不走catch语句

b 异常产生被捕获到,则try异常后的语句不执行,但一异常体系之后的代码可以执行

c 可以使用多个catch来捕获可能出现的不同异常

d 不确定具体异常时,可以使用异常的父类来捕获异常

e 若catch分支存在继承关系则必须将子类写在父类之前

f 多个catch分支只会走一个分支,其他的不执行。

g 无论是否产生异常 finally代码块的内容必定会被执行,除非整个JVM退出(例如 System.exit)

出现异常不处理,直接抛回给调用者处理:throw 与 throws

throws:用在方法声明上,明确表示该方法可能产生某些异常,但不处理,抛回给调用者处理。

关键点:
1.throws关键字在方法列表之后进行定义
2.throws可以抛出多个异常,多个异常使用"∵"分隔,若有父子关系,只需要抛出父类异常即可!
3.throws抛出的必须是Exception以及其子类

throw:用在方法内部,程序员在出现异常时,自己产生异常对象并向外抛出(原本异常由JVM产生,现在由程序员自己产生)一般配合自定义异常使用。  

C 自定义异常  

需要拓展的是非受查异常继承RuntimeException类
若需要拓展的是受查异常继承Exception类


14 内部类

将一个类定义在另一个类的内部,这个类就叫内部类。

内部类分为四种:成员内部类,静态内部类,方法内部类(局部内部类),匿名内部类

我们最需要注意的一点就是,内部类与其外部类之间无论使用什么权限对其各自的属性或方法进行封装,他们都仍然可以互相访问到对方的属性和方法,只不过有些情况是需不需要创建对象的区别。因为内部类仍然处在外部类的内部,我们可以认为它们可以是一体的。

内部类其他知识点参考链接:http://t.csdn.cn/9DvWb