java入门笔记

chp1.语言基础

基本语法、标识符、命名规范、八种基本类型、操作符、运算符、if else、switch

chp2.循环结构

while、do while、for、break、continue

chp3.函数

函数的三要素、return的用法

chp4.数组

一维数组、数组参数、数组返回值、数组增删、扩容、排序

chp5.面向对象

类和对象、实例变量、构造方法、方法重载、引用的概念、this关键字

chp6.面向对象三大特性

封装、继承、多态、对象创建过程、访问修饰符、super关键字、方法重写、instanceof

chp7.三个修饰符

static、final、abstract

chp8.接口

基本语法、接口的作用、接口回调

chp9.集合框架

Collection、List、Set、Map的接口及其实现类、迭代器、foreach

chp10.异常

分类、产生、传递、处理、自定义异常

 

chp1.语言基础

一、HelloWorld：

1.创建 .java结尾的源文件。

2.class：类（代码的容器）。

3.main：主函数，程序执行入口。

4.一行只写一句逻辑代码，并且以 ;结束。

二、编译、运行：

1.编译：javac源文件名称.java例：javac A.java

2.运行：java类名例：java HelloWorld

三、类的阐述：

1.在一个源文件中，可以定义多个类，编译后，每个类都会生成独立的字节码文件。

2.在一个类中，只能有一个主函数，每个类都可以有自己的主函数。

3.公开类（public class）的类名要和文件名完全相同。

4.一个源文件中，只能有一个公开类。

四、Package（包）：-- 文件夹

1.作用：管理类、区分类。

2.语法：package包名;（必须是源文件的第一行）

3.带包编译：javac -d .源文件名称.java（自动生成目录结构）。

4.带包运行：java包名.类名。（全限定名）

注：域名倒置com.baidu.vip.dept.group.project.model.test.HelloWorld.java

五、编码规范：

1.良好的注释习惯：

I.注释不参与编译。

II.单行注释： //单行

III.多行注释： /*多行*/

IV.文档注释： /**Doc*/   javadoc -d . TestPackage.java

2.良好的标识符命名规范：

I.硬性：

a.字母、数字、_、$

b.数字不能开头。

c.不能与关键字、保留字重名。

II.软性：

a.望文生义、见名知义。

b.类名可以由一个或多个单词组成，每个单词的首字母大写，帕斯卡命名法（pasacl）HelloWorld  UserName  IdentityCard

c.函数、变量名由一个或多个单词组成，首单词首字母小写，拼接词的首字母大写，驼峰命名法（camel）。helloWorld userName

d.包名全小写，只能使用特殊符号 .，并且不以 . 开头或结尾。

e.常量全大写，多个单词用 _链接。USER_NAME  HELLO_WORLD

8bit = 1byte - kb - mb - gb - tb - pb - eb - zb - yb - bb - db - cb - xb

六、变量：

1.概念：一个数据存储空间的表示，它是存储数据的基本单元。

2.语法：

I.声明：数据类型变量名;

赋值：变量名 =值;

II.声明并赋值：数据类型变量名 =值; //常用

III.同时声明多个相同类型的变量：

数据类型变量名,变量名,变量名 = 值;

注：变量一定要先赋值，后使用。

七、数据类型：

1.基本数据类型（原始、简单）8种：

I.整数：

a.byte1个字节-128 ~ 127-2^7 ~ 2^7-1

b.short2个字节-32768 ~ 32767-2^15 ~ 2^15-1

c.int4个字节-2147483648 ~ 2147483647 -2^31 ^ 2^31-1

d.long8个字节-922京~ 922京-2^63 ~ 2^63-1附加L

II.小数（浮点）：近似值 1bit符号位  8bit指数位  23bit尾数位

a.float：4个字节1.4E-45 ~ 3.4E38附加F

b.double：8个字节4.9E-324 ~ 1.7E308附加D

III.字符：

a.char2个字节 \u0000 ~ \uFFFF 'A' ,01000001,101,65,\u0041

b.转义字符：\'\"\\ \t缩进制表位  \n换行

c.unicode编码：万国码、统一码

IV.布尔：boolean取值：true / false

2.引用数据类型（对象）：

I.字符串：String"字面值"

八、类型转换：

1.自动类型转换：

