java初学者必看经典

时间 2019-11-19

标签 java 初学者经典栏目 Java 繁體版

原文原文链接

配置java环境变量：html

JAVA_HOME：配置JDK的目录java

CLASSPATH：指定到哪里去找运行时须要用到的类代码（字节码）程序员

PATH：指定可执行程序的位置sql

LINUX系统（在" .bash_profile "下的环境变量设置）数据库

JAVA_HOME=/opt/jdk1.5.0_06apache

CLASSPATH=.:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar编程

PATH=$PATH:$JAVA_HOME/bin:.windows

export JAVA_HOME CLASSPATH PATH (将指定的环境变量声明为全局的)设计模式

windows系统：数组

右击个人电脑-->属性-->高级-->环境变量

Java的运行过程：

编译：生成可执行文件，如C++中利用g++生成a.out，效率高，但不跨平台

解释：解释器把源文件逐行解释，跨平台但效率不高

在java中：先编译后解释，把.java文件编译成.class字节码文件

Java源代码文件(.java文件)--->

Java编译器(javac)--->

Java字节码文件(.class文件，平台无关的)--->

Java解释器(java)，执行Java字节码

Java的垃圾回收：

由一个后台线程gc进行垃圾回收

虚拟机断定内存不够的时候会中断代码的运行，这时候gc才进行垃圾回收

缺点：不可以精确的去回收内存

java.lang.System.gc(); 建议回收内存，但系统不必定回应，他会先去看内存是否够用，够用则不予理睬，不够用才会去进行垃圾回收

内存中什么算是垃圾：

再也不被引用的对象(局部变量，没有指针指向的)

java的安全性：

沙箱机制：只能作沙箱容许的操做

经过下面环节，实现安全

加载有用的类文件，不须要的不加载

校验字节码，查看容许的操做

查看代码和虚拟机的特性是否相符

查看代码是否有破坏性

查看是否有违规操做，如越界

查看类型是否匹配，类型转换是否能正确执行

源程序：

package mypack; //至关于一个目录

public class HelloWorld{

public static void main(String[] args){

System.out.println(“Hello World”);

}

注：

一、文件名必须和public修饰的类名一致，以.java做为文件后缀，若是定义的类不是public的，则文件名与类名能够不一样。

二、一个.java文件中能够有多个class，可是只有一个public修饰的类。

三、java源代码文件编译后，一个类对应生成一个.class文件

四、一个java应用程序应该包含一个main()方法，并且其签名是固定的，它是应用程序的入口方法，能够定义在任意一个类中，不必定是public修饰的类

编译：javac -d . HelloWorld.java

含有包的类，在编译的时候最好用上面的格式，-d指的是让该类生成的时候按照包结构去生成，" . "指的是在当前路径下生成

若是不用上面的格式，也能够用javac HelloWorld.java，可是须要注意的是包结构就要由本身去创建，而后将生成的.class文件放到该目录下

执行：java mypack.HelloWorld

将字节码文件交给Java虚拟机去解释执行

须要注意的事，必须使用包名.类名去解释执行

包(package)：把源文件放在目录下

因为工程的须要，将不一样的源文件放在不一样的目录下，从而引入了包。

包能够看做就是一个存放java源文件的目录。

在源码中声明一个包名：package p;(只能放在第一行，且最多只能是一行)

若是指定多层包，那么在包名之间咱们能够用.做为分隔符：package p1.p2.p3.p4;

用“javac HelloWorld.java –d 绝对路径”，编译后生成的字节码文件就会放在指定的包结构下

执行该程序须要用" java 包名.类名 "

引进包中的某个类：import 包名.类名;

引进包中的全部类：import 包名.*;

注释：

// 单行注释，到本行结束的全部字符会被编译器忽略

/* */ 多行注释，在/* */之间的全部字符会被编译器忽略

/** */ 文档注释， java特有的，在/** */之间的全部字符会被编译器忽略

能够用javadoc把java源程序中这种注释抽取出来造成html页面(只有写在包，类，属性，方法，构造器，引入以前的注释才能够进行抽取)

标识符：

命名规则：

(1) 由字母、数字、下划线、$组成，不能以数字开头

(2) 大小写敏感

(3) 不得使用java中的关键字和保留字

关键字：都是小写的，jdk1.2多了strictfp(精准浮点型)，关键字 jdk1.4多了assert(断言)关键字， jdk1.5多了enum(枚举) 关键字

随着学习进度，会慢慢接触到的

true、false、null严格说不该该算关键字，应称其为保留字更合适

习惯：

(1) 标识符要符合语义信息

(2) 包名全部字母小写

(3) 类名每一个单词首字母大写，其它小写 //TarenaStudent

(4) 变量和方法：第一个单词小写，从第二个单词开始首字母大写 //tarenaStudent

(5) 常量：全部字母大写，每一个单词之间用" _ "链接

基本数据类型：8种

1) 整型

byte 1B 8位 -128到127

short 2B 16位 -2^15到(2^15)-1

int 4B 32位 -2^31到(2^31)-1

long 8B 64位 -2^63到(2^63)-1

2) 浮点类型

float 4B 32位

double 8B 64位

3) 字符类型

char 2B 16位

4) 布尔型 1B

boolean false/true

注：

一、Java中的自动类型提高问题。

1)、正向过程：从低字节到高字节能够自动转换。

byte->short->int->long->float->double

2)、逆向过程：从高字节到低字节用强制类型转换。

例：int a = (int)4.562；

注：逆向转换将丢失精度。

二、boolean：只有true和false。

三、char：Java中用" \u四位十六进制的数字 (即便在注释中出现\u，后面若是跟的不是4个数字，也会报错)"表示将字符转换成对应的unicode编码，字符类型要用单引号括起来。

四、黙认浮点类型为double，float数据类型有一个后缀为" f "或" F "。

五、long类型有一个后缀，为" l " 或者" L "

引用数据类型：

类、接口、数组

引用类型变量名 = new 引用类型名(参数); //new后面通常跟的都是类的构造器

成员：写在类体括号里面的

内存空间的分配：

内存分为：

栈：存放简单数据类型变量(值和变量名都存在栈中)，存放引用数据类型的变量名以及它所指向的实例的首地址

堆：存放引用数据类型的实例

华为培训讲义次日

局部变量：不是声明在类体括号里面的变量

(1)必需要先赋值，后使用，不然通不过编译，局部变量没有默认初始化值

(2)做用范围：定义开始到定义它的代码块结束

(3)同一范围内，不容许2个局部变量命名冲突

参数传递时，简单类型进行值转递 (参数进行传递时都会先去栈中生成一个副本的，使用结束后释放)

自动类型提高：

byte a = 1;

byte b = 2;

a = a+b; //编译出错自动类型提高成int

a += b; //自加没有自动类型提高问题

类型自动提高规则：

a和b做某种运算

a和b中有double，结果就是double

a和b中有float，结果就是float

a和b中有long，结果就是long

除此以外，结果都是int

把高字节转成低字节,须要做强制类型转换. byte c=(byte)a+b;

移位运算符：效率最高

>> 有符号右移，补符号位

移负数位，则将该数值加32后再进行移位

数值的2进制是按照补码保存的

>>> 右移后高位都补0

逻辑运算符：

&/|也能够做为逻辑运算符

&& 先判断前面一个条件，若是为假，则不用计算后一个条件

|| 先判断前面一个条件，若是为真，则不用计算后一个条件

" + "运算符：

两个操做的对象是数值时，是加法

若是有一个是字符串时，则是字符串的链接

流程控制语句：

同Core C++

switch中的变量类型只能是byte、 short、int、char四种类型以及enum类型

switch(exp) exp 能够是整形表达式或者enum类型数据

数组：

声明数组：

数组能如下列形式声明：

类型[] array;

类型 array[];

注：

JAVA中推荐用：类型[] array;

一个数组是一个对象

声明一个数组没有建立一个对象

声明时不用指定长度

建立数组：

建立基本数据类型数组：int[] i = new int[2];

建立引用数据类型数组：Student[] s = new Student[100];

数组建立后其中的元素有初始值

类型黙认值

byte 0

short 0

int 0

long 0l

float 0.0f

double 0.0d

char \u0000

boolean false

reference types null

注：

建立时必定要指定长度

int[] i2=new int[]; //error

初始化数组：

声明、建立、初始化分开：

int[] i; //定义数组

i = new int[2]; //分配空间

i[0] = 0; //初始化

i[1] = 1;

声明、建立、初始化在同一时间：

int[] i = {0,1}; //显示初始化 {}中有几个值,则数组长度为几

Student[] s = {new Student(),new Student()};

注： int[] i=new int[]{1,2,3}; //后面[]中不能够写数值

int[] i1=new int[3]{1,2,3}; //error

二维数组：(实际上是一个一维数组，它的每个元素又是一个一维数组)

int[][] i1 = new int[2][3];

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

int[][] i3 = new int[][3]; //不容许高维没分配空间而先给低维分配空间

