JAVA基础总结

类：是一个概念、是一个模型，是一组具有相同属性和行为的对象的抽象

对象：对象是类的一个实体，是实实在在的看得见、摸得着的一个实例。

定义一个类的步骤

对象的实例化：

类名对象名=new 类名（）；

对象名.属性1=值1；

对象名.方法()；

基本数据类型和引用数据类型的区别

**基本数据类型通过变量名访问到的就是变量标识的内存数据*-*

**引用数据类型通过标识的名称访问到的是所引用的对象的地/址；**

通过   标识符名.属性    来访问对象的属性

通过   标识名.方法()    的形式来调用对象的方法

成员变量：

定义在类的内部，该类的所有方法都可以访问，系统会为成员变量自动根据数据类型赋初值

局部变量：

定义在方法内部，或方法内的每个代码块儿里，局部变量只能定义它的方法或代码块儿访问。

并且系统不会自动为局部变量赋初值，因此在使用之前必须要为局部变量赋初值

方法的定义:

1.无参方法

访问修饰符返回值类型 方法的名字(){

//方法体

}

带有返回值的方法在调用的时候通常可以放在一个赋值表达式中，或者一个输出语句中。

带有返回值的方法，在方法中要有和返回值类型相匹配的的返回值结果。

不带返回值的方法在调用时通常都是一个独立的调用语句，因为没有返回值，

所以不能对结果进行赋值在方法体中，如果要使用return，

则return语句后什么也不跟。

2.带参方法的定义

访问修饰符  返回值类型 方法名(数据类型 参数1，数据类型 参数2。。。。){

   //方法体

}

*****

在调用带有参数的方法时，方法调用处的参数称为实际参数。需要携带实际值。方法定义时的参数称为形式参数，主要限定参数的类型、个数、顺序。实际参数的类型，个数和顺序要和形式参数一一对应。当方法的参数是一个对象类型的数组时，要注意实际参数数组的创建，以及数组中每一个元素实例化，否则程序执行过程中有可能引发空指针异常。

 

为什么使用包：

为了对项目中的类进行分门别类的管理，避免同名类的命名冲突，对类中的属性和方法进行保护，增加安全性。

如何创建包：

在 eclipse 中有两种方式

a。右键--新建--package

b. 右键--新建--类--设置类名和包名

通过语句打包；

package包名

包的命名

构成包的名字的左右标识符都要小写.包名可以互相嵌套。通常是组织的倒置的域名加其他

如：

com.tarena.android.karen

导包：

当前类如果要使用非当前包中其它类。需要导入即可以导入系统包中的类，也可以导入自定义包中的类。

如：

import java.util.Scanner;

import grahpics.Shape;

 

构造方法

与类同名 无任何返回值类型（连void也没有），在创建一个类的对象时调用。当我们定义了一个类,没有为其显示定义任何构造方法时，该类被加载的时候，系统会为其创建一个隐式无参构造方法。

 

构造方法的重载

在一个类中可以定义多个构造方法。这些构造方法需要有不同的参数列表，参数的个数不同，或数据类型不同,这样的多个构造方法形成重载；

方法的重载

方法重载是事物多样性的一种体现手法；在一个类中可以有多个名称相同的方法，但是这些方法具有不同的参数类型列表，这样的几个方法形成重载，仅有返回值类型不同时，无法构成重载。

封装

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

在eclipse里封装的的快捷键

alt+shift+s—〉Select getters andsetters to create;

 

封装的好处：

隐藏事物的实现细节，限制外部的访问方式，降低用户的使用难度。

this关键字的使用；

指带当前类的对象的引用

当前的一个成员方法去调用另一个成员方法的时候可以通过this.方法名（）。

 

区别局部变量和成员变量，

当局部变量和成员变量同名时。this.变量名：访问的是本类的成员变量

本类的一个构造方法调用类的另一个构造方法时用：this();

例如：

  name-->局部变量

  this.name-->成员变量

 

继承：

1.子类继承父类中所有非私有的属性和方法，子类是无法继承父类的构造方法的。

2.子类只能有一个直接的父类（java只支持单继承）

3.在继承关系中当一个子类继承了一个父类。创建一个子类对象时会默认先创建一个父类对象，在创建一个子类对象

4.如果一个父类没有定义无参构造方法，那么可以在子类构造方法中显式的指明调用父类的哪一个带参构造方法，否则会报语法错误，

5.在子类中可以通过关键字super调用父类的方法，属性和构造方法。

 

***

访问修饰符

private（私有的）：所修饰的属性和方法只在本类中可见；