I.两种类型相互兼容。

II.目标类型大于源类型。

2.强制类型转换：

I.两种类型相互兼容。

II.目标类型小于源类型。

III.规则：

I.整数长度合适，数据完整。

II.整数长度不适，去掉高位。

III.小数强转整数，失去精度。

IV.字符整数互转，数据完整。

V.boolean的取值只能true和false，不可与其他类型转换。

九、表达式：

1.概念：使用运算符链接的变量或字面值，并可以得到一个最终结果。

2.自动类型提升：

I.两个操作数有一个为double时，运算结果提升为double。

II.没有double，出现float，结果提升为float。

III.没有float，出现long，结果提升为long。

IV.没有long，出现int，结果提升为int。

V.没有int，出现short或byte，结果提升为int。

十、运算符：

1.算数运算符：+  -  *  /  %  ++  --

2.赋值运算符：=  +=  -=  *=  /=  %=

3.关系运算符：>  <  >=  <=  ==  !=

4.逻辑运算符：

I.&&（并且）：两个条件同时为true，结果才为true。

II.||（或者）：两个条件有一个为true，结果为true。

III. !（非）：取反。

5.三元运算符：布尔表达式 ?结果1 :结果2  //往往用作判断后赋值

十一、控制台输入：

1.引用包：import包名.类名; //将外部class文件引入到自身文件中。

2.声明Scanner变量。// Scanner input = new Scanner(System.in);

3.使用Scanner类中的变量调用对应函数（区分类型）：

I.input.nextInt();//整数

II.input.nextDouble();//小数

III.input.next();//字符串

IV.input.next().charAt(0);//字符

十二、选择结构：

1.基本if选择结构：

if(布尔表达式){

//表达式结果为true，执行此代码块

}

2.if else选择结构：

if(布尔表达式){

//结果为true，执行此代码块

}else{

//结果为false，执行此代码块

}

3.多重if选择结构：

if(布尔表达式){

}else if(布尔表达式){

}else if(布尔表达式){

}else{ //可省略

}

注：相互排斥，当有一个条件满足时，其他均不再执行。适用于区间判断，保证升降顺序。

4.嵌套if选择结构：

if(布尔表达式){ //外层条件满足时

if(布尔表达式){ //再去判断内层条件

}

}

注：选择结构中，可以嵌套另一个选择结构，可任意组合。当外层条件满足时，再判断内层条件。

十三、分支结构：

1.switch分支结构：byte short int char //JDK 7+可以判断String

switch(byte / short / int / char){

case 1:

break;

case 2:

break;

case 3:

break;

default:

break;

}

注：适用于等值判断，所有case值不可相同。当某个条件满足时，并不会自动结束整个switch结构，而会向下贯穿，应当增加break。

2.break关键字：终止当前switch分支结构。

三、局部变量：

1.概念：声明在函数内部的变量，需先赋值再使用。

2.作用范围：定义行开始到包含其代码块结束。

3.避免命名冲突。

 

chp2.循环

一、循环：

1.概念：通过某个条件，使一段代码周而复始的执行。

2.组成：初始部分、循环条件、循环操作、迭代部分。

3.分类：

I.while循环：

特性：先判断、再执行。

应用场景：循环次数明确。

例：统计1、2、3、4、5 ...... 100所有数的和。

II.do......while循环：

特性：先执行、再判断。（首次没有入口条件）

应用场景：循环次数不明确。

例：先上机编码，再检查结果。

III.for循环：

特点：先判断、再执行。

应用场景：循环次数明确。

例：与while解决相同问题。

二、流程控制语句：

1.break：终止、跳出switch或循环结构。

2.continue：结束本次循环、进入下一次循环。

三、嵌套循环：

1.概念：一个完整的循环结构中，嵌套另一个完整的循环结构。

2.图形：外层循环控制行数，内层循环控制列数。

3.其他：外层控制循环次数，内层控制单次循环操作。

4.循环Label标签，可为循环定义名称，并选择性跳出循环。

5.三重循环效率低，可读性差。

 

chp3.函数

一、概念：实现特定功能的一段代码，可反复使用。

二、定义：

1.语法：

public static返回值类型 函数名称(形式参数列表 ){

//函数主体

[ return value; ] //返回值

}

2.组成：

