java基础笔记

JavaAPI:Application Programming Interface

Java 版本：  javaSE

javaEE:企业网站开发，核心：EJB

javaME:嵌入式系统开发

应用领域：桌面应用程序开发

嵌入式系统开发

电子商务应用

企业级应用系统开发

交互式系统开发

多媒体系统开发

分布式系统开发

Web应用系统开发

语言的特性：简单

面向对象

分布性：包括操作分布和数据分布。操作分布：在多个不同的主机上布置相关操作。数据分布：将数据分别存放在多个不同的主机上，这些主机是网络中的不同成员。Java可以凭借URL（统一资源定位符）对象访问网络对象，访问方式与访问本地系统相同。

可移植性：

解释型：需要解释器，慢

安全性：删除了指针和内存释放等语法，有效的避免了非法操作内存

健壮性

多线程：多核处理器，同一时间并行执行许多任务

高性能

动态

JDK：java开发环境

JRE：java运行环境

Windows系统的JDK环境

设定JAVA_HOME,CLASSPATH和path

环境变量配置：不区分大小写

右击这台电脑->单机属性->高级系统设置->选择环境变量

在用户变量新建：变量名:java_home    变量值：路径

在系统变量新建：变量名：classpath    变量值：路径（相对路径（%java_home%\....）&绝对路径）

验证JDK是否安装成功

通过“开始”菜单下的cmd命令（或win+R，输入cmd,回车）

在命令提示符后输入命令java –version（注：java后有一个空格）

如果显示JDK的版本信息，则安装成功。

第一个java程序

public class Test{

         public static voidmain(String []args){

                   System.out.println("HelloJava");

         }

}

保存到C盘：Test.java

Win+R->cmd进入控制台->将控制台路径设为C盘：cd c:\->输入javacTest.java->控制台会输出Hello java

什么是java语言

1995年由sun公司推出的，java之父詹姆斯 戈士林博士设计，完成了java金属的原始编译和虚拟机，最初名字是OAK

通过解释方式运行的语言：跨平台

Java语言程序代码的编译的运行过程：

程序源代码->编译器->字节码->JVM（java虚拟机）->机器码->在机器上运行      

Java的主类结构:

         1包声明：关键字：package（域名倒写）

         2声明成员变量和局部变量：成员变量：类之中，针对类的生命周期

局部变量：方法里面有效

         3主方法：publicstatic void main(String[]args){}java程序的入口

         4导入API类库：通过import关键字导入相关的类，

比较运算符：属于二元运算符，用于程序中的变量和变量，变量和常量之间以及其他类型的信息之间的比较。运算结果是boolean型，通常用在条件语句中来作为判断的依据

包括（>,<,==,>=,<=,!=）

编码规范：

         每条语句要单独占一行

         每条命令都要以分号结束

         声明变量时要分行声明

         Java语句中多个空格看成一个

         不使用技术性很高，难懂，易混淆判断的语句

         对于关键的方法要多加注释

变量的有效范围：

         局部变量和成员变量名相同发，局部变量会屏蔽成员变量

标识符和关键字：

         1标识符:反映出变量的用途，便于维护

                   由字母，数字，下划线和美元符号，第一个字符不能为数字

                   Java语言使用Unicode标准字符集，最多可以识别65535个字符，因此，java语言中字母可以是Unicode字符集中的任何字符，包括拉丁字母，汉字，日文等许多语言中的字符

                   不能是java的关键字和保留字

                   在java语言中标识符是区分大小写的

         2关键字：

                   intpublic this finally Boolean abstrsct long short throw return break for staticnew interface if double………

布尔类型：

         Boolean:true&false(没有规定占多少空间)，不能通过1&0来代替

代码注释：

         //单行注释

         /*多行注释*/

         /**文档注释*/ 生成到开发文档中

浮点类型：

         float（单精度浮点类型）:赋值时需在结尾加“F”或“f‘,范围在1.4E-45和3.4028235E-38之间

         Boolean（双精度浮点类型）:默认都是double类型，范围在4.9E-324和1.7976931348623127E-308.

         Java里面的浮点数不适合做高精度运算，不能用于金融，国防等

赋值运算符：

         ’=‘为二元运算符

         变量类型 变量名=所赋的值

逻辑运算符：

         &&：逻辑与 同时为真才返回true

         ||：逻辑或  有一个为真就返回true

         !：逻辑非

返回值为布尔类型的表达式，操作元也必须是boolean型数据

三元运算符：

表达式？true :false，可以使用if else代替

声明变量：

         声明变量时可以补赋值，也可以直接赋值

声明常量：

         一直不会改变的量（constant）关键字：final（赋值后不能被修改，只能被赋值一次）