默认访问修饰符：所修饰的属性和方法在当前包中子类和非子类都可见，在不同包中都不可见

protected（受保护的）：所修饰的属性和方法在当前包中子类和非子类都可见。不同包中只有子类可见

public（共有的）：是可见度最大的，无论是否在一个包中，子类和非子类都可见。

访问修饰符

本类

同包

子类          

其他

private

√

   

默认(friendly)

√

√

  

protected

√

√

√

 

public

√

√

√

√

 

快捷键

ctrl：-->跳转调用的方法

shift+alt+z-->选择语句（if、while、switch）

在继承关系里子类创建过程：先初始化父类的属性，在调用父类的构造方法，再初始化子类属性，最后调用子类的构造方法。子类对象创建完成。

方法的重写：

在子类中如果拥有和父类签名完全相同的方法（访问修饰符要大于等于父类方法的访问修饰符），那么子类的方法会完全覆盖父类的方法，叫做方法的重写，构造方法不能被继承，所以也不可以被重写

 

抽象类：

当父类没必要被实例化的时候，仅是一个抽象的概念，我们可以把父类定义成抽象类，

抽象类中可以通过定义抽象方法来约束子类的行为（如果一个类中有一个方法是抽象的，那么它所在的类一定要被定义成抽象类）；当一个子类继承一个抽象的父类时，该子类必须要实现从父类那里继承过来的抽象方法，否则该子类也要定义成抽象的

 

 

 

多态

1.里氏替换原则：

在继承关系中一个子类继承父类，只要父类对象出现的地方都可以被子类替换，替换后，父类引用可以调用到的是子类从父类那里继承过来的属性和方法，如果子类对父类方法进行了重写，那么也可以调用到重写后的方法。但是不能调用子类特有的属性和方法

2.多态：

同一个父类，不同的子类对象对同一个指令的相应过程不一样。称为多态。

实现方式：

1)通过继承父类，实现抽象方法，通过里氏替换原则，把方法的参数类型设定为父类类型，

在进行方法调用的时候可以传进来不同子类对象作为方法的实参。从而实现多态。

 

****

3.方法重写（override）和方法重载（overload）

方法重写：是以继承为基础，子类继承父类之后，子类中拥有和父类签名完全相同（方法的名字，方法的参数列表，方法的返回值类型和父类中的某方法相同，访问修饰符要大于等于父类方法的访问修饰符）的方法，该方法实现对父类方法的重写.构造方法不能被继承，所以也不可以被重写

 

方法的重载：是指在同一个类中具有多个同名的方法，而这些同名方法又具有不同的参数列表（方法的参数个数，或类型不同，仅返回值类型不同无法构成重载）。那么我们说这些同名方法实现了重载。

 

静态和final

static:修改的变量只在类加载时分配一次存储空间，它属于该类的所有对象共享的一个储存区域，不属于类的某个对象所独有，所以在访问静态变量时，通常不需要实例化对象，通过类直接访问即可，所以也是类变量。

 

在静态方法中只能访问静态字段和静态的方法，而不能直接访问非静态的变量和非静态的方法，因为它的加载时机要早于非静态的变量和方法。

 

非静态方法（成员方法）可以访问类变量和类方法。

在静态方法中不可以使用this和super关键字进行变量和方法的访问。

 

final（最终的）:修饰的变量不可以被重新赋值，称为常量

接口：

接口是能力和行为的约定，它只提供约定，而不做任何实现，接口所有的方法都是抽象的，接口里面可以有静态的常量，而不能有变量以及构造方法，一个类可以同一个直接的父类，但是可以同时实现多个接口，如果一个类实现一个接口，就必须实现该接口中所有的方法，如果有一个方法没有实现，那么这个类就要定义成抽象类。

面向接口的编程可以更自然的去实现多态，提高程序后期的可维护性和可扩展性。

 

接口和抽象类的区别？

接口中所有的方法都是抽象的，并且不允许有构造方法以及成员变量，但是抽象类可以有构造方法、成员变量，除了抽象方法，还可以有已经实现的非抽象方法。接口允许多继承，但是抽象类不支持。

 

相同点是接口和抽象类都不允许实例化，都可以通过抽象方法约束子类的行为。

通过继承类和实现接口都可以实现多态。

== 和 equals（）

在对两个引用类型做比较的时候，前者比较的是两个引用的地址是不是相同，即他们两个是否引用了同一个对象，后着比较的是两个引用指向的对象保存的数据是否相同。

 

方法调用传参时，如果参数类型是基本数据类型（int，char，float、double，boolean、byte