I.函数名称：望文生义（Camel）。

II.函数主体：逻辑代码，完成特定功能。

III.形式参数列表：可声明一个或多个形参，既函数的局部变量。

IV.返回值类型：基本数据类型、引用数据类型、void。

V.返回值：

a.return value;//结束当前函数，并伴有返回值，返回到调用处。

b.规定：一个函数只能有一个返回值。

c.注意：当函数存在分支语句时，保证所有分支都具备返回值。

d.return; //单独出现，表示结束当前函数，返回到调用处。

三、调用：

1.无参调用：函数名称();

2.有参调用：函数名称(实际参数列表); //为形参赋予实际的值，要保证类型、个数、顺序都与形参列表相同。

3.数据接收：数据类型变量名 =函数名称(实参);//当调用具有返回值类型的函数时，使用变量存储其结果。

4.执行机制：调用函数时，程序会调转到函数定义位置，优先执行函数内部内容。当函数执行结束时会携带返回值，返回到调用位置，继续执行。

四、总结：

1.一个类中可以定义多个函数，函数之间属于并列关系，不可嵌套。

2.一个函数只做一件事儿（单一职能原则）。

3.减少代码冗余，提供复用性，提供可读性，提供可维护性，方便分工合作。

五、递归：

1.将大问题拆分成小问题，解决方案相同，有一个固定规律，函数自己调用自己。

2.最终必须包含出口条件，避免无穷递归。

 

chp4.数组

一、概念：一组连续的存储空间，存储多个相同数据类型的值。

二、语法：

1.数据类型[]变量名;//声明数组

变量名 = new数据类型[长度];//分配存储空间

2.数据类型[]变量名 = new 数据类型[长度]; //声明并分配空间

3.数据类型[]变量名 = new 数据类型[]{值1,值2,值3,...}; //声明并赋值

4.数据类型[]变量名 = {值1,值2,值3,...}; //声明并赋值

三、数组的默认值：

1.int0

2.double0.0

3.char\u0000ａ

4.booleanfalse

5.Stringnull（引用数据类型的默认值都是null）

6.其他null

四、数组的访问：

1.index（下标、索引），有效值：0 ~ length - 1

2.数组名[下标]进行数组元素的访问。

3.遍历：从头至尾逐一访问数组的元素。

4.长度：数组名.length    //获取数组的长度

注意：如访问不存在的下标时，发生数组下标越界异常

ArrayIndexOutOfBoundsException

五、应用：

1.变量中的数据拷贝：

I.基本数据类型，复制的是值。一方改变不影响另一方。

II.引用数据类型，复制的是地址。一方改变会影响另一方。

2.数组扩容：

I.声明：在原数组的长度基础上，重新声明新数组。

II.赋值：

a.通过循环将原数组中所有元素逐一赋值给新数组。

b.System.arraycopy(原名,原数组起始下标,新名,新数组起始下标,个数);

3.java.util.Arrays.copyOf(原数组名,新长度); //自动创建、赋值、返回新数组

六、排序：

1.冒泡排序：相邻的两个值比较大小，互换位置（升序：小值靠前。降序：大值靠前）。外层：length - 1内层：length - 1 - i

2.选择排序：固定位置的值和其他位置的值比较大小，互换位置。

外层：length - 1内层：int j = i + 1 ;  j < length

3.快速排序：java.util.Arrays.sort(数组名); //JDK提供（只能做升序，如需降序应元素倒置）。

 

chp5.面向对象思想

一、Object Oriented Programming：

1.一切客观存在的事物都是对象，万物皆对象。

2.对象一定具备自己的特征（属性）和行为（方法）。

二、类：

1.概念：

I.在多个相同或类似的对象中，抽取出共性的特征和行为。

II.类是对象的集合（模板）。

2.组成：

I.属性：

a.成员变量（实例变量）：声明在类的内部，函数的外部。

b.语法：数据类型变量名;

c.成员变量和局部变量的区别：

 

局部变量

成员变量

定义位置

函数内部

类的内部、函数的外部

默认值

无

字面值（与数组相同）

使用范围

定义行到包含其代码块结束

本类有效

命名冲突

不允许重名

可与局部变量重名、局部变量优先

注：如果成员变量的声明和赋值分开完成时，则赋值语句必须在函数内部。