算术运算符：

         +，-，*，/，%

位运算符：

         用于处理整数和字符型的操作数，对其内存进行操作，数据在内存中以二进制的形式表示，例如int型变量7的二进制表示是00000000 00000000 00000000 00000111，-8的二进制表示是1111111111111111 11111111 11111000，最高位是符号位，0表示正数，1表示负数

00

11

按位与：00

按位或：11

取反：11  00

异或：11

移位运算符：>>(向右移位),<<（向左移位）,>>>（无符号的向右移位）

显示类型转换：

         把高精度的变量的值赋值给低精度的变量时，必须使用显示类型转换

         (类型名)要转换的值   （byte）205；越界=-51

隐式类型转换：

         占用空间小的级别低，占用空间大的级别高，从低级到高级转换的规则

运算符优先级：

    从上到下是由高到低：

var++和var--（后置操作符）

+，-（一元加号和一元减号），++var和--var（前置操作符）

（type）（类型转换）

！（非）

*，/，%（乘法，除法和求余运算）

+，-（二元加法和减法）

<,<=,>,>=（比较运算符）

==，!=（相等操作符）

^(异或)

&&（条件与）

||（条件或）

=，+=，-=，*=，/=,%=(赋值操作符)

 

整数类型：

         byte:范围-128~127,占用内存小，一般用于IO部分

         short：短整型，两个字节，范围：-32768~32767

         int:范围-2147483648~2147483647

long：长整型，在对long型变量赋值时结尾必须加上“L“或”l“，否则将不认为是long型，拥有8个字节，范围9223372036854775808~9223372036854775807

 

自增和自减运算符：

         单目运算符 ++  --

         A=++I,先将i的值加1，再赋值给A

         A=i++,先将i的值赋值给A,再将i加1

字符类型：

         char两个字节的存储空间，定义时，用单引号括起来

do……while循环语句

         先执行一遍循环体，再判断条件

         do{

                   执行语句

}while(条件表达式);

for循环语句：

         java5新增了foreach

for(初始值 ;判断语句 ;改变步长){

                   执行循环体

}

foreach(intx:arr) //遍历数组{      

        

}

 

if条件语句：

         if(){}

         if(){}else{}

         if(){}elseif(){}else{}

switch多分支语句：

         语句中表达式的值必须是整型或字符型，常量值1~n必须也是整型或字符型

         switch(整型/枚举/字符串/包装类){

                   case1:

         case2:

         default:

}

while循环语句：

         条件判断语句

         while(条件表达式){

         执行语句

}

复合语句：

         以一组{ }开始和结尾

按字典顺序比较两个字符串：

         compareTo()方法

         如果按字典顺序比String对象位于参数字符串之前，则比较结果为一个负整数，如果按字典顺序此String对象位于参数字符串之后，则结果为一个正整数，如果相等，则结果为零

         str.compareTo(Stringotherstr)

         其中，str,otherstr是参加比较的两个字符串对象

常规类型格式化：

         经常对常规类型的数据进行格式化，例如格式化为整数，科学技术表示等

         format()

创建字符串：

         Stringdata[]={‘a’,’b’,’c’};

         =chardata[]={‘a’,’b’,’c’};

          String str=new String(data);

获取指定索引位置的字符串：

         使用charAt()方法可将指定索引处的字符返回

         str.charAt(intindex)

         str:任意字符串

         index：整型值，用于指定要返回字符的下标

获取子字符串：

         substring(intbeginIndex,int endIndex) 从beginIndex开始，到endIndex-1

         substring(intbeginIndex) 从beginIndex开始到结束

获取字符串长度：

         length()

链接多个字符串：

         使用’+‘运算符可完成对多个字符串连接的功能。’+‘运算符可以链接多个运算符并产生一个String对象

链接其他数据类型：

         如果将字符串同这些数据类型进行连接，会将这些数据直接转换成字符串

判断字符串的开始和结尾：

         stsrtsWith()与endsWith()方法分别用于判断字符串是否以指定的内容开始或结束，这两个方法的返回值都为boolean类型

         str.startsWith(Stringprefix)

         str.endsWith(Stringsuffix)

判断字符串是否相等：

         判断字符串是否相等有equals(),equalsgnoreCase()（忽略大小写）两种方法

         重写equals()使其成为自己想要的，例如比较两个对象的ID是否相同，如相同，为同一个人

         ==只适用于基本数据类型，使用只是判断引用类型是否指向同一个对象

去除空格：

         trim()方法返回字符串的副本，忽略前导空格和尾部空格

         str.trim()

日期和时间字符串格式化：

         format()