、long、short）也叫值类型，那么是把实际参数的值复制一份传给形式参数，形参和实参拥有独立的存储空间，    ****对形参的修改不会影响到实际参数。****

 

如果参数的类型是引用类型，那么是把引用的地址传递给形参。形参和实参引用同一块存储区域，****对形参的修改将直接影响到实际参数****

 

引用数据类型：

类、数组、接口、String

内部类

**1.非静态内部类

属于外部类的一个成员，如果想要在外部类的外部去创建内部类的对象时，

用以下的语法

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

inner.print();

在内部类中要访问外部类的同名属性时可以通过以下语法：

外部类.this.属性。

在非静态内部类当中不可以有静态类成员（属性，方法，代码块）

2.静态内部类

该类被static修饰，作为外部类的静态成员，在静态内部类中不能访问

外部类的所有非静态类成员。但是可以访问外部类中的静态成员。

在外部类的外部，如果要创建外部类的静态内部类的对象，语法如下：

Outer2.Inner inner=new Outer2.Inner();

inner.print2();

3.局部内部类

定义在方法内的类，称为局部内部类，在局部内部类中如果要访问方法的局部变量时，

这个变量要被定义成一个常量（要用final（常量）来修饰）。

**4.匿名内部类

当某一个类定义出来之后，只在定义时使用一次，我们就把该定义成匿名类。

在实例化匿名类对象时，可以借助于其父类或父接口的名字。它如果要引用所在

方法的局部变量时和局部内部类的规则一样，被引用的局部变量都要定义成常量。

简单工厂设计模式(simplefactory)

把对象的创建交给工厂，而不是由用户自己直接生产（直接实例化）。

简单工厂的组成：

1.抽象产品父类；

2.具体产品子类；

3.工厂类；

String

String是一个final类，直接父类为 Object，String是常量；它们的值在创建之后不能更改。

字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。

length()返回值类型为int，表示字符串的长度  标识符.length（）。

equals（）当被比较的字符串和原字符串的每一个对应的字符都相等，返回值为真

（比较时区分大小写）

 

== 和 equals（）

在对两个引用类型做比较的时候，前者比较的是两个引用的地址是不是相同，

（即他们两个是否引用了同一个对象），是返回真，不是返回假。

后着比较的是两个引用指向的对象保存的数据是否相同。是返回真，不是返回假。

 

valueOf(参数)：

将指定参数转换成一个字符串对象；

concat（参数）：

把原字符串和参数字符串连接成一个新的字符串；

indexOf（参数）：

返回找到的指定参数字符，在字符串中第一次出现的索引（存在的话返回值大于等于0），

如果不存在，返回值为-1；

lastIndexOf（参数）：

返回找到的指定参数字符，在字符串中最后一次出现的索引（存在的话返回值大于等于0），

如果不存在，返回值为-1；

subString（beginIndex）：

从指定搜索位置开始到整个字符串结束的内容，返回从指定索引位置开始，到字符串结束的所有字符；

subString（beginIndex ，endIndex）：

从指定搜索位置（beginIndex）开始到指定位置（endIndex）-1的内容，返回从指定索引位置开始，

到指定字符串位置的所有字符；

split（参数）：

将字符串按照指定的参数作为分隔符，对字符串进行分割，返回值是一个字符串数组

charAt（参数）：

返回字符串中指定索引位置的字符。

endWit（参数）：

判断该字符串是否以指定参数作为结尾。

getBytes（）：

返回当前字符串的一个字节数组表示。

StringBuffer类和String类的区别：

String类创建的字符串对象具有不变性

StringBuffer类创建的字符串对象，会在内存中分配一个缓冲区，

当我们要对其构建的字符串对象添加字符的时候，会在缓冲区中进行字符的追加。

如果我们要对字符串做一些频繁的修改时，使用StringBuffer会比较节约内存

StringBuffer类和StringBuilder类的区别

StringBuffer实现了线程的同步，在多线程模式下，推荐使用StringBuffer；

StringBuilder类没有实现线程同步，在单线程模式下，推荐使用StringBuilder。

 

常用类：

Math：

max（参数1，参数2）获取最大值；

min（参数1，参数2）获取最小值；

ceil（参数）返回不小于参数的最小整数；

floor（参数）返回不大于参数的最大整数；

random（）返回一个0到1的但不包含1的一个双精度随机数；

round（）返回一个四舍五入的精度为0的双精度数；

bow（n，m）返回一个n的m次幂；

sqrt（n）返回你的平方根；

Random：

setSeed（参数）：

可以指定生成随机数种子，如果随机数种子相同，则生成的每一组随机数是相同的