II.方法：

访问修饰符返回值类型方法名(形参列表 ){

//方法主体

}

III.方法重载（Overload）：

a.概念：方法名称相同、参数列表不同（类型、个数、顺序）。

b.作用：屏蔽使用差异，使用方式更灵活、方便。

IV.构造方法：

a.构造方法名与类名完全相同。

b.没有返回值类型。

c.创建对象时，触发构造方法的调用，不可通过句点手动调用。

d.注意：

i.在类中，如果没有显示定义构造方法，则class默认提供无参构造方法。

ii.如手动添加了构造方法，则无参构造不再默认提供，根据需求手动添加。（建议：显示定义无参构造）

iii.通过关键字new对象时，根据传入参数确定调用的构造方法，完成创建。

iv.构造方法可在创建对象的同时，完成属性的赋值操作。

三、对象：将数据及对数据的操作放在一起，作为一个相互依存不可分割的整体。

1.概念：

I.具有多个特征和行为的实体。

II.对象是类的实例。

2.创建对象：

I.语法：数据类型对象名 = new数据类型();

II.分配空间：栈分配变量空间，堆分配对象空间。

四、访问属性及方法：

1.引用（reference）中保存对象在堆中的地址。

2.引用.属性名   或   引用.方法名()

s1.name; //取值

s1.name = "tom"; //赋值

s1.study(); //调用方法

五、this关键字：

1.引用（当前实例）：当成员变量和局部变量重名时，优先使用局部变量，如需使用成员变量，应增加this关键字。如：this.name / this.sayHi()

2.this()只能在构造方法中调用其他构造方法，this()或this(实参)必须在构造方法的第一行。

 

chp6.面向对象三大特性

一、封装：

1.概念：尽可能隐藏对象的内部实现细节，控制用户对对象的访问及修改的程度、权限。

2.实现：

I.私有属性：private修饰属性名称。

II.公共方法：public修饰对应的get、set方法。

III.访问形式：

a.封装前：

i.赋值：s1.age = 19;

ii.取值：s1.age

b.封装后：

i.赋值：s1.setAge(19);

ii.取值：s1.getAge();

IV.遵循POJO（Plain Ordinary Java Object）简单的Java对象，用以存储数据，简称实体类。

二、继承：

1.类与类之间满足is a的关系。子类（派生类）是一个父类（超类、基类）。

2.父类的抽象：

I.父类：在一组相同或类似的类中，抽取共性的特征和行为，封装在父类中，实现重用。

II.功能越精细，重合点越多，越贴近直接父类。

III.功能越粗略，重合点越少，越贴近Object类。

3.继承语法：class子类 extends 父类{}

4.产生继承关系后，子类可以使用父类中的属性和方法，也可以定义独有的属性和方法，从而提高代码可扩展性。

5.Java中为单继承，一个类只能有一个直接父类，但可以多级继承。

6.不可继承：

I.父类构造方法。

II.private修饰的属性和方法。

III.当父子类不在同一个包时，使用default修饰的属性和方法。

 

本类

同包

不在一个包中的子类

其他

private

yes

 

 

 

default

yes

yes

 

 

protected

yes

yes

yes

 

public

yes

yes

yes

yes

 

7.方法的覆盖（Override重写）：

I.当父类所定义的方法无法满足子类需求时，可在子类中声明和父类完全相同的方法进行覆盖。

II.访问修饰符要求子类和父类相同，或比父类更宽泛。

8.super关键字：

I.在子类中，通过 super.访问父类的属性和方法。

II.super()、super(实参)显示调用父类构造方法，必须在子类构造方法的第一行。

III.在子类构造方法中，如不显示添加super()，则class默认提供。

9.继承关系初始化：构建子类对象时，先构建父类对象。

I.初始化父类属性。

II.执行完毕父类构造方法。

III.初始化子类属性。

IV.执行完毕子类构造方法。

三、多态：

1.概念：父类引用指向子类对象，从而产生多种形态。

2.语法：

父类类型引用名称 = new子类类型(); //主观类型-- 实际类型

注：父类引用仅可调用自身声明的方法，不可调用子类独有方法。

3.应用场景：

I.使用父类作为方法形参，实现多态。

II.使用父类作为方法返回值，实现多态。

