标签：通用   批量   func   bounds   子线程   打包   开源框架   列表   文件名   

1. Java概述

-       Java同C#（Visual C#）和.NET（.NET Framework 3.0）三分天下。

-       我们通常叫某个版本java 8或者jdk1.8。

#Java发展史

思路：兴盛衰亡（时间人物事件）

-      名字由来：

         起名字的时候，有人在喝爪哇岛上产的咖啡，于是起了这名字

-       重要时间节点：

         1. 1995年5月，诞生于sun

2. 1998年12月，java1.2

         3. 2004年9月，java5

         4. 2009年，sun被Oracl收购

#什么是软件

         1. 一系列按照特定顺序组织的计算机数据和指令的集合。

         2. 是人与计算机之间交互的桥梁。

#Java特点

1. 跨平台原理：通过JVM实现了Write once，run everywhere。

#新版本特性

@版本升级机制：

升级有三个部分：高效、简化书写、安全。

@JDK1.5

-         foreach语句是java5的新特征之一，在遍历数组、集合方面，foreach为开发人员提供了极大的方便。

-         注解功能。（jdk5以后的新功能）

-         自动装箱和自动拆箱。（jdk5以后的新功能）

-         Switch()后面可以放枚举（jdk5以后）

-         泛型机制的产生，导致安全隐患的产生（jdk5以后）

@JDK1.7

-       增加了二进制表示方法：“0b“，例如用二进制表示整数3，

                          Int a=0b000000000000000000000000000000011;//b后面有30个0；

-       增加了间隔符“_“,例如int a=111_222;等价于int a=111222;

-       switch后括号内数据类型可以是String类（jdk1.7以后）;

-       把Scanner之类的定义为流了，要求有开有关（java1.7以后）。

#java学习相关

@学习步骤

         1. 基础语法OOP面向对象实用API数据库javaWebSSM企业框架项目能力

@SSM（Spring+SpringMVC+MyBatis）框架集

-         由Spring、SpringMVC、MyBatis三个开源框架整合而成，常作为数据源较简单的web项目的框架。

@文档编辑

需求文档、概要设计文档、概要设计文档、数据库设计文档、接口设计文档。

@职业相关

-         相关职业：

         实施、程序员、运维。

-         Java软件工程师职业发展：

1. 技术方向：高级工程师、架构师。

2. 管理方向：项目经理、产品经理。

3. 商业方向：咨询顾问、销售经理。

@为什么要有开源精神

         1. 一门技术，如果它是开源的话，它就会变得越来越成熟。

         2. 当你写了一段团队里都能通用的程序代码时，你可以共享出去，节省大家开发时间，

也创造了别人给你提出问题的环境，让你的代码更加完善。

#java的应用

-         按开发领域（技术平台、技术架构）分类：

1. Java SE（之前叫J2SE，桌面程序、控制台开发），是基础核心，技术包括面向对象

  、API、JVM。

2. Java EE（之前叫J2EE，企业级开发，如网站开发和基于b/s模式的编程），技术体系

包含Servlet JSP、EJB、服务。

3. Java ME（之前叫J2ME，嵌入式开发，如手机、小家电等），技术包括移动设备、游

  戏、通信、PDA。

-       按开发对象分类：

1. 客户端（CS）

2. 浏览器（BS）

3. 移动端（Android App）

4. 高速运算和存储

#程序结构

@ JDK && JRE && JVM的关系与区别：

1. JDK>JRE>JVM

2. jre里面包含jvm（java虚拟机）、java核心类库等。

3. jdk里面包含jre和jdk开发工具、编译工具javac、打包工具jar等。

#搭建Java运行环境

第一步：安装JDK，记住安装路径；

-         第一次跳出的设置安装路径值得是jdk安装路径，第二次跳出的安装路径指的是jre的安装路径，jdk环境变量设置的是前者，两者不要搞混了。

-         注意：第二次的jre可以不安装，因为JDK里面已经包含了jre。

      尽量将java环境变量配置到path路径的头部。

第二步：设置环境变量。

新建系统变量JAVA_HOME,设置JAVA_HOME的值;（自定义环境变量是为了减少对path路径的操作，避免对path路径的误操作风险。）

新建系统变量CLASSPATH,设置JCLASSPATH的值;(jdk5.0以上版本可以不对classpath进行设置)

编辑系统变量path的值;

第三步：测试是否安装和设置成功

调出DOS命令行窗口；

依次输入javac、java、java -version;//有时需要重启dos，激活环境变量。

如果安装了多个jdk，可以通过javac –version可以查看当前使用的jdk版本。

#Java执行过程

@正常编译运行

第一步：写源程序（用Eclipse或者新手可用记事本编辑），生成文件后缀为.java；

第二步：JDK编译源程序，生成文件后缀为.class（该文件是可以运行在任何支持Java虚拟机的硬件平台和操作系统上的二进制文件）;

第三步：运行

@反编译

-         工具：

1. Jad

- 使用方法：

1.1 解压找到要反编译的.class文件，放到解压后的文件夹中（与jad.exe在同一个目

 录）打开DOS，切换到jad.exe所在目录输入命令：jad –s java *.class

1.2 如果中文显示为unicode格式，可在java后输入“-8”参数解决，jad –s java -8 *.class。

2. FrontEndPlus

- 定义：实质核心是Jad，图形化的工具。

- 使用方法：

1.1 FileDecompile class file找到要反编译的.class文件打开即可。

1.2 如果出现中文，则在界面选择ConfigurationsDecompiler Options勾选上最后一项。

#人机交互方式

1. 图形化界面（Graphical User Interface=GUI）

2. 命令行方式（Command Line Interface=CLI）

2. 基础语法

#命名规则

@类名

-       一个java源文件可以有多个class类，但是只能有一个public class类，public class 后面的类名一定与该java文件名一致;

-       类名第一个字母大写，方法名第一个字母小写

@全局规则

-       Java对大小写非常敏感，例如：需要大写的有String、System.out.print等;

-       每一行命令后必须以分号结束;

@变量规则

#书写规范

@缩进

Tab键可以空八格，下一级要相对于上一级缩进一次；

@成对编程

-       括号、引号都应该写完后，再往里面加内容;

-       花括号要成对，第一个花括号放在变量名后，第二个括号要与关键字第一个字母对齐;

@注释

单行注释//;

多行注释/*内容*/;

文档注释/**内容*/;

#注释

@功能注释

单行注释//;

多行注释/*内容*/;

文档注释/**内容*/;

@内容注释

1. @override//重写

#变量和参数

#变量分类

@常量

-         常量名字一般用大写字母和下划线，用final来定义，例如定义圆周率，final double PI=3.14;//像ruby语言中只要是大写就默认为是常量;

-         Final修饰的变量只能被初始化一次;

@实例变量（成员变量、全局变量）（成员属性、成员方法）

-         方法内部、类的内部定义的变量；

-         如果不初始化，它会自动初始化为该类型的默认出事值（数值型变量初始成0或0.0，字符型变量的初始值是16位的0即\u0000，布尔型默认是false，所有引用类型默认是null。

@局部变量

-         方法或语句块内部定义的变量

-         在使用前必须先声明和初始化

@成员变量和局部变量的区别

1. 作用域不同。

2. 初始值不同。Java会给成员变量一个初始值。数字0，布尔false,char\u0000,引用：null。

3. 在同一个方法中，不允许有同名局部变量。在不同的方法中，可以有同名局部变量。

4. 在同一个类中，成员变量和局部变量同名时，局部变量具有更高的优先级（就近原则）

#变量声明和定义

-       用房间来类比变量，则对应关系为：旅馆-内存地址，房间-变量，房间名字-变量名，房间类型-变量类型，入住的客人-变量值;

-       变量的作用：便于批量修改;

-       变量的批量声明：int a,b,c;或者int a=1,b=2,c=3;

#变量的三要素

-       数据类型：决定变量大小;

-       变量名称：方便计算机寻找这个变量;

-       变量的值：用来存储数据;

-       变量的作用域;

#变量命名规则

-       变量名=首字母(字母/下划线”_”/”$”符号)+其余部分(数字/字母/下划线”_”/”$”符号);

-       变量名是汉字也不会报错;

-       变量名不允许重复;

-       命名不能与关键字、布尔值和null相同

#变量命名规范和技巧

-       见名之义;

-       首字母小写和驼峰命名法;

-       接收的变量名与有返回值得方法名一样。这样便于一看就知道是哪个方法返回的。

#变量的使用

-       变量使用之前一定要赋值;

-       可以在一行中声明多个变量;

-       可以将变量的声明和初始化放在同一行中;

-       同名变量数据类型采用就近原则;

#可变参数（动态参数）

1. 一个方法只能有一个动态参数。

2. 一个方法中，既有普通参数又有动态参数，动态参数只能放最后。

3. 动态参数实质是数组参数的简写形式。它使得不用每一次都要手动的建立数组对象。

只要将要操作的元素作为参数传递即可。隐式的将这些参数封装成数组。

4. 动态参数一般只能对同一类型。要对不同类型，用Object。

5. jdk5.0版本开始。【实例】2：实现n个参数的和，版本变动前后对比：

3. 1优化前的代码：

//通过数组实现n个参数的和

public class Test {

   public static void show(int[] arr){

      int sum = 0;

      for (int i = 0; i < arr.length; i++) {

          sum+=arr[i];

      }

      System.out.println(sum);

   }

//测试类

public static void main(String[] args) {

   int[] arr = {3,4};

   show(arr);

   int[] arr1 = {1,2,3};

   show(arr1);

   }

}

3.2 优化后的代码：

         //通过动态实现n个参数的和，在方法阶段并没有减少代码量，

         //代码量减少主要体现在调用阶段，如下main函数中。

         public static void show(int...arr){

      int sum = 0;

      for (int i = 0; i < arr.length; i++) {

          sum+=arr[i];

      }

      System.out.println(sum);

   }

         //测试类

         public static void main(String[] args) {

                  //动态参数时，参数可以是分开的数也可以是数组

                  int[] arr1 = {1,2,3};

      show(arr1);

      show(1,2,3);

   }

#字符集

@Unicode

-   定义：

1. Unicode字符集占用两个字节，可同时包含2的16次方=65536个字符。

2.ASCII/ANSI只包含了255个字符，实际是Unicode的一个子集。

-       使用场景：

Java中内置了一个Unicode码表，无论什么字符都用两个字节表示。

-         使用方法：

1.通常采用16进制表示，范围在’\u0000’到’\uFFFF’。\u0000到\u00FF表示这是一个ASCII/ANSI码。\u表示这是一个Unicode值。\u0000代表的应该是NULL，输出控制台是一个空格。

@UTF-8

         1. 国际通用的一种编码格式。

@GB2312

         1.一种中文编码格式。

@注意事项

1. Scanner接收键盘输入，输出字符集为GBK

2. ANSI编码可以理解为GBK。

3. 中文乱码原因：文件编码格式和程序环境编码格式不一致。

4. GBK是GB2312的扩展。

#数据类型

-       Java是一种强类型语言，每个变量都必须声明其类型;//像javascript则是弱类型语言

         ，声明变量时只需“var 变量名;“即可。

@数据类型分类

1. Java中除基本类型之外的变量类型都称之为引用类型。

2. 分类：

-       基本数据类型:

-         数值型

-       整型类型（byte、short、int、long）

-       浮点类型（float、double）

-       字符型（char）

-       布尔型（boolean）//容量是1位，不是1个字节

-       引用数据类型（所有引用类型的地址都是4个字节）

         -       类（class）、String、Scanner、Random……

         -       接口（interface）

         -       数组

-       自定义数据类型：自己定义的类或接口。

@自动类型转换

1. 条件：两者要兼容，目标类型容量大于源类型;这里的“容量”指的是取值范围，而

不是数据类型的字节大小；

2. 上图黑色箭头也可以逆向自动转换，条件是源类型容量不超出目标类型，例如byte

         B=123;//int类型123在byte取值范围-128~127之间;

@强制类型转换

1. 语法：

-       （目标类型名）源数据;

2. 原理：

-       强制转化的时候可能损失精度，损失精度实质是丢失字节。

@基本类型转换时常见错误和问题

1. 表达式中的类型提升问题

不同类型的数据，做所有的二元运算（+-*/%），都会有类型提升的问题；例如

int a=3;

long b=4;

int c=(int)(a+b);

2. L和l的问题

         例如：计算某人72年心跳的次数

                          long times=70L*60*24*356*70;//L大写，最好放在第一个数字后，防止L之前

                          的结果造成溢出；       

3 .溢出问题:

@基本数据类型和引用数据类型的比较

1. 传参时的区别：

                  1.1 一个方法不能改变一个基本数据类型参数的值。

                  1.2 一个方法可以改变一个引用数据类型参数的属性。

                  1.3 一个方法不能将一个引用数据类型的参数指向一个新的引用。

@Char（字符型）

容量、范围、书写、转义字符

@float（浮点型）

1. float与double的区别：

1.1 float是单精度类型,精度是8位有效数字，取值范围是10的-38次方到10的38次方

float占用4个字节的存储空间

1.2 double是双精度类型，精度是17位有效数字，取值范围是10的-308次方到10的

308次方，double占用8个字节的存储空间

1.3 当你不声明的时候，默认小数都用double来表示，所以如果要用float的话，则应

该在其后加上f

例如：float a=1.3;

则会提示不能将double转化成float  这成为窄型转化

如果要用float来修饰的话，则应该使用float a=1.3f

1.4 注意float是8位有效数字，第7位数字将会产生四舍五入

所以如果一个float变量 这样定义:  float a=1.32344435;   则第7位将产生四舍五入;

@int（整型）

1. Java语言整型常数的三种表示形式：

-       十进制整数，如：99

-       八进制整数，如：015

-       十六进制整数，如：0x15

2. java语言的整型常数默认为int，声明long型常量可以后加”l”或”L”（建议使用大写，

小写容易误认为数字1），如：

                  -       long a=55555555;//不会出错，在Int表示的范围内(21亿内)

                  -       long b=55555555555;//报错，已经超出Int的表示范围

@数组

&相关概念

1. 数组的长度是确定的。数组一旦被创建，它的大小是不可以改变的。

2. 数组的元素必须是相同类型。

3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型。

4. 数组属于引用类型。

5. 数组元素大小默认是4个字节。

5. 类比理解数组：

博物架→标识符

古玩→数据

物品编号→元素下标

物品类型→元素类型

6. 数组的缺陷：