int[][] i2 = new int[2][];

i2[0] = new int[2];

i2[1] = new int[3];

数组长度：

数组的属性length

数组长度一旦肯定,不可改变

int[] i = new int[5]; 则i.length= 5

数组拷贝：

系统类System提供的

static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

src：源数组

srcPos：从源数组哪一个位置开始拷贝(位置指的是元素的下标)

dest：目标数组

destPos：拷贝的元素放到目标数组的起始位置

length：拷贝多少个

数组排序：

本身实现一个排序方法来进行排序

或者调用java.util.Arrays.sort(Object o)

华为培训讲义第三天

类和对象：

类：主观抽象，是对象的模板，能够实例化对象----具备相同属性和行为的对象的集合。

习惯上类的定义格式：

package xxx;

import xxx;

public class Xxxx{

属性 ······;

构造器 ······;

方法 ······;

}

区分实例变量以及类变量，二者都有初始值，或在定义时候初始化或者在构造函数中初始化，而局部变量没有初始值，必须定义时候初始化。

定义属性：实例变量

格式：[ 修饰符 ] 类型变量名 [ = ? ]

实例变量定义在类中但在任何方法以外。

实例变量有默认值：各类各样的0。(同数组)

实例变量的做用域至少在本类内部，受访问控制符的限制。

在重合做用域，实例变量和局部变量容许有命名冲突，“局部优先”。

定义方法：

格式： [ 修饰符 ] 返回类型方法名( 参数列表 ) [ throws 异常 ] { ······ }

java中全部参数都是值传递。

当没有值返回时，返回类型必须被定义为void。

返回类型必须与方法名相邻，其余修饰符能够调换位置。

构造器：

在建立对象的过程当中调用的方法。

构造器没有返回类型。

构造器的名字与类名相同。

格式为：[ 修饰符 ] 类名( 参数列表 ){ }，修饰符能够是private、 protected、 default、private

在一个对象的生成周期中构造器只用一次，由系统自动调用，不容许手工调用。

程序员没有提供一个构造器，系统会自动提供一个无参的构造器。

得到对象的方式：

经过new（在堆空间中申请分配空间），new 类名()，能够经过这种形式或的一个对象，这时的对象是没法使用，必须把他的地址存放进一个对象变量才可以使用。

例如：

Car c=new Car();

注意：

最好在写类时提供一个无参的构造器。

默认是自带一个无参构造器，但若是手动写了一个带参数的构造器，必须加上一个无参构造器。

this关键字：

this是个隐式参数，表明当前对象;