4.作用：

I.屏蔽子类间的差异。

II.灵活、耦合度低。

5.对象类型转换：

I.父类引用中保存子类真实实例，称为向上转型（装箱）。

如：Anima a = new Dog();    Vehicle v = new Bus();

II.将父类引用中的真实子类对象，强转为子类类型，称为向下转型（拆箱）。

如：Dog d = (Dog)a;Bus b = (Bus)v;

III.向下转型时，如子类真实类型与目标类型不匹配，发生类型转换异常（java.lang.ClassCastException）。

如：Vehicle veh = new Bicycle();

 Car car = (Car)veh; //转换异常

6.类型判断（instanceof）：

I.语法：父类引用 instanceof类名; //判断引用和类型是否匹配

 

chp7.三大修饰符

一、static（静态）：

1.概念：static修饰符，表示类级别成员。//动态=对象、静态=类

2.静态属性（类变量）：

I.全类共有的属性（不属于某一个实例对象）。

II.访问静态属性可以使用类名.静态属性名。如：Person.sun;

3.静态方法（类方法）：

I.全类共有的方法（不属于某一个实例对象）。

II.访问静态方法可以使用类名.静态方法名。如：Person.method();

Math.random();  Math.sqrt();

III.所有引用调用的静态方法都转换成类名调用。

IV.静态方法可以继承、不能覆盖，没有多态。

V.静态方法不能直接调用非静态的属性和方法。（可能还没有对象）

4.静态代码块：

I.类加载的时候被执行一次，不能手动调用。

II.类加载：

a. JVM首次使用（new对象时、调用静态成员、使用子类时，Class.forName("类名")）某个类时，通过CLASSPATH查找该类的

class文件。

b.将类的描述信息（属性、方法）加载到内存中，进行保存。

III.优先加载，可为静态属性赋值，或任何程序必要的初始行为。

二、abstract（抽象）：

1.修饰类：不能new对象。

2.修饰方法：只有方法声明，没有方法实现。（必须包含在一个抽象类中）

3.作用：强制使用多态。

4.注：

I.抽象类不一定有抽象方法，但有抽象方法的类一定是抽象类。

II.子类继承抽象类后，必须实现父类所有的抽象方法，否则子类还是抽象类。

三、final（最终）：

1.修饰类：此类不能被继承。（String、Math、System）

2.修饰方法：此方法不能被覆盖。（与abstract属非法搭配）

3.修饰变量：此变量的值不可改变（常量）。

I.只能被赋值一次：

a.手动初始化。

b.动态代码块或构造方法中。

c.静态代码块可以为静态常量赋值。

d.常用public static final公开静态常量。

II.注意：

a.基本数据类型--值不可变。

b.引用数据类型--地址不可变。

福利：哈哈

只要好好学，事业会有的，爱情也是会有的，奋斗吧，美女们，帅哥们~

chp8.接口

一、概念：相当于特殊的抽象类，接口是一种能力，接口是一种约定。

二、语法：

1.定义接口：interface接口名{}

2.实现接口：implements接口名{}

  implements接口1 ,接口2 ,接口3 , ...

三、与抽象类的对比：

1.相同：

I.编译成字节码文件。

II.不能创建对象（接口不是类，没有构造方法）。

III.可以作为引用类型。

2.不同：

I.所有属性都是公开静态常量，隐式使用public static final修饰。

II.所有方法都是公开抽象方法，隐式使用public abstract修饰。

四、规范：

1.任何类在实现接口时，必须实现接口中所有的抽象方法，否则还是抽象类。

2.实现接口的抽象方法，访问修饰符必须是public。

五、应用环境：Java为单继承，当父类定义的方法个数无法满足子类需求时，可以通过实现接口来扩充子类的能力。

六、关系：

1.类与类 =继承//单继承

2.类与接口 =实现//多实现

3.接口与接口 =继承//多继承

七、接口引用：接口引用指向实现类对象，也可使用多态，仅可调用接口中声明的方法。

八、好处：

1.设计与实现完全分离。

2.更自然的使用多态。

3.更容易搭建程序框架。

4.更容易更换实现。

5.耦合度降低。

九、接口回调：开发过程中，定义接口之后，先有接口的使用者，后有接口的实现者。

 