声明字符串：

         字符串必须包含在一对” ”（双引号）之内，          

         String s=null; //此时的字符串不能使用，必须指向一个对象之后才能使用

使用正则表达式：

         Patternp =Pattern.compile(“a*b”);

         Matcherm=p.matcher(“aaaaab”);

         Booleanb=m.matches();

=Boolean b=Pattern.matches(“a*b”,”aaaaab”);

         正则表达式的限定符：？0次或1次；* 0次或多次；+ 一次或多次；{n} 正好出现n次；{n,}至少出项n次；{n,m}出现n次至m次

字符串查找：

         indexOf(Stringa):返回搜索的字符或字符串首次出现的位置

         lastIndexOf(Stringstr)：返回最后一次出现的位置

字符串分割:

split(String sign)方法：根据指定的分割符对字符串进行完全分割

split(String sign,int limit):根据给定的分割符对字符串进行拆分，并限定拆分的份数

字符串生成器：

         String是用final修饰的，不可更改，当需要大量的字符串时，定义起来比较麻烦

         Java提供了StringBuilder类

         StringBuffer类，与StringBuilder类似，多了一个线程安全的问题，

字符串替换：

         replace(charoldChar,char newChar):实现将指定的字符或字符串替换成新的字符或字符串

字母大小写转换：

         toLowerCase()方法可将字符串中的所有字符从大写字母改为小写字母

         toUpperCase()方法将字符串中的小写字母改为大写字母

遍历数组：

         for循环

         for(intx[]:arr2){

for(int e:x){

if(e==x.length){

System.out.print(e);

}else

System.out.print(e+”,”);

}

}

 

初始化一维数组：

         Intarr[]=new int[]{1,2,3,5,25};//第一种方式

         intarr2[]={34,23,12,6} //第二种

创建一维数组：

         数组作为对象允许使用new关键字进行内存分配，在使用数组之前，必须首先定义数组变量所属的类型，即声明数组

         数组元素类型 数组名字[];

         数组元素类型 [] 数组名字;

对数组进行排序：

         Array.sort(object)

         object:指进行排序的数组名称

         返回值：排序后的数组

二维数组的初始化：

         typearrayname[][]={value1,value2,……..valuen};

二维数组的创建：

         数组元素类型 数组名字[][];

         数组元素类型 [][] 数组名字;

反转排序：

         for(inti=0;i<array.length/2;i++){

temp=array[i];

array[i]=array[array.lenght-1-i];

array[array.length-1-i]=temp;

}

复制数组：

         copyOf()复制数组至指定长度

         copyOfRange()将指定数组的指定长度复制到一个新的数组中

冒泡排序：

         for(inti=1;i<array.length;i++){

for(int j=0;j<array.length-I;j++){

if(array[j]>array[j+1]){

int temp array[j];

array[j]=array[j+1];

array[j+1]=temp;

}

}

}

使用二维数组：

        

使用一维数组：

        

数组查询：

         二分查找法：首先将数组进行排序

         binarySearch(Object[].Objectkey)

         binarySearch(Object[].,intfromIndex,int toIndex,Object key)

数组概述：

         数组是具有相同数据类型的一组数据的集合，在java中同样将数组看作一个对象，虽然基本数据类型不是对象，但是由基本数据类型组成的数组则是对象

填充替换数组元素：

         Arrays类的静态方法fill()对数组的元素进行替换

直接选择排序：

         速度要比 冒泡排序快一些

         Intindex;

For(inti=1;i<array.length;i++){

Index=0;

For(int j=1;j<=array.length-I;j++){

If(array[j]>array[index]){

Index=j;

}

}

Int temp=array[array.length-i];

array[array.length-i]=array[index];

array[index]=temp;

}

This关键字：

         this可以调用成员变量和成员方法，但通常使用对象.成员变量或对象.成员方法进行调用，事实上this引用就是对一个对象的引用，this指代类的一个对象

成员变量

         对象的属性成为成员变量，成员变量对应于类对象的属性

成员方法：

         使用成员方法对应于类对象的行为

         权限修饰符 返回值类型 方法名(参数类型 参数名){

…….//方法体

return 返回值

}

对象：

         类就是封装对象的属性和行为的载体，而对象就是类的抽象出来的实例

对象的比较：

         ==：比较对象内存空间的位置

         equals():对象的内容

对象的创建：

         通过new操作符来创建对象，每实例化一个对象就会自动调用一次构造方法，实质上这个过程就是创建对象的过程，也就是使用new操作符调用构造方法创建对象