如果想通过种子来控制随机数的不同，可以使用系统时间作为随机种子；

Arrays：

提供了对数组操作的各种方法。

binarySearch() 按照二分查找算法在一个以排好序的数组进行指定元素的检索，

如果存在返回索引，不存在返回-1

sort（参数）可以对所有的基本数据类型进行直接的升序排序。如果要对自定义的

引用类型进行排序，需要该类型实现compareable接口，或者为这种自定义类型编写

专用的comparator比较器。

System

gc()试图让垃圾回收器进行垃圾的回收，但垃圾回收器会有一套自己的算法，不一定每次能

确保gc（）的时候就会回收垃圾。一但执行了垃圾回收机制，那么就会去回调被当做垃圾回收的

对象的finallize（），所以我们可以在该方法中去处理一些对象销毁前的操作。

runFinallization()该方法会强制调用被回收对象的finallize（）方法。

currentTimeMillions（）获取当前系统时间以从1970年1月1日到当前系统时间的一个长整形的毫秒数

exit（）可退出当前系统。

 

Calender：日历方法

getInstance（）是一个工厂方法，返回一个日历对象的实例

set（）方法组，用来设置日历对象的各个字段

get（）方法组，用来获得日历对象的各个字段

getTime（）方法用来将日历对象转换成日期（Date）对象；

setTime（）方法用来将日历对象设置成该日期对象；

getTimeInMillis（）以长整型的毫秒为单位返回日历对象的信息

 

 

Date

根据构造方法来构造日期对象，其大多数方法已经过时，可以被日历的方法所替换

getTime（）以长整型的毫秒为单位返回日历对象的信息

SimpleDateFormat

format（）可以将一个日期对象以指定的格式格式化后以字符串方式返回；

parse（）可以将一个日期格式的字符串，解析成一个Date对象。

 

正则表达式：

正则表达式是有字符和元字符组成的字符串作为字符串的验证规则存在

正则表达式的使用两种方式：

String的matches（）方法，直接将字符串对象与正则表达式进行模式匹配，匹配上则返回真，

否则返回假。

使用Pattern和Matcher类

Pattrern的compile（）方法创建模式对象

Pattrern的matcher（）方法生成匹配器

（Matcher类的对象）

在由Matcher的matche（）方法进行模式匹配，匹配成功返回真，否则返回假

常用正则表达式的元字符：

异常：

程序在运行过程中发生的不正常事件，导致程序运行的中断。

try{

}catch（异常类型 参数）{

}

try块是用来监控可能发生异常的代码

catch块是用来捕获发生的异常

当try块中没有异常发生的时候，catch块不会启动，程序会正常执行try块内的代码，

及try--catch块之后的其他代码

当try块中的异常发生的时候，如果产生的异常类型和catch块捕获的异常相匹配，

那么会启动catch捕获异常程序执行，如果异常的类型和捕获的类型不匹配。

则无法捕获异常，程序会在异常发生处中断。

try{

}catch（异常类型 参数）{

}finally{

}块：

无论有没有异常发生，都必须要执行的操作，放在该语句块中。

如果有异常发生，并且异常被catch捕获了，在catch块中有system。exit（1）语句

退出程序，这时finally将不能执行。

多重catch块的使用：

为了可以捕获try块中发生的多种类型的异常，可以使用多重catch块，用来捕获不同类型的异常，

多重catch顺序是先特殊后一般，即先子类后父类。

 

 

throws关键字

放在方法定义的地方，用来声明该方法有可能会引发的异常，而方法本身不对异常处理。谁调用，

谁对方法可能引发的异常做处理。

throw关键字

真正的去引发一个异常，当程序中有一些不合理操作发生时，我们可以使用throw来由程序员

通过代码去引发一个异常，该异常也会被捕获。

集合

List集合（不唯一，有序的）

ArrayList（List）：

是一个长度可以动态的改变的一个动态数组。

在对集合元素进行遍历的时候和随机访问元素的效率比较高。

add（Object 0）增加

add（int a  Object 0）在a增加

remove（Object）删除

clear（）清空

LinkedList（List）：

采用链表存储空间（前一个元素末尾会保留下一个元素的地址，元素储存位置并不是连续的）

当我们要对集合元素进行频繁插入，删除、更新头尾元素的操作的时候时，效率比ArrayList高。

如果对数据要进行频繁的遍历操作时，可以选择ArrayList。

add（Object 0）增加

add（int a  Object 0）在a增加

remove（Object）删除

clear（）清空

Set集合(唯一，无序的)