chp9. Object、内部类、包装类、String

一、Object：

1.概念：

I.超类，所有类都直接或间接的继承了Object。

II.Object类型可以存储任何对象，作为参数，可接收任何对象。作为返回值，可返回任何对象。

2.常用方法：

I.public boolean equals(Object obj) //比较两个对象是否相同

II.public String toString() //返回该对象的字符串表示

III.public Class getClass() //返回该对象的运行时类型

IV.protected void finalize() //标示对象是否需要回收

a.垃圾回收：销毁垃圾对象，释放存储空间。

b.垃圾对象：没有任何引用指向此对象。

c.垃圾回收器：Garbage Collection：GC、Garbage First：G1

1).自动回收：JVM的内存耗尽，不能为新对象分配空间时，一次性回收所有垃圾对象。

2).手动回收：使用System.gc();通知JVM做回收，在GC处于空闲时，真正执行垃圾收回。

二、内部类：

1.概念：

I.在类的内部再定义一个类。

II.内部类可以访问外部类的私有成员。

2.分类：

I.成员内部类：

a.外部类的一个部分，创建内部类对象时，必须依赖外部类对象。

b.通过外部类类名.this访问外部类成员。

c.语法：

Outer out = new Outer();

Outer.Inner in = out.new Inner();

II.静态内部类：

a.不依赖外部类对象，可直接创建内部类对象，或通过类名访问。

b.只能直接访问外部类的静态成员

c.语法：

Outer.Inner in = new Outer.Inner();//创建对象

Outer.Inner.staticMethod(); //可直接访问内部类静态方法

III.局部内部类：

a.定义在方法内部，作用范围和创建对象范围仅在方法主体中。

b.可访问定义自身类的方法中的局部变量，但必须修饰为final，保证生命周期一致。

c.隐藏类的内部实现细节。

IV.匿名内部类：

a.没有类名的局部内部类。

b.必须继承一个类或实现一个接口。

c.定义类、实现类、创建对象的语法合并。

d.生命周期内只能创建一个对象。

注：仅接口公开，实现类作为匿名内部类加以隐藏，强制弱耦合。

三、包装类：

1.概念：

I.8种基本数据类型所对应的引用数据类型。

II.Object可统一所有数据类型，包装类的默认值是null。

2.类型匹配：

byte--->Byte

short--->Short

int--->Integer

long--->Long

float--->Float

double--->Double

char--->Character

boolean--->Boolean

3.类型转换：

public static int parseInt(String s)

public static Integer valueOf(String s)

new Integer(String s)

public int intValue()

4.考虑类型兼容问题，避免异常发生。

5.JDK 5.0之后，自动装箱、拆箱。基本类型与包装类型自动转换。

四、String：

1.概念：

I.字符串是常量，创建之后不可改变。

II.字符串字面量存储在串池中，可以共享。

III.创建对象：

String s1 = "abc"; //产生一个对象，存放在串池中

String s2 = new String("def"); //产生两个对象，串池、堆中各一个

2.常用方法：请参考API（java.lang.String）。

3.缓冲字符串：

I.StringBuffer：JDK 1.0线程安全，速度慢，效率低

II.StringBuilder：JDK 5.0 线程不安全，速度快，效率高

 

chp10.集合框架

一、概念：

1.对象的容器，存储对象的对象，代替数组。

2.位置：java.util.*;

3.结构：

二、Collection体系集合：

1.Collection父接口：

I.特点：存储所有Object对象。

II.方法：

add()、clear()、contains()、isEmpty()、remove()、size()、toArray()

2.List接口（继承Collection）：

I.特点：有序、有下标、可以重复。

II.方法：

void add(int index , Object e)//在index位置插入对象e

Object get(int index) //返回index位置的对象

Object remove(int index) //移除index位置的对象

Object set(int index , Object e) //替换index位置的对象

III.实现类：

a.ArrayList【重点】：

1).数组结构存储。

2).轻量级，JDK1.2操作速度快，线程不安全。

3).查询快，增删慢。

b.Vector：

1).数组结构存储。

2).重量级，JDK1.0操作速度慢，线程安全。

3).查询快，增删慢。

c.LinkedList：

1).链表结构存储。

2).查询慢，增删快。

3).实现Stack后进先出

4).实现Queue 先进先出