publie class Student{

private String name;

public void setName(String name){

this.name=name; //this.name为当前对象的成员变量

}

若是某个构造方法的第一个语句具备形式this( ··· )，那么这个构造方法将调用同一类中的其余构造方法。

注意：

在构造器中this(...)必须放在该构造器的第一行。

this不能出如今静态方法里面

类、对象、实例三者的关系：

类：是对象的模板，能够实例化对象

对象：类的个体

实例：实现的对象

student s;

s=new student();

其中 Student为类，s为对象，new Student()为实例，s赋值后也是实例了。

方法重载：

方法名相同，参数表不一样，不考虑返回值类型(但最好仍是使返回类型一致)。

编译器根据参数，选择一个方法，若是没有彻底匹配的，对于参数表采用“向上就近匹配原则”，但不容许模棱两可。

方法重载屏蔽了一个对象的同一类方法因为参数不一样所形成的差别。

封装：

类的属性加private修饰符，来限制只可以在类的内部进行访问，有效的保护数据。

对于类中的私有属性，要对其给出一对方法getXxx()，setXxx()访问私有属性，保证对私有属性的操做的安全性。

方法公开的是方法的声明，即只须知道参数和返回值就能够调用该方法，隐藏方法的实现的细节。

一个对象和外界的联系应当经过一个统一的接口，应当公开的公开，应当隐藏的隐藏。

继承：

父类到子类是从通常到特殊的关系。

泛化：将不一样子类中的共性抽象成父类的过程。

特化：在原有父类的基础上加入一些个性的过程。

原则：父类放共性，子类放个性。

继承的关键字：extends

Java只支持单继承：一个类最多只有一个直接的父类。

方法覆盖：

方法名：相同

参数表：相同

访问限制符：相同或者更宽

返回值类型：相同或者子类返回的类型是父类返回的类型的子类（在JDK5.0之后）

抛出的异常：不能比父类更宽。

super关键字：

super()表示调用父类的构造器

super()也和this()同样必须放在方法的第一句

super()和this()不能同时出现

super能够屏蔽子类属性和父类属性重名时带来的属性遮盖，super. 表示调用父类的方法或属性

在子类的构造器中若是没有指定调用父类的哪个构造器，那么就会调用父类的无参构造器，即super()

注意：

父类的构造器不能被子类继承

方法和属性能够被继承，权限不限制可否继承过来，限制的是可否直接访问

即私有继承，虽然子类不能直接访问，但子类依旧拥有。

先构造父类，后构造子类，先this后super

多态：

多态分为两种：编译时多态和运行时多态。

编译时类型：主观概念，把它看做什么。

运行时类型：客观概念，实际它是什么。

例：Animal a=new Dog();

指着狗问，这个动物是什么？

运行时多态的三原则：

对象类型不变。

只能对对象调用编译时类型中定义的方法。

在程序的运行时，根据对象的运行时类型，找覆盖后的方法来调用。（运行时动态类型绑定）

强制类型转换：必定没有新对象生成。(父类的引用赋值给子类的引用须要进行强制类型转换)

关键字：instanceof

用法：引用 instanceof 类名判断这个引用所指向的对象是否属于这个类。

用在强制转换以前，避免类型转换异常。

if(a instanceof Dog){

Dog d=(Dog)a;

}

多态的做用：把不一样的子类对象都看成父类来看，能够屏蔽不一样子类对象之间的差别，写出通用的代码，作出通用的编程，以适应需求的不断变化。

华为培训讲义第四天

修饰符static：把对象相关的变成类相关的，它能够修饰属性、方法、代码块和内部类

static修饰属性（类变量）：

那么这个属性就能够用" 类名.属性名 "来访问，也就是使这个属性成为本类的类变量，为本类对象所共享。

类加载的过程，类自己也是保存在文件中（字节码文件保存着类的信息）的，java会经过I/O流把类的文件读入JVM（java虚拟机），这个过程称为类的加载。JVM会经过类路径（CLASSPATH）来找字节码文件。须要的时候才会进行类加载，生成对象时是先加载后构造

类变量，会在加载时自动初始化，初始化规则和实例变量相同。

注意：

类中的实例变量是在建立对象时被初始化的

static修饰的属性，是在类加载时被建立并进行初始化，类加载的过程只进行一次，也就是类变量只会被建立一次。

static修饰方法（静态方法）：

会使这个方法成为整个类所公有的方法，能够用" 类名.方法名 "访问。

static修饰的方法，不能直接访问本类中的非静态成员，但本类的非静态方法能够访问本类的静态成员。

在静态方法中不能出现this关键字。

父类中是静态方法，子类中不能覆盖为非静态方法，在符合覆盖规则的前提下，在父子类中，父类中的静态方法能够被子类中的静态方法覆盖，可是没有多态。（在使用对象调用静态方法时实际上是调用编译时类型的静态方法）

java中的main方法必须写成static的缘由：在类加载时没法建立对象，而静态方法能够不经过对象调用，因此在类加载时就能够经过main方法入口来运行程序。

static修饰初始代码块：

这时这个初始代码块就叫作静态初始代码块，这个代码块只在类加载时被执行一次。

能够用静态初始代码块初始化一个类。

动态初始代码块，写在类体中的“{}”，这个代码块是在生成对象时运行，这种代码块叫动态初始代码块。Static{ }

单例设计模式：

一个类只容许有一个对象，保证全部引用的对象都是同一个对象。

由于只容许存在一个对象，则不容许在外面直接new出新的对象，因此应该把构造器设为private，。

在类内定义一个公开的静态方法，让使用者进行调用，经过该方法去得到一个实例。

例：

public calss Singleton{

private static Singleton s;

private Singleton(){}

public static Synchroinized Singleton newInstance(){

if ( s == null)

s = new Singleton();

return s;

}

修饰符final：不容许改变，能够修饰变量、方法、类

final修饰变量：

被final修饰的变量就会变成常量，一旦赋值不能改变

常量能够在初始化时直接赋值，也能够在构造方法里赋值，只能在这两种方法里二选一，不能不为常量赋值

常量不会有默认初始值

锁定栈，使栈中的数据不能够改变

静态常量只能在初始化时直接赋值

final修饰方法：

被final修饰的方法将不能被其子类覆盖，保持方法的稳定不能被覆盖

final修饰类：

被final修饰的类将不能被继承

final类中的方法也都是final的

注意：

final不能用来修饰构造方法

访问权限控制：

private：

本类内部能够访问

不能继承到子类

default：

本类内部能够访问，同包其余类也能够访问。

同包可继承

protected：

本类内部能够访问，不一样包的子类也能够访问，同包其余类也能够访问。

能继承到子类

public：

任何地方均可以访问

能继承到子类

华为培训讲义第5天

修饰符abstract：抽象的，定义框架不去实现，能够修饰类和方法

abstract修饰类：

会使这个类成为一个抽象类，这个类将不能生成对象实例，但能够作为对象变量声明的类型，也就是编译时类型

抽象类就至关于一个类的半成品，须要子类继承并覆盖其中的抽象方法，这时子类才又建立实例的能力，若是子类没有实现父类的抽象方法，那么子类也要为抽象类。

abstract修饰方法：

会使这个方法变成抽象方法，也就是只有声明而没有实现，实现部分以";"代替，须要子类继承实现。

抽象方法表明了某种标准，定义标准，定义功能，在子类中去实现功能（子类继承了父类并须要给出从父类继承的抽象方法的实现）。

方法一时间想不到怎么被实现，或有意要子类去实现而定义某种标准，这个方法能够被定义为抽象。

注意：

有抽象方法的类必定是抽象类。可是抽象类中不必定都是抽象方法，也能够全是具体方法。

接口(interface)：

接口的定义：接口从本质上说是一种特殊的抽象类。

关键字interface。

在接口中，全部的方法为公开、抽象的方法：public abstract

在接口中，全部的属性都是公开、静态的常量：public static final

接口与接口之间能够多继承，用extends，多个之间用逗号隔开。

接口中没有构造方法，不能用“new 接口名”来实例化一个接口，但能够声明一个接口。

接口的实现：

关键字implements

一个类实现一个接口必须实现接口中全部的方法，不然其为抽象类，而且在实现类中的方法要加上public(不能省略)。

类中的默认修饰符：default。

接口中的默认修饰符：public。

一个类除了继承另外一个类外（只能继承一个类），还能够实现多个接口(接口之间用逗号分隔)。

接口的做用：

间接实现多继承：用接口来实现多继承并不会增长类关系的复杂度。由于接口不是类，与类不在一个层次上，是在类的基础上进行再次抽象。

接口能够抽象出次要类型，分出主、次关系类型，符合看世界的通常方法。

接口隔离，与封装性有关。一个对象都有多个方面，能够只展现其中几个方面，其余的都隐藏。所以能够看为“更高层次的封装”，把一个大接口作成若干个小接口。

经过接口制定标准（最重要的做用）----接口的做用，协议的制定。

接口：制定标准。

接口的调用者：使用标准。

接口的实现类：实现标准。

解耦合做用：把使用标准和实现标准分开，使得标准的制定者和实现者解除偶合关系，具备极强的可移植性

例：sun公司提供一套访问数据库的接口（标准），java程序员访问数据库时针对数据库接口编程。接口由各个数据库厂商负责实现。

接口编程的原则

尽可能针对接口编程（能用接口就尽可能用接口）

接口隔离原则（用若干个小接口取代一个大接口）

注意：

接口中没有构造器，也没有main方法

封装类：

Java为每个简单数据类型提供了一个封装类。

除int和char，其他类型首字母大写即成封装类。

int Integer

char Character

最经常使用的两个封装类Integer和Double

jdk1.4以前基本类型和封装类的转化是须要构造器去转化的，到了jdk1.5是自动进行转化的

int、Integer和String之间的转化(最经常使用的)

int i=1;

Integer in = new Integer(i); //int --> Integer

int i = in.intValue(); //Integer --> int

String str = String.valueOf(i); //Int --> String

int ii = Integer.parseInt(str); //String --> int

String s = in.toString(); //Integer --> String

Integer inte = Integer.valueOf(str); //String --> Integer

Object类

hashCode()：

返回该对象的哈希码值

hashCode 的常规协定是：

在 Java 应用程序执行期间，在同一对象上屡次调用 hashCode 方法时，必须一致地返回相同的整数，前提是对象上 equals 比较中所用的信息没有被修改。

若是根据 equals(Object) 方法，两个对象是相等的，那么在两个对象中的每一个对象上调用 hashCode 方法都必须生成相同的整数结果,反之不必定成立，例如针对hashmap,hashtable,与arraylist是不同的。

toString()：

返回该对象的字符串表示。

一般，toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂。建议全部子类都重写此方法。

equals()

指示某个其余对象是否与此对象“相等”。

equals 方法在非空对象引用上实现相等关系：

自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。

对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true。

传递性：对于任何非空引用值 x、y 和 z，若是 x.equals(y) 返回 true，而且 y.equals(z) 返回 true，那么 x.equals(z) 应返回 true。

一致性：对于任何非空引用值 x 和 y，屡次调用 x.equals(y)始终返回 true 或始终返回 false，前提是对象上 equals 比较中所用的信息没有被修改。对于任何非空引用值 x，x.equals(null) 都应返回 false。

注意：

当此方法被重写时，一般有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具备相等的哈希码。

String、StringBuffer和StringBulder

String：不可改变的Unicode字符序列

池化思想，把须要共享的数据放在池中，用一个存储区域来存放一些公用资源以减小存储空间的开销。

在String类中，以字面值建立时，会到Java方法空间的串池中去查找，若是没有则会在串池里建立一个字符串对象，并返回其地址赋给对象变量，若是有就返回串池中字符串的地址，并把这个地址赋给对象变量。

若是是new，则会在堆空间中建立String类的对象，不会有上述的过程

如：

String s1 = "abc"; //新建立，字符串常量池中没有该串，则会在池中建立一个串"abc"

String s2 = "abc"; //串池中已经存在"abc"，则s2会去指向"abc"而不会去建立一个新的

String s3 = new String("abc"); //直接在堆中去开辟一个新的空间，而不会去池中查找

类中的具体方法查看下Api文档。

调用任何String中的方法，不会改变String自身，除非从新赋值。

StringBuffer：可改变的Unicode字符序列

容许并发操做，是线程安全的

String类在进行字符串链接时会显得效率很低，就是由于它所产生的对象的属性是不可以修改的，当链接字符串时也就只能建立新的对象。

对于不少字符串链接时，应当使用StringBuffer类，使用这个类的对象来进行字符串链接时就不会有多余的中间对象生成，从而优化了效率。

例：对于字符串链接String str = "A" + "B" + "C" + "D";

产生："AB"、"ABC"、"ABCD"

在串池中产生的"AB"、"ABC"明显是多余对象，浪费空间。

解决方案：

String s = null;

StringBuffer sb = new StringBuffer("A");

sb.append("B");

sb.append("C");

sb.append("D");

s = sb.toString();

StringBulder：可改变的Unicode字符序列

操做同StringBuffer，只是不支持并发操做，非线程安全的

华为培训讲义第6天

集合：保存多个其余对象的对象，不能保存简单类型

List：有序(存放元素的顺序)，可重复的集合

ArrayList：实质就是一个会自动增加的数组

查询效率比较高，增删的效率比较低，适用于查询比较频繁，增删动做较少的元素管理的集合。

加载大批量的数据时，先进行手动扩容(就是调用ensureCapacity(int minCapacity)方法)，这样能够提升效率。

LinkedList：底层是用双向循环链表来实现的

查询效率低，可是增删效率很高，适用于增删动做的比较频繁，查询次数较少的元素管理的集合

Set：无序的，不容许有重复元素的集合

HashSet：----注意不是用hash码的值去存储

Object类中的hashCode()的方法是全部类都会继承的方法，这个方法会算出一个Hash码值返回，HashSet会用Hash码值去和数组长度取模，对象的模值(这个模值就是对象要存放在数组中的位置，和数组的下标相同)相同时才会判断数组中的元素和要加入的对象的内容是否相同，若是不一样才会再找位置添加进去，相同则不容许添加。

若是数组中的元素和要加入的对象的hashCode()返回了相同的Hash码值，才会用equals()方法来判断两个对象的内容是否相同。

注意：要存入HashSet的集合对象中的自定义类必须覆盖hashCode()、equals()两个方法，才能保证集合中元素不重复。

TreeSet：可排序的Set

SortedSet接口是Set的子接口，TreeSet是SortedSet接口的实现类，他能够对集合中的元素进行排序。

将自定义类的对象存放在TreeSet中，这个类须要实现了Comparable接口，TreeSet能够自动过滤掉重复元素因此不在须要重载hashCode()方法，TreeSet会根据比较规则判断元素内容是否相同，不一样则会存入，TreeSet会在元素存入时就进行排序。

Comparable接口：

也叫作可比较接口，这个接口在java.lang包下，只要根据指定类型的排序规则实现了这个接口，就是可排序的。

这个接口中只定义了一个 compareTo(Object o) 方法，该方法的返回值类型是整型，若是当前对象大于参数对象就返回正数，当前对象等于参数对象就返回0，当前对象小于参数对象就返回负值，这样写就是升序排列，反之则是进行降序排列。

Comparator接口：

比较器Comparator接口，是另外一种对自定义类型对象的集合总体排序的方法，存在于java.util包下。

这个接口中定义了一个 compare(Object o1,Object o2) 方法来比较两个对象，这个方法的返回值定义和上面介绍的那个方法是同样。

利用这种方式，则在建立集合的时候把定义好的比较器做为参数，构造一个集合

Map：存放key-value对(有关系的两个对象，一个作key，一个作value，同时存入)

HashMap：基于哈希表的 Map 接口的实现，此实现提供全部可选的映射操做，并容许使用 null 值和 null 键

遍历：

先调用keySet()获得key的set集合，

再迭代遍历key的set集合，

根据key获得value。

Hashtable：同HashMap，通常不使用

HashMap与Hashtable的区别：

HashMap：非线程安全，不支持并发控制，容许空的键值对。

Hashtable：是线程安全，支持并发控制，不容许有空的键值对。

SortedMap接口：Map的子接口，按某一特定排序规则来存放所加入的键值对

实现类：TreeMap类。

Key值的排序规则，同SortedSet接口实现类TreeSet

注意：

key通常是8种基本类型的封装类或者是String类，拿本身自定义的类做为Key没有意义。

key不可重复，value能够重复

华为培训讲义第7天

反射：

反射：在运行时动态分析或使用一个类进行工做。

java.lang.Class类：描述类信息的类。

类对象：描述一个类信息的对象，当虚拟机加载类的时候，就会建立这个类的类对象并加载该对象，Class是类对象的类型。

得到类对象的方式：

用" 类名.class "得到这个类的类对象。

用类的对象掉用getClass()，如object.getClass()获得这个对象的类型的类对象。

可使用Class.forName(类名)，也能够获得这个类的类对象，（注意，这里写的类名必须是全限定名（全名），是包名加类名，XXX.XXX.XXXX）。

基本类型也有类对象，用" 封装类.TYPE "能够得到对应的基本类型的类对象。

java.lang.reflect包下的三个重要类：

Field属性类：用来描述属性的信息。

Method方法类：方法的信息的描述。

Constructor构造方法类：用来描述构造方法的信息。

Class类中的经常使用方法：

newInstance()

建立此 Class 对象所表示的类的一个新实例(调用无参构造建立的对象)。

getDeclaredMethods()

得到的是一个Method方法类对象的数组，得到本类(不包括父类)声明的全部(包括private的)方法对象。

getMethods() //推荐使用

得到的是一个Method方法类对象的数组，得到全部(父类的也包括)publice的方法对象。

getDeclaredConstructors()

得到的是一个Constructor构造方法类对象的数组，得到这个类声明的全部构造方法对象。

getConstructors() //推荐使用

得到的是一个Constructor构造方法类对象的数组，得到全部publice的构造方法对象。

getDeclaredFields() //推荐使用

得到的是一个Field属性类对象的数组，得到本类声明的全部属性的属性对象。

getFields()

得到的是一个Field属性类对象的数组，得到全部publice的属性对象。

使用反射构造一个类的对象的步骤：

a. 得到类对象

b. 得到构造方法对象

c. 得到对象，用构造方法对象调用构造方法，若是使用无参构造方法，能够跳过第二步，直接使用" 类对象.newInstance() "方法来得到这个类的对象

d. 得到方法对象

e. 用方法对象调用方法（用这个类的对象做为第一参数）

以下面的例子：

反射机制的实现类：

package day07.reflect;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

public class TestReflect {

public static Object get(String className , Map<String,Object> map) throws Exception{

Class c = Class.forName(className); //得到类对象

Object o = c.newInstance(); //得到对象

Set<String> set = map.keySet();

for(String str : set){

String s = "set" + str.substring(0,1).toUpperCase()+str.substring(1);

Field f = c.getDeclaredField(str);

Method m = c.getMethod(s, f.getType()); //得到方法对象

m.invoke(o, map.get(str)); //用方法对象调用方法

}

return o;

}

public static void main(String[] args) throws Exception {

Map m = new HashMap();

m.put("name", "zhang");

m.put("age", 22);

Object o = get("day07.reflect.Student",m);

Student s = (Student) o;

System.out.println(s.getName() + " " + s.getAge());

Map m1 = new HashMap();

m1.put("name", "li");

m1.put("gender", "男");

Object o1 = get("day07.reflect.Teacher",m1);

Teacher t = (Teacher) o1;

System.out.println(t.getName() + " " + t.getGender());

}

学生类：

package day07.reflect;

public class Student {

private String name;

private int age;

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

教师类：

package day07.reflect;

public class Teacher {

private String name;

private String gender;

public String getGender() {

return gender;

}

public void setGender(String gender) {

this.gender = gender;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

内部类：

定义：

定义在另一个类中的类，就是内部类。

编译后生成的两个独立的类：Outer.class 和Outer$Inner.class。

内部类的分类：

静态内部类：静态内部类定义在类中，任何方法外，用static修饰

静态内部类只能访问外部类的静态成员。

在外部类的外部，要建立一个静态内部类对象不须要外部类对象：

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

在本类内部生成内部类对象的方式：

Inner in = new Inner();

成员内部类：做为外部类的一个成员存在，与外部类的属性、方法并列

在内部类中能够直接访问外部类的私有属性。

内部类和外部类的实例变量容许命名冲突。

在内部类中访问实例变量：this.属性

在内部类访问外部类的实例变量：外部类名.this.属性

在外部类的外部，要建立一个成员内部类对象，要首先创建一个外部类对象，而后再建立一个成员内部类对象。

Outer out = new Outer();

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

在本类内部生成内部类对象的方式：

在静态方法中：Inner in = new Outer().new Inner();

在非静态方法中：Inner in = this.new Inner();

成员内部类不能够有静态成员，这是由于静态属性是在加载类的时候建立，这个时候内部类尚未被建立。

局部内部类：在外部类的方法中定义的内部类

与局部变量相似，在局部内部类前不能够加修饰符public和private，其做用域为定义它的代码块。

局部内部类不只能够访问外部类的实例变量，还能够访问外部类的局部变量，但要求外部类的局部变量必须为final的。

配合接口使用，来作到强制弱耦合。

在外部类的外部不可建立局部内部类对象，只能在局部内部类所在的方法中建立：

Inner in = new Inner();

匿名内部类：一种特殊的局部内部类

没有名字，也没有class、extends、implements关键字

用一种隐含的方式实现一个接口或继承一个类，而且只能建立一次实例。

实现方式：在某个语句中，new 父类/父接口名字(){ 类体中实现方法 }

例如：

TreesSet ts = new TreeSet(new Comparator(){

public int compare(Object o1, Object o2){

return 0;

}

});

匿名内部类属于局部内部类，那么局部内部类的全部限制都对其生效。

匿名内部类是惟一一种无构造方法的类，由于构造器的名字必须合类名相同，而匿名内部类没有类名。

华为培训讲义第8天

异常：

异常的分类

Java会将全部的异常封装成对象，其根本父类为Throwable。

Throwable有两个子类：Error 和Exception。

Error：一个Error对象表示一个程序错误，指的是底层的低级的不可恢复的严重错误

遇到Error，程序必定会退出，由于已经失去了运行所必须的物理环境。

对于Error咱们没法进行处理，由于咱们是经过程序来应对错误的，但是程序已经退出了。

Exception：由特定因素，致使程序没法继续，但不影响虚拟机的正常执行。

未检查异常(Runtime Exception)：

是由于程序员没有进行必要的检查，因为程序员的疏忽而引发的异常。

对于未检查异常能够不处理，编译能够经过，应对未检查异常的方法就是养成良好的检查习惯

已检查异常(非Runtime Exception)：

是不可避免的，对于已检查异常必须处理，不然编译不经过。

异常处理的机制：

当一个方法中有一条语句出现了异常，它就会throw（抛出）一个异常对象（throw 异常对象），而后后面的语句不会执行，而返回上一级方法，其上一级方法接受到了异常对象以后，有可能对这个异常进行处理(进行处理则不会上抛)，也可能将这个异常传到它的上一级，若是最上一级(main方法)不处理就会传给虚拟机，虚拟机就会终止程序的运行。

异常的处理方式：throws和try-catch方法

try-catch处理方式：

try{ //一个

(1)可能出现异常的语句

} catch(XxxException e /*捕获的异常*/){ //0或n个

(2)处理异常的代码

} finally{ //0或1个

(3)必需要执行的代码

}

(4)方法中的其余代码

若是代码正确，那么程序不通过catch语句直接向下运行；

若是代码不正确，则将返回的异常对象和e进行匹配，若是匹配成功，则处理其后面的异常处理代码。

try中若是发现错误，即跳出try块去匹配catch，那么try后面的语句就不会被执行。

一个try能够跟多个catch语句，用于处理不一样状况，可是不能将父类型的exception的位置写在子类型的excepiton以前。

在try-catch后还能够再跟一子句finally。其中的代码语句论有没有异常都会被执行(由于finally子句的这个特性，因此通常将释放资源，关闭链接的语句写在里面)。

finally中的代码和try-catch中的代码冲突时，finally中的代码必定会被执行且会忽略try-catch中的代码。可是若是try-catch中有System.exit(0);(虚拟机退出语句)，则不会去执行fianlly中的代码。另外若是try语句中含有return语句，finally语句在return语句执行后执行。

throws/throw处理方式：

throw 写在方法内，后面跟一个异常对象。

throws 在方法的定义中说明方法可能抛出的异常，后面跟异常类的名字，声明这个方法将不处理异常，把异常交给上一级方法处理。

调用时，调用者不能抛出范围更小的异常。

对于方法a，若是它定义了throws Exception。那么当它调用的方法b返回异常对象时，方法a并不处理，而将这个异常对象向上一级返回，若是全部的方法均不进行处理，返回到主方法，如主方法也不进行处理，则到虚拟机中，程序停止。

若是在方法的程序中有一行throw new Exception()，那么其后的程序不执行，若是没有对这个可能出现的检查结果进行处理，那么程序就会报错。

throws和throw没有必然的联系。

注意：

方法的覆盖中，若是子类的方法抛出的例外是父类方法抛出的例外的父类型，那么编译就会出错：子类没法覆盖父类。

子类抛出的例外或者与父类抛出的例外一致，或者是父类抛出例外的子类型，或者子类型不抛出例外。

若是父类型无throws时，子类型也不容许出现throws。此时只能使用try catch。

自定义异常：

a. 使其继承Exception或者RuntimeException。

b. 写构造器，直接调用父类的构造器

断言(assert)：用来调试、测试代码

格式：

assert 布尔表达式: 字符串 (若是布尔表达式为false时，这个字符串才会显示)

注意：

assert默认是关闭的，使用时须要使用" -ea "进行开启，" -da "是关闭，如：java -ea 类名。

断言是以异常方式去执行的，当断言的布尔表达式为假时，会中断代码。

不能继承性的打开(java -ea:类名这样只能打开该类，若是存在父类，不会去打开父类)

图形界面：

AWT：抽象窗口工具(Abstract Window Toolkit)

组件：图形界面中全部能看到的，好比按钮等。

容器：用来管理其余组件的对象

布局管理器：布置组件在容器中的位置和大小

Swing：AWT的一个加强版

构造图形界面的步骤：

选择一个容器

设置容器的布局管理器

向容器中添加组件

事件的监听

容器(Container)：用于管理其余的组件的对象，组件必须放到容器里

JFrame：一个最顶层的窗体容器，全部其余的组件必须放在顶层容器里。

JPanel：不是顶层容器，必须放在顶层容器中，是透明的（默认）。

容器的方法：

add(Component com) 将组件加入容器。

setLayout(LayoutManager manager) 设置布局管理器。

setSize(int width,int height) 设置窗口大小

setVisible(boolean b) 显示或隐藏此组件

setDefaultCloseOperation(int operation) 设置关闭窗体上时默认执行的操做

布局管理：布置组件在容器中的位置和大小

FlowLayout：流式布局管理，Panel和JPanel的默认布局管理就是FlowLayout

三种构造方式：

FlowLayout()

构造一个新的 FlowLayout，居中对齐，默认的水平和垂直间隙是 5 个单位。

FlowLayout(int align)

构造一个新的 FlowLayout，对齐方式是指定的，默认的水平和垂直间隙是 5 个单位。

FlowLayout(int align, int hgap, int vgap)

建立一个新的流布局管理器，具备指定的对齐方式以及指定的水平和垂直间隙。

BorderLayout：按方位进行布局管理，不明确指定，就会默认加载在中间，Frame和JFrame默认的布局管理器是BorderLayout

两种构造方式：

BorderLayout()

构造一个组件之间没有间距的新边界布局。

BorderLayout(int hgap, int vgap)

用指定的组件之间的水平间距构造一个边界布局。

GridLayout：网格布局，经过行列、间距来用网格分割，把组件放入网格中，先行后列摆放组件。

三种构造方式：

GridLayout()

建立具备默认值的网格布局，即每一个组件占据一行一列。

GridLayout(int rows, int cols)

建立具备指定行数和列数的网格布局。

GridLayout(int rows, int cols, int hgap, int vgap)

建立具备指定行数和列数的网格布局，并将水平和垂直间距设置为指定值。

组件：图形界面中全部能看到的

JButton ：按钮

JTextField：单行文本域

JTextArea：多行文本区

JLabel：标签

华为培训讲义第9天

图形界面：

布局管理器：

CardLayout：卡片布局，面板重叠放置，只能看到一个，最早添加的会被显示出来，能够进行翻动

两种构造方法：

CardLayout()

建立一个间隙大小为 0 的新卡片布局。

CardLayout(int hgap, int vgap)

建立一个具备指定的水平和垂直间隙的新卡片布局。

经常使用的方法：

previous(Container parent)

翻转到指定容器的前一张卡片。

show(Container parent, String name)

翻转到已添加到此布局的具备指定 name 的组件

next(Container parent)

翻转到指定容器的下一张卡片。

first(Container parent)

翻转到容器的第一张卡片。

last(Container parent)

翻转到容器的最后一张卡片。

GridBagLayout：加强版的网格布局，组件能够跨行跨列的进行布局。

构造方法：

GridBagLayout()

建立网格包布局管理器。

注意：

该布局管理器的具体实现须要借助GridBagConstraints类，利用GridBagConstraints类的属性对组件进行设置，具体内容查看API文档。

菜单项：

JMenuBar：菜单栏的实现，将JMenu对象添加到菜单栏以构造菜单

构造方法：

JMenuBar()

建立新的菜单栏。

JMenu：菜单的该实现是一个包含JMenuItem的弹出窗口

构造方法：

JMenu(String s)

构造一个新JMenu，用提供的字符串做为其文本。

JMenuItem：菜单中的项的实现，菜单项本质上是位于列表中的按钮

构造方法：

JMenuItem(String text)

建立带有指定文本的JMenuItem。

AWT事件模型：

事件模型的三要素：

事件源(Object)：事件的产生者。

事件(EventObject)：描述发生了什么事情。

事件监听(EventListener)：事件的处理者

关系：

事件只与事件源有关，与事件监听无关

一个事件源能够注册多个事件监听。

一个事件监听器能够在多个事件源中注册。

一个事件源能够就同一类事件注册多个事件监听。

事件处理机制：委派式的处理机制(是一种松耦合)

组件自身会产生事件对象，但自己不必定负责处理，而是交给一个监听者去处理

实现监听的步骤：

a. 实现监听接口implements XxxxListener

b. 重写方法actionPerformed(ActionEvent e)

c. 注册监听addXxxxListener(ActionListener l)

适配器：一个重写了全部接口中方法的类

在java.awt.event包中，会有一些适配器，也就是把相应的XxxxListener，换成XxxxAdapter就是适配器。

在AWT中常常用匿名内部类来继承适配器作监听

华为培训讲义第10天

JFC：java基础类库(具体的类能够查看API文档)

观察者模式：

事件监听者对事件源进行监听，事件源会发生某些事件，监听者须要对事件做出相应的处理。

事件监听者(Observer)：

处理事件

事件对象(Observable)：

注册监听

取消监听

通知监听

编程步骤：

a. 定义一个监听者，使其实现Observer接口，实现其中的方法update(Observable o, Object arg)。

b. 定义一个事件对象，使其继承Observable类，定义一个产生事件的方法，在方法里去注册监听addObserver(Observer o)、标志改变setChanged()（若是不写，则说明该事件没有发生，监听者不会反映）、启动监听notifyObservers()。

注意：注册监听和标志改变不分前后，但标志改变和启动监听是不能互换的。

应用：当某事物发生变化，须要采起行动，则能够采用观察者模式。

适配器模式：

Adapter适配器模式是一种结构型模式，将两个互不兼容的类纠合在一块儿。

主要应对：因为应用环境的变化，经常须要将“一些现存的对象”放在新的环境中应用，可是，新环境要求的接口是现存对象所不知足的。

做用：在不改变源代码的状况下实现需求。

java.math.BigDecimal：不可变的、任意精度的有符号十进制数。

必须用String类型进行构造，才能实现精确计算

I/O流后面会详细讲解，今天的了解下就能够了。

华为培训讲义第11天

多线程：

进程与线程：

进程：同一个操做系统中执行的一个子程序，包含了三部分虚拟CPU、代码、数据

多进程：同一个操做系统中执行的多个并行的子程序。能够提升cpu的使用率

线程：在同一个进程当中执行的子程序流

多线程：同一个进程当中并发执行的多个子程序流。能够提升cpu的使用率

进程与线程的区别：

进程有独立的进程空间，进程中的数据存放空间（堆空间和栈空间）是独立的。

线程的堆空间是共享的，栈空间是独立的，线程消耗的资源也比进程小，相互之间能够影响的。

java中如何调进程：

调用本地程序的两个类

Runtime

Runtime.getRuntime.exec(...); //执行一个程序

其返回值就是Process类型

Process

注意：

只有运行状态的线程才有机会执行代码，主线程的停止不会影响其余的正在运行中的线程，主线程停止也就是main()方法退出了。只有进程中的全部线程都停止时，进程（JVM进程）才会退出，只要有线程没有停止，进程就不会退出。

操做系统决定线程是否有优先级，独占式的操做系统中系统会有优先级的概念，共享式的操做系统则不会有优先级的。

在线程的内部，程序依然顺序执行

线程编程的两种方法：

写一个类，继承Thread类，覆盖Thread类中继承来的run()方法，这样就写好了自定义的线程类。

继承java.lang.Thread类：

class MyThread extends Thread{

public void run(){ //覆盖run()，线程体方法，自身其实就是普通的方法

.......

}

启动线程：

public class TestThread{

public static void main(){

Thread t1=new Mythread();

T1.start(); //调用start()来启动线程，线程启动方法，向线程调度器说明当前线程已经准备好了，是一种可运行状态

}

写一个类，实现Runable接口，实现其中的run()方法。这种方法写好的类的对象须要做为线程类建立对象时构造方法的参数。

实现java.lang.Runnable接口：

Class MyThread implements Runnable{

public void run(){

}

启动线程：

public class TestThread{

public static void main(){

Runnable myThread = new MyThread();

Thread t = new Thread(myThread);

t.start();

}

Thread中的一些方法：

currentThread()

返回对当前正在执行的线程对象的引用(实现接口方式时使用)

sleep(long millis)

在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)。

本线程不会去抢，除非sleep结束。

多个线程之间都会去抢执行权限，不会考虑优先级。

yield()

暂停当前正在执行的线程对象，并执行其余线程。

只给本类或者优先级大于本类优先级的线程去抢。

join()

等待该线程终止。

放在start()前面则没有用处。

setDaemon(boolean on)

将该线程标记为守护线程，守护线程须要依赖其余线程，会在虚拟机中止的时候中止。

线程的生命周期：

1）初始状态：此时线程只是处于JVM进程中，只是建立了一个线程对象，并无真正开始运行。

2）可动行状态：调用线程对象的start()方法，此时线程才真正的被建立，进入可运行状态，等待CPU的调度。“万事俱备，只欠CPU”。

3）运行状态：正在运行的线程，此时它拥有CPU的执行权。

4）阻塞状态：运行状态中的线程，若是正在等待用户输入或调用了sleep()和join()等方法都会致使线程进入阻塞状态，注意从阻塞状态出来的线程不必定立刻回到运行状态，而是从新回到可运行状态，等待CPU的再次调度。

5）等待队列状态：一个线程调用一个对象的wait()会自动放弃该对象的锁标记，进入等待队列状态，只有当有另一线程调用临界资源的notify()或notifyAll()方法，建议多使用notifyAll()，才会将等待队列中的线程释放，此线程进入锁池状态。

6）锁池状态：每一个对象都有互斥锁标记，以防止对临界资源的访问形成数据的不一致，和数据的不完整性。一个线程拥有一个对象的锁标记后，另外一线程想访问该对象，必须在锁池中等待。由系统决定哪一个线程拿到锁标记并运行。注意从锁池状态出来的线程不是立刻回到运行状态，而是从新回到可运行状态，等待CPU的再次调度。

7）终止状态：一个线程运行结束后称为终止状态，一个进程中只有全部的线程退出后才会终止。

华为培训讲义第12天

多线程：

多线程的同步：

多线程并发访问同一个对象（临界资源），若是不对线程进行同步控制，破坏了原子操做(不可再分的操做)，则会形成临界资源(两个线程同时访问的资源)的数据不一致。

每个对象都有一个互斥的锁标记和一个锁池。当线程拥有这个对象的锁标记时才能访问这个资源，没有锁标记便进入锁池，保证在同步代码块中只有一个线程，解决了多线程同步控制的问题。

关键字：synchronized //线程在同步代码中必须采用串行访问

synchronized修饰代码块：对括号内的对象object加锁，只有拿到对象锁标记的线程才能进入该代码块。

public void push(char c){

synchronized(object){ //object只要是对象就能够，但必须保证是同一对象

……

同步代码

……

}

synchronized修饰方法：在整个方法范围内对当前对象的加锁，只有拿到对象锁标记的线程才能执行该方法。尽量的少用

public synchronized void push(char c) {

……

同步代码

……

}

一个线程能够同时拥有多个对象的锁标记，锁标记若是过多，就会出现线程等待其余线程释放锁标记，而又都不释放本身的锁标记供其余线程运行的情况，形成死锁。

静态方法能够是同步方法：可是它所锁的并非当前对象，是类对象。

抽象方法不能是synchronized同步的方法。

构造方法不能是synchronized同步的方法。

线程由于未拿到锁标记而发生阻塞进入锁池（lock pool）。每一个对象都有本身的一个锁池的空间，用于放置等待运行的线程。由系统决定哪一个线程拿到锁标记并运行

利用Collections类中的synchronizedXxxx(Xxxx ss)方法能够获得相应集合的线程安全的集合

注意：

在同步语句块中不能直接操做对象锁正在使用的对象。

对象与锁一一对应。

同步依赖对象锁，锁对象相同，同步语句串行，锁对象不一样，同步语句并行。

顺序锁，不要回调，反向打开。

能不用同步就不用同步，有数据共享冲突时才使用同步。

等待通知机制：

线程间通讯使用的空间称之为对象的等待对列（wait pool），该队列也是属于对象的空间的。

使用Object类中wait()的方法，在运行状态中，线程调用wait()，此时表示线程将释放本身全部的锁标记和CPU的占用，同时进入这个对象的等待池。等待池的状态也是阻塞状态，只不过线程释放本身的锁标记。只有在对该对象加锁的同步代码块里，才能掉用该对象的wait()，表示线程将会释放全部锁标记，进入等待队列，线程将进入等待队列状态。

一个线程进入了一个对对象加锁的同步代码块，并对该对象调用了wait()方法，释放本身拥有的全部锁标记，进入该对象等待队列，另外一个线程得到了该对象的锁标记，进入代码块对该对象调用了notify()方法，就会从等待队列里释放出一线程，释放出的这个线程要继续运行就还要进入那个同步代码块，由于得不到要访问代码块对象的锁标记，而进入该对象的锁池，等待锁标记释放。

什么状况下释放锁：

同类代码执行完毕。

异常未处理，错误退出。

调用wait()。

华为培训讲义第13天

I/O流

流的概念：程序与数据来源之间的桥梁

流的分类：

按数据方向分：输入流和输出流

输入流：InputStream/Reader

输出流：OutputStream/Writer

按数据类型分：字节流和字符流

字节流：InputStream/OutputStream

字符流：Reader/Writer

按流的功能分：节点流和处理流

节点流用操做数据的来源。

处理流用来封装节点流，从而给节点流增长一个功能，不能独立存在，在关闭流时若是使用了处理流，只需关闭最外层的流就能够了。

区分节点流和处理流的小方法：

看构造器，节点流参数为数据来源，而处理流参数为其余流。

选择流的思路：

先考虑是输入流仍是输出流，

再考虑是字节流仍是字符流，

最后考虑是节点流仍是处理流。

字符流：Reader和Writer全部字符流的父类型

Java技术使用Unicode来表示字符串和字符，并且提供16位版本的流，以便用相似的方法处理字符。

若是构造了一个链接到流的Reader和Writer，转换规则会在使用缺省平台所定义的字节编码和Unicode之间切换。

桥梁流：InputStreamReader和OutputStreamWriter（字节流转化成字符流的桥转换器）

这两个类不是用于直接输入输出的，他是将字节流转换成字符流的桥转换器，并能够指定编解码方式。

逐行读写流：BufferedReader/BufferedWriter

以上两个都是过滤流，须要用其余的节点流来做参数构造对象。

BufferedReader的方法：readLine():String ，当他的返回值是null时，就表示读取完毕了。要注意，再写入时要注意写换行符，不然会出现阻塞。

BufferedWriter的方法：newLine() ，这个方法会写出一个换行符。

管道流：线程交互的时候使用

PipedInputStream/PipedOutputStream

传送输出流能够链接到传送输入流，以建立通讯管道。传送输出流是管道的发送端。一般，数据由某个线程写入 PipedOutputStream 对象，并由其余线程从链接的 PipedInputStream 读取。

注意：管道输出流和管道输入流须要对接。

数据流：DataInputStream和DataOutputStream

经过流来读写Java基本类，注意DataInputStream和DataOutputStream的方法是成对的。

支持直接输出输入各类数据类型。

注意：使用DataOutputStream/DataInputStream时，要注意写入顺序和读取顺序相同，不然会将没有分割写入的信息分割不正确而读取出错误的数据。

Properties类：针对属性文件(*.properties，内容是name=value)进行操做，在java.util包下

load(InputStream inStream)

从输入流中读取属性列表（键和元素对）。

getProperty(String key)

用指定的键在此属性列表中搜索属性。

java编码方式：

编码：把字符转换成数字存储到计算机中，按ASCII将字母映射为整数。

解码：把数字从计算机转换成相应的字符的过程。

不一样的国家有不一样的编码，当编码方式和解码方式不统一时，产生乱码。

由于美国最先发展软件，因此每种的编码都向上兼容ASCII 因此英文没有乱码。

ASCII（英文） 1个字符占一个字节（全部的编码集都兼容ASCII）

ISO8859-1（拉丁文） 1个字符占一个字节

GB-2312/GBK 1个字符占两个字节（多用于中文）

Unicode 1个字符占两个字节（网络传输速度慢）

UTF-8 变长字节，对于英文一个字节，对于汉字两个或三个字节。

中文编码时出现乱码的状况：

用流操做文件。

网页（动态静态）。

网络传递消息。

解决乱码的方式：

String temp = 乱码的字符串

temp = new String(temp.getBytes("ISO8859-1") , "GBK")

将temp按照ISO8859-1的方式进行解码生成一个字节序列，而后在按照GBK的方式解码字节序列生成字符串。

File类：可表示文件或者目录

File下的方法是对磁盘上的文件进行磁盘操做，可是没法读写文件的内容。

构造器：

File(String pathname) //以文件的路径作参数

File类的方法：

boolean createNewFile()

建立一个新文件

File createTempFile(String prefix, String suffix, File directory)

在指定目录中建立一个新的空文件，使用给定的前缀和后缀字符串生成其名称。会在前缀和后缀之间加一个随机数

boolean mkdir()

建立一个新目录

boolean delete()

删除文件，删除的是建立File对象时指定与之关联建立的那个文件。

String[] List()

返回当前File对象下全部显文件和目录名（相对路径）

File[] ListFiles()

返回当前File对象（必须是目录）下的全部File对象，能够用getName()来访问到文件名。

boolean isDirectory()和boolean isFile()

判断到底是目录仍是文件。

boolean exists()

判断文件或文件夹是否存在。

String getPath()

得到相对路径。

String getAbsolutePath()

得到文件的绝对路径

注意：

File类的对象实施表示一个文件并非真正的文件，只是一个代理而已，经过这个代理来操做文件

建立一个文件对象和建立一个文件在java中是两个不一样的概念。前者是在虚拟机中建立了一个文件，但却并无将它真正地建立到OS的文件系统中，随着虚拟机的关闭，这个建立的对象也就消失了。而建立一个文件才是在系统中真正地创建一个文件。

例如：

File f=new File(“11.txt”); //建立一个名为11.txt的文件对象

f.CreateNewFile(); //真正地建立文件

RandomAccessFile：

容许随机访问文件，类支持直接输出输入各类数据类型。

构造器：

RandomAccessFile(File file, String mode)

建立从中读取和向其中写入（可选）的随机存取文件流，该文件由 File 参数指定。

RandomAccessFile(String name, String mode)

建立从中读取和向其中写入（可选）的随机存取文件流，该文件具备指定名称。

mode( r：以只读方式打开 rw：可读可写，不存在则建立)

华为培训讲义第14天

包名、类名和属性能够被序列化，方法和构造器不会被序列化的。

静态属性不会被序列化的。

属性会被递归序列化的，也就是一个类中有引用类型的属性，若是这个属性对应的类实现了Serializable接口，在对象序列化时，也一样会对这个类中的属性进行对象序列化，若是没有实现Serializable接口，则会抛出异常。

全部属性必须都是可序列化的，特别是当有些属性自己也是对象的时候，要尤为注意这一点。

网络中传递对象必须实现序列化。

nio无阻塞的I/O（优化的I/O）

java.nio 定义块

Buffer类：一种用于特定的基本类型数据的容器

缓冲：就是块，用来存储内容。

容量：内存开辟的大小，根据类型的不一样，有不一样的空间。

界限：可用部分，即不该读取或写入的第一个元素的索引。

位置：当前指针的位置，从0开始。

容量>=界限>=位置

华为培训讲义第15天

网络编程：

多线程+网络：

一、服务器端的等待客户链接代码（ while(true) ），服务器端与单个客户端交互的代码放入线程体（ run ）

二、客户端若有其余要求，与服务器交互的代码也要放入线程体

三、ServerSocket和Socket编码基于TCP/IP协议，重发一切错误数据，当网络很差时会使性能不好

四、Server端

new ServerSocket启动等待链接线程

在accept后启动交互线程

注意：交互时注意对应产生，读写流对应和次数对应

URL：网址，统一资源定位器

经常使用的构造器：

URL(String spec)

spec 一个完整的网址（协议+网址）

根据 String 表示形式建立 URL 对象。

URLConnection：与网址进行链接

经过URL的openConnection()方法生成一个URLConnection实例，经过下面两个方法，进行流的操做

getInputStream()

返回今后打开的链接读取的输入流

getOutputStream()

返回写入到此链接的输出流。

UDP编程：这种信息传输方式至关于传真，信息打包，在接收端准备纸

特色：

一、一种无链接协议，速度快

二、不保证数据的完整，不会进行重发

DatagramSocket和DatagramPacket类：

DatagramSocket：此类表示用来发送和接收数据报包的套接字。

DatagramPacket：数据报包，是UDP下进行传输数据的单位，数据存放在字节数组中，其中包括了目标地址和端口以及传送的信息。

用于接收：

DatagramPacket(byte[] buf , int length)

用于发送：

DatagramPacket(byte[] buf , int length , InetAddress address , int port )

UDP发送端：

一、建立一个DatagramSocket，不须要参数

二、建立一个DatagramPacket，指明接收方的IP地址和端口号

三、发送数据send(DatagramPacket p)

四、关闭DatagramSocket

UDP接收端：

一、建立一个DatagramSocket，指定接收方的IP地址和端口号

二、建立一个DatagramPacket，不须要IP地址和端口号

三、接收数据receive(DatagramPacket p)

四、关闭DatagramSocket

经常使用类库：

java.lang.*:

System 系统

Object 对象

clone()

equals()

hashCode()

toString()

Class 类

String/StringBuffer/StringBuilder 与字符串相关的

Thread 线程

全部的封装类

java.util.*:

Set--->HashSet,TreeSet

List--->ArrayList

Map--->HashMap(线程安全，不支持空),HashTable(线程不安全，支持空)

Collections--->外同步

Properties

Date

观察者-->Observable,接口Observer

数据结构+工具类

java.sql.*: 后面立刻会讲到，JDBC

java.awt/swing.*：没什么机会用到

java.io.*: 流至关的多

File/FilenameFilter

Serializable 对象序列化接口

注意：写一个类要考虑的事情：一、无参构造器，二、实现序列化接口，三、重写equals,hashCode

FileInputStream

FileOutputStream

InputStreamReader

PrintStream

BufferedReader

nio包

java.net.*: 之后JSP,Servlet用的时候这个包都已经写好了

InetAddress--->IP地址

URL----------->网址

URLConnection---->链接

ServerSocket,Socket----TCP/IP

DatagramSocket,DatagramPacket----UDP

一些零散的类：

Comparable（可比较的）,Comparator（比较器）

java.math.*;数字在商业软件中应用时找这个包

BigDecimal

与反射相关的：java.lang.reflect: 用的机会比较少

Runtime（运行环境）,Process（进程），这两个在java.lang包里，用了这些就不能跨平台了，并且效率低

华为培训讲义第16天

国际化：让世界上每一个人都能看懂。

Locale类（java.util包下）：包括全部国家、地区、语言

存在不少的静态属性，来表示国家、语言

三种构造方法：

Locale(String language)

根据语言代码构造一个语言环境。

Locale(String language, String country)

根据语言和国家构造一个语言环境。

Locale(String language, String country, String variant)

根据语言、国家和变量构造一个语言环境。

经常使用方法：

Locale getDefault()

得到此 Java 虚拟机实例的当前默认语言环境值。

String getDisplayCountry()

返回适合向用户显示的语言环境国家名。

void setDefault(Locale newLocale)

为此 Java 虚拟机实例设置默认语言环境。

String getLanguage()

返回此语言环境的语言代码。

String getCountry()

返回此语言环境的国家/地区代码。

注意：

国家会兼容语言，但语言不会兼容国家。

java.text.*：该包下存在许多格式化类

NumberFormat抽象类：

经常使用方法：

NumberFormat getInstance()

返回当前默认语言环境的通用数字格式。

NumberFormat getInstance(Locale inLocale)

返回指定语言环境的通用数字格式。

String format(double number)

根据国家，进行格式规范。

NumberFormat getCurrencyInstance(Locale inLocale)

返回指定语言环境的货币格式。

SimpleDateFormat类：

模式字母：

y 年

M 年中的月份

H 一天中的小时数（0-23）

h am/pm 中的小时数（1-12）

m 小时中的分钟数

s 分钟中的秒数

构造器：

SimpleDateFormat(String pattern)

用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。

经常使用方法：

String format(Date date)

将一个 Date 格式化为日期/时间字符串。

注意：

看到相应的模式字母，就会进行转换。

实现国际化：

一、先写各个语言对应的文字类，使其extends ListResourceBundle，而后重写getContents()，返回一个二维数组。

二、在程序中按照Local和ListResourceBundle的baseName来选择对应的资源，调用getString()/getObject()取得value

ResourceBundle类：

ResourceBundle getBundle(String baseName, Locale locale)

baseName为对应的ListResourceBundle的类名(包名.类名)

使用指定的基本名称和语言环境，以及调用方的类加载器获取资源包。

注意：根据key去查找value时，当前没有会去查找默认的，默认的也没有则会抛出异常

5.0新特性：

一、自动装箱，自动解箱(简单类型->对象类型)

小于127的数值在自动装箱时只作一次装箱，作" == "时相等。

null没法自动解箱。

先装箱后赋值和先解箱后赋值时，须要注意是否可以匹配。

二、静态import

用于导入类中的静态属性和静态方法。

格式：import static 包名.类名.属性/方法/*

注意：

必须是静态的成员。

静态导入时，不容许导入同名方法/属性。

使用时，可省略" 类名. "就像使用本类方法同样

三、加强for循环：for( : )

方式统一，能够处理数组和集合。

不能够同时对两个以上的集合进行操做。

不支持删除元素。

四、可变长的参数：(...)

用于取代数组，实际上仍是按数组进行处理，容许传递非数组的值（0到n个，中间用逗号分隔）。

可变长参数只能出现一次，且必定会放在参数列表的最后。

做参数时，可变长参数能够不传，但数组不能够。

五、格式化输入输出：Scanner类

了解下就能够，知道有这个类就OK。

六、枚举Enum：本质上也是一个类，具备类全部特性

格式：

enum 枚举名{

枚举值1,

枚举值2,

.....

}

特性：

显示一些同类型的清单。

一个枚举值就是一个枚举对象。

能够有构造器，但不能是public的。

具备一个私有的默认无参的构造器，显式构造后，默认的构造器会消失。

属性，方法和类同样。

枚举是final的(对于外部没法继承)，但在内部能够去实现。

注意：

清单里的类，会调用匹配的构造器，如无，则会报错。

在枚举中能够有抽象方法，但在清单中的全部子类都必须实现他。

若是要写属性和方法，则最后的一个枚举值要以分号结束。

枚举中的values()方法会返回枚举中的全部枚举值： Color[] ss = Color.values();

七、泛型

八、元数据（注释），项目中推广度通常

华为培训讲义第17天

5.0新特性：

泛型：

泛型的形式：

<E>

<E extends Numner&comparator> 类名&接口，表示E继承Numner类实现comparator接口

<?> 泛型通配符表示任意类型，仅用于传参

<? extends 类型> 表示这个类型能够是该类或者该类的子类。

<? super 类型> 表示这个类型能够是该类或者该类的父类。

泛型的优势：

指定泛型后，取出数据时不须要进行强制类型转换，能够直接赋值给相应类型。

能够限定集合中的元素类型，保证集合中的元素是按照要求放入的。

能够加强多态(继承多个接口而无需写继承类)。

保证参数有效。

泛型的局限性：

不能实例化泛型

T t = new T(); //error

数组不可用泛型限定

List<String>[] list = new List<String>[10]; //错误

E[] a = new E[10]; //错误

类的静态变量不能声明为类的泛型类型

public class GenClass<T> {

private static T t; //编译错误

}

静态方法能够是泛型方法(在修饰符和返回值之间写泛型)，可是不可使用类的泛型。

static void copyArrayToList(Object[] os,List<T> ls){

//错误，T为类的泛型

}

static <E> void copyArrayToList(E[] os,List<E> ls){

//泛型方法，正确的

}

泛型不能使用简单类型

GenList<int> nList = new GenList<int>(); //编译错误

泛型类不能是异常类，也就是该泛型类不能继承自Throwable以及其子类

public class MyExpection<T> extends Exception{ } //编译错误

能够抛出（throws）泛型类，但catch的参数不能是泛型类。

注意：

编译时类型的泛型和运行时类型的泛型必定要一致，没有多态。

支持泛型的集合，只能存放指定的类型，或者是指定类型的子类型。

注释（元数据）：

描述代码的代码，做用是规范编译器的语法。

三种内置注释：

@Deprecated 所标注的程序元素是不推荐使用的

@Override 检查是否为合法的覆盖父类的方法

@SuppressWarnings 注释类或方法，忽略其中的某些类型的警告信息

注释的三种类型：

标记注释：不须要任何参数

@Override

@Deprecated

单值注释：有一个值的注释

@注释名（值名=值）

值名通常为value，能够省略的，直接写值就能够

值的类型是有限制的，只能是如下几种：

8种基本数据类型

String

Class

Enum

Annotation

以及他们的数组

多值注释：每一个值之间用逗号隔开

四种元注释：java.lang.annotation中的类

元注释：注释注释的注释，用来限定注释的特征

@Terget 用来限定某个注释的使用范围，能够对什么元素进行注释

@Retention 用来描述注释的有效范围

@Inherited 用来描述某注释是否有继承性

@Documented 用来限定注释的信息是否可以进行文档化

自定义注释：

在自定义注释时，要用元注释来进行描述。

如：

import java.lang.annotation.*;

@Target({ElementType.METHOD})

@Inherited

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface InProgress {

String author(); //定义属性

String limited();

}

解析注释：利用反射

一、Class.forName()

二、getMethod

三、判断是否有注释

四、getAnnotation

并发线程：

三个多线程包：

java.util.concurrent 包含了经常使用的多线程工具，是新的多线程工具的主体。

java.util.concurrent.atomic 包含了不用加锁状况下就能改变值的原子变量。

java.util.concurrent.locks 包含锁定的工具。

Executor接口：

替代了Thread类，他能够建立定量的、动态的以及周期性的线程池。

ExecutorService接口：

线程池，用来存放线程来节省建立和销毁资源的消耗。

Callable和Future接口：

Callable是相似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。Callable和Runnable有几点不一样：

Callable规定的方法是call()，而Runnable规定的方法是run().

Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。

call()方法可抛出异常，而run()方法是不能抛出异常的。

运行Callable任务可拿到一个Future对象，经过Future对象可了解任务执行状况，可取消任务的执行，还可获取任务执行的结果。

华为培训讲义第18天

软件开发流程：

一、可行性分析

二、需求分析->开发测试

三、概要设计->分隔模块，定义框架等

四、详细设计->类设计、接口设计

五、编码

六、测试

七、部署

八、维护

单元测试：

要求：

要有边界值的分析，主要针对分支语句的临界点

语句覆盖，保证写的任何语句都要运行到

断定覆盖，全部判断的地方都要覆盖掉

条件覆盖，保证全部条件都要覆盖掉

路径覆盖，全部分支都要测试到

步骤：

一、针对每一个类写一个TestCase，在setUp方法中初始化要测试类，在tearDown方法中将测试类置为null

二、逐一编写以test开头的方法

三、新建一个套件类，再把全部的TestCase类加入套件类

Ant：用于对项目的总体构建、修改及部署等操做

Ant的下载：

去阿帕奇官方网站下载

在eclipse的eclipse3.2\plugins\org.apache.ant_1.6.5

创建ant的步骤：

一、写类：src和build.xml必须本身写，src中的源程序要按照包结构去构建好

projectName

classes

src

build.xml

二、写build.xml

<?xml version="1.0" encoding="GB2312" ?>

</classpath>

</java>

</target>

</target>

</target>

</project>

三、ant配置环境变量

Path->org.apache.ant_1.6.5\bin

ClassPath->org.apache.ant_1.6.5\lib

四、运行

建立可运行的jar文件：

一、先建起一个空文件夹

二、把全部的源文件拷贝到该文件夹下

三、javac -d . * 编译此文件夹下各源文件

四、删除源文件

五、jar -cvf test.jar * 完成第一次打包

六、jar -xvf test.jar 解压

七、删除test.jar

八、改META_INF中的文件，加上Main-Class: MenuFrame （注意中间有空格），保存

九、jar -cvfM test.jar *

十、java -jar test.jar 能够运行

重构：

在不改变软件任何功能的前提下对代码进行修改，调整其结构，提升其可读性，下降其修改的成本。

重构的基本思想就是集中精力使设计简化，而且在新的需求出现时提供一个持续发展（而非扩展）的环境。

重构是一项功能强大的技术，但需以微小的步伐修改程序才行。

重构的优势：

重构能够改进软件的设计；

重构可使你的代码看起来更易理解；

重构能够找出潜伏的Bug；

重构能够帮助你提升编程的速度――在一次次的迭代过程当中阻止系统腐败变质，减小在调试中所花的时间；

重构可使咱们更快速的开发软件，甚至还能够提升咱们的设计质量。

利用eclipse重构代码：

代码封装

方法移位(父类<->子类)

抽取方法

提炼接口