集合的增加

         Setnumber=new HashSet() ;

         number.add(newInteger(100));

                 .

                  .               

         number.add(newInteger(500));//增加

         for(Object object : number) {//逐个打印

             Integer integer=(Integer)object;

             System.out.println("集合的元素"+object);

         }

Iterator 迭代器集合（对集合进行打印）

通过集合对象获得他们的迭代器，通过While循环来控制集合元素的迭代

 

例如                Iterator  iterator=number.iterator();//替代set的for循环

                     while (iterator.hasNext()){  //判断是否有下一个指针

                    Integer integer=(Integer)iterator.next();

                   System.out.println(integer);

                    }

 

          泛型类  Iterator<Student> iterator=number.iterator<Student>();//替代set的for循环

                     while (iterator.hasNext()){  //判断是否有下一个指针

                    Student integer=iterator.next();

                   System.out.println(integer);

                    }

 

Map集合

1.唯一，无序的；

2.长度动态可维护；

3.可通过关键字检索。

 

Map集合的实现类HashMap

元素的内存在存储方式是以键（key）值（value）对的方式存放的。

containsValue(Object value)

         如果此映射将一个或多个键映射到指定值，则返回 true。

put(K key, V value)

         在此映射中关联指定值与指定键--存储。

remove(Object key)

     从此映射中移除指定键的映射关系（如果存在）--移除。

ketSet

    返回此映射中所包含的键的Set 视图

通常不会对Map结构的集合进行遍历操作，如果想去进行所有元素的查看可以先拿键集，

在根据键获得值

例如：          SetkeySet=student.keySet();

                   for(Object object : keySet) {

                            Stringid2=(String)object;

                   Studentst1=    (Student)student.get(id2);

                   System.out.println("姓名:" +st1.getName() + "\t学号：" + st1.getId()

                                     + "\t年龄：" +st1.getAge());

                   }

 

Vector和ArrayList区别

Vector实现了线程同步，在多线程模式下，可以选择使用Vector，保证数据的一致。

ArrayList没有实现线程同步，单线程模式下使用速度高，

 

HashTable和HashMap区别

HashTable实现了线程同步，在多线程模式下，可以选择使用Vector，保证数据的一致。

HashMap没有实现线程同步，单线程模式下使用速度高，

 

泛型集合

java的集合框架是支持泛型的，通过设置集合的泛型实参可以控制集合中添加的元素的数据类型，

一但在创建集合对象的时候，限定了泛型实参，集合中所添加的元素的类型就确定了，这样的话，

把元素添加到集合里的时候就不用在做装箱操作，获取元素时，也不在所拆箱操作，避免的类型

转换的异常。

泛型类：

在定义类的时候，可以通过泛型形参限定类所操作的数据类型，称为泛型类。

泛型通配符：

?作为泛型泛型通配符，可以限定方法的参数，支持某泛型类型。

泛型上限：? extends 类（接口）来限定泛型的上限，泛型实参的类型只能是指定的类的及其子类类型。

泛型下限：? super   类（接口） 来限定泛型的下限，泛型实参的类型只能是指定的类的及其父类类型。

递归：

使用的是数学当中的递推的思想，也叫降阶。实现的方式是在方法自己调用自己，在递归的方法中

必须有条件语句用来结束递归，否则会导致死循环，所有的递归都可以用循环替换，反之亦然。

IO流：

IN(input/output)

分类：根据数据的流向可以分为输入流（读的操作）和输出流（写的操作），流的方向

区分是以内存为参考。

根据对流的操作方式可以分为：字节（一个字节一个字节操作）流和字符流（一个字符一个字符操作）。

File类（文件或文件夹）

是一个文件或文件夹的一个抽象，提供了对文件和文件夹进行操作的各种方法

文件和目录路径名的抽象表示形式

boolean createNewFile()

     当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。

File.separator  //（相当于文件分隔符：\\）

file.exists();//判断文件或文件夹是否存在

file.delete();//删除文件及空的文件夹

file.isFile()//判断是否是文件

file1.isDirectory()//判断是不是一个文件夹

file.getName（）//获得文件或文件夹的名字

file.createNewFile();//创建一个文件

file1.mkdir();//创建文件夹

file1.mkdirs();//创建文件夹及其父目录

file.length()//文件长度

file.lastModified()//文件最后更新时间

file.list（）返回文件夹或文件的列表

file.isFile（）以File对象数组的方式返回子文件或文件夹

String[] lists=file1.list();

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

System.out.println(lists[i]);                                          

}//文件中子文件（以字符串格式输出）

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

 System.out.println(files[i].getName());

}//文件中子文件的名字（带路径目的所有文件）

 