6.1 数组长度固定不变、不能很好地适应元素数量动态变化的情况。

6.2 可通过属组名.length获取数组的长度，却无法直接获取数组中实际存储的元素个

数。

         6.3 数组采用在内存中分配连续空间的存储方式存储，根据元素信息查找时效率比较

低，需要多次比较。

         针对数组的缺陷，Java提供了比数组更灵活、更实用的集合框架。

&对象数组

-         定义：

数组内存储的元素是对象。

-         使用方法：

1. 调用该对象数组时，对象数组可以为null。如Student[] str=new Student[5];str[0]==null;
2. 当对象数组为null时，数组.属性不可被调用。如str[0]==null;时，如果执行str[0].name会抛出空指针异常。

&多维数组

-         二维数组是以数组为元素的数组，也就是数组里面存储数组。二维以上数组类推。四维数组常用于3D图形的转换；

-        

&动态数组

         1. 常称ArrayList为动态数组。

&数组的用法

-         两种声明方式：

1. int[] arr

2. int arr[]

-         三种初始化方式：

1. 动态初始化：

                  a.声明数组     int[] arr;//等价于int arr[];

b.分配空间     arr=new int[5];

c.赋值              arr[0]=8;

d.使用              arr[0]=a[0]*10;

2. 默认初始化：//数组元素相当于对象的成员变量，默认值跟成员变量的规则一样。数字0，布尔false,char\u0000,引用：null

3. 静态初始化：int[] arr={3,4,5}或者int a[] =new int[]{3,4,5}。经验：有时候我们为了好看，

会采用缩进。

&数组的属性

-       .length 数组的长度

&数组的应用

-         排序：

Arrays.sort(数组名);//表示对数组进行升序排列

-         拷贝：

采用方法System.arraycopy(Object src, int srcpos, Object dest, int destpos, int length)。该方法可以将src数组里的元素赋值给dest数组的元素，其中srcpos指定从src数组第几个元素开始赋值，length参数指定将src数组的多少个元素赋给dest数组的元素。

-         转化为字符串：

1. Arrays.toString(数组变量);

-       二分法查找某元素的索引：

Arrays.binarySearch(int[] , int a)

-         填充：

Arrays.fill(a,2,4,100);//数组a将2到4索引的元素替换为100。

-         遍历、批量存储、求和、最大值、最小值、添加值、修改值、删除值：

用for循环实现。

添加值的时候用index=-1 变量名来标记添加位置。

修改值的时候用indexNew=-1 index=-1 变量名来标记添加位置。

删除值的时候右边覆盖左边，最后一个赋值为null。

#运算符

@运算符分类

-       分类一：赋值运算符：=

                          扩展赋值运算符：+=,-=,*=,/=

算术运算符：+,-,*/,%

关系运算符：>,>=,<,<=,==,!=,instanceof

逻辑运算符：&&(短路与),||(短路或),!

条件运算符：?:

位运算符：&，|，^，~，>>，<<，>>>

-       分类二：一元运算符（单目运算符）：!,~,++,--

二元运算符：

三元运算符：

@运算符的级优先

-       总体而言：算术运算符》关系运算符》逻辑运算符》条件运算符》赋值运算符；

-       单目运算符优先级最高的是：++，--；

-       关系运算符中，“==”“！=”优先级低于其他。

-       （）的优先级最高。

@运算的结合顺序

-       从右往左的运算符：只有赋值运算符、条件运算符、复合赋值运算符和单目运算符;

@常用运算符注意

-         逻辑运算符：

1. 逻辑运算符！，操作数为1，其后只能接boolean类型;

-       赋值运算符：

-       1. 推荐使用复合赋值运算符，比如+=等，便于程序编译处理，具有更好的性能。

         2. 对于==，当操作数是简单数据类型，直接比较值；当操作数是引用类型，比较两者

的内存地址是否相同。

-       算数运算符：

1. 对于取模运算，如果两个操作数中有一个浮点数，结果也是浮点数，保留小数部分。

2. +号被作为连接符的情况：当两个操作数中有一个为字符串类型时，相加结果为字符串类型。

-       关系运算符：

1. >,<,>=,<=只支持数值类型的比较，==，！=支持所有数据类型的比较。

-       逻辑运算符：

1. 优先级别从高到低：！，&，^，|，&&，||

-       位运算符：

1. x乘上2的n次方，使用位运算符执行效率更高，即x<<n。

2. 一个整数每向左移动1位，其值扩大两倍，前提是移出的位数不包含有效数字。

3. 一个整数每向右移动1位，其值缩小1/2倍，前提是移出的位数不包含有效数字。

4. 位运算符的操作数是整型数，包括byte、short、int、long和char。

5. 如果操作数是char、byte、short，位运算符前其值会自动晋升为int，其运算结果也

为int。

6. 位运算符的运算结果也是整型数，包括int、long。

#流程控制

@循环结构

&注意

-         组成：初始化；条件判断；循环体；迭代；

-         使用条件：1、重复执行的代码 2、相近或相似的代码，其中变化的地方是有规律的;

-         while与do-while的区别：do-while不管条件符不符合至少会执行1次;

-         for循环比while更简洁,特点是要求循环次数固定;for循环即使for(; ;)这样也能运行，不会报错，不过是死循环，可以用break跳出;

-         for循环比while内存使用率更高，循环变量i占用的空间在for循环结束后会被释放。

-         循环与if能够互相嵌套;

-         Do-while一般应用于有菜单循环显示的题目。可以用while(true)替换。

&foreach语句

1.定义格式：

2. 底层原理是迭代器，将复杂的迭代器代码简化，优化了代码书写。

3. foreach对集合遍历的时候，是有局限的，只能对集合中的元素进行取出，不能进行修改等操作。

4. 高级for和传统for的区别：

         高级for有一个局限性，必须有遍历的目标。建议在遍历数组的时候使用传统for，因

为传统for可以定义脚表，便于对元素操作。

&多重循环

1. dowhile-for

2. for-for：

for双循环：外层控制行数，内层控制列数;外层循坏1次，内层循环1遍。

@分支结构

&if分支结构

-         if选择结构分类：

单分支、双分支、多分枝、嵌套结构

-         注意：

1. if()后可以不加{}，但是他的控制范围只包括下一条语句范围。

2. else子句不能单独使用，与最近的if语句配对使用。

3. 条件测试对象必须是布尔类型，这点与c、c++不同。

4. 不论分支if里面有多少个表达式，只会执行符合条件的一个。

&switch分支结构

-       等值比较判断用switch

-       后面括号内，可以是int或者可以自动转换为int的类型(byte、short、char)，枚举类也可，jdk7里面也可以是Sting类;

-       case穿透现象：

         switch可以看作是if-else的特例，（default也可以省略，相当于ifelse里面可省略else）default后面的break可加可不加，case后面不加case的话会发生所谓的case穿透现象，所以一般在每个case后面都要加一个break

         例子：利用case穿透现象，输出a到z的元音、半元音、辅音

&嵌套结构

-         if-if、switch-if、if-switch-if

@跳转语句

&contiune

-         只能用于循环结构，可以加速循环，直接跳过剩下语句进入下一次循环;

-         While和do-while中，continue执行完毕后，程序将直接判断循环条件。在for循环中，continue使程序先跳到循环变量计算部分，然后再判断循环条件。

&return

-         作用：结束方法的运行、返回值。

-         应用：

1. 只能返回一个值。

2. 其后不能有代码啦。

&带标签的break和continue

-         可用于跳到最外层循环

#异常

@相关概念

         1. 异常会中断正在运行的程序。

@异常分析

         1. runtime异常：一般有两种情况：

                  第一，传入的参数非法。

                  第二，无参的方法里面传参数。

                  第三，改变对象的状态。

         2. 异常处理模块可以处理的错误是运行时错误。而逻辑错误、语法错误、内部错误这

些在编译的时候就会呈现出来。

         3. 异常包括4部分信息：所属的线程、异常的名字，异常的描述，异常的位置

&程序调试

1. 基本步骤：猜测错误位置→设置断点→单步运行→观察变量;

2. 可以通过输出运行来获取程序执行过程。

@JAVA异常处理机制

&处理机制

         1. java异常处理机制主要为了捕获运行期错误，发生错误时，将引发异常，该异常由一

个java代码块捕获。Java中可能引发异常的代码块最佳的处理时期就是在编译阶段

的时候处理并捕获。

         2. 异常处理机制已经成为主流编程语言的必备功能，它使程序的异常处理代码和业务

逻辑代码分离，保证了程序代码的优雅性，提高了程序代码的健壮性、安全性和可
维护性。

         3. 在将来的开发中能对程序进行合理、及时地异常处理是对程序员的基本要求。

&try&catch&finally

-         便捷输出操作：选中要处理的代码，右键→surround with→第一个

-         三种情况：

1. 无异常

2. 有异常，而且恰好和catch后面的异常类型匹配

3. 有异常，但是和catch后面的异常类型不匹配

1. try

         1.1 当一条语句产生异常时，就会跳过该段后面的代码。

         1.2 代码中可能会产生并抛出一种或几种类型的异常对象。

         1.3 一个try语句必须带至少一个catch语句或一个finally语句块

         1.4 当catch处理异常结束后，是不会回到try语句中去执行尚未执行的代码。

2. catch

         2.1 每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型异

                  常对象。

         2.2 常用方法：（这些方法都继承自Throwable类，主要用来调试，还需要真正处理的

代码）

                  a) toString()方法：显示异常的类名和产生异常的原因。

                  b) getMessage()方法：只显示产生异常的字符串描述，但不显示类名。是输出信息

                          printStackTrace()的一部分。有的异常该方法返回值为空。。

                  c) printStackTrace()方法：输出异常的堆栈信息。堆栈信息包括运行到当前类的执行

流程，它将输出从方法调用处到异常抛出处的方法调用序列。堆栈信息还包括异常类型以及对该异常的详细描述。

         2.3 catch捕获异常时的捕获顺序：如果异常类之间有继承关系，在顺序上，越是顶层的

            类，越放在下面。再不然直接把多余的catch省略。出现什么样的异常执行对应异

常处理块，如果没有匹配的异常，则执行其父类异常处理块。

         2.4多重catch块：

                  2.4.1 排列catch语句的顺序：先子类后父类，先特殊后一般，最后一个一般都是

Exception类。

                  2.4.2 发生异常时按顺序逐个匹配。

                  2.4.3 只执行第一个与异常类型匹配的catch语句。

3. finally

         3.1 不管是否发生异常，都会执行finally语句块。唯一例外是在finally代码块之前有

System.exit(1)，程序不会执行finally，会中断退出。

         3.2 通常在finally中关闭程序块已打开的资源。比如：文件流、释放数据库连接等。

4. return的执行顺序

         4.1 catch里面存在 return的执行顺序：先执行try、catch，给返回值赋值。再执行finally。

            最后执行return结束程序，并输出返回值。当有多个return时，返回的是最后一个

            return的值。

         4.2 try里面存return的执行顺序：同样是最后执行return退出程序。

&声明异常：throws子句

1. 一般声明的异常是必须被处理的Checked Exception类异常（因为声明运行时异常没意义，调用的时候不会报错），当Checked Exception产生时，不一定立刻处理它，可以再把异常Throws出去。

2. 一个方法可以抛出多个已检查异常，但必须在方法首部列出所有的异常，之间用逗号隔

   开。

3. 一个方法一般在自身没有能力处理相关异常时候，声明异常。

4. 怎么处理声明的异常？

         4.1 调用者去处理异常。

         4.2 调用者继续声明异常。

         4.3 main方法中声明的异常由java虚拟机处理。

5. 子类声明的异常范围不能超过父类声明的范围，包含如下意思：

1. 父类没有声明异常子类也不能。

2. 不可抛出原有方法抛出的异常的父类或上层。

3. 抛出的异常的类型数目不能比父类多。

&手动抛出异常：throw子句

1. 对于一个已经存在的异常类，抛出该类异常对象的过程如下：

         -       找到一个合适的异常类。

         -       创建该类的对象。

         -       将对象抛出。

         -       自身catch处理该异常对象。或者在第一行throws声明该异常。

2. throw一般跟自定义异常搭配使用。

&对比throw和throws

&自定义异常

1. 当JDK中的异常类型不能满足程序的需要时，可以自定义异常类。一般与throw搭配用。

2. 使用自定义异常类的步骤：

         2.1 定义异常类（继承Throwable类、或Exception类、或RuntimeException类，一般继

承Exception类，强制调用者去处理异常）

         2.2 编写构造方法、继承父类的实现。

【示例】常见的构造方法有：

                  2.2.1 无参：

   public MyException() {

      super();

   }

                  2.2.2 一个参数：

   public MyException(String message) {

      super(message);

   }

   public MyException(Throwable cause) {

      super(cause);

   }

                  2.2.3 两个参数：

   public MyException(String message, Throwable cause) {

      super(message, cause);

   }    

         2.3 实例化自定义异常对象，并在程序中使用throw抛出。

&异常链（jdk1.4版本提出）

&处理过程

&异常处理原则

1. 异常处理与性能：

1.1 只有在可能出现异常的时候，加try-catch。当程序没有发生异常时try-catch不影像性能，当发生异常的时候JVM才会去额外操作处理。

1.2 try-catch放在一个方法里的时候，会在方法栈里面去找相应的方法代码去执行，如果找到异常，它会在同一个方法里去找catch（异常处理的代码），这时候性能影像不大。

2. 异常只能用于非正常情况。

3. 若产生异常的方法有能力处理异常，则在该方法中处理掉异常。

4. 不要将过于庞大的代码放在try里面。（不利于分析定位异常）

5. 在catch中指定具体的异常类。

@异常类

&异常体系结构图

1. Eclipse报错分为两种：编译时报错、运行时报错。

2. 所有异常类都是Throwable类的子类，它派生了两个子类：Error类和Exception类。

         3. 行时异常提倡通过提高程序设计的健壮性，避免掉该异常，不提倡去处理。

&常见异常

-       非法字符\uff1b，一般表示标点符号错误;

-       程序包不存在，一般表示大小写错误;

-       结束死循环：ctrl+C。

-       源程序里面有无法访问到的语句，编译的时候也会报错;

-       ArrayIndexOutOfBoundsException 数组下标溢出。

-       NullPointerException 空指针异常，一般是调用对象方法的时候，对象没有new出来。