对象的销毁：

         每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址将被回收，在其他语言中需要手动回收废弃的对象，java拥有一套完整的垃圾回收机制：回收堆里面的已经没有引用的对象，去掉引用，直接将对象赋值为null

对象的引用：

         Java中真正操作标识符实质上是一个引用

         类名 对象引用名称

引用存在栈里，对象存在堆里

多态：

         多态的实现不依赖具体类，而是依赖于抽象类和接口

访问对象的属性和行为：

         使用”对象。类成员”来获取对象的属性和行为，对象的属性和行为在类中是通过类成员变量和成员方法的形式来表示的，所以当对象获取类成员，也就相应的获取了对象的属性和行为

封装：

         是面向对象的核心思想，将对象的属性和行为封装起来，而将对象的属性和行为封装起来的载体就是类，类通常对客户隐藏其实现细节

继承:

         通过继承实现子类具有父类全部属性和行为的一种功能，java只支持单继承，即只能继承一个类，不能同时继承两个类

静态变量，常量和方法：

         关键字：static，用其修饰的变量，常量等属于类

         在处理问题时会需要两个类在同一个内存区域共享一个数据

         不需要创建实例，直接使用类名就能调用其方法

局部变量：

         局部变量在方法执行时创建，在方法结束时被销毁，局部变量在使用时必须进行赋值操作或被初始化，否则会出现编译错误

         而成员变量起初就会被赋予一个初始值

局部变量的有效范围：

         又可称为变量的作用域，局部变量的有效范围从该变量的声明开始到该变量的结束为止

类：

         对象的模板，类是封装对象的属性和行为的载体，比较抽象的概念

         对象的行为是以方法的形式定义的，属性是以成员变量的形式定义的

类的构造方法：

         构造方法是一个与类同名的方法且没有返回值，对象的创建就是通过构造方法完成的，每当类实例化一个对象时，类就会自动调用构造方法

类的主方法：

         如要直接在主方法中调用其它方法，则该方法也是静态的

权限修饰符：

         public：

         private：只能在本类中使用

         protectd:同一个包内的类可以访问，子类可以访问

         没有修饰符：只有在同一个包内，其他类可以访问

Boolean:

         Boolean类将基本类型为boolean的值包装在一个对象中，一个Boolean类型的对象只包含一个类型为boolean的字段

         valueOf(Booleanb)

         valueOf(Strings)

Byte:

        

Character:

        

Double:

        

Integer:

         包装类：包装基本类型，为了基本类型和引用类型的过度，提供包装类（8种）

Number:

         抽象类Number是BigDecimal，BigInteger，Byte，Double。Float，Integer，Long和Short类的父类，Number的子类必须提供提示将表示的数值转换为byte，double，float，int，long,short的方法

BigDecimal:

         BigDecimal和BigInteger都能实现大数据的运算，不同的是BigDecimal加入了小数的概念。一般的float型和double型数据只可以用来做科学计算或工程计算，商业计算中要求数字精度比较高，所以要用到java.math. BigDecimal类，BigDecimal类支持任何精度的定点数，可以用来精确计算货币值

BigInteger:

         高精度的整数计算

Math.random()方法：

         产生随机数，默认生成大于等于0小于1.0的double型随机数

         m+(int)(Math.Random()*n)

Math类：

         提供众多数学函数方法，主要包括三角函数，指数函数。取整函数，取最大值，最小值以及平均值函数方法，都被定义为static形式。还有一些常用数学常量，如圆周率，E等

Math.数学方法

Random类：

         Randomr=new Randow();

         可以通过实例化一个Random对象创建一个随机数生成器

常用数学运算方法：

        

数字格式化：

         Java主要对浮点型数据进行格式化操作

         使用java.text.DecimalFormat格式化数字

Instanceof判断对象类型：

         当在程序执行向下转型操作时，如果父类对象不是子类对象的实例，就会发生ClassCastException异常，所以在执行向下转型之前需要养成一个良好的习惯，就是判断父类对象是否为子类对象的实例

Object类：

         是所有类的父类，是java类层中的最高层类，当创建一个类时，总是在继承，除非某个类已经指定要从其他类继承，否则就是从java.lang.Object类继承而来的，所有的类都是Object子类，所以在定义时，省略了extendsObject关键字

抽象类：

         在解决实际问题时，一般将父类定义为抽象类，需要使用这个父类进行继承与多态处理。

         关键字：abstract，不能被实例化

多态：

         通常使用方法的重载（Overloading）和重写（Overriding）实现类的多态性