File file=new File("e:"+File.separator+"test.txt");

                            file.createNewFile();//在e盘创建一个test.txt文件

// 查看文件夹内所有文件

public class TestFile1 {

        

         publicstatic void main(String[] args) {

                   Filefile1 = new File("e:" + File.separator + "java基础");

                   showFiles(file1);

         }

 

         privatestatic void showFiles(File file1) {

                   if(file1.isDirectory()) {

                            //c查看该文件夹的子文件列表；

                            File[]files = file1.listFiles();

                            if(files != null) {

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

                                               showFiles(files[i]);

                                     }

                            }

                   }else {

                            System.out.println(file1);

                   }

         }

 

}

 

//创建一个文件夹

         publicstatic void main(String[] args) {

                   Filefile=newFile("e:"+File.separator+"ooooo"+File.separator+"kkkkkk");

                   if(!file.exists()) {

                            file.mkdirs();//只是创建一层用file.mkdir();

                            System.out.println("创建文件夹成功");

                   }

         }

}

输入和输出流

InputStream：--所有字节输入流祖先

OutputStream：--所有字节输出流祖先

Reader：--所有字符输入流祖先

Writer：--所有字符输出流祖先

步骤如下：

1.先找到一个要操作的资源。可能是文件，也可能是文件夹

2.根据字节流和字符流的子类，决定输入和输出的位置

3.进行读或写的操作

4.关闭

FileInputStream（extends InputStream）：

字节输入流，通过read（）方法实现以字节的方式对文件进行读取的操作。

FileOutputStream（extends OutputStream）：

字节输出流，通过write（）方法实现以字节的方式对文件进行写的操作。