&Error

         1. 表示仅靠程序本身无法恢复的严重错误，如内存溢出、动态链表失败、虚拟机错误。

         2. 应用程序不应该抛出这种类型的错误（一般由虚拟机抛出）。

         3. 假如出现这种错误。应尽力使程序安全退出。

         4. 在程序设计的时候应该更关注Exception类。

&Exception

         1. 定义：

由Java应用程序抛出和处理的非常严重错误，如所需文件找不到、网络连接不通或连接中断、算数运算出错（如被零除）、数组下标越界、装载一个不存在的类、对null对象操作、类型转换异常等。

         2. Exception类可以分为两大类：运行时异常、Checked异常（非运行时异常）

& Checked异常（非运行时异常）

         1. 定义：

除了运行时异常外的其它从Exception类继承来的异常类。要求程序

必须处理该类异常。

*java.io.FileNotFoundfException

*java.io.IOException

*java.lang.ClassNotFoundException

不能加载所需类

*java.lang.IllegalAccessException

&运行时异常

         1. 包括RuntimeException及其子类。不要求程序必须对他们进行处理。

*java.lang.NullPointerException

         1. 说明：

                  尝试访问null对象成员对象。

2. 生成条件：

         当应用程序试图在需要对象的地方使用null时，抛出该异常。这种情况包括：

1. 调用null对象的实例方法。
2. 访问或修改null字段。
3. 如果一个数组为null，试图用属性length获得其长度时。
4. 如果一个数组为null，试图访问或者修改其中某个元素。
5. 在需要抛出一个异常对象时，该对象为null。（将null作为Throwable值抛出）

*java.util.InputMismatchException

         1. 说明：

                  欲得到的数据类型与实际输入的类型不匹配。

*java.lang.IllegalArgumentException

         1. 说明：方法收到非法参数。

*java.lang.ArithmeticException

         1. 说明：算数错误异常。

*java.lang.ArrayIndexOutOfBoundsException

         1. 说明：数组下标越界。

*java.lang.ClassCastException

         1. 说明：对象强制类型转换出错。

*ClassNotFoundException

         1. 说明：不能加载所需的类。

*java.lang.NumberFormatException

1. 生成条件：

当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常

@ java.util.ConcurrentModificationException

1. 当两个或以上对象对同一个引用的数据并发操作，但不允许这种修改时，会抛出这种

异常。

2. 【实例】：

2.1 异常现象代码：

2.2 修改后代码：

                  - 上图注释：元素的引用虽然被it对象移除了，但是元素java002仍被Object引用

。最终集合al内容改变。

#Java的格式化输出

@Java字符串转换符表

&常用转换符表

&日期与时间转换符表

&搭配转换符的标识

@String.format()

         1. String类的format()方法用于创建格式化的字符串以及连接多个字符串对象。熟悉C

语言的同学应该记得C语言的sprintf()方法，两者有类似之处。format()方法有两种重载形式:

         1.1 format(String format, Object… args) 新字符串使用本地语言环境，制定字符串

格式和参数生成格式化的新字符串。

                  1.2 format(Locale locale, String format, Object… args) 使用指定的语言环境，制定字

符串格式和参数生成格式化的字符串。

&【实例】3：数字类型格式化输出

public static void main(String[] args) {

        String str=null;

        str=String.format("Hi,%s", "王力");

        System.out.println(str);

        str=String.format("Hi,%s:%s.%s", "王南","王力","王张");          

        System.out.println(str);                        

        System.out.printf("字母a的大写是：%c %n", ‘A‘);

        System.out.printf("3>7的结果是：%b %n", 3>7);

        System.out.printf("100的一半是：%d %n", 100/2);

        System.out.printf("100的16进制数是：%x %n", 100);

        System.out.printf("100的8进制数是：%o %n", 100);

        System.out.printf("50元的书打8.5折扣是：%f 元%n", 50*0.85);

        System.out.printf("上面价格的16进制数是：%a %n", 50*0.85);

        System.out.printf("上面价格的指数表示：%e %n", 50*0.85);

        System.out.printf("上面价格的指数和浮点数结果的长度较短的是：%g %n", 50*0.85);

        System.out.printf("上面的折扣是%d%% %n", 85);

        System.out.printf("字母A的散列码是：%h %n", ‘A‘);

}

&【实例】4：日期类型格式化输出：

     public static void main(String[] args) {

     Date date = new Date(); // 创建Date对象date

     String year = String.format("%tY", date); // 转换符%tY：4位年份；如：2015

     String moth = String.format("%tB", date); // 转换符%tB：指定语言环境的月份全称；如：十一月；November（英文）

     String day = String.format("%td", date); // 转换符%td：一个月中的第几天（01-31）；如：28

     String week = String.format("%ta", date); // 转换符%ta：指定语言环境的星期几简称；如：星期六

     String noon = String.format("%tp", date); // 转换符%tp：指定语言环境下上午或下午标记；如：下午、pm（英文）

     String hour = String.format("%tH", date); // 转换符%tH：2位数字的24小时制的小时（0-23）；如：16

     String minute = String.format("%tM", date);// 转换符%tM：2位数字的分钟（0-59）；如：59

     String second = String.format("%tS", date);// 转换符%tS：2为数字的秒数（0-60）；如：52

     String millisecond = String.format("%tL", date);// 转换符%tL：3位数字的毫秒数（000-999）；如：888

     String form = String.format("%tF", date); // 转换符%tF：“年-月-日”格式（4位年份）；如：2015-11-28

     String time2 = String.format("%tT", date); // 转换符%tT：“时：分：秒”格式（24时制）；如：17:18:37

     String time = String.format("%tc", date); // 转换符%tc：包括全部日期和时间信息；如：星期六 十一月 28                        16:48:33 CST 2015

     System.out.println("现在是" + year + "年" + moth + day + "日" + week + "  " + noon + hour + "时" + minute +               "分"+ second + "秒" + millisecond + "毫秒");

     System.out.println("全部的时间信息是：" + time);

     System.out.println("年-月-日格式：" + form);

     System.out.println("时:分:秒格式：" + time2);

  }

&【实例】5：日期类型格式化输出

         public static void main(String[] args) {

    Date date=new Date();                                   

    //b的使用，月份简称

    String str=String.format(Locale.US,"英文月份简称：%tb",date);    

    System.out.println(str);                                                                           

    System.out.printf("本地月份简称：%tb%n",date);

    //B的使用，月份全称

    str=String.format(Locale.US,"英文月份全称：%tB",date);

    System.out.println(str);

    System.out.printf("本地月份全称：%tB%n",date);

    //a的使用，星期简称

    str=String.format(Locale.US,"英文星期的简称：%ta",date);

    System.out.println(str);

    //A的使用，星期全称

    System.out.printf("本地星期的简称：%tA%n",date);

    //C的使用，年前两位

    System.out.printf("年的前两位数字（不足两位前面补0）：%tC%n",date);

    //y的使用，年后两位

    System.out.printf("年的后两位数字（不足两位前面补0）：%ty%n",date);

    //j的使用，一年的天数

    System.out.printf("一年中的天数（即年的第几天）：%tj%n",date);

    //m的使用，月份

    System.out.printf("两位数字的月份（不足两位前面补0）：%tm%n",date);

    //d的使用，日（二位，不够补零）

    System.out.printf("两位数字的日（不足两位前面补0）：%td%n",date);

    //e的使用，日（一位不补零）

    System.out.printf("月份的日（前面不补0）：%te",date);

}

@java.text.DecimalFormat(格式化输出数字)

&实例化对象

         1. DecimalFormat df=(DecimalFormat)NumberFormat.getInstance();

         2. DecimalFormat df1=(DecimalFormat) DecimalFormat.getInstance();

         3. 因为DecimalFormat继承自NumberFormat。

&设定小数位数

系统默认小数位数为3，如：

DecimalFormat df=(DecimalFormat)NumberFormat.getInstance();

      System.out.println(df.format(12.3456789));

输出：12.346

现在可以通过如下方法把小数为设为两位：

        df.setMaximumFractionDigits(2);

        System.out.println(df.format(12.3456789));

则输出为：12.35

&将数字转化为百分比输出

有如下两种方法：

(1)：

df.applyPattern("##.##%");

System.out.println(df.format(12.3456789));

                System.out.println(df.format(1));

System.out.println(df.format(0.015));

//输出分别为：1234.57%  100%    1.5%

(2)：

  df.setMaximumFractionDigits(2);

  System.out.println(df.format(12.3456789*100)+"%");

  System.out.println(df.format(1*100)+"%");

  System.out.println(df.format(0.015*100)+"%");

//输出分别为：

1,234.57%   100%   1.5%

&设置分组大小

  DecimalFormat df1=(DecimalFormat) DecimalFormat.getInstance();

  df1.setGroupingSize(2);

  System.out.println(df1.format(123456789));

//输出：1,23,45,67,89

还可以通过df1.setGroupingUsed(false);来禁用分组设置，如：

  DecimalFormat df1=(DecimalFormat) DecimalFormat.getInstance();

  df1.setGroupingSize(2);

  df1.setGroupingUsed(false);

  System.out.println(df1.format(123456789));

//输出：123456789

&设置小数为必须为2位

  DecimalFormat df2=(DecimalFormat) DecimalFormat.getInstance();

  df2.applyPattern("0.00");

  System.out.println(df2.format(1.2));

//输出：1.20

@System.out.printf()

#API文档阅读

-         下载地址：www.oracle.com

@基本结构

@生成自己项目的API文档

-         文档注释：

/**

-         使用JAVADOC可以生成API文明文档，解决了代码和文档分离的问题。

-         常用的java注释标签：

@Author 作者

@version 版本

@param 参数

@return 返回值的含义

@throws 抛出异常描述

@deprecated 废弃、建议用户不再使用的方法

#Java关键字

-         Java里面总共有48个关键字。在Eclipse里面显示为紫红色

@import

         1. 语法格式：

         -       import [参数] 包名

2. 导入Arrays类中的所有静态成员：

-       import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。

3. 引用需注意：

                  3.1 当类名重名时，需要指定具体的包名。

                  3.2 当方法名重名时，需要指定所属的对象或者类。

@final

-       使用方法：

         1. 修饰变量：被修饰变量变为常量，只能被初始化一次。修饰数组，则该数组的引用

            地址是不可变的，但是数组里面的元素是可变的。

         2. 修饰方法：该方法不可被子类重写。但是可以被重载。

         3. 修饰类：修饰的类不能有子类，不能被继承。比如Math、String。

@static

&相关概念

         1. 在方法里不能定义static变量。

&分类用法：

1. static变量

         1.1 与类变量相对应的是实例变量。

2. static方法

         2.1 静态方法中不能使用this和super。

         2.2 不能直接访问所属类的实例变量和实例方法。

         2.3 可以直接访问所属类的静态变量和静态方法。

         2.4 静态方法必须被实现。

         2.5 实例方法可以直接访问所属类的静态成员和实例成员。

3. static代码块

         3.1 JVM加载类时，加载静态代码块。

         3.2 如果有多个静态块，按顺序加载。

         3.3 每个静态代码块只会被执行一次。

         3.4 静态代码块可用于初始化数据。

&static内存分析实例：

         如下student类的代码和内存分析图：

-       使用方法

1.类只能使用类的，对象既可以使用类的也可以使用对象的方法。即static只能调static，非static既能调static也能调非static。

2.通过引用也可以使用static变量和static方法。不过，一般还是使用类名.static成员名来访问

3. static变量能被所有实例共享，可作为实例间交流的共享数据。

4. 如果类中的所有实例都包含一个相同的实例属性，可以把这个属性定义为静态类型，

   从而节省内存空间。通常如static final

5. 在方法里不可以定义static变量。

@instanceof和isInstance

-         区别：

1. Instanceof可以理解为主动句：obj instanceof class，即这个对象是不是这种类型。左

小右大。

isInstance可以理解为被动句：class.isInstance(obj)，即这个对象能不能转化为这个类。

左大右小。返回值都是布尔类型。

         2. Instanceof是一个关键字，而isInstance()是一个方法。

-  instance用法：

         1. 一个对象是本身类的一个对象。

2. 一个对象是本身类父类（父类的父类）和接口（接口的接口）的一个对象。

3．所有对象都是Object的对象。

4.凡是null有关的都是false：null instanceof class

-  isInstance用法：

         1. 一个对象是本身类的一个对象。

2．一个对象能被本身类父类（父类的父类）和接口（接口的接口）的一个对象转化。

3. 所有对象都能被Object强转。

4. 凡是null有关的都是false：class.isInstance(obj)。

5.类名.class和对象.getClass()几乎没有任何区别，因为一个类被类加载器加载后，是唯一的一个类。

@native

-         native关键字说明其修饰的方法是一个原生态方法，方法对应的实现不是在当前文件，而是在用其他语言（如C和C++）实现的文件中。

-         Java语言本身不能对操作系统底层进行访问和操作，但是可以通过JNI接口调用其他语言来实现对底层的访问。

-         JNI是Java本机接口（Java Native Interface），是一个本机编程接口，它是Java软件开发工具箱（Java Software Development Kit，SDK）的一部分。

-         JNI允许Java代码使用以其他语言编写的代码和代码库。

-       Invocation API（JNI的一部分）可以用来将Java虚拟机（JVM）嵌入到本机应用程序中，从而允许程序员从本机代码内部调用Java代码。

@null

         1. null和empty的区别：null是连装东西的篮子都没有，empty是有篮子，但里面没东

西。

@transient

         1. 可以屏蔽指定字段（该字段一般是敏感信息，如密码）的序列化。

@default

1. 【实例】

1.1 default关键字在接口中修饰方法时，方法可以有方法体。

         这是Java8的新特性。类似于C++中的虚函数。

1.2 当一个类实现接口时，可以不去实现default修饰的方法。如果去实现，就等

于子类覆盖了这个方法。

public interface Test{

         default public void method() {

                  System.out.println("method in interface");//$1.1

         }

}

3. 面向对象

#面向对象思维

1. 过程：

-       OOA（面向对象分析）、OOD（面向对象设计）;

2. 与面向对象编程的区别：

先有具体对象，然后抽象出各个对象之间像的部分，归纳出类，再通过类去认识其他对象;而编程的时候是先写类之后，再有对象;

#面向对象编程（oop=object oriented programming）

1. 本质：

-       以类的方式组织代码，以对象的方式组织（封装）数据;把相近的数据、近的行为

放到一起管理;

2. 与面相过程编程的对比：

-       利用面向对象的思维去把握整体，就像高层的组织决策一样；用面向过程思维去把

握细节，就像工人做事都有一定工序；

#面向对象设计的原则

         1. 摘取代码中变化的行为，形成接口。

                  1.1 例如，在“愤怒的小鸟”游戏中，鸟叫的行为变化性很大，有的鸟叫，有的鸟

不叫，各种鸟叫的叫声也不一样，这种行为最好定义为接口。

         2. 多用组合，少用继承

2.1 在“愤怒的小鸟”游戏中，通过抽象类中包含鸟叫的属性来实现组合，有效地

减少了代码冗余。

         3. 针对接口编程，不依赖于具体实现

                  3.1 如果对一个类型有依赖，应尽量依赖接口，尽量少依赖子类。因为子类一旦变

化，代码变动的可能性大，而接口要稳定得多。

                  3.2 在具体的代码实现中，体现在方法参数尽量使用接口，方法的返回值尽量使用

接口，属性类型尽量使用接口等。

         4. 针对扩展开放，针对改变关闭

                  4.1 如果项目中的需求发生了变化，应该添加一个新的接口或者类，而不要去修改

原有的代码。

         5. 【实例】1：愤怒的小鸟：

                  5.1 定义鸟叫的接口：

                  -       public interface ShoutAbility{

             public void shout();//鸟叫的抽象方法

          }

                  5.2 定义类来描述“嗷嗷”叫，“喳喳”叫两种鸟叫的方式，并实现鸟叫的方式。

        -   /*嗷嗷叫*/