方法的重载：

         在同一个类中允许同时存在一个以上的同名方法，只要这些方法的参数个数或类型不同即可（类型出现的次序不同也可以）

         publicstatic int add(int… a){ //定义不定长参数方法}

接口：

         接口是抽象类的延伸，可以将它看做是纯粹的抽象类，接口中所有的方法都没有方法体

         关键字：interface，implements

         接口可以实现多继承

类的继承：

         关键字：extends

向上转型：

         两个类之间存在继承的关系，由特殊类型到普通类型，会丢失一些信息

向下转型“

         由普通类型到特殊类型，将较抽象类转换为较具体的类，通常会出现问题，可以说子类对象总是父类的一个实例，但父类对象不一定是子类的实例。

类名冲突：

         同名类放在不同的包中

完整的类路径：

         一个完整的类名需要包名与类名的组合，任何一个类都隶属于一个类包

创建类包：

         包名一般都是小写

导入类包:

         import关键字导入类包

final变量：

         可用于声明变量，一旦变量被设定，就不可以再改变该变量的值，通常，由final定义的变量为常量

         finaldouble PI=3.14；

final方法：

         定义为final的方法不能被重写，将方法定义为final类型可以防止任何子类修改该类的定义与实现方式，同时定义为final的方法执行效率要高于final方法，一个定义为private的方法隐式被指定为final类型，这样无需将一个定义为private的方法再定义为final类型

final类：

         定义为final的类不能被继承，如果将某个类设置为final形式，则类中的所有方法都被隐式设置为final形式，但是final类中的成员变量可以被定义为final或非final形式

成员内部类：

         可以在内部类中直接存取其所在类的私有成员变量

         publicclass OuterClass{

//外部类

private class InnerClass{

// 内部类

}

}

内部类的对象实例化操作必须在外部类或外部类的非静态方法中实现

局部内部类：

         是在类的方法中定义的内部类，它的作用范围也是在这个方法体内

匿名内部类：

         不一定要给内部类取一个名字，可以直接以对象名来代替。匿名内部类的所有实现代码都需要在大括号之间进行编写

         returnnew A(){

…….//内部类体

}；

处理swing事件，事件监听器使用比较多一点

静态内部类：

         在非静态内部类中不可以声明静态成员，静态内部类最大的特点：不可以使用外部类的非静态成员。普通的内部类对象隐式的在外部保留了一个引用，指向创建它的外部类对象，但如果内部类被定义为static时，他应该具有更多的限制

         创建静态内部类的对象，不需要其外部类的对象

         不能从静态内部类的对象中访问非静态外部类的对象。

内部类的继承：

         publicclass Out extends A.B{

//继承A类的内部类B类

}

异常概述：

         在程序运行时可能出现的一些错误称为异常，异常是一个在程序执行期间发生的事件，它中断了正在执行的程序的正常指令流

错误：

         异常产生后，如果不做任何处理，程序就会终止，抛出异常，程序将停留在出现异常的位置，不再执行下面的语句

捕捉异常：

         捕获结构：trycatch finally

         try:存放可能发生异常的java语句

         catch程序块在try语句块之后，用来激发被捕获的异常；

         finally：语句块是异常处理结构的最后执行部分，无论try块中的代码如何退出，都将执行finally块，是可选的

Java常见异常：

        

自定义异常：

         继承Exception异常类

         创建自定义异常类

         在方法中通过throw关键字抛出异常对象

         如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理，否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作

         在出现异常方法的调用者中捕获并处理异常

使用throws关键字抛出异常：

         方法的声明中

使用throw关键字抛出异常：

         用于方法体中，抛出一个异常对象，程序在执行到throw语句时立即终止，它后面的语句都不执行，通过throw抛出异常后，如果想在上一级代码中来捕获并处理异常，则需要在抛出异常的方法中使用throws关键字在方法声明中指明要抛出的异常，如果要捕捉throw抛出的异常，则必须使用try-catch语句

运行时异常：

         RuntimeException异常是程序运行过程中产生的异常。Java类库中的每个包中都定义了异常类，所有这些类都是Throwabble类的子类，Throwable类派生了两个子类，分别是Exception和Error类，Error类及其子类用来描述java运行系统中的内部错误以及资源耗尽的错误，这类错误比较严重，Exception类称为非致命类性类，可以通过捕获处理使程序继续执行，Exception类又根据错误发生的原因分为RuntimeException异常和非RuntimeException之外的异常

异常的使用原则：

         不要使用过多的异常

         使用try-catch捕获异常时，要对异常作出处理

         Try-catch语句块的范围不要太大，不利于异常的分析

         一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或子异常

集合类概述：

         又被称为容器。与数组的区别是，数组的长度是固定的，集合的长度是可变的，数组用来存放基本数据类型，集合用来存放对象的引用

Collection接口：

         该接口通常不能直接使用，该接口提供了添加元素，删除元素，管理数据地方法。List接口和Set接口都继承了Collection接口

List接口：

         除包含Collection接口中的方法外，还定义了：

         get(intIndex):获得指定索引位置的元素

         set(intindex,Object obj):将集合中指定索引位置的对象修改为指定的对象

List接口的实现类：

         常用：

ArrayList：实现了可变的数组，允许所有元素，包括null，并可以根据索引位置对集合进行快速的随机访问，缺点是向指定的索引位置插入对象或删除对象的速度比较慢

LinkedList；采用链表结构保存对象，这种结构的优点是便于向集合中插入和删除对象，但对于随机访问集合中的对象，使用LinkedList类实现List集合的效率较慢

使用List集合时通常声明为List类型，可通过不同的实现来实例化集合

Set集合：

         其中的对象不按特定的方式排序，只是简单的把对象加入集合中，但Set集合中不能包含重复对象，继承Collection接口

Map接口：   

         提供了将key映射到值得对象，一个映射不能包含重复的key,每个key最多只能映射到一个值

Map接口的实现类：

         Map接口常用的实现类有HashMap和TreeMap。建议使用HashMap类实现Map集合，因为由HashMap类实现的Map集合对于添加和删除映射关系效率更高

         HashMap是基于哈希表的Map接口的实现，HashMap通过哈希码对其内部的映射关系进行快速查找，而TreeMap中的映射关系存在一定的顺序，如果希望Map集合中的对象也存在一定的顺序，应该使用TreeMap类实现Map集合

流概述：

         是一组有序的数据序列，分为输入流和输出流，I/O流提供了一条通道程序，可以使用这条通道把源中的字节序列送到目的地，虽然I/O流经常与磁盘文件存取有关，但是程序的源和目的地也可以是键盘，鼠标，内存或显示器窗口等

输入流：

         InputStream类是字节输入流的抽象类，是所有字节输入流的父类

         Reader类是字符输入流的抽象类，所有字符输入流的实现都是它的子类

输出流：

         OutputStream类是字节输出流的抽象类，是所有字节输出流的超类

         类中所有的方法均返回void

Writer类是字符输出流的抽象类，所有字符输出类的实现都是其他类的子类

文件的创建与删除：

         可以使用File类创建一个文件对象，通常使用以下3种构造方法来创建文件

         File(Stringpathname)

         File(Stringparent,String child)

         File(Filef,String child)

         createNewFile()创建文件

         delete()删除文件

获取文件信息：

                                                                                           

FileInputStream与FileOutputStream类：

         都是用来操作磁盘文件，如果用户的读取需求比较简单，则可以使用FileInputStream类

         只提供了对字节或字节数组的读取方式

FileReader类和FileWriter类：

         由于汉字在文件中占用两个字节如果使用字节流，读取不好可能会出现乱码现象，此时采用FileReader类和FileWriter类可避免这种现象

BufferedInputStream类与BufferedOutputStream类：

         带缓存的输入输出流，多了一个flush方法来将缓存区的数据强制输出完

         实现减少文件读取次数

BufferedReader类与BufferedWriter类：

         同样具有内部缓存机制，并可以以行为单位进行输入输出’   使用其Write()方法时，数据并没有立刻被写入至输出流中，而是首先进入缓存区，如果想立刻将缓存区中的数据写入输出流中，一定要调用flush()方法

数据输入输出流：

         DataInputStream类与DataOutputStream类允许应用程序以与机器无关的方式从底层输入流中读取基本java数据类型

         只提供了一个readUTF()方法返回字符串

压缩文件:

         利用ZipOutputStream类对象，可将文件压缩为“zip”文件。ZipOutputStream构造函数：

         ZipOutputStream(OutputStreamout);

解压缩ZIP文件：

         ZipInputStream类可读取ZIP压缩格式的文件

访问构造方法：

         在通过下列一组方法访问构造方法时，将返回Constructor类型的对象或数组。每个Constructor对象代表一个构造方法，利用Constructor对象可以操纵相应的构造方法

         getConstructors()

         getConstructor(Class<?>…parameterTypes)

         getDeclaredConstructors()

         getDeclaredConstructor(Class<?>…parameterTypes)

         如果是访问指定的构造方法，需要根据该构造方法的入口参数的类型来访问

访问成员变量:

         在通过下列一组方法访问成员变量时，将返回Field类型的对象或数组。每个Field对象代表一个成员变量，利用Field对象可以操纵相应的成员变量

         getFields()

         getField(Stringname)

         getDeclaredFields()

         getDeclaredField(Stringname0

访问方法：

         使用反射。

在通过下列一组方法访问方法时，将返回Method类型的对象或数组。每个Method对象代表一个方法，利用Method对象可以操纵相应的方法

         getMethods()

         getMethod(Stringname,Class<?>…parameterTypes)

         getDeclaredMethods()

         getDeclaredMethod(Stringname,Class<?>…paramertertypes)

         如果是访问指定的方法，需要根据该方法的名称和入口参数的类型来访问

定义Annotation类型：

         需要用到用来定义接口的inter发擦关键字，不过需要在interface关键字前加一个“@”符号，即定义Annotation类型的关键字为@interface，这个关键字的隐含意思是继承了java.lang.annotation.Annotation接口

         public@interface NoMemberAnnotation{

String value();//成员的定义

}

访问Annotation信息：

         在定义Annotation类型时将@Retention设置为RetentionPolicy.RUNTIME,那么在运行程序时通过反射就可以获取到相关的Annotation信息

使用枚举类型设置常量：

         publicenum Constants{

Constants_A,

Constants .B

Constants .C

}

Enum是定义枚举类型关键字，当需要在程序中使用常量时，可以使用Constants.Constants_A来表示

常量在接口里定义不能被修改

深入了解枚举类型：

         枚举类型较传统定义常量的方式，除了具有参数类型检测的优势之外，还具有其他方面的优势

         用户可以将一个枚举类型看作是一个类，它继承于java.lang.Enum类，当定义一个枚举类型时，每一个枚举类型成员都可以咯不做是枚举类型的一个实例，这些枚举类型成员都默认被final，public，static所修饰，所以当使用枚举类型成员时直接使用枚举类型名称调用枚举类型成员即可

         枚举类型可以定义接口

使用枚举类型的优势：

         类型安全

         紧凑有效的数据定义

         可以和程序其他部分完美交互

         运行效率高

定义泛型类:

         设计程序时通常使用传入的值与返回的值都以Object类型为主。当需要使用这些实例时，必须正确的将该实例转换为原来的类型，否则在运行时将会发生ClassCastException异常。JDK1.5版本以后，提出了泛型机制

         类名<T>

         T代表一个类型的名称

         通过这种方式可以将类设置为支持泛型的类

泛型的常规方法：

         定义泛型类时声明多个类型

         定义泛型类时声明数组类型

         集合类声明容器的元素

泛型的高级用法:

         限制泛型可用类型：<Textends List> T的类型只能是List类的子类

         使用类型通配符：<?>可以使用？来表示通配符

         继承泛型类与是信啊泛型接口

         Interface|<T1>{}

         ClassSubClass<T1,T2,T3>implements i<T1>{}

泛型总结：

         泛型的参数只能是类类型，不可以是简单类型

         泛型的类型个数可以有多个

         可以使用extends关键字限制泛型的类型

         可以使用通配符限制泛型的类型

线程简介：

        

继承Thread类：  

         程序员启动一个新线程需要建立Thread实例

实现Runnable接口：

         如果程序员需要继承其他类并使该程序可以使用线程，就需要使用Runnable接口

         publicclass Thread extends Object implements Runnable

线程的生命周期：

         包含7种状态：出生状态，就绪状态，运行状态，等待状态，休眠状态，阻塞状态和死亡状态

线程的休眠：

         sleep(休眠时间)

线程的加入：

         join(),另一个线程等待刚加入进去的线程结束后，才能继续执行

线程的中断：

         stop()废除了

         现在提倡在run()方法中使用无限循环的形式，然后使用一个布尔型标记控制循环的停止

线程的礼让：

         yield()对于支持多任务的操作系统来说，不需要调用yeild()方法，因为操作系统会为线程自动分配CPU时间片来执行

线程的优先级：

         Thread.MIN_PRIORITY(常数1)

         Thread.MAX_PRIORITY(常数10)

         Thread.NORM_PRIORITY(常数5):默认情况下

         每个新线程都继承了父线程的优先级

线程安全：

         与进程相比，线程可共享资源

         来源于多个线程同时存取单一对象的数据

线程同步机制：

         同步块：synchronized(“”)

         同步方法: synchronized修饰方法

UDP网络程序：

         广播数据报程序

DatagramSocket:

         用于发送和接受数据报的套接字

         构造方法：DatagramSocket()：创建DatagramSocket对象，构造数据报套接字并将其绑定到本地主机上任何可用的端口。

                                     DatagramSocket(intport)：绑定到本地主机上的指定端口，常用

                                     DatagramSocket(intport,InetAddress addr)：绑定到指定的本地地址，适用于有多块网卡和多个IP的情况

DatagramPacket::

         表示数据报

网络协议：

         IP协议

         TCP与UDP协议

局域网与因特网：

         WANLAN

端口与套接字：

         一台计算机只有单一的链接到网络的物理连接

         Socket用于将应用程序与端口的链接

TCP网络程序：

        

ServerSocket类：

         用来表示服务器套接字，主要功能是等待来自网络上的请求，可以通过指定的端口来等待链接的套接字，服务器套接字一次可以与一个套接字链接

InetAddress类：

         与IP地址相关的类，利用该类可以获取IP地址，主机地址等信息

SQL语言：

         结构化查询语言

         数据定义语言：表格

         数据操纵语言：数据

         数据控制语言：授权

         事务控制语言：事务

什么是数据库：

         一种存储结构

         特点：实现数据共享

                   减少数据的冗余度

                   数据的独立性

                   数据实现集中控制

                   数据的一致性和可维护性，以确保数据的安全性和 可靠性

         由文件系统发展出来的

数据库的种类及功能：

         基于数据模型：层次型，网状型，关系型及面向对象型

         层次数据库：淘汰了

         网状数据库

         面向对象数据库

         关系数据库：重点，最流行的

JDBC-ODBC桥：

         JDBC驱动程序，完成了从JDBC操作到ODBC操作之间的转换工作，允许JDBC驱动程序被用作ODBC的驱动程序，使用JDBC-ODBC桥连接数据库的步骤如下：

         1首先加载JDBC-ODBC桥的驱动程序

         2使用java.sql包中的Connection接口，并通过DriveManager类的静态方法getConnection()创建链接对象

         3向数据库发送SQL语句

JDBC技术：

         面向对象的应用程序接口，指定了统一的访问各种类型关系数据库的标准接口，JDBC是一种底层的API

         与数据库建立一个链接

         向数据库发送SQL语句

         处理从数据库返回的结果

         JDBC不能直接访问数据库，必须依赖于数据库厂商提供的JDBC驱动

JDBC驱动程序的类型：

         总体结构：4个组件

                   应用程序，驱动程序管理器，驱动程序和数据源组成

         JDBC驱动基本分为以下四种：JDBC-ODBC桥

                                                                           本地API-部分用java编写的驱动程序

                                                                           JDBC网络驱动

                                                                           本地协议驱动

Connection接口：

         代表与特定的数据库的链接

DriverManager类：

         用来管理数据库中的所有驱动程序，是JDBC的管理层，作用于用户和去驱动之间，跟踪可用的驱动程序，并在数据库的驱动程序之间建立连接，也处理诸如驱动程序登录时间限制及登录和跟踪信息的显示等事务，方法都是静态方法，在程序中无需进行实例化，直接通过类名就可以调用

PreparedStatement接口：

         继承了Statement接口，用于执行动态的SQL语句

ResultSet接口：

         封装结果集，类似于一个临时表。用来暂时存放数据库查询操作所获得的结果集

Statement接口：

         用于创建向数据库中传递SQL语句的对象，该接口提供了一些方法可以实现对数据库的常用操作

处理查询结果集：

         ResultSet

连接数据库：

        

模糊查询：

         LIKE操作符用于模糊查询，可使用“%”来代替0个或多个字符，使用下划线“_”来代替一个字符。例：查询一个型姓张的同学的信息

         select*from tb_stu where name like ‘张%’

顺序查询：

         ResultSet类的next()方法的返回值是boolean类型的数据，当游标移动到最后一行之后会返回false，下面的实例就是将数据表tb_emp的全部信息显示在控制台上

         sql=con.createStatement();

         res=sql.executeQuery(“select* from tb_emp”);

         while(res.next()){

String id =res.getString(“id”);

…….

}

添加、修改、删除记录：

         sql=con.prepareStatement(“insert into tb_emp values(?,?,?)”);

sql =con.prepareStatement(“updatetb_stu set birthday”+”=?where id=(select min(id) from tb_emp)”);

sql =con.prepareStatement(“deletefrom tb_emp where id=”+”(select min(id)from tb_emp)”);

向数据库发送SQL语句：

         要执行SQL语句首先要获得Statement类对象，通过创建的连接数据库对象con的createStatement()方法获得Statement对象

预处理语句：

         prepareStatement()

打印控制类：

         PrinterJob类是控制打印的主要类，抽象类，不能实例化对象

         获取PrinterJob对象

         打印任务的名称属性

         设置打印页面

         获取打印用户

         打印状态

“打印”对话框：

         boolean=ok=job.printDialog();

         job是PrinterJob类的实例对象

打印页面：

         必须实现Printable接口

多页打印：

         Book类：append()

打印预览

         Printer接口：print()方法