//创建一个文件，并把内容写进去（输出流）

         publicstatic void main(String[] args) {

 

                   OutputStreamoutputStream = null;

                   try{

                            outputStream= new FileOutputStream("e:" + File.separator

                                               +"Hello.txt");

                   }catch (FileNotFoundException e) {

                            e.printStackTrace();

                   }

                   Strings = "Hello,Word";

                   s.getBytes();

                   byteb[] = s.getBytes();

                   //如果输出流关联的文件不存在

                   //在执行流的输出（写文件）之前先创建文件在写文件

                   try{

                            outputStream.write(b);

                            System.out.println("文件创建成功");

                   }catch (IOException e) {

                            e.printStackTrace();

                }finally{

                            if(outputStream!=null){

                                     try{

                                               outputStream.close();

                                     }catch (IOException e) {

                                      e.printStackTrace();

                                     }

                   }

         }

//调用文件中内容（文件的输入流）

public static void main(String[] args) {

                   InputStreaminputStream = null;

                   Filefile = new File("e:" + File.separator + "Hello.txt");

                   if(file.exists()) {

                            try{

                                     inputStream= new FileInputStream(file);

                            }catch (FileNotFoundException e) {

                                     //TODO Auto-generated catch block

                                     e.printStackTrace();

                            }

                            //构建一个数组，该数组用来存放读的数据

                            intlength = (int) file.length();

                            byte[]b = new byte[length];

                            try{

                                     inputStream.read(b);

                            }catch (IOException e) {

                                     e.printStackTrace();

                            }finally {

                                     if (inputStream != null) {

                                               try{

                                                        inputStream.close();

                                               }catch (IOException e) {

                                                        e.printStackTrace();

                                               }

                                     }

                            }

                            System.out.println(newString(b));

                   }else {

                            System.out.println("你所读取的文件不存在");

                   }

         }

写入字符流Writer

所有写入字符流的祖先

abstract void close() 关闭此流，但要先刷新它。

 voidwrite(char[] cbuf) 写入字符数组。     

abstract void  write(char[] cbuf, int off,int len)    写入字符数组的某一部分。

 void    write(int c)           写入单个字符

 void    write(String str)          写入字符串。

 void    write(String str, int off, int len)  写入字符串的某一部分。

abstract void flush()  刷新该流的缓冲。

 

 

//文件的写入

public static void main(String[] args) {

                   //声明字符输出流

                   Writerwriter = null;

                   //操作的文件的路径

                   Stringpath = "e:" + File.separator + "test.txt";

                   try{

                            writer= new FileWriter(path);

                            Strings = "hello hello hello !!!";

                            writer.write(s);

                            System.out.println("文件写入成功！！");

                   }catch (IOException e) {

                            e.printStackTrace();

                   }finally {

                            if(writer != null) {

                                     try{

                                               writer.close();

                                     }catch (IOException e) {

                                               e.printStackTrace();

                                     }

                            }

                   }

         }

 

FileWriter

Writer 的子类

读取字符流Reader

所有读取字符流的祖先

abstract void close()  关闭该流并释放与之关联的所有资源。

 intread()    读取单个字符。

 intread(char[] cbuf)    将字符读入数组。

abstract int read(char[] cbuf, int off, int len)    将字符读入数组的某一部分。

 intread(CharBuffer target)    试图将字符读入指定的字符缓冲区。

 boolean ready()    判断是否准备读取此流。

 voidreset()      重置该流。

 longskip(long n)     跳过字符。

//文件的读取

public static void main(String[] args) {

                   Readerreader = null;

                   Filefile = new File("e:" + File.separator + "test.txt");

                   if(file.exists()) {

                            try{

                                     reader= new FileReader(file);

                                     char[]b = new char[1024];

                                               reader.read(b);

                                               Stringstring = new String(b);

                                               System.out.println(string);

                                               System.out.println("读取成功");

                            }catch (Exception e) {

                                     e.printStackTrace();

                            }finally {

                                     if(reader != null) {

                                               try{

                                                        reader.close();

                                               }catch (IOException e) {

                                                        e.printStackTrace();

                                               }

                                     }

                            }

                   }else {

                            System.out.println("要读取的内容不存在");

                   }

         }

 

 

FileReader

 Reader的子类

字节流和字符流的区别：

1.两者的操作形式一样，功能也一样；

2.区别：字节流没有使用到缓冲区，而是直接操作输出的，

而字符流是使用缓冲区，操作缓冲区的输出

除了处理文本文件，其他都用字节流操作。

FileReader （extends Reader ）

是以字符为单位来读取文件，

FileWiter（extends Witer ）

是以字符为单位来写文件，

他们都比较擅长对字符文件进行操作，如果文件的存储方式是以字符方式存储的，推荐使用这两个类

BufferedInputStream

在FileInputStream之上添加一个缓冲区，如果要操作的二进制文件比较大，使用

BufferedInputStream读取效率比较高。

BufferedOutputStream

在FileOutputStream之上添加一个缓冲区，如果要写的数据比较多，使用

BufferedOutputStream效率比较高。

BufferedReader

对FileReader进行了装饰，在FileReader字符流基础上添加了缓冲区，在读取的字符文件比较大时

不需要自行设计缓冲区，默认添加了缓冲大小为（8k），也可以在创建对象时自行设计缓冲区大小。

BufferedWriter

对FileWriter进行了装饰，在FileWriter字符流基础上添加了缓冲区，在写的字符文件的时候，

会先把写入的内容写在缓冲区，在刷新发哦磁盘中，提高了写入的效率。

OutoutStreamWriter

将字符输出流转换为字节输出流

InputStreamReader

将字节输入流转换成字符输入流

//键盘输入输出的字节，字符流转换

public static void main(String[] args) {

                   //字节流向字符流的转换

                   InputStreaminputStream = System.in;

                   //将键盘的这个字节输入流转换成一个字符流；

                   InputStreamReaderreader = new InputStreamReader(inputStream);

                   //将字符流包装成带有缓冲区的输入流。

                   BufferedReaderbufferedReader = new BufferedReader(reader);

                   PrintStreamprintStream = System.out;

                   //将字节输出流转换成字符输出流

                   OutputStreamWriterwriter = new OutputStreamWriter(printStream);

                   //

                   BufferedWriterbufferedWriter = new BufferedWriter(writer);

                   Stringline =null;

                   try{

                            while((line=bufferedReader.readLine())!= null) {

                                     if(line.equals("over")) {

                                               break;

                                     }

                                     bufferedWriter.write(line);

                                     bufferedWriter.newLine();//加换行符

                                     writer.flush();

                            }

                   }catch (IOException e) {

 

                            e.printStackTrace();

                   }finally {

 

                            if(bufferedReader != null) {

                                     try{

                                               bufferedReader.close();

                                     }catch (IOException e) {

                                               e.printStackTrace();

                                     }

                            }

                            if(bufferedWriter != null) {

                                     try{

                                               bufferedWriter.close();

                                     }catch (IOException e) {

                                               e.printStackTrace();

                                     }

                            }

                   }

         }

 

 

内存操作流

 

ByteArrayInputStream;

内存操作输入流，读取数据来自于内存。

ByteArrayOutputStream;

内存操作输出流，输出数据的目标是内存。

//大写字母转换小写字母

         publicstatic void main(String[] args) {

                   Stringch = "ABHAOHDALKJDAKDJLKAJAL";

                   ByteArrayInputStreambyteArrayInputStream = new ByteArrayInputStream(ch.getBytes());

                   ByteArrayOutputStreambyteArrayOutputStream = new ByteArrayOutputStream();

                   inttemp;

                   while((temp = byteArrayInputStream.read()) != -1) {

                            charc = (char) temp;// 转换成小写字母

                            byteArrayOutputStream.write(Character.toLowerCase(c));

                   }

                   System.out.println(byteArrayOutputStream.toString());

         }

 

装饰类

DataInputStream

针对java基本数据类型进行数据输入。

DataOutputStream

针对java基本数据类型进行数据输出。

Xml文件解析

(eXtendsiblib Markup Language )可扩展性标记语言 是一种简单的数据存储语言，使用一系列简单标签描述数据

应用场合：

  数据存储

  数据交换

  数据配置

 

Pull解析

 Pull解析解析步骤：

       1.创建解析器工厂

       2.创建解析器对象

       3.将解析器与XML流文件进行关联

       4.根据触发事件类型不同在解析的过程中获取不同数据 

Dom解析

(Domcument Object Mode )即文档对象模型

DOM把XML文件映射成一个倒挂的树

 DOM解析解析步骤：

       1.获得Dom解析器工厂对象

       2.获得Dom解析器

       3.通过解析器将XML文档转换成一个DOM对象

       4.DOM对象作为整个解析起点    

Sax解析

Pull解析和Sax解析类似，都是基于流（steam）操作文件

DTD（document type definition）

文档类型定义语言，通过dtd文档可以对编写的XML文件进行有效性约束

使得我们的xml数据文件更加通用。

反射机制

 

程序在运行的过程中，而不是在代码编写阶段，动态的去获取一个对象所属的类型的信息的过程

我们称之为反射

反射的根源是：Class对象

获得Class的三种方法

1.Class clz=类名.class；

2.Student s=new Student（）；

Class clz=对象名.getClass；

3.Class clz=Class.forName（"要加载的类的完全限定名（包括包名和类名的）"）。

ggetMethods();

返回的是超类以及本类中的一些公有的方法构成的Method类型的数组。

getDeclaredMethods():

返回的是本类中定义的所有的公有以及私有的方法构成的数组。

getMethod(参数,参数):

获得的是超类或本类中定义的公有的指定方法名的一个Method对象

getDeclaredMethod(参数,参数):

获得的是本类中定义的公有或私有的指定名的一个Method对象

getFields():

返回超类以及本类中定义的公有的字段构成的对象数组。

getField(参数):

返回超类或本类中定义的公有的指定字段名的一个字段对象

getDeclaredFields():

返回是本类中公有或私有的所有的字段构成的一个数组

getDeclaredField(参数):

返回的是类中的公有的或私有的指定字段名的一个字段

getConstructors()

返回类中所有的公有的构造方法构成的一个数组

getConstructor(可变参数):

返回类中指定参数列表的一个构造方法对象。

java.lang.reflect：

所有的反射的Api都在该包中。

Method,Field，Constructor。。。。

在一些框架的配置信息中经常会把一些类的完全限定名的信息写在其中，通过反射方式，动态的构建类的对象，比如android当中的Activity的信息，就是配置在清单文件中。

使用可变参数的时机：

当参数的类型确定而参数的个数不确定时，可以选择使用可变参数。

使用时的注意事项

1.方法的参数如果有可变参数，那么可变参数只能放在整个参数列表的最后。

2.方法中最多只能有一个可变参数

给可变参数传参数:

1.可以不传参数

2.可以传一个或多个类型相同的参数，参数之间用逗号隔开。

3.可以直接传入一个数组。

4.如果可变参数的类型是引用类型，那当传入的是数组时，注意数组元素的实例化。

 

枚举：

1.当某变量的数据值的个数可以穷举的时候，可以使用枚举类型。

枚举的定义:

public enum 名称{

值1，值2，值3

}

2.枚举默认继承java.lang.Enum类

3.枚举可以定义方法，但是在方法定义前要创建枚举的实例。

public enum Color2 {

 RED("红色",1),GREEN("绿色",2),YELLOW("黄色",3),BULE("蓝色",4);

 private String name;

 private int index;

 private Color2(String name,int index){

 this.name=name;

 this.index=index;

}

 public static String getName(int index){

  for(Color2 c:Color2.values()){

    if(c.index==index){

      return c.name;

    }

 }   

 }

}

4.枚举的构造方法只能是私有的。

5.因为枚举有父类，所有可以进行方法的重写。

6.枚举虽然不可以再继承其它的父类，但是可以再实现接口。

7.支持枚举的集合：

  EnumSet ,EnumMap