public class Aoshout implements ShoutAbility{

   public void shout(){

   System.out.println(嗷_ _);

   }

}

/*喳喳叫*/

public class ZhaShout implements ShoutAbility{

   public void shout(){

      System.out.println("喳喳!");

   }

}

        5.3 在鸟的抽象类中将接口作为属性，通过属性调用接口的方法。

public abstract class Bird{

   ShoutAbility shout_ability;//鸟叫的方式

   //鸟类的构造方法，用来初始化鸟叫的行为

   public Bird(ShoutAbility shout_ability){

      this.shout_ablility=shout_ability;

   }

   //叫

   public void shout(){

      shout_ability.shout();//调用接口的方法

   }

   //飞行

   public void fly(){

      System.out.println("弹射飞");

   }

   public abstract void attack();//攻击

}

//炸弹鸟

public class BombBird extends Bird{

   public BombBird(ShoutAbility shout_ability){

      super(shout_ability);

   }

   //重写攻击方法

   public void attack(){

      System.out.println("炸弹攻击！");

   }

}

//分裂鸟

public class SplitBird extends Bird{

   public SplitBird(ShoutAbility shout_ability){

      super(shout_ability);

   }

   //重写攻击方法

   public void attack(){

      System.out.println("分裂攻击！");

   }

}

//测试类

public class Test{

   public static void main(String[] args){

      ShoutAbility ao_shout = new AoShout();//嗷嗷叫

      ShoutAbility zha_shout = new ZhaShout();//喳喳叫

      Bird bomb = new BombBird(zha_shout);//炸弹鸟喳喳叫

      Bird split = new SplitBird(ao_shout);//分裂鸟嗷嗷叫

      bomb.shout();

      split.shout();

      //.......省略其他代码

   }

#类和对象

@关系图

@基本概念

-         对象：

n  是具体的事物;。我们叫Object、instance（实例）。

n  我们说某个类的对象，某个类的实例，是一样的意思。对象是Java程序的核心，在Java程序中“万事万物皆对象”。

n  java中的对象是通过引用对其操作的。

-         类：

1.是对对象的抽象（抽出像的部分）。

2.类中定义了这一类对象所应具有的属性（静态的数据）和方法（动态的行为）。JDK提供了很多类供编程人员使用，编程人员也可以定义自己的类。

3.Java里面规定，所有代码都要写到类里面。

4.类的属性（field或者叫成员变量），作用范围是整个类体，如果不对其初始化，java使用默认的值对其初始化。属性的定义格式如下：

5. 类是用来产生对象存放数据用的。

-         对象和类的关系：

具体到抽象、特殊到一般。 类可以看成是一类对象的模板，对象可以看成该类的一个具体实例。

-         类的属性定义格式：

@类图

-         工具：visio、rose(用的更多些)。

-         模板：

-         使用方法：

1. 接口用虚线指向。

#抽象类

@相关概念

1. 抽象方法指只有方法的声明，没有方法体的方法。

    2. 抽象类增强了继承的约束。

         3. 抽象类是指提供其子类共性部分，只声明方法的存在而不具体实现它的类，它

就是为了让子类来继承的。

@好处

1. 抽象类的作用：把设计和实现分开了。设计由抽象类来规范，可以避免子类设计的随意。实现通过子类来实施。
2. 为所有子类提供了一个模板，子类可以在这个模板基础上进行扩展。
3. 抽象类中已经实现的方法可以被其子类使用，从而实现了代码的复用性。
4. 抽象类提供的抽象方法，保证了子类具有自身的独特性。
5. 抽象类可以实现多态。

@使用方法

1．  抽象类可以没有抽象方法，有抽象方法的类只能定义抽象类。

2．  如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类。

3．  抽象类不能被实例化。

4．  抽象类可以包含一般属性、方法、非抽象的构造方法。但非抽象的构造方法不能来new实例，只能在构造子类时被子类调用：此时先构造父类，再构造子类。

5．  抽象类只能用来继承。

6．  没有抽象构造方法，也没有抽象静态方法。

7．  子类如果不是抽象类，则必须重写抽象类中的全部抽象方法。

8．  Abstract 修饰符不能和final或者private关键字一起使用。

#接口（interface）

@相关概念：

1. 接口是比抽象类还要抽象的类，它使继承具有更强的约束性。接口只包含抽象方法和常量。它可以更加规范地对子类约束，使设计规范和具体实现彻底分离。
2. 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是什么……则必须能……”的思想。
3. 接口是一种能力、功能、服务。
4. 面向接口编程：关心实现类有何种能力，而不关心实现细节。面向接口的约定而不考虑接口的具体实现。
5. 接口是访问数据的方式。
6. 接口和类抽象类是一个层次的概念，命名规则相同。
7. 接口的好处：降低代码间的耦合性，提高代码的可扩展性和可维护性。

@使用方法：

1. 接口中只有全局静态常量、公开抽象方法：

1.1 接口中定义常量时，必须指定初始值，前缀默认是public static final，写或不写

该前缀都一样。

1.2 接口中定义方法是，前缀默认是public abstract，写或不写都一样。

2. 一个类只能继承一个父类，但可以通过implements实现多个接口。继承和实现可以同

时进行，但extends必须位于implements之前。

3. 接口之间可以通过extends实现继承关系（叫做复合接口），一个接口可以继承多个

接口。但一个接口不能实现另一个接口，        一个接口也不能继承类。

4. 一个类必须实现接口抽象方法，否则必须定义为抽象类。

5. 接口的定义格式：

[访问修饰符] interface 接口名 [extends 父接口1，父接口2，父接口3……]{

                            - 常量定义  //总是public static final

                            - 方法定义  //总是public abstract

}

6. 接口中不能有构造方法，且接口不能被实例化，但是可以用于声明引用变量类型。

7. 接口的应用：

         7.1 在日常工作中更多的用接口，抽象类用的少，二者本质是一样的。

         7.2 许多人定义接口名的时候首字母会加个I，表示是接口。

7.3 什么时候写接口：当两者之间是has a的关系。什么时候写继承：当两者之间

是is a的关系。

7.4 用接口来放常量的方法用的少了，多用枚举来放常量。

7.5 将不变的东西放入父类，将改变的东西放入接口。

8. 接口一旦公布，必须要非常的稳定。

9. 接口只能被public修饰，或者省略修饰符。

#抽象类vs接口

1. 相同点：

         1.1 代表系统的抽象层。

         1.2 都不能被实例化

         1.3 都能包含抽象方法

2. 不同点

         2.1 在抽象了中可以为部分方法提供默认实现，而借口只能包含抽象方法。

         2.2 一个类只能继承一个直接的父类，但可以实现多个接口。

         2.3 已存在继承数，可以方便的抽取接口，但是抽取抽象类不容易。

3. 使用原则：

         3.1 接口做系统与外界交互的窗口：接口提供服务

         3.2 接口本身一旦制定，就不允许随意修改

         3.3 抽象类可以完成部分功能实现，还有部分功能可作为系统的扩展点。它介于具体与

                  抽象之间。

#内部类（interclasses）

@相关概念

1. 定义：

一般情况下，我们把类定义成独立的单元。有些情况下，我们把一个类放在另一个类的内部定义，称为内部类（内置类、嵌套类）。

2. 分类：

          成员内部类（分为非静态内部类、静态内部类）、匿名内部类、局部内部类

3. 成员内部类：

可以使用private、protect、pubblic任意进行修饰。会生成类文件名：外部类$内部类.class。

         4. 非静态内部类：

外部类里使用非静态内部类和平时使用其它类没什么不同。

5. 内部类的特点：

5.1 内部类提供了更好的封装。只能让外部类直接访问，不允许同一个包中的其它

类直接访问。

5.2 内部类可以直接访问外部类中的成员，包括私有成员，内部类被当成其外部类

的成员。但外部类不能访问内部类的内部属性。

5.3 外部内要访问内部类中的成员必须建立内部类对象。

5.4内部类可以被成员的访问修饰符修饰（可以被所有访问符修饰）。

@成员内部类

&非静态内部类

1. 非静态内部类必须寄存在一个外部类对象里。因此，如果有一个非静态内部类对象，

那么一定存在对应的外部类。非静态内部类对象单独属于外部类的某个对象。

2. 非静态内部类可以使用外部类的成员，但是外部类不能直接访问非静态内部类成员。

3. 非静态内部类不能有静态方法、静态属性、静态初始化块。

4. 静态成员不能访问非静态成员：外部类的静态方法、静态代码块不能访问非静态内

部类、，包括不能使用非静态内部类定义变量、创建实例。

5. 成员变量的访问要点：

5.1 内部类里方法的局部变量：变量名。

5.2 内部类属性：this.变量名。

5.3 外部类属性：外部类名.this.变量名。（如果名字不冲突，可以直接变量名）

         6. 【示例】外部类以外的地方使用非静态内部类：

      Face.Nose nose=new Face().new Nose();

      //等价于：

Face f2=new Face();

Face.Nose nose2=f2.new Nose();

7. 【实例】内部类的访问

         7.1 内部类Inner可以直接访问外部类Outer中的成员num。

7.2 Outer外部类的方法method()要访问内部类Inner的方法show(),必须要建立内

部类的对象。

class Outer{

   private int num=3;

   class Inner{//内部类

      void show() {

          System.out.println("show run..."+num);//$3.1

      }

   }

   public void method() {

      Inner in = new Inner();//$3.2

      in.show();

   }

}

&静态内部类（类似于静态属性）

1. 定义方式：

Static class ClassName{

//类体

}

2. 当一个静态内部类对象存在，并不一定存在对应的外部类对象。因此， 静态内部类

的实例方法不能直接访问外部类的实例方法。

3. 静态内部类看作外部类的一个静态成员。因此，外部类的方法中可以通过：“静态

内部类.名字”访问静态内部类的静态成员（即内部类是静态的，成员是静态的：

Outer.Inner.function()）。通过new“静态内部类()”访问静态内部类的实例。

4. 静态内部类可以访问外部类中的静态成员。

5. 【示例】外部类以外的地方使用静态内部类：

         Face.Nose Inner=new Face.Nose();

6. 如果内部类中定义了静态成员，那么内部类也必须是静态的。

匿名内部类

         -       使用场景：

适合那种只需要使用一次的类。比如：键盘监听操作等等。语法（调用和构造放一起，如下：）

                  new 父类构造器(实参类表)v实现接口(){

//匿名内部类类体！

}

@局部内部类

         定义在方法内部。作用域只限于本方法。用的非常少。

@内部类的应用

1. 由于内部类提供了更好的封装特性，并且可以很方便的访问外部类的属性。所以通

常内部类在只为所在外部类提供服务的情况下优先使用。

2. 一般用于类的设计：

                  分析事物时，发现事物描中还有事物，而且这个事物还在访问被描述的事物的内容，

这时就把还有的事物定义成内部类来描述。

#方法（method、fuction）

&抽象方法：

         1. 方法分为抽象方法和普通方法。

         2. 抽象方法只能定义在抽象类中。

         3. 抽象方法没有方法体，即无花括号{}。

&基本概念

-       定义：

类似其它语言的函数，方法本意是功能或功能块，是一段用来完成特定功能的代

         码片段;

-       声明格式：[修饰符1 修饰符2…….] 返回值类型 方法名(形式参数列表){

//java语句;

}

-       形式参数：

在方法调用时接收外界传入的数据;

-       实参：

调用方法时实际传给方法的数据;

-       返回值：方法在执行完毕后返回给调用它的环境的数据。

-       返回值类型：事先约定的返回值的数据类型，如无返回值，必须给出返回值类型void;

-       java语言中使用下述形式调用方法：

要求先定义，后调用。

对象名.方法名（实参列表）；实参的数目、数据类型和次序必须和所调用方法声明的形参列表匹配;

-       设计方法的原则：最好保持方法的原子性，就是一个方法只实现1个功能，这有利于后

         后期的扩展;

-       方法传参：

         基本数据类型，操作传递的是变量的值，改变一个变量的值不会影像另一个变量。

引用类型传递的是对象的引用（可理解为内存地址），是把原来的引用传递给另一个引

用。

         Java中只有值传递。

-         方法和类的关系：

面向对象中，整个程序的基本单位是类，方法从属于类；

-         类的方法定义和调用：

&构造器

-         构造器是花括号里面只有属性的方法;

-         上图注释：

1. 如果我们定义了构造器，系统默认的无参的构造函数会被覆盖，如果还想调用，

就需要手写出来。

         2. n个类属性，可以构造2的n次方个构造方法（前提是比考虑数据类型不同，顺序不

同不算）。

&方法的重载

-         基本原则：不构成歧义即可;

-         注意事项：

1. 与返回值和和类型无关。

&方法链

         1. return this 方便了我们写方法链

#密封类和密封方法

         1. 被final修饰的类叫做密封类。密封类不能被继承。

         2. 被final修饰的方法叫做密封方法。密封方法不能被重写。

#封装/隐藏（encapsulation）

@封装的步骤

         1. 将属性私有化。

         2. 使用公有的方法来访问私有的属性。

         3. 在set/get方法中设置存取访问控制语句。

@封装的两大原则：