三、泛型集合【重点】：（范）

I.参数化类型，类型安全的集合，限制元素类型必须一致。

II.编译时即可检查。

III.访问时，不必类型转换（拆箱）。

IV.不同泛型之间的引用不能相互赋值，泛型不存在多态。

四、Collections工具类：

I.public static void reverse(List<?> list) //倒置元素

II.public static void shuffle(List<?> list) //随机置换

III.public static void sort(List<?> list) //升序排序

五、Set接口（继承Collection）：

I.特点：无序、无下标、不可重复。

II.方法：继承自Collection。

III.实现类：

a.HashSet：

1).iterator()：迭代器

2).for(数据类型 变量名: 集合/数组)：foreach循环

3).hashCode：JDK根据对象的地址或字符串或数字算出来的int类型数值。哈希码并不是绝对唯一，尽量保证不同对象返回不同哈希码。绝对保证相同对象返回相同哈希码。

4).将自定义类型对象存入HashSet时，无法保证数据相同的元素不重复，必须重写hashCode()，和equals()。

b.LinkedHashSet：保留元素插入顺序。

c.TreeSet：实现了SortedSet接口，对集合元素自动排序。

六、Map体系集合：

1.Map父接口：

I.特点：存储一对儿数据。key - value。无序、无下标，键不可重复。值可以重复。通过自定义键访问值。

II.方法：

Object put(Object key ,Object value)//关联键值(key重复则覆盖原值)

Object get(Object key) //通过键取值

Set keySet() //所有键

Collection values() //所有值

Set entrySet() //所有"键=值"的形

III.实现类：

a.HashMap【重点】：

1).JDK 1.2操作速度快，线程不安全。

2).允许使用null作为键或值。

b.Hashtable：

1).JDK 1.0操作速度慢，线程安全。

2).不允许使用null作为键或值。

c.Properties：

1).Hashtable子类，非泛型类。

2).key和value都是String类型，常用于读取配置文件。

3).setProperty(String key,String value) / getProperty(String key)

d.TreeMap：实现了sortedMap接口，自动对key排序。

主线：ArrayList、HashSet、HashMap

副线：泛型集合、迭代器、 foreach

 

chp11.异常

一、概念：程序在运行过程中出现的特殊情况。

二、异常分类：

Throwable：

|-- Error：错误，JVM、硬件、执行逻辑错误，不能用代码处理。

|-- Exception：异常，程序在运行和配置中产生的问题，可处理。

|-- RuntimeException：运行时异常，可处理可不处理。

|-- CheckedException：已检查异常，必须处理。

三、异常的产生：

1.自动抛出异常：当程序在运行时遇到不符合规范的代码或结果，会产生异常。

2.手动抛出异常：throw new异常类型;

3.产生异常的结果：相当于遇到return语句，导致程序中止。

四、异常的传递：按照方法调用链反向传递。m3 -> m2 -> m1 -> main -> JVM

五、异常处理：

1.作用：发生异常时，为提高代码的容错性，避免程序中止，可以执行一些预判的处理代码，从而尽量减少程序异常带来的损失。

2.方式：

I.消极处理：throws声明异常，修饰在方法参数列表的后端。

public static void m3(int i)throws Exception{} //消极处理

注：只有异常的传递，最终没有捕获异常，程序仍旧会中止。

II.积极处理：捕获、处理异常。

try{

//可能出现异常的代码

}catch(Exception e){ //将捕获到的异常对象赋值给e引用

//异常处理代码

// e.printStackTrace() //打印堆栈跟踪信息

// e.getMessage() //只获取异常原因，无堆栈信息

}finally{

//无论是否发生异常，此代码块一定会执行

//常用作关闭资源

}

3.异常结构：

try{} catch( ){}

try{} catch( ){} finally{}

try{} catch( ){} catch( ){} .... finally{}

try{} finally{}

注：可以有多个catch块，遵循从小到大的顺序，父类异常在最后。

六、自定义异常：

1.需继承自Exception或Exception的子类，常用RuntimeException。

2.继承CheckedException后，通常不直接处理，以throws声明，交由调用者处理。

七、异常的方法重写：

1.遵循重写规则。

2.子类重写父类方法时，不可抛出比父类更宽泛的已检查异常。