         1. 把尽可能多的东西藏起来，对外提供便捷接口。

         2. 把所有属性都隐藏起来。

@封装的好处

1. 安全: 防止随意访问和不合理赋值。

2. 提高系统的可扩展性、可维护性。

3. 有助于系统之间的松耦合，提高系统独立性。

4.降低了构建大型系统的风险。

@访问权限控制

1. 1.      类成员的访问修饰符

1.1 一般使用private。（除非本属性确认会让子类继承）。提供相应的get/set方法来访问相关的属性，从而提供对属性的读取/设置操作。（注意：boolean变量的get方法是用：is开头。）

1.2 一些只用于本类的辅助方法可以用private。

1.3 希望其它类调用的方法用public。

1.4 常量和static修饰的变量通常公开。

1. 2.      类的访问修饰符

顶级类的访问修饰符只能用public（共有访问级别）和默认（包级私有访问）。（补

充：后面会讲到匿名类）

         3. 接口的访问修饰符

                  3.1 接口的修饰符如果是public，则该接口在整个项目中可见。

                  3.2 如果省略修饰符，该接口只在当前包中可见。

@使用包改进信息的输出

         包机制也是封装的一种形式。

-       package中的核心包：

java.lang

-       为什么需要package包？

         1.为了解决类之间重名冲入问题；

         2.文件分门别类，便于搜索和管理；

         3.有助于实施访问权限的控制。

-       package怎么用？

         1.通常是类的第一句非注释性语句，并且只能有一句。

         2.写项目的时候都要加包，不要使用默认包；

         3.包命名规范：

-       包名前缀一般是全部小写的ASCii字母，且是一个顶级域名com,net,org,gov,edu，

通常是使用组织的网络域名倒序。

         -       包名后续部分依不同机构各自内部的规范不同而不同，、。这类命名规范可能以特

定目录名的组成来区分部门、项目、机器名或注册机。

-       包命名不能使用关键字。

-       包名一般由小写字母组成，不能以圆点开头或结尾。

-       注意事项！

1. com.car和com.gao.car，这两个包没有包含关系，是两个完全独立的包，只是逻辑上看起来后者是前者的一部分。

#继承

&相关概念

-         被继承的叫做父类，超类，基类；继承的叫做子类、派生类。

-         继承是一种约束。

&子类能继承与不能继承父类什么？

1. 继承public和protected修饰的属性和方法，不管子类和父类是否在同一个包里。

2. 继承默认修饰符修饰的方法和属性，但子类和父类必须在同一个包里。

3. 不能继承父类的private成员。

4. 不能继承父类的构造方法。只能通过父类调用。

&继承的好处

-         在OOD层面，继承是对某一批类的抽象，从而实现对现实世界更好的建模。

-         在OOP层面，提高代码的复用性。

-         子类继承父类，除了父类的构造方法。可以得到父类的全部属性和方法。

&使用方法

-         extend的意思是“扩展”，子类是父类的扩展。

-         java中在类中只有单继承（即一个类只能有一个父类），没有像c++那样的多继承。

-         java中多继承，可以通过接口来实现。

-         如果定义一个类时，没有调用extends。则它的父类是：java.lang.Object（根类）。

-         继承的层次不可太多，尽量两到三层。

-         继承的最上层最好抽象。

&常见错误

         1. 编译器报错：Implicit super constructor Person() is undefined for default constructor.

Must define an explicit constructor

分析：因为你的父类已经定义了一个有参的构造函数并且父类中没有默认的无参构造方法，此时

编译器不会为你调用默认的构造函数，

当子类继承时，必须在自己的构造函数显式调用父类的构造函数，自己才能确保子类在初始化前

父类会被实例化，

如果你父类中有无参的构造函数，子类就不会强制要求调用，即你写的那个就可以通过，

编译器会默认帮你调用父类的构造函数。

&方法重写（override）

*使用方法

1. 在子类中根据需要对从基类中继承来的方法进行重写。
2. 重写方法必须和被重写方法具有相同的方法名称、参数列表，其中返回类型相同或为其子类型。
3. 重写方法不能比被重写方法有更严格的访问权限（由于多态）。
4. 重写的方法里面通过super.可以调用父类。
5. 子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法（注：静态方法中无法使用super）。
6. 父类静态方法不能被子类覆盖为非静态方法，父类的非静态方法不能被子类覆盖为静态方法。
7. 父类的私有方法不能被子类覆盖。
8. 不能抛出比父类方法更多的异常。
9. 子类的返回值范围不能超出父类。

*重写与重载的区别

&子类继承父类时构造方法的调用规则：

1. 子类构造方法没有通过super显示调用父类的有参构造方法，也没有通过this显示调

   用自身其它构造方法，那么系统默认先调用父类的无参构造方法。

2. 子类构造方法通过super显示调用父类的有参构造方法，那么执行父类相应的构造方

   法，而不执行父类无参构造。

3. 子类构造方法通过this显示调用自身其它构造方法，在相应构造方法中应用以上两

  条原则。

4. 在实例化子类时，会首先执行其父类的构造方法，然后再执行子类的构造方法。

&Object类

-         相关概念：

是所有java类的根基类。

如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类。

-         常用方法：

1. equals(): 比较两个对象是否为同一个对象。当有特殊需求时，如认为属性相同即为同一对象，需要重写equals()方法。底层实现是依赖“==”运算符。

2. hashCold()//返回该对象的哈希代码值

3. getClass()//获取当前对象所属的类信息，返回Class类对象。

4. toString()//按字符串对象返回，当前对象本身的有关信息。默认返回：包名+类名+@+

哈希码（根据对象内存位置生成，唯一不重复）。

         5. clone()//生成当前对象的一个副本，并返回。

&super关键字（父类对象）

-         定义：

super是直接父类的引用。是一个隐式参数。

super代表父类对象。

-         用法：

1. 可以通过super来访问父类中被子类覆盖的方法（包括构造方法）和属性。super可以使被屏蔽的成员可见。
2. 只能在方法中调用super()。
3. 一般在子类的构造方法中调用父类的构造方法，而且必须位于花括号中第一行。
4. 任何类的构造函数中，若是构造函数的第一行代码没有显示的调用super()；那么java默认会调用super();作为父类的初始化函数。所以你这里的super();加不加都无所谓。
5. Super不可以访问父类中的private成员。

&this关键字   

-       定义：

1.是一个隐式参数，在方法参数是中虽然没写，但是默认传递的，所以方法中可以用this。可以理解为等价于对象名，等于是传递对象的引用地址。

2.多层wrap结构时，this总是指向最外层的对象。

-       用法：

1.this调用重载的构造方法，只能在构造方法中使用，且必须是构造方法的第一条语句

         2. this只能调用实例变量和实例方法、和构造方法，但不能调用类变量和类方法。

         3. 访问本类成员变量或成员方法，如果没有则从父类中找。

-       实例：

&继承VS组合

-         如果光是考虑代码的复用，组合完全可以替代继承。

-         对比结果：

1.组合比继承更灵活。

2.都可以实现代码复用。

-         使用方法：

1.“is-a”关系使用继承！

2.”has-a”关系使用组合！在子类里面new一个父类出来用。

#多态（polymorphism）

&相关概念

1. 把编译比作生活中说的话，把程序运行比作生活中做的事。那么多态就是让话不要说死，办事的时候就能更灵活应对。
2. 是OOP中的一个重要特性，主要是用来实现动态联编的，即程序的最终状态只有在执行过程中才被决定，而非在编译期间就决定了。这可以提高大型系统的灵活性和可扩展性。
3. 是方法的一种现象。
4. 同一个父类对象，赋予不同的子类引用，运行相同的方法，呈现不同的结果。这种现象称之为多态。
5. 抽象类和接口是实现多态的两种重要方式。
6. 多态是实现低耦合的方式之一。

&使用方法：

         1.多态存在的三个必要条件：要有继承、要有方法重写、父类引用指向子类；

2.声明的类名称可以与调用的内名称不同，一般声明的部分是父类。例如有两个类Animal和其子类Cat、Dog，实现多态操作Animal a=new Cat或Animal b=new Dog。其中a指向Cat，b指向Dog。

3.使用父类作为方法的形参和用父类做方法的返回值，是java中实现和使用多态的主要方式。

&向上转型

         1. 语法格式：<父类型><引用变量名> = new <子类型>;

         2. 规则：

                  2.1 将一个父类引用指向子类对象称为向上转型，系统会自动进行类型转换。

                  2.2 如果父类方法被子类重写，此时通过父类引用变量调用的是子类覆盖父类的方

法，不是父类的方法。

2.3 此时通过父类引用变量无法调用子类特有方法。

&向下转型

         1. 如果需要调用子类的特有方法，可以通过把父类强制类型转化为子类。

2. 语法格式：<子类型><引用变量名> = （<子类型>）<父类型的引用变量>;

3. 应用场景：应用接口做参数时，子类既有继承又有实现时，需要向下转型。

4. 凡是类型强转最好都先进行instanceOf判断，避免出现类型转换异常。

&多态的应用：

1. callback回调、

2. hook（钩子函数）

3. 模板方法模式。

4. 使用父类作为返回值。这种类叫做工厂类。可以理解为发送一个父类给别人用。

5. 使用父类作为形参。可理解为接收一个父类给自己用。

&java中多态的绑定机制

-         动态绑定：实例方法与引用变量实际引用的对象绑定。由运行时的jvm决定。

-         静态绑定：静态方法与引用变量所声明的类型绑定。实际上在编译阶段就做了绑定。

 成员变量也属于静态绑定。

#引用数据类型

@包装类（wrapper class）

&相关概念

1. 为什么需要包装类：

         JAVA不是一个纯面向对象的语言，Java中的基本数据类型是不面向对象的。但是我们

         实际使用中经常需要将基本数据类型转化成对象，便于操作。比如：集合的操作中。   

2. 作用：

2.1 包装类均位于java.lang包，提供：字符串、基本数据类型、对象之间互相转化

的方式。

2.2  包含每种基本数据类型的相关属性，如最大值、最小值等。

         3. JDK1.5以后，允许基本数据类型和包装类型进行混合数学运算。

&包装类的关系图

&包装类的常用方法

         1. 共性方法：

         2. Integer特有方法：

&自动封装和自动拆箱（auto-boxing&unboxing）

-       自动封装：

基本类型自动地封装到与它相同类型的包装中，比如：

         Integer i = 100;本质上是，编译器编译时为我们添加了：Interger i = new Integer(100);

-       自动拆箱：

         包装类对象自动转化成基本数据类型。如：

         int a = new Integer(100);本质上是，编译器编译时为我们添加了：

int a = new Integer(100).intValue();

&缓存问题

//[-128,127]之间的数，仍然当作基本数据类型处理

         Integer d3 = 127;

         Integer d4 = 127;

         System.out.println(d3==d4);

         System.out.println(d3.equals(d4));

@枚举

         1. 定义：

                          指由一组固定的常量组成的类型。枚举不是类，是与类和接口同一层概念。

         2.枚举的好处：类型安全，易于输入，代码清晰。

         3. 语法格式：

         4. 【实例】

                  4.1 优化前（使用if判断保证类型安全）：

if(!(Gender.equals(male)||Gender.equals(female))) {

         System.out.println("性别类型错误！");

}

                  4.2 优化后（使用enum保证类型安全）：

public enum Gender {

         male,female

}

         5. 枚举一般用于switch和if的条件选择

@String（存储字符串）

&相关概念

1. String对象是用来存储字符串的，是数组典型的应用，底层实现是通过数组。

2. java字符串是Unicode字符序列。

3. 字符串的不可变性：是不可变字符序列（执行完方法后原字符变量不改变）。

4. java没有内置的字符串类型，而是在标准java类库中提供了一个预定义的类String。每个用双引号扩起来的字符串都是String类的一个实例

&常用方法

     1. 改：

                  - toLowerCase();

                  - toUpperCase();

                  - trim();

                  - replace();字符串替换，可以使用方法链。

     2. 判断：

                  - equals();

                  - equalsIgnoreCase();

                  - endsWith();

                  - startsWith();

                  - matches();

     3. 转：

                  - split();

     4. 查：

- substring(int a);

        - substring(int a, int b);

&String和各种格式互相转换

-       其它类型转String

1. String s = String.valueOf(value);其中value为任意一种数据类型。

-       字符串转化为各种数字类型：

1. byte a = Byte.parseByte(s);

2. short b= Short.parseShort(s);

3. 以此类推Integer/Long/Float/Double。

4. 字符串转字节数组：.byte[ ] words = str.getByte();

@StringBuilder（可变长度字符串）

- 内部机制：

         数组扩容实质是用新数组代替老数组。

- 特点：

1.1 线程不安全，效率高。字符数组初始长度为16。

1.2 当对字符串操作频繁时，效率高于String。

- 常用方法：

1.1 增：

- append(String a);//方法通过return this 实现方法链。

- insert(int a,String b);//

每隔三位插入一个逗号：

1.2删：

   - delete方法删除的时候包头不包尾。也可使用方法链。

1.3 构造：

             - 无参构造。

             - String类型做参数。

1.4 转:

             - toString();//转化为String类型。

1.5 查：

             - length();//返回字符串长度

@StringBuffer（可变长度字符串）

- 特点：

2.1 线程安全，效率低。字符数组初始长度为16。对字符串的操作效率比String类高。

-   常用方法：同StringBuilder

4. Java高级API

         1. 所谓API就是一些已经写好、可直接调用的类库。

#实用类

@日期时间

&关系图谱

&java.util.Date

         1. 它的对象表示一个特定的瞬间，精确到毫秒。Java中的时间表示实质是数字，是从：

                  标准纪元1970.1.1 ，0点开始到某个时刻的毫秒数，类型是long。

         2. 常用方法：

         3. 相关方法：

                  3.1 System.currentTimeMillis()//显示当前系统时间的毫秒数

&java.text.DateFormat和java.text.SimpleDateFormat

-       作用：  nnn

         完成字符串和时间对象的转化

-       用法：（可以看API文档详情）

         1. 已知格式和日期，转化为字符串：.format

         DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");

DateFormat df2 = new SimpleDateFormat("yyyy-MM-dd");

DateFormat df3 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

//将时间对象按格式化字符串，转化为字符串

Date d = new Date(232322424214L);

String str = df.format(d);

String str3 = df3.format(d);

2. 已知格式和字符串，转化为日期：.parse

& GregorianCalendar

- GregorianCalendar是Calendar的一个具体子类，提供了世界上大多数国家/地区使用的标准日历系统。

&Calendar

         1.Calendar是抽象类。

2. 静态方法：

                  2.1 getInstance();//返回一个日期类的实例。

         3. 字段属性

@Math

1. Math. Random。

-   Math.random()是令系统随机选取大于等于 0.0 且小于 1.0 的伪随机 double

值；

      -  方法一：

      -  方法二：支持多线程的

@Scanner

&使用方法

-         使用步骤

1.导入扫描仪 import java.util.Scanner;或者import java.util.*;

2.声明一个新的扫描仪 Scanner 变量名=new Scanner(System.in);

3.使用扫描仪 :

整数型数据输入：in.nextInt()来接收;

双精度小数输入：in.nextDouble()来接收;

字符串输入：in.next()来接收;

-         批量接收键盘输入

多个值之间用空格隔开，可以实现多个值的批量输入

&常用方法

1. hasNextInt();判断是否为整数，返回布尔值。

2. close();关闭扫描器。

         3. next()和nextLine的区别：

                  next()只识别非符号输入，而nextLine()可以识别回车、制表符等操作。

@System

1. 常用方法：

         -      

@java.util.Random

         1. 常用方法：

#Java集合框架

@相关概念

         1. 为什么会出现这么多容器？

                  因为每一个容器对数据的存储方式都不同。这个存储方式称之为：数据结构。

         2. 集合框架是对一些常用的数据结构的封装。

         3. 集合是用于存储对象的。

         4. 集合中不可以存储基本数据类型，如果使用了基本数据类型，会自动转换为对应的

包装类。

5. 创建对象时通常左边是接口，右边实现类。例如List list = new ArrayList()。这样便于

后期修改，当要转化为LinkedList类型时，只需把ArrayList()换成LinkedList()。

@java集合框架体系图

         1. 接口：

是代表集合的抽象数据类型。接口允许集合独立操纵其代表的细节。在面向对象的

语言，接口通常形成一个层次。

2. 实现（类）：

是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构。

3. 算法：

是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些

算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。

@Java集合类关系图

1. Java集合框架提供了一套性能优良/使用方便的接口和类，它位于java.util包中。

2. 上图注释：

                  2.1 虚线框表示接口或者抽象类。实线框表示开发中常用的实现类。

                  2.2 Utilities里面的为工具类（算法类），提供了对左上方类和接口的一些操作方法。

                  3.3 Iterator、Collection、Map之间有关联，但不是继承关系。

                  2.4 可以把Vector类归为List接口下。

@集合接口

&相关概念

         1. Collection接口存储一组不唯一、无序对象。

         2. List接口存储一组不唯一，有序（插入顺序）的对象。

         3. Set接口存储一组唯一，无序的对象。如果元素重复，后面的会覆盖前面的。

         4. Map接口存储一组键值对，提供key到value的映射，其中key是唯一的。

         5. Collextion函数库是在java.util包下的一些接口和类。

         6. Collextion函数库只能用来存放对象。

         7. Collextion接口是集合框架中的根接口。

         8. Collextion代表一组对象。

&Collection接口

         1. 常用方法

1. clear()和removeAll(Collection c)

这两个方法的目的是不同的。clear()方法是

为了通过删除所有元素而重置列表，而removeAll(Collection c)是为了从集合中删除某

些存在于另一个提供的集合中的元素，并不是为了从集合中移除所有元素。所以如果

你的目的是删除所有元素，用clear(),如果你的目的是删除某些存在于另一集合的元

素，那么选择removeAll(Collection c)方法。

&List接口

1. 区别于Collection接口的方法（凡是可以操作下标的方法都是该体系的特有方法）：

2. listIterator():可以在遍历过程中对集合进行增删改查

         3. List集合判断元素是否相同，依据的是元素自身的equals方法。包括contains()，

                  Remove()等方法。

&Set接口

         1. set集合的方法和Collection是一致的。

         2. 判断对象依赖的是元素，hashCode和equals方法。

         3. Set底层使用的是map集合。

&Map接口

*遍历map

方法一：通过迭代器Iterator

方法二：增强型for循环

方法三：键值对entrySet

         2. 【实例】：

import java.util.*;

public class Test {

   public static void main(String[] args) {

     Map<String, String> map = new HashMap<String, String>();

      map.put("1", "value1");

      map.put("2", "value2");

      map.put("3", "value3");

      // 第一种：普遍使用，二次取值

      System.out.println("通过Map.keySet遍历key和value：");

      for (String key : map.keySet()) {

          System.out.println("key= " + key + " and value= " + map.get(key));

      }

      // 第二种

      System.out.println("通过Map.entrySet使用iterator遍历key和value：");

      Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();

      while (it.hasNext()) {

          Map.Entry<String, String> entry = it.next();

          System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());

      }

      // 第三种：推荐，尤其是容量大时

      System.out.println("通过Map.entrySet遍历key和value");

      for (Map.Entry<String, String> entry : map.entrySet()) {

          System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());

      }

      // 第四种

      System.out.println("通过Map.values()遍历所有的value，但不能遍历key");

      for (String v : map.values()) {

          System.out.println("value= " + v);

      }

   }

}

*共性方法

         1. put方法：添加元素，如果添加到相同的键那么后添加的会覆盖原有的值。put方法

      会返回该键的被覆盖的值。

         2. KeySet方法：将Map中所有的键存入到Set<K>集合中。因为set具备迭代器。所以

      可以通过迭代方式取出所有的键，再根据get方法获取每个键对应的值。

         3. map集合取出原理：将map集合转成set集合，再通过迭代器取出。

         4. entrySet：将Map集合中的映射关系存入到Set<Map.Entry<k,v>>集合中，而这个关系

      的数据类型是：Map.Entry，它是一个接口，内里有getKey和getValue的方法。（泛

      型嵌套形式）

         5. Map.Entry是Map接口中的一个内部接口

6.values方法返回映射中值的Collection视图。

7. 常用方法：

@集合实现类（集合类）

&ArrayList（动态数组）

1. 相关概念：

1. 实现了长度可变的数组，在内存中分配连续的空间。

2. 在ArrayList中遍历元素和随机访问元素效率较高。除了增删情况，一般优选

ArraList作为容器。

3. 对数组进行了封装，底层实现是Object类数组。允许集合元素之为null。

4. 线程不安全，效率高。线程不同步。一般定义在局部变量中，跟线程没有关系。

5. 可以加锁保证安全。

6. 扩容是采用50%延长。

7. 使用ArraList之前需要导入相应的接口和类，代码如下：

         import java.util.ArrayList;

         import java.util.List;

8. 在不知道数据的索引且需要全部遍历的情况下，ArrayList效率同样很低。

2. 特有方法：

2.1 注释：

2.1.1. 所有标红的方法都是Collection接口共有的方法。

         3. 【实例】遍历ArrayList

3.1 三种方法都是用来遍历ArrayList集合，第三种方法是采用迭代器的方法，该方

法可以不用担心在遍历的过程中会超出集合的长度。

import java.util.*;

public class Test{
public static void main(String[] args) {
    List<String> list=new ArrayList<String>();
    list.add("Hello");
    list.add("World");
    list.add("HAHAHAHA");
    //第一种遍历方法使用foreach遍历List
    for (Stringstr : list) {            //也可以改写for(int i=0;i<list.size();i++)这种形式
       System.out.println(str);
    }

    //第二种遍历，把链表变为数组相关的内容进行遍历
    String[] strArray=new String[list.size()];
    list.toArray(strArray);
    for(int i=0;i<strArray.length;i++) //这里也可以改写为  foreach(String str:strArray)这种形式
    {
       System.out.println(strArray[i]);
    }
    
   //第三种遍历使用迭代器进行相关遍历
    
    Iterator<String> ite=list.iterator();
    while(ite.hasNext())//判断下一个元素之后有值
    {
        System.out.println(ite.next());
    }
}
}

&LinkedList（链接列表）

                  1. 底层采用链表存储实现。

                  2. 插入、删除元素时效率较高。

                  3. 线程不安全，效率高。一般定义在局部变量中，跟线程没有关系。

                  4. 除了包含ArraList类所包含的方法外，还包含First、Last字样的该类特有方法:

         5. LinkedList类和ArraList类所包含的大部分方法是完全一样的，这主要是因为它们都是

Lis接口的实现类。

&Vector

1. 线程安全，效率低。当多个线程需要共享的时候，考虑使用Vector。

2. 底层实现是Object类数组。与ArrayList几乎一样。基本被ArrayList取代。

         3. Vector在Jdk1.0版本就有了，当时还没有集合框架。在jdk1.2版本中成为集合框架成

员。

         4. 与新Collection实现不同，Vector是线程同步的。

         5. 扩容是采用2倍延长方式。

         6. elements()枚举是Vector特有的取出方式:

         7. 包含elemen字样的方法都是该类特有方法。

&Hashset

         1. 底层数据结构时哈希表。是非线程安全的，线程是非同步的。

         2. 允许集合中的元素值为null。

         2. 哈希表结构特点：如果两个哈希地址一样，再比较两个是否是指向同一个对象，如

果不是一个对象，则会在前一个地址基础上顺延，两个对象在同一个地址上，如果是

一个对象则不会存入哈希地址。如果一开始就不是一样的哈希地址，那么会把开辟一

个新空间给新地址。

         3. HashSet是如何保证元素的唯一性呢？

           是通过元素的两个方法，hashCode和equals来完成。

           如果元素的hashcode的值相同，才会判断段equals的值是否为true。

           如果元素的hashcode的值不同，则不会调用equals。所以建立一个有针对性的

Hashcode,程序会更高效，可以依据对象内容来设计，比如Person对象：

         4. HashSet判断和删除的依据：

                  依赖的是元素，hashCode和equals方法。原因是数据结构不同，依赖的方法就不

一样。

         5. 遍历HashSet：

                  5.1 增强for循环（不能用普通for循环，因为HashSet没有get()方法）。

                  5.2 使用Iterator接口。

*TreeSet

         1. 可以对set集合中的元素进行排序，是不同步的。字符串按照ACCii码表排序。

         2. TreeSet排序的第一种方法：让元素自身具备比较性，通过实现Comparable接口的

compareTo方法来具备此特性。这种方式也叫做元素的自然顺序或默认顺序。重复元

素无法进入set集合。

2.1【实例】正序排序：

  public int compareTo(Object o) {

     Person p = (Person)o;

     if(this.age>p.age)

        return 1;

     if(this.age<p.age)

        return -1;

     return 0;

  }

         3. 记住，排序时，当主要条件相同时，一定要判断一下次要条件。

         4. TreeSet底层实现是二叉树，输出采用的是中序遍历。如果元素较多，查找是先二分，

再遍历。

         5. 保证元素唯一性的依据是：就是根据比较方法返回的结果是否是0，是0就是相同元

素，不存。

         6. TreeSet的第二种排序方式：

           当元素自身不具备比较性，或者具备的比较性是不符合需要的。

           这时候需要集合自身具备比较性。在集合初始化时就有了比较方式。

           定义比较器（自定义类），实现Comparator接口的compare()方法，将比较器对象作

为参数传递给TreeSet集合的构造函数。

         7. 如果TreeSet的元素、容器自身都具备比较性。那么排序时以容器的比较性为主。

         8. Comparator接口的compare()实现倒序，只需将o1和o2换个位置即可。

*HashTable

         1. 底层是哈希表。任何非null对象都可以用作键或值。

         2. 用作键的对象必须实现hashcode方法和equals方法。

         3. 元老级的类，jdk1.0版本就有了。一般元老级的是线程同步的。

*HashMap

         1. 底层是哈希表。允许使用null值和null键。除了非同步和允许使用null之外，与

hashTable大致相同。

         2. jdk1.2版本，相对于hashtable效率要高。

         3. 判断一个键是否存在：

                  3.1 可以通过get方法的返回值来判断。注意一个例外：当null作为键值存储时。

*HashTable与HashMap的比较

*TreeMap

         1. 底层是二叉树。

         2. 线程不同步。

         3. 可以用于给map集合中的键进行排序。键元素自身具备比较性，或者通过比较器使

      容器具备比较性。

    4. Map的扩展---一对多映射       

@迭代器

         1. Iterator it = ArrayList.iterator();//获取迭代器，用于取出集合中的元素。

         2. 迭代器的内部设计方式：内部类实现接口。

         3. 在迭代时，循环中next()调用一次，就要hasNext()判断一次。

         4. Enumeration<E>接口的功能与 Iterator 接口的功能是重复的。此外，Iterator 接口添

加了一个可选的移除操作，并使用较短的方法名。新的实现应该优先考虑使用 Iterator

接口而不是 Enumeration 接口。

5. 利用iterator()方法迭代的两种写法比较：

         -       上图注释：高亮部分性能更优，把it作为局部变量，省去了it的存储空间。

         6. 常用方法：

@比较器

                  1. 对象排序不是用重写Comparable接口，就是用实现Comparator接口。

&Comparable接口

         1. 此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，

类的 compareTo 方法被称为它的自然比较方法。

&Comparator接口

@算法类

&Collections

         1. sort方法自然排序。只能对list集合。元素自身必须具有比较性。

         2. sort方法自定义比较器排序。只能对list集合。

         3. max方法根据自然顺序获取最大值。

         4. max方法根据自定义比较器获取最大值。

         5. binarySearch方法查找某个元素，返回index。只能对list集合。如果没有该元素，返

           回-（插入点-1）。

         6. binarySearch方法根据自定义比较器排序后，获得其index。

         7. fill方法可以将list集合中所有元素替换成指定元素。或者部分元素替换成指定元素。

         8. replaceAll将指定的老元素替换为指定的性元素。

         9.reverse反转。

10. reverseOrder可以强行逆转实现了Comparable接口的对象Collection的自然顺序。

11. reverseOrder可以强行逆转指定比较器的顺序。

12. SynList使非同步的list变成list

13 swap：交换两个指定位置的元素。

14. shuffle：打乱原集合中元素的顺序。

&Arrays

         1. 用于操作数组的工具类，里面都是静态方法。

         2. 转：

2.1数组与集合之间的转换：

2.1.1 将数组变成list集合。asList：将数组变成list集合。它的好处有：可以使用集合的思想和方法来操作数组中的元素。

注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的。

如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中

的元素。如果数组中的元素都是基本数据类型，将该数组作为一个整体，使之成

为集合中的一个元素。

2.1.2 将集合变数组：

Collection接口中的toArray方法。

                  2.2数组变字符串：

                          toString(array);

3. 常用方法：

         3.1 equals(array1,array2);

         3.2 sort(array);

         3.3 fill(array,val);

         3.4 copyOf(array,length);

         3.5 binarySearch(array,val);

@泛型

         1. JDK5.0版本以后出现的新特性。用于解决安全问题，是一个安全机制。

         2. 泛型的由来：参考了数组设计，数组在一开始定义的时候就明确了类型。

         2. 泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

         3. 泛型的好处：

3.1 如果容器不定义泛型，类型不匹配时，在编译阶段不会报错，是内伤。定义之

后，编译阶段就会报错，内伤转外伤，让程序员更容易识别。

                  3.2 避免了从容器中获取元素需要强制转化的麻烦。

         3. 泛型的缺点：不能预先使用子类中的特有方法（同样是多态的缺陷）。

         4. 尖括号<>是用来接收类型的形式参数。

&泛型方法

         1. 泛型定义在方法上：泛型方法， 当需要不同方法操作不同类型时可以定义泛型方法。

         2. 静态方法泛型： 静态方法不可以访问类上定义的泛型，如果静态方法确定的类型不

确定，可以将泛型定义在方法上。

&泛型类

         1. 泛型定义在类上：泛型类。

什么时候自定义泛型类：当类中要操作的引用数据类型不确定的时候，早期定义

Object来完成扩展。现在定义泛型来完成扩展。

泛型类可以作为返回值或者形式参数。

         2. 泛型类中可以包含泛型方法，互不冲突。

&泛型接口

                  9.1定义泛型接口

                  9.2 在子类中明确类

                  或者在子类中继续地定义泛型，等到调用阶段再明确类。

&类型通配符（泛型限定）

1. 接收任意类型，采用通配符方法（也可以理解为占位符）：

-       [类名]<?> 或者 直接[类名]。

//比如Collection接口的containAll方法。

2. 接收任意类型，采用泛型方法：

3. <? extends E>：

如下图，接收Person类和Person类的子类。上限定了。再比如Collection接口和

TreeSet的addAll方法。

4. <? super E> ：

可以接收E类型和E类型的父类。下限定了。比如TreeSet里面的构造方法。

5. 泛型限定分为上限和下限。泛型限定的用于程序扩展的。

#Java I/O

@相关概念

         1. 流：用来读写文件，是一组有序的数据数列。是以先进先出的方式发送信息的通道。

         2.

@File类

&示例

&常用

         - 绝对路径：从根盘符出发的路径，例E:\1\2\3\a.txt

         - 相对路径：从相对于当前位置出发的路径，例我在1位置，找a.txt，相对路径为

1\2\3\a.txt

@JAVA流的分类

        - 字符流是字符流+编码表的封装。实质是字节流

@FileInputStream类

@FileOutputStream类

         - 上图最后一个构造方法，布尔类型为ture表示输入的内容追加到文件内，反之则覆盖

文件内容。

         -  对于一些自带缓冲区的流，flush()会把未满的缓冲区中的内容强制清空出去。

@FileReader类

         -  解决中文乱码：字符流去读的时候，指定字符流的编码格式。FileReader无法指定编

码格式。会按照文件系统默认编码格式读（获取默认编码的方法：

System.getProperty(“file.encoding”)）。

         -  InputStringReader实际上是把字节流包成了字符流。自身采用的是一种适配器的模

式。可以作为字节流和字符流之间过渡的桥梁。

         -  FileReader是InputStreamReader的子类。

@BufferedReader

    1. 是一个缓冲流，是一个带缓冲区的输出流。缓冲流的缓冲区可以避免多次对数

据源的操作，提高了效率。

    2. 实质是将FileReader和InputStream再包装了一层。

    3. 是Reader类的一个子类。

@FileWriter类

         1. newline();//可以用来换行。

@BufferedWriter

@读写二进制文件

         - 上图第二行错误：DataInputStream应该是FileterInputStream的子类。

         - 上图倒数第二行错误：DataOutputStream应该是FileterOutputStream的子类。

@序列化和反序列化

@注意

         1. 有时候缓冲流没关闭会导致文件无法读写。输入流一定要记得关了，输出流记得

flush。多个流中，先开的后关，后开的先关。

         2. 带缓冲区输出流关闭的时候，会先将缓冲区的内容清空出来，再关闭。

         3. 缓冲区有默认大小。

         4. 字节流复制文件需注意：

                 4.1 读多少个，就写多少个，用len变量。

                  4.2 一般一个读匹配一个写就可以。

@读写

         1.

6. 并发编程

@反射机制

#java.net

      1. Socket:

                  1.1 用完了要关掉。

                  1.2  方法InputStream getInputStream();//返回输入流

                  1.3  方法InetAddress getInetAddress();//返回IP地址对象

      2. DatagramPacket：

                  2.1 封装数据包。

                  2.2 处理数据包。

                  2.3 构造方法DatagramPacket(byte[]礼物,int 容积netAddress地址，int端口号);

                  2.4构造方法DatagramPacket(byte[]礼物，int容积);

                  2.5 bytes[] getData();//返回包裹里面的礼物。

                  2.6 方法SocketAddress getSocketAddress();//获取包裹所在机器的地址。

      3. DatagramSocket：

3.1 发送数据包。

3.2 接收数据包。

3.3 方法void send(DatagramPacket 包裹);//发送包裹

3.4 构造方法DatagramSocket(int端口);

3.5 无参构造；

3.6方法void receive(DatagramPacket 包裹);//接收包裹

      4. InetAddress：

4.1 方法String getHostAddress();//获取客户端IP信息

4.2 方法static InetAddress getByName(“localhost”);//获取本机地址，返回

InetAddress。

4. 常用工具类库

#DOM4j

@相关概念

                  1. 开源。

                  2. 应用于java平台。

5. 并发编程

#注解

#多线程

@相关概念

         1. 主线程：

                  1.1 main()方法即为主线程入口。

                  1.2 产生其他子线程的线程。

                  1.3 必须最后完成执行，因为他执行各种关闭动作。

                  1.4 不同的线程会占用CPU的不同时间片。

         2. 多线程：

                  1.1 多线程不是真正的并行，是多个线程交替执行。

                  1.2 线程每次执行时长由分配的CPU时间片长度决定。

@java.lang.Thread类

         1. 支持多线程编程。

         2. 静态方法：

                  2.1 currentThread();//获取主线程对象。

         3. 实例方法：

                  3.1 getName();//返回当前线程对象名

                  3.2 setNamer();//设置当前线程对象名。

         4. 实现了runnable接口，重写了run()方法。

@创建线程

&继承Thread类创建线程

&实现Runnable接口创建线程

&比较两种创建线程的方式

         1. 继承Thread类方式特点：

                  1.1 编写简单，可直接操作线程。

                  1.2 适用于单继承。

         2. 实现Runnable接口方式 特点：

                  2.1 避免单继承局限性。

                  2.2 便于共享资源。

         3. 结论：

3.1 推荐使用实现Runnable接口方式创建线程。

3.2 使用带参构造时，在初始化线程的时候就要明确线程任务。

                  3.3 实现Runnable接口的好处：

3.3.1 将线程的任务从线程的子类中分离出来，进行了单独的封装。

3.3.2 按照面向对象的思想将任务封装成对象。

3.3.3 避免了java单继承的局限性。

@线程的状态

@线程的调用

         1. sleep()中millis为休眠时长，以毫秒为单位。

           调用sleep() 方法需处理InterruptedException异常。

           可以用sleep()方法模拟网络延迟或者模拟代码执行过程。

         2. Thread静态常量，Norm_priority表示默认优先级5.

@线程的同步

&线程不安全条件

         1. 当多个线程操作共享的资源。

2. 操作共享数据的线程代码有多条。

&线程不安全原因

当一个线程在执行操作共享数据的多条代码过程中，该线程未完成全部操作的时候，其它线程参与了执行，修改了共享数据，造成数据不安全问题。

&解决思路

         1. 将多条操作共享数据的线程代码同时封装起来，当有线程执行这些代码的时候，其

它线程不允许参与运算。必须等当前线程把这些代码执行完毕后，其它线程才可以参与

运算。

2. 线程的切换使用if(flag)

3. 建议使用同步代码块来解决问题。

4. 为了保持同步函数与同步代码块的锁一致，可以将锁设置为字节码文件对象。字节

码文件进内存时会先创造对象，所有对象建立后都有自己所属的字节码文件对象。

&同步方法（同步函数）

         1. 同步函数用的锁是this对象。

         2. 当同步代码块的锁是this对象时，可以将同步代码块简写为同步函数。

         3. 静态的同步函数使用的锁是 该函数所属字节码文件对象。可以用 getClass方法获

取，也可以用当前 类名.Class 表示。

&同步代码块

         1. 同步代码块的锁是任意的。

&同步的前提、好处和弊端

         1.好处：解决了线程不安全问题。

         2.弊端：相对降低了效率，因为同步外的线程都会判断同步锁。

         3.前提：必须有多个线程并使用同一个锁。

@线程安全的类型

@死锁

         1. 死锁的描述：

有个门需要两把锁才能打开，小明拿了锁1，小红拿了锁2，两个人都想先进门，不

愿意把自己的钥匙交给对方，造成僵持状态。

         2. 定义：

           实质是两个对象都在等待对方先完成，造成程序的停滞。

         3. 死锁的条件：

                  3.1 两个或两个以上线程在活动。

                  3.2 某个线程拿到一个锁以后，还想拿第二个锁，造成锁的嵌套。

@案例：生产者与消费者问题

         1. 避免重复生产和重复消费。设置标志位。

         2. 交替生产。设置交替标志。

         3. 实现了先生产后消费，并且交替进行。

@线程池

&使用线程池的好处

&工具类

&构造类

*关系图

*ThreadPoolExecutor类

1. 核心池里面的线程会被保留，其它的线程在超过keepAliveTime的时间后会被销毁。

&线程池的执行原理

6. 网络编程（Java Web、J2EE Web）

#网络基础知识

@相关概念

1. 网络通信协议：为了在网络中不同的计算机之间进行通信而建立的规则、标准或约

定的集合。

@网络模型

         1. 网络层是一种逻辑层，路由选择是在网络层做的。

@IP地址

&IP地址的组成

IP地址共32位，由4个8位二进制数组成。2的8次方-1=255=8个1的二进制。

IP地址 = 网络地址+主机地址。

                    网络地址：标识计算机或网络设备所在的网段（也叫做网络ID）。

                    主机地址：标识特定主机或网络设备。

&IP地址分类

&IP地址的配置和检查

         1. 查看本机IP地址：ipconfig。

         2. 测试网络是否畅通：ping 目标IP地址。或者：nslookup 目标IP地址。

       &常用IP地址

         1. localhost代表的是本机。

         2. 127.0.0.1是本机回环地址。

&子网掩码

                  一般情况c类是前面三个数都是255，b类前两个数是255，a类第一个数是255。

&DNS

@端口

                  1. 默认端口http：80、mySql：3306、Oracle：1521

                  2. 有效端口0~65535，其中1-1024是系统使用和保留的端口。

                  3. 用于标识进程的逻辑地址，不同进程的标识。

@网络服务器

         1.分类：web服务器（Apache Tomcat）、邮件服务器（Microsoft IIS）

         2. 作用：接收用户的请求，并给出相应的响应。

@网络通讯要素

         IP地址、端口号、传输协议

#socket编程

@Socket（套接字）

*简介

                  1. Socket最早出现在unix上。

                  2. Socket可以理解为插座，端口可以理解为插孔，二者结合就提供了一种服务。

                  3. Socket是提供给应用程序的接口。

*Socket分类

                  1.流式套接字是基于 TCP协议的Socket通信。

                  2.数据报式台套接字是基于UDP协议的Socket通信。

@Socket通信原理（机制）

                  和打电话类似。

@基于TCP协议的Socket编程

@基于UDP协议的Socket编程

         1. 步骤：

         2. 思路：

                  2.1 LoginClient类

                          声明一个礼物，将该礼物打散成字节数组。

声明一个包裹在包裹上标明，容量，寄送地址和端口。

声明一个快递点，调用快递点的send(包裹)方法发送包裹。

//接收服务器的响应。

声明个新包裹。

                          调用receive(包裹)方法接收包裹。

                          拆礼物，声明一个String类，将字节数组作为参数传入变成String类。

                  2.1 LoginServer类

                          声明一个空包裹，标明内容和容积。

                          声明一个站点，明确站点的端口，调用receive(包裹)方法接收包裹

                          声明一个String类，将bytes[]类转化为String，即拆分包裹。

                          //给客户端一个响应

                          从包裹中获取客户端的地址。

                          声明一个String礼物，将该礼物打散成字节数组。

                          声明一个新包裹，标明该新包裹的bytes[]、int容积、寄送地址。

                          调用快递点的send(包裹)方法发送包裹。

@多个客户端对应一个服务器的交互的思路

通过多线程处理多请求来实现

1. 服务器：

一直监听客户请求。

一旦监听到有客户请求，立刻创建一个线程，开启线程。

2. 线程：

接收客户请求，给予客户一个响应（即是之前服务器做的事情）。

线程构造方法中去绑定客户端的Socket。

3. 客户端：

发送请求到服务器。

接收服务器的相应。

4. 如何获得客户端的IP

    InetAddress可以获得对应的IP地址，实质是java提供的对IP地址的封装，通过

InetAddress对象可以实现对IP地址的操作。

#XML

@相关概念

                  1. XML与操作系统、编程语言开发平台无关。

                  2. 应用于：网络数据交互、配置应用程序和网站、Ajax的基石。

                  3. 不同的浏览器由于内核不同，对xml文档的解析后的显示也不同，但结果相同。

@XML文档结构

                  1. 声明：

                          1.1 如果没写编码，默认编码为UTF-8.

                  2. 文档元素描述信息：

                          2.1 树形结构。

@XML格式与规范

&声明

&注释

                           1. <!--->

&语法

         -  命名元素名称最好见名知义。

         -  元素名称最好不包含-、:、.

         -  元素名可以根据数据库中表的列名来定义。这样方便将来框架的映射。

&两种书写方法

&转义符

@相关工具

                  &XMLSpy

@XML解析器

      &非验证解析器

                  1. 检查文档格式是否良好。

      &验证解析器

                  1. 使用DTD（文档类型定义，实质是xml的一种验证机制）检查文档的有效性。是基于格式良好的基础上去验证类容是否有效。

@XML命名空间

         1. 类似于java中的包的作用。

         2. 利用前缀来避免命名冲突。

         3. 格式：xmlns：名字=”值”

@解析XML的技术

         1. DOM4J实质是对DOM的封装。

@DOM解析技术

       &DOM解析XML文档

      *1. 简介

      *2. DOM解析包：org.w3c.dom

       &获取并添加元素步骤

//查东西

         3.1 创建解析器工厂

         3.2 获得解析器

         3.3 用解析器来解析XML文件获得Document对象

         3.4 拿到某节点集合

         3.5遍历节点集合

         3.6 拿到节点集合中的某个节点

         3.7 将节点转化为元素，获得元素中的属性值

         3.8 可以通过Node类和Element类再继续找子节点集合

         3.9 过滤子节点集合，找出其中的元素节点

//加东西

         3.1 通过文档树创建一个要添加的元素

         3.2 为添加的元素设置属性值

         3.3 追加一个添加元素的孩子元素

         3.4 在文档树中拿到要添加元素的父元素，并将添加元素作为父元素的孩子元素

       &保存XML文件并设置缩进步骤

                  1. 思路：

                  2. 步骤：

                          2.1 创建转换器工厂

                          2.1.1 首行缩进4个空格

                          2.2 创建转换器

                          2.2.1 设置输出时的编码，并并允许缩进

                          2.3 获取源

                          2.4 获取目的地

                          [2.4.1]解决乱码问题需指定输出编码

                          2.5 将源转换到目的地的xml文件中

       &修改元素步骤

                  1. 获取要修改的元素节点集合

                  2. 遍历出集合中的元素节点

                  3. 获取元素节点中的元素

        4. 修改元素的属性

       &删除元素步骤

        1. 获取要删除的元素集合

        2. 遍历出集合中的元素节点

                  3. 获取元素节点中的元素

                  4. 过滤出要删除的元素

                  5. 找到要删除元素的父节点，然后删除其孩子

@DOM4j解析技术

&导入jar包

         方法一：

                  1. 选择项目右键

                  2.

                  3.

                  4.  

                  5.

                  6.

                  7.输入资源名，点击ok

                  8.

                  9. 找到项目下lib文件夹中的DOM4j，点击打开

         方法二：

                  1.

                  2.

                  3. 找到项目下lib文件夹中的DOM4j，点击打开

&获取document对象步骤

                  1. 获取一个解析器

                  2. 获得document对象

&显示某节点信息

         //查找某个元素的属性

                  3. 获取根节点

                  4. 获得所有根结点的子节点集合的迭代器

                  5. 判断迭代器是否有下一个对象

                  6. 取出迭代器中的对象，并转换为元素

                  7. 获得元素某个属性的值

         //继续查找某元素的某个子元素的属性

                  8. 获取该元素所有子元素的迭代器

                  9. 判断迭代器是否有下一个对象

                  10. 获取迭代器中的对象，将其转换为元素，并获得所需属性值

&增加元素信息步骤

                  1. 获得xml根元素

                  2. 在根元素下创建并添加的元素

                  3. 设置元素的属性

&保存xml文件

                  1. 创建解析器

                  2. 设置转换的字符编码（可选）

                  3. 创建输出流

或者

                  4. 将输出流写到xml文件中

&修改节点信息

                  1. 获取根节点

                  2. 获取根节点的子节点集合对应的迭代器

                  3. 判断迭代器中是否有下一个值

                  4. 获取迭代器中的对象，并转换为元素

                  5. 设置元素的属性

&删除某节点步骤

                  1. 获取根节点

                  2. 获取根节点的子节点集合对应的迭代器

                  3. 判断迭代器中是否有下一个值

                  4. 获取迭代器中的对象，并转换为元素

                  5. 过滤出要删除的元素

                  6. 获得父节点，再删除其孩子

8. JVM与内存

@内存分析图注释

-         调用方法时会先到方法区找类，如果没有就到classpath去找，还没有就报错，有的话就用class loader类加载器去加载。

-         操作对象就是操作它的地址。

@JVM内存分为四个部分

1.栈区(stacksegment)存放函数的参数值、局部变量的值等，在超过这个变量的作用域时会被系统自动释放;

优点：存取速度比堆快;

缺点：存在栈中的数据大小、生存期必须是确定的，无灵活性;

2.堆区(heapsegment)存放由new创建的对象和数组，JVM会不定时的查看这个对象，如果没有引用指向这个对象就回收

优点：可以动态分配JVM内存;

缺点：要在运行时分配JVM内存，速度慢

-       方法区：存在于堆区内，存放类的信息（代码）、static变量、常量池（字符串常量）等。

-       注意事项！

1．常量池有共享机制。

2.每个方法都对应一个stack frame栈帧，方法在栈帧里运行后，栈帧就释放掉了。

3.静态区

4.动态区

@垃圾回收机制（Garbage Collection）

-         对象空间的分配：

使用new关键字创建对象即可。

-         对象空间的释放：

将对象赋值null即可，垃圾回收器负责回收所有不可达对象的内存空间。

-         要点：

1. 程序员无权调用垃圾回收器。

2.程序员可以通过System.gc()，通知GC运行，当时JAVA规范并不能保证立刻运行。

3.finanlize方法，是JAVA提供给程序员用来释放对象或资源的方法，但是尽量少用。

-       C++和JAVA垃圾回收的区别：

就像食堂和餐馆的区别，Java适用于大型服务器或大型项目的开发。

@注意事项！

Java里面除基础类型，都是引用类型。栈内存里面可以声明和访问基础类型（比如int），但是引用类型（比如Scanner）需要在栈内存中声明，然后到堆内存中访问

9. 算法

#数字交换;

#汉字的输出机制：输入码(外码)→机内码→国标码(交换码)→输出码(字模);

#累加求和;

#数值颠倒;

#递归算法

-         递归算法是一种耗时耗空间的算法，因为程序需要从最外层到最里层，再返回到最外层;

-         基本思想：自己调用自己;

-         递归结构包括两个部分：

1. 定义递归头：设置何种情况递归停止；
2. 递归体：设置何种情况需要调用自身方法；

#冒泡排序

#选择排序（效率高于冒泡排序）

#数组查找算法

#二分法查找

-         用法：

1. 必须先对数组进行排序。

10. 程序设计

11. 开发工具

#MyEclipse

-         MyEclipse与Eclipse的区别：MyEclipse是收费的，Eclipse是开源的;

-         默认绑定的是jdk1.6版本

#Eclipse

@相关概念

1. 最初由IBM发起，随后贡献给开源社区。特点：开源、插件机制（一切皆是插件）、

是一个平台（并不是只能开发java）。

2. 下载地址：官网eclipse.org。

3. Eclipse是自动编译的，在保存的那一刻就做好了，相当调用了javac。

4. 语法检查：

4.1 对正在编写的源代码进行语法检查，对错误的源代码将使用红色波浪线进行提

示

4.2 对未使用的成员或有安全隐患的成员使用黄色波浪线进行警告提醒。

         5. Eclipse组成之窗口：

                  5.1 Problems窗口：

                          显示所有语法及错误所在位置。

                  5.2 TypeHierarchy窗口：

                          显示Java继承的层次结构，选中类后，按F4键显示。

@常用操作

&工作空间的基本配置

         1. JRE的配置（默认会安装自带的JDK）：

                  1.1（全局设置）

当安装了多个jre版本时，切换时需要配置：

window→preferences→java→Installed JREs//jdk文件夹里面的jre

1.2 某个项目设置

右键Package Explore空白处→Build Path→configure Build Path→java Build Path

→Libraries

2. 编译级别设置（compiler默认选中的就是最高版本）

* 来查看当前使用的jre版本

*  window→preferences→java→compiler

3. 如何去掉默认注释：

        点击WindowPreferenceJavaCodeStyleCode Templates，选择你不需要的

内容，通过右边的Edit按钮进行编辑。

注意：只删除注释部分，不是注释部分的不要删除。

    4. 行号的显示和隐藏：

        显示：在代码区域右边的空白区域，右击，选择show line numbers即可。

        隐藏：把上面的动作重复一次。

    5. 调整字体及颜色：

        5.1 可以使用字体verdana，字号16;默认字体是consolas。字体不一样图形输出会

变形打印图形一般用consolas字体。

                  5.2 Java代码区域的字体和颜色：

                          点击window→preferences→GeneralAppearanceColor and FontsBasic

            Text FontEdit.

        5.3 控制台：

点击window→preferences→General→Appearance→Color and Fonts→Debug

            →Console Font→Edit.

    6. 恢复窗体布局：

        点击windowResert Perspective

    7. 找回窗体：

        点击WindowShow View

- 打开导航视图

Windows→show view→navigator

- 删除项目：

如果没有勾选删除源文件的选项，那么当新建同名的项目时，相当于导入。

- 切换工作空间

FIile→Switch Workspace

- 外观样式设置

window→preferences→general→appearance→color and fonts

-     字符编码集设置 （建议使用UTF-8）

1.打开Windows ==> Preferences ==> General==> Content types在右侧的“Content Types”下面挨个点击文件类型，在右下方的“Default encoding”中输入“UTF-8”点击    “UPDATE”进行设置。

2. 点击General==>Workspace 右侧下方有一个选择Text file encoding在Others中选择“UTF-8”点击应用

- 创建文件

* 可以创建基于文本的文件，包括但不限于：txt、xml、properties

* 打开方式：左键文件→open with→选择打开方式

- 编辑器（Editor）

* 可关联不同类型的文件到不同类型的编辑器，如果没有相应的内部编辑器，则会打开相应的外部编辑器，在windows上，可以作为OLE文档打开嵌入编辑器

* 在编辑器的选项卡（Tab）上的星号*表示该文件未保存

- 命令行参数与虚拟机参数

         * 命令行参数可以将外部字符串传给程序main方法的参数；例如

           for(String s:args){

                           System.out.println(s);

                  }//右键鼠标→run as→run configurations→Arguments选项卡.program arguments→

             输入参数值即可

         * 虚拟机参数可以设置JRE启动时使用的内存大小，垃圾回收器及若干辅助性息；

           虚拟机参数路径如上命令行参数路径；

- 管理源代码

* 可以使用多个Source Folder存放源代码，适合讲功能代码和测试代码分开;

* 操作：右键程序包文件→new→Source Folder

-     创建工作集

working set可以将相关的多个Java项目放在一起管理;

- 编辑器的分拆与克隆

- 导入项目

右键Package Explore空白处→Existing Projects into Workspace→Select root drectory

- 查看历史版本

         右键代码区→compare with→Local History

- 快速生成类属性的get（布尔变量是is）和set方法

         右键代码区→Source→Generate Getter and Setter

- 查看一个方法被谁引用（调用）的快捷键四种方式：

1.（首推）双击选中该方法，Ctrl+Alt+H

如果你想知道一个类的方法到底被那些其他的类调用，那么请选中这个方法名，然后按“Ctrl+Alt+H”，

Eclipse就会显示出这个方法被哪些方法调用，最终产生一个调用关系树。

2.（次推）选中该方法，Ctrl+Shift+G  就显示这个方法被谁引用了 ，

   查询在整个工作区中被谁引用了

3.选中该方法，Ctrl + H（全局搜索）

4.选中该方法右键 reference

@常用快捷键

- 内容辅助键：

alt+/快速输出方法框架，例如

* main方法的快捷键：main alt+/;

* 输出打印快捷键: syso alt+/;或者选中要输出的内容+alt+/

* switch框架：switch alt+/;

* 快速输出重写父类的方法框架：假设父类有个earnMoney()方法，则在子类

ea+alt+/即可快速覆盖重写。

- 快速向上或向下复制：ctrl+alt+方向键

- 代码上下移动：选择要被移动的代码，alt+方向键

- 查看源码：按F3键或者按住ctrl键后，用鼠标点击。

- 快速删除某行：ctrl+D

- 格式化：

选择要格式化的代码区域，英文状态下，Ctrl+Shift+F组合键。

也可以通过Alt+/组合键提示的类，自动把包导入。

- 单行注释：ctrl+/。再次选中，重复操作组合键可以取消掉注释。

- 文档注释：alt+shift+j

- 多行注释：ctrl+shift+/。再次选中，按Ctrl+Shift+\组合键可以取消掉多行注释。

- 重命名：先选择类文件alt+shift+R

- 导入包：ctrl+shift+O

- 快速运行程序：f11

- 查找/替换：ctrl+F

- 查看继承关系：

1.鼠标悬停在类名上，并按ctrl+T

2.选中类名，右键Open Type Hierarchy

         - 快速选中一行：shift+home/end

         - 打开资源：ctrl+shift+o

         - 快速Outline：ctrl+o

         - 快速转换编辑器：ctrl+pguo/pgdn或者ctrl+e

         - 快捷键提示：ctrl+shift+l

         - 提取本地变量及方法：alt+shift+l及alt+shift+m

         - 在当前行之下或之上创建一个空白行：

                  Shift+enter或ctrl+shift+enter

         - 窗口最大化：ctrl+m                                             

         - Debug及run：F11及ctrl+F11

         - 查找某变量使用次数：ctrl+shift+u

         - 快速修改：ctrl+1

         - 查看方法源代码：ctrl+shift+T

         - 关闭编辑器：ctrl+w

         - 创建新类：alt+shift+n,然后按c新建class。

         - 打印出源：先写出syst，然后ctrl+/，选中systrace即可。

         - 撤销和反撤销：ctrl+z和ctrl+y

         - 菜单栏：alt

         - 查看属性：alt+enter

         - 抽取方法：alt+shift+M

@常见问题处理

&source not found

-         定义：查看源代码时，显示没有找到源码。

-         解决方法：windowspreferenceJavaInstalled JREs选择编译级别Edit展开rt.jar选择source attachmentSource Attachment选择External location，path里面填写jdk中src.zip的路径。

& eclipse代码中每行的开始和结尾出现多余的特殊符号

-         解决办法：window -> preferences -> general -> editors -> text editors ->show whitespace charactors 把选项前面的勾去掉就好了。

@Eclipse支持的其他工具

-         Ant、Maven、Junit、CVS、Git等

@Eclipse插件开发

@Eclipse RCP

#javaFX SDK

         SUN公司应用于互联网的一种脚本编程语言，有更便捷的展示图形界面的能力。不火，

同类应用有ajax。

java基础知识总结

标签：通用   批量   func   bounds   子线程   打包   开源框架   列表   文件名   

原文地址：https://www.cnblogs.com/zsc1/p/9226769.html