java的学习笔记

1.标识符的命名规则

Ø  由26个英文字母大小写，0-9 ，_或 $ 组成 

Ø  数字不可以开头。

Ø  不可以使用关键字和保留字，但能包含关键字和保留字。

Ø  Java中严格区分大小写，长度无限制。

Ø  标识符不能包含空格。

2.Java中的名称命名规范

Ø  包名：多单词组成时所有字母都小写：xxxyyyzzz

Ø  类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz

Ø  变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz

Ø  常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

3.Java程序介绍

Ø  源文件以.java结尾；

Ø  文件可以有多个class声明的类；

Ø  类中可以有主方法，其格式是固定的public static void main(String []args)；

Ø  main()函数是程序的入口，方法内是程序的执行部分；

Ø  一个源文件只能有一个public类，同时要求此类的类名与源文件名一致；

Ø  与源文件一致的类名可以不是public类型，但是只能同一个包内调用；

Ø  每个语句都以；结尾；

Ø  执行程序编译：javac.exe 生成多个.class文件运行 java.exe。

4.基本类型转换

容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为

    有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。

    byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。

    当把任何基本类型的值和字符串值进行连接运算时(+)，基本类型的值将自动转化为字符串类型。

3.String类

    值null可以赋值给任何引用类型（类、接口、数组）的变量，用以表示这个引用类型变量中保存的地址为空。

    String类属于引用类型，可用null赋值。

String类是一个典型的不可变类，String对象创建出来就不可能被改变。创建出的字符串将存放在数据区，保证每个字符串常量只有一个，不会产生多个副本。

String s0 = “hello”;

String s1 = “hello”; 

String s2 = “he” + “llo”;

System.out.println(s0 ==s1);

System.out.println(s0 ==s2);

String相当于一个引用，引用放在栈里面，数据放在堆里面

逻辑运算与与或

instanceof 检查是否是类的对象“Hello” instanceof  String true

逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。

“&”和“&&”的区别：

单&时，左边无论真假，右边都进行运算；

双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

“|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。

异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。

逻辑运算符不像c++或c语言非零为真，0位假，逻辑运算时true为真，false为假

移位运算符>>>无符号右移,不管数字是正数还是负数，移位时左边一律添加0

运算优先级

括号类成员排第一，全体单目运算符排第二，乘除三，加减四，移位五关系六，等于与不等于排第七，位与位异或位或八九十，逻辑或与与十二与十一，条件高于赋值。

数组：

数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。

每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长度(元素个数)

java对象

当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。除了基本数据类型之外的变量类型都是引用类型，如上面的Person及前面讲过的数组

JAVA中的实参向形参传递参数：

Java里方法的参数传递方式只有一种：值传递。  即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

多维数组的动态初始化：

格式1（动态初始化）：int[][] arr = new int[3][2];

格式2（动态初始化）：int[][] arr = new int[3][];

arr[0] = new int[3];    arr[1] = new int[1];   arr[2] = new int[2];

格式3（静态初始化）：int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};

Java权限修饰符public、protected、private置于类的成员定义前，用来限定对象对该类成员的访问权限

对于class的权限修饰只可以用public和default(缺省)。 public类可以在任意地方被访问。default类只可以被同一个包内部的类访问

 

构造函数的定义：

根据参数不同，构造器可以分为如下两类：

隐式无参构造器（系统默认提供）

显式定义一个或多个构造器（无参、有参）

注  意：

Java语言中，每个类都至少有一个构造器

默认构造器的修饰符与所属类的修饰符一致

一旦显式定义了构造器，则系统不再提供默认构造器

一个类可以创建多个重载的构造器

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

 

this的使用

1.使用this()必须放在构造器的首行！

2.使用this调用本类中其他的构造器，保证至少有一个构造器是不用this的。

 

//下面采用数组形参来定义方法

public static void test(int a,String[] books);

//以可变个数形参来定义方法

public static void test(int a,String…books);

1.可变参数：方法参数部分指定类型的参数个数是可变多个

2.声明方式：方法名（参数的类型名...参数名）

3.可变参数方法的使用与方法参数部分使用数组是一致的

4.方法的参数部分有可变形参，需要放在形参声明的最后

 

package

         package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。它的格式为：

         package 顶层包名.子包名 ;

         举例：pack\Test.java

                   packagep1;    //指定类Test属于包p1

                   publicclass Test{

                           public void display(){

                                               System.out.println("in  method display()");

                           }

                   }

包对应于文件系统的目录，package语句中，用 “.” 来指明包(目录)的层次；

包通常用小写单词，类名首字母通常大写。

import

         为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)。import语句告诉编译器到哪里去寻找类。

         语法格式：

         import  包名[.子包名…]. <类名|*>

若引入的包为：java.lang，则编译器默认可获取此包下的类，不需要再显示声明。

import语句出现在package语句之后、类定义之前

一个源文件中可包含多个import语句

可以使用import lee.*;语句，表明导入lee包下的所有类。而lee包下sub子包内的类则不会被导入。import lee.sub.*;

import语句不是必需的，可坚持在类里使用其它类的全名 JDK 1.5加入import static语句

java的继承关系

java只支持单继承，不允许多重继承

1.一个子类只能有一个父类

2.一个父类可以派生出多个子类

继承与法classSubclass extends Superclass{ }

覆盖：

定义：在子类中可以根据需要对从父类中继承来的方法进行改造，也称方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法

1、重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型。

2、重写方法不能使用比被重写方法更严格的访问权限。

3、重写和被重写的方法须同时为static的，或同时为非static的

4、子类方法抛出的异常不能大于父类被重写方法的异常

关键字super

在Java类中使用super来调用父类中的指定操作：

1、super可用于访问父类中定义的属性

2、super可用于调用父类中定义的成员方法

3、super可用于在子类构造方法中调用父类的构造器

注意：

1、尤其当子父类出现同名成员时，可以用super进行区分

2、super的追溯不仅限于直接父类

3、super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

调用父类的构造器

1、子类中所有的构造器默认都会访问父类中空参数的构造器

2、当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器，且必须放在构造器的第一行

3、如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错

super(…)和this(…)调用语句不能同时在一个构造器中出现。

super(…)或this(…)调用语句只能作为构造器中的第一句出现。

多态性，是面向对象中最重要的概念，在java中有两种体现：

1、方法的重载(overload)和重写(overwrite)。

2、对象的多态性   ——可以直接应用在抽象类和接口上。

Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定

 

对象的多态 —在Java中,子类的对象可以替代父类的对象使用

1、一个变量只能有一种确定的数据类型

2、一个引用类型变量可能指向(引用)多种不同类型的对象

3、一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法

子类继承父类

1、若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中

2、对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量

基本数据类型的Casting：

1、自动类型转换：小的数据类型可以自动转换成大的数据类型

   如long g=20;           doubled=12.0f

2、强制类型转换：可以把大的数据类型强制转换(casting)成小的数据类型

   如 float f=(float)12.0;   inta=(int)1200L

对Java对象的强制类型转换称为造型

   1、从子类到父类的类型转换可以自动进行

   2、从父类到子类的类型转换必须通过造型(强制类型转换)实现

   3、无继承关系的引用类型间的转换是非法的

   4、在造型前可以使用instanceof操作符测试一个对象的类型

instanceof

x instanceof A：检验x是否为类A的对象，返回值为boolean型。

要求x所属的类与类A必须是子类和父类的关系，否则编译错误。

如果x属于类A的子类B，x instanceof  A值也为true

public class mytest {   

public static void main(String[] argv){

    Graduate s1=new Graduate();

    if (s1 instanceof Person) {

       System.out.println("Person");  

    }

    if (s1 instanceof Student){

       System.out.println("Student");

    }

    if (s1 instanceof Graduate){

       System.out.println("Graduate");

    }

}

}

class Person {}

class Student extends Person {}

class Graduate extends Student{}

public class Test{

               public void method(Person e) {    //设Person类中没有getschool()         方法

                    // System.out.pritnln(e.getschool());   //非法,编译时错误

                     if(e instanceof  Student){

                             Student me = (Student)e;    //将e强制转换为Student类型

                             System.out.pritnln(me.getschool());

                     }      

            }

             public static  void main(Stirng args[]){

                    Test t = new Test();

                     Student m = new Student();

                     t.method(m);

             }

}

JAVA的内存结构

Object类是所有Java类的根父类

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

基本数据类型         包装类

          boolean             Boolean               

          byte                Byte

          short              Short

          int                  Integer

          long                Long

          char                Character

          float               Float

          double        Double

Integer t = new Integer(i);

boolean b = bObj.booleanValue();

String fstr =String.valueOf(2.34f);

String s1 =Integer.toString(314);

Float f = Float.parseFloat(“12.1”);

 

关键字static

使用范围：

在Java类中，可用static修饰属性、方法、代码块、内部类

1、被修饰后的成员具备以下特点：

2、随着类的加载而加载

3、优先于对象存在

4、修饰的成员，被所有对象所共享

5、访问权限允许时，可不创建对象，直接被类调用

类变量:

类变量（类属性）由该类的所有实例共享

类方法:

1、没有对象的实例时，可以用类名.方法名()的形式访问由static标记的类方法。

2、在static方法内部只能访问类的static属性，不能访问类的非static属性。

3、因为不需要实例就可以访问static方法，因此static方法内部不能有this。(也不能有super ? YES!)

4、重载的方法需要同时为static的或者非static的

java的初始化过程

一、初始化块(代码块)作用： 对Java对象进行初始化

二 、程序的执行顺序：

1、声明成员变量的默认值 

2、显式初始化、多个初始化块依次被执行（同级别下按先后顺序执行）

3、构造器再对成员进行赋值操作

静态初始化块

1、一个类中初始化块若有修饰符，则只能被static修饰，称为静态代码块(static block)，当类被载入时，类属性的声明和静态代码块先后顺序被执行，且只被执行一次。

2、static块通常用于初始化static (类)属性

非静态代码块：没有static修饰的代码块

 1.可以有输出语句。

 2.可以对类的属性、类的声明进行初始化操作。

 3.可以调用静态的变量或方法。

 4.若有多个非静态的代码块，那么按照从上到下的顺序依次执行。

 5.每次创建对象的时候，都会执行一次。且先于构造器执行

静态代码块：用static 修饰的代码块

 1.可以有输出语句。

 2.可以对类的属性、类的声明进行初始化操作。

 3.不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。

 4.若有多个静态的代码块，那么按照从上到下的顺序依次执行。

 5.静态代码块的执行要先于非静态代码块。

 6.静态代码块只执行一次

class Person {

    private int id=1;

    private int j;

    {

    System.out.println("echo");

    j=2;

    }

    public static int total = 0;

    public Person() {

    System.out.println("hello");

       total++;

       id = total;

    }

    public void myout(){

    System.out.println("hello");

    }

    public static void myprintf(Person e){

    e.myout();

    }

}

关键字final

在Java中声明类、属性和方法时，可使用关键字final来修饰,表示“最终”。

1、final标记的类不能被继承。提高安全性，提高程序的可读性。

String类、System类、StringBuffer类

2、final标记的方法不能被子类重写。

Object类中的getClass()。

3、final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只能被赋值一次。

final标记的成员变量必须在声明的同时或在每个构造方法中或代码块中显式赋值，然后才能使用final double PI=3.14

class Person {

    private final int id;

    private final int j;

    {

    System.out.println("echo");

    j=2;

    }

    public static int total = 0;

    public Person() {

    System.out.println("hello");

       total++;7

       id = total;

    }

    public void myout(){

    System.out.println("hello");

    }

    public static void myprintf(Person e){

    e.myout();

    }

}

 

抽象类

抽象类的定义

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类

1、用abstract关键字来修饰一个类时，这个类叫做抽象类；

2、用abstract来修饰一个方法时，该方法叫做抽象方法。

@抽象方法：只有方法的声明，没有方法的实现。以分号结束：abstract int abstractMethod( int a );

@含有抽象方法的类必须被声明为抽象类。

@抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。

@不能用abstract修饰属性、私有方法、构造器、静态方法、final的方法。

接口

1、有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。

2、接口(interface)是抽象方法和常量值的定义的集合。

3、从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

4、实现接口类：

class SubClass implementsInterfaceA{ }

一个类可以实现多个接口，接口也可以继承其它接口

一、接口的特点：

1、用interface来定义。

2、接口中的所有成员变量都默认是由public static final修饰的。

3、接口中的所有方法都默认是由public abstract修饰的。

4、接口没有构造器。

5、接口采用多继承机制。

二、接口定义举例

    public interface Runner {

         intID = 1;

         voidstart();

         publicvoid run();

         voidstop();

    }

等价于

 public interface Runner {

         publicstatic final int ID = 1;

         publicabstract void start();

         publicabstract void run();

         publicabstract void stop();

    }

1、实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。

2、接口的主要用途就是被实现类实现。（面向接口编程）

3、与继承关系类似，接口与实现类之间存在多态性

4、定义Java类的语法格式：先写extends，后写implements

         <modifier> class < name> [extends < superclass>]

         [implements< interface> [,< interface>]* ] {

                   <declarations>*

         }

 一个类可以实现多个无关的接口

interface Runner { public voidrun();}

interface Swimmer {public doubleswim();}

class Creator{public int eat(){…}}

class Man extends Creatorimplements Runner ,Swimmer{

                   publicvoid run() {……}

                   publicdouble swim()  {……}

                   publicint eat() {……}

}

与继承关系类似，接口与实现类之间存在多态性

public class Test{

         publicstatic void main(String args[]){

                   Testt = new Test();

                   Manm = new Man();

                   t.m1(m);

                   t.m2(m);

                   t.m3(m);

         }

         publicString m1(Runner f) { f.run(); }

         publicvoid  m2(Swimmer s) {s.swim();}

         publicvoid  m3(Creator a) {a.eat();}}

如果实现接口的类中没有实现接口中的全部方法，必须将此类定义为抽象类

接口也可以继承另一个接口，使用extends关键字。

interface MyInterface{

                   Strings=“MyInterface”;

                   publicvoid absM1();

         }

         interfaceSubInterface extends MyInterface{

                   publicvoid absM2();

         }

         publicclass SubAdapter implements SubInterface{

                   publicvoid absM1(){System.out.println(“absM1”);}

                   publicvoid absM2(){System.out.println(“absM2”);}

         }

接口用法总结

1、通过接口可以实现不相关类的相同行为，而不需要考虑这些类之间的层次关系。

2、通过接口可以指明多个类需要实现的方法，一般用于定义对象的扩张功能。

3、接口主要用来定义规范。解除耦合关系。

类的成员之五：内部类

1、在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。

2、Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。

Innerclass的名字不能与包含它的类名相同；

3、Inner class可以使用外部类的私有数据，因为它是外部类的成员，同一个类的成员之间可相互访问。而外部类要访问内部类中的成员需要:内部类.成员或者内部类对象.成员。

4、分类：成员内部类（static成员内部类和非static成员内部类）

             局部内部类（不谈修饰符）、匿名内部类

一、Inner class作为类的成员：

1、可以声明为final的

2、和外部类不同，Inner class可声明为private或protected；

3、Inner class 可以声明为static的，但此时就不能再使用外层类的非static的成员变量；

二Inner class作为类：

1、可以声明为abstract类 ，因此可以被其它的内部类继承

2、【注意】非static的内部类中的成员不能声明为static的，只有在外部类或static的内部类中才可声明static成员

匿名内部类

匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。

new 父类构造器（实参列表）|实现接口(){

    //匿名内部类的类体部分

}

interface  A{

         public  abstract void fun1();

}

public class Outer{

         publicstatic void main(String[] args) {

                   newOuter().callInner(new A(){

               //接口是不能new但此处比较特殊是子类对象实现接口，只不过没有为对象取名

                            publicvoid fun1() {

                                     System.out.println(“implement for fun1");

                            }

                   });//两步写成一步了

         }

         publicvoid callInner(A a) {

                   a.fun1();

         }

} 

 

 

异常处理

1、Java提供的是异常处理的抓抛模型。

2、Java程序的执行过程中如出现异常，会生成一个异常类对象，该异常对象将被提交给Java运行时系统，这个过程称为抛出(throw)异常。

3、异常对象的生成由虚拟机自动生成：程序运行过程中，虚拟机检测到程序发生了问题，如果在当前代码中没有找到相应的处理程序，就会在后台自动创建一个对应异常类的实例对象并抛出——自动抛出

4、由开发人员手动创建：Exception exception = new ClassCastException();——创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样

1、如果一个方法内抛出异常，该异常对象会被抛给调用者方法中处理。如果异常没有在调用者方法中处理，它继续被抛给这个调用方法的上层方法。这个过程将一直继续下去，直到异常被处理。这一过程称为捕获(catch)异常。

2、如果一个异常回到main()方法，并且main()也不处理，则程序运行终止。

3、程序员通常只能处理Exception，而对Error无能为力。

异常处理是通过try-catch-finally语句实现的。

try{

         ...... //可能产生异常的代码

}

catch( ExceptionName1 e ){

         ...... //当产生ExceptionName1型异常时的处置措施

}

catch( ExceptionName2 e ){

......         //当产生ExceptionName2型异常时的处置措施

} 

finally{

...... //无论是否发生异常，都无条件执行的语句

                   }  ]

l try

         捕获异常的第一步是用try{…}语句块选定捕获异常的范围，将可能出现异常的代码放在try语句块中。

l catch (Exceptiontype e)

         在catch语句块中是对异常对象进行处理的代码。每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。

l 捕获异常的有关信息：

         与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法。

Ø getMessage()   获取异常信息，返回字符串

Ø printStackTrace()  获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

Ø finally

Ø 捕获异常的最后一步是通过finally语句为异常处理提供一个统一的出口，使得在控制流转到程序的其它部分以前，能够对程序的状态作统一的管理。

Ø 不论在try代码块中是否发生了异常事件，catch语句是否执行，catch语句是否有异常，catch语句中是否有return，finally块中的语句都会被执行。

Ø finally语句和catch语句是任选的

不捕获异常时的情况

1、前面使用的异常都是RuntimeException类或是它的子类，这些类的异常的特点是：即使没有使用try和catch捕获，Java自己也能捕获，并且编译通过  ( 但运行时会发生异常使得程序运行终止)。

2、如果抛出的异常是IOException等类型的非运行时异常，则必须捕获，否则编译错误。也就是说，我们必须处理编译时异常，将异常进行捕捉，转化为运行时异常

声明抛出异常

l 声明抛出异常是Java中处理异常的第二种方式

Ø 如果一个方法(中的语句执行时)可能生成某种异常，但是并不能确定如何处理这种异常，则此方法应显示地声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。

Ø 在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。

l 声明抛出异常举例：

         importjava.io.*;

public class Test6_4{

         publicstatic void main(String[] args){

                  Test6_4 t = new Test6_4();

                   try{

                           t.readFile();

                    }catch(IOException e){   }

         }

         publicvoid readFile() throws IOException {

                   FileInputStreamin=new FileInputStream("myfile.txt");

                   intb;        

                   b= in.read();

                   while(b!=-1)   {

                            System.out.print((char)b);

                            b= in.read();

                   }

                   in.close();         

         }

}

     }

重写方法声明抛出异常的原则

l 重写方法不能抛出比被重写方法范围更大的异常类型。在多态的情况下，对methodA()方法的调用-异常的捕获按父类声明的异常处理。

public classA {

   public void methodA() throws IOException {

                 ……

           }  }

    public class B1 extends A {

           publicvoid methodA() throws FileNotFoundException {

……

           }  }

    public class B2 extends A {

           publicvoid methodA() throws Exception {   //报错

                   ……

       }  }

人工抛出异常

创建用户自定义异常类

l 一般地，用户自定义异常类都是RuntimeException的子类。

l 自定义异常类通常需要编写几个重载的构造器。

l 自定义的异常类对象通过throw抛出。

l 自定义异常最重要的是异常类的名字，当异常出现时，可以根据名字判断异常类型。

用户自定义异常类MyException，用于描述数据取值范围错误信息。用户自己的异常类必须继承现有的异常类

class MyException extendsException {

     staticfinal long serialVersionUID = 1L;

         privateint idnumber;

        publicMyException(String message, int id) {

                   super(message);

                   this.idnumber= id;

        }

         publicint getId() {

                   returnidnumber;

        }

}

public class Test6_5{

        public void regist(int num) throwsMyException {

        if(num < 0)

                  throw new MyException(“人数为负值，不合理”, 3);

         else

                   System.out.println("登记人数" + num );

        }

        public void manager() {

        try{

                   regist(100);

        }catch (MyException e) {

                   System.out.print("登记失败，出错种类"+e.getId());               

         }

         System.out.print("本次登记操作结束");

       }

       public static void main(String args[]){

         Test6_5 t = new Test6_5();

         t.manager();

       }

}

File 类

1、java.io.File类：文件和目录路径名的抽象表示形式，与平台无关。

2、File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。

3、File对象可以作为参数传递给流的构造函数。

一、File类的常见构造方法：

1、public File(String pathname)

    以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。

2、public File(String parent,String child)

    以parent为父路径，child为子路径创建File对象。

二、File的静态属性String separator存储了当前系统的路

文件创建  

File file = new File("hello.txt");

        if(!file.exists()) {

            try {

                if (file.createNewFile()) {

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

                }

            } catch (Exception e) {

                // TODO: handleexception

                e.printStackTrace();

            }

        } else {

            System.out.println("文件已存在");

        }

目录创建

  File file = new File("hello");

        if(!file.exists()) {

            try {

                if (file.mkdir()) {

                    System.out.println("创建目录成功");

                }

            } catch (Exception e) {

                // TODO: handleexception

                e.printStackTrace();

            }

        } else {

            System.out.println("目录已存在");

        }

目录创建

  File file = new File("F:\\work\\mytest","hello");

        if(!file.exists()) {

            try {

                if (file.mkdir()) {

                    System.out.println("创建目录成功");

                }

            } catch (Exception e) {

                // TODO: handleexception

                e.printStackTrace();

            }

        } else {

            System.out.println("目录已存在");

        }

目录删除

File file = new File("hello");

        if(file.exists()) {

            try {

                if (file.delete()) {

                    System.out.println("删除文件成功");

                }

            } catch (Exception e) {

                // TODO: handleexception

                e.printStackTrace();

            }

        } else {

            System.out.println("删除文件失败");

        }

File file = newFile("F:\\work\\mytest","hello");

System.out.println(file.getPath());

F:\work\mytest\hello

 System.out.println(file.getParent());

F:\work\mytest

File file = newFile("hello");

System.out.println(file.getParent());

null

System.out.println(file.getPath());

hello

System.out.println(file.getAbsoluteFile());

F:\work\mytest\hello

System.out.println(file.getAbsolutePath());

F:\work\mytest\hello

File file = newFile("hello");

System.out.println(""+file.canRead());

true

public long length()

    返回由此抽象路径名表示的文件的长度。如果此路径名表示一个目录,则返回值是不确定的。

public long lastModified()

返回此抽象路径名表示的文件最后一次被修改的时间表示文件最后一次被修改的时间的 long 值，用与时间点（1970 年 1 月 1 日，00:00:00 GMT）之间的毫秒数表示；如果该文件不存在，或者发生 I/O 错误，则返回0L

public String[] list(FilenameFilter filter)

返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。除了返回数组中的字符串必须满足过滤器外，此方法的行为与list() 方法相同。如果给定 filter 为 null，则接受所有名称。否则，当且仅当在此抽象路径名及其表示的目录中的文件名或目录名上调用过滤器的FilenameFilter.accept(java.io.File,java.lang.String) 方法返回true 时，该名称才满足过滤器。

      File file = new File("hello");

        if(file.exists()) {

            try {

                 String[]s1=file.list(newFilenameFilter(){

 

                     public boolean accept(Filearg0, String arg1) {

                         if(arg1.equals("test1.txt"))

                         return true;

                         else

                         return false;

                     }

                   

                 });

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

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

                 }

            } catch (Exception e) {

                // TODO: handle exception

                e.printStackTrace();

            }

        } else {

            System.out.println("目录已存在");

        }

test1.txt

Java IO原理

输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。

输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中

字节流 

try {

       FileInputStream file1=new FileInputStream("F:\\work\\mytest\\hello\\e1.jpg");

       FileOutputStreamfile2=newFileOutputStream("F:\\work\\mytest\\hello\\e2.jpg",true);

       byte[]arr=new byte[32];

       int len;

       while(true){

              len=file1.read(arr);

              if(len==-1)break;

              file2.write(arr);

       }

       file1.close();

       file2.close();

    } catch (FileNotFoundException e) {

       // TODOAuto-generated catch block

       e.printStackTrace();

    }catch (IOException e) {

       // TODOAuto-generated catch block

       e.printStackTrace();

    }

字符流

       FileReader file1=new FileReader("F:\\work\\mytest\\hello\\test1.txt");

       FileWriter file2=new FileWriter("F:\\work\\mytest\\hello\\test2.txt",true);

       char[]arr=new char[32];

       int len;

       while(true){

              len=file1.read(arr);

              if(len==-1)break;

              file2.write(arr);

       }

       file1.close();

       file2.close();

    } catch (FileNotFoundException e) {

       // TODOAuto-generated catch block

       e.printStackTrace();

    }catch (IOException e) {

       // TODOAuto-generated catch block

       e.printStackTrace();

    }

带缓存区的字符流

    try {

       BufferedReader file1=new BufferedReader(new FileReader("F:\\work\\mytest\\hello\\test1.txt"));

       BufferedWriter file2=new BufferedWriter(new FileWriter("F:\\work\\mytest\\hello\\test2.txt",true));

       String str=null;

       int len;

       while(true){

              str=file1.readLine();

               if(str==null)break;

              file2.write(str,0,str.length());

       }

       file1.close();

       file2.close();

    } catch (FileNotFoundException e) {

       // TODOAuto-generated catch block

       e.printStackTrace();

    }catch (IOException e) {

       // TODOAuto-generated catch block

       e.printStackTrace();

    }

带缓存区的字节流

    try {

       BufferedInputStreamfile1=newBufferedInputStream(newFileInputStream("F:\\work\\mytest\\hello\\test1.txt"));

       BufferedOutputStreamfile2=newBufferedOutputStream(newFileOutputStream("F:\\work\\mytest\\hello\\test2.txt",true));

       byte[] arr=new byte[32];

       int len;

       while(true){

              len=file1.read(arr);

              if(len==-1)break;

              file2.write(arr);

       }

       file1.close();

       file2.close();

    } catch (FileNotFoundException e) {

       // TODOAuto-generated catch block

       e.printStackTrace();

    }catch (IOException e) {

       // TODOAuto-generated catch block

       e.printStackTrace();

    }

 

        try {

       FileInputStream fis = new FileInputStream("F:\\work\\mytest\\hello\\test1.txt");

        FileOutputStream fos = new FileOutputStream("F:\\work\\mytest\\hello\\test2.txt");

 

        InputStreamReader isr = new InputStreamReader(fis,"ASCII");

        OutputStreamWriter osw = new OutputStreamWriter(fos,"ASCII");

 

        BufferedReader br = new BufferedReader(isr);

        BufferedWriter bw = new BufferedWriter(osw);

 

       String str=null;

       int len;

       while(true){

              str=br.readLine();

              if(str==null)break;

              bw.write(str,0,str.length());

       }

       br.close();

       bw.close();

    } catch (FileNotFoundException e) {

       // TODOAuto-generated catch block

       e.printStackTrace();

    }catch (IOException e) {

       // TODOAuto-generated catch block

       e.printStackTrace();

    }

标准输入输出流

1、System.in和System.out分别代表了系统标准的输入和输出设备

2、默认输入设备是键盘，输出设备是显示器

3、System.in的类型是InputStream

4、System.out的类型是PrintStream，其是OutputStream的子类FilterOutputStream的子类

5、通过System类的setIn，setOut方法对默认设备进行改变。

public static voidsetIn(InputStream in)

public static voidsetOut(PrintStream out)

    System.out.println("请输入信息(退出输入e或exit):");

    //把"标准"输入流(键盘输入)这个字节流包装成字符流,再包装成缓冲流

    BufferedReader br = new BufferedReader(newInputStreamReader(System.in));

    try {

       FileOutputStream fos =newFileOutputStream(new File("F:\\work\\mytest\\hello\\test1.txt"));

       PrintStream ps = new PrintStream(fos,true);

       System.setOut(ps);

    } catch (FileNotFoundException e1) {

       // TODOAuto-generated catch block

       e1.printStackTrace();

    }

 

    String s = null;

    try {

    while ((s = br.readLine()) != null) {  //读取用户输入的一行数据 --> 阻塞程序

    if (s.equalsIgnoreCase("e") || s.equalsIgnoreCase("exit")) {

        System.out.println("安全退出!!");

           break;

    }

    //将读取到的整行字符串转成大写输出

    System.out.println(s);

    System.out.println("继续输入信息");

    }   } catch (IOExceptione) {

       e.printStackTrace();

       } finally {

       try {

       if (br != null) {

       br.close();  //关闭过滤流时,会自动关闭它包装的底层节点流

    }   }  catch (IOException e) {

           e.printStackTrace();

       }   }

打印流

1、在整个IO包中，打印流是输出信息最方便的类。

2、PrintStream(字节打印流)和PrintWriter(字符打印流)

3、提供了一系列重载的print和println方法，用于多种数据类型的输出

4、PrintStream和PrintWriter的输出不会抛出异常

5、PrintStream和PrintWriter有自动flush功能

6、System.out返回的是PrintStream的实例

数据流

1、为了方便地操作Java语言的基本数据类型的数据，可以使用数据流。数据流有两个类：(用于读取和写出基本数据类型的数据）

2、DataInputStream和DataOutputStream分别“套接”在 InputStream 和 OutputStream 节点流上

DataInputStream中的方法

   boolean readBoolean()     byte readByte()

   char readChar()       float readFloat()

   double readDouble()       short readShort()

   long readLong()       int readInt()

   String readUTF()       void readFully(byte[] b)

DataOutputStream中的方法将上述的方法的read改为相应的write即可

    DataOutputStream dos = null;

    try {  //创建连接到指定文件的数据输出流对象

       dos = new DataOutputStream(newFileOutputStream("F:\\work\\mytest\\hello\\test1.txt",true));

           dos.writeUTF("中国");  //写UTF字符串

           dos.writeBoolean(false);  //写入布尔值

           dos.writeLong(1234567890L);  //写入长整数

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

       } catch (IOException e) {

           e.printStackTrace();

       } finally {   //关闭流对象

           try {

           if (dos != null) {

           // 关闭过滤流时,会自动关闭它包装的底层节点流

           dos.close();

           }

       } catch (IOException e) {

           e.printStackTrace();

       }   }

RandomAccessFile 类

1、RandomAccessFile 类支持 “随机访问” 的方式，程序可以直接跳到文件的任意地方来读、写文件

支持只访问文件的部分内容

可以向已存在的文件后追加内容

2、RandomAccessFile 对象包含一个记录指针，用以标示当前读写处的位置。RandomAccessFile 类对象可以自由移动记录指针：

long getFilePointer()：获取文件记录指针的当前位置

void seek(long pos)：将文件记录指针定位到 pos 位置

1、构造器

public RandomAccessFile(File file, String mode)

public RandomAccessFile(String name, String mode)

2、创建 RandomAccessFile 类实例需要指定一个 mode 参数，该参数指定 RandomAccessFile 的访问模式：

r: 以只读方式打开

rw：打开以便读取和写入

rwd:打开以便读取和写入；同步文件内容的更新

rws:打开以便读取和写入；同步文件内容和元数据的更新

    RandomAccessFile raf;

    try {

       raf = new RandomAccessFile("F:\\work\\mytest\\hello\\test1.txt","rw");

       raf.seek(0);

       String c;

       byte [] b = new byte[1024];

       int off = 0;

       int len = 2;

       raf.read(b, 0, len);

       //c=raf.readLine();

       String str = new String(b, 0, len);

       System.out.println(str);

       raf.close();

    } catch (FileNotFoundException e) {

       // TODOAuto-generated catch block

       e.printStackTrace();

    }catch (IOException e) {

       // TODOAuto-generated catch block

       e.printStackTrace();

    }

    RandomAccessFile raf;

    try {

       raf = new RandomAccessFile("F:\\work\\mytest\\hello\\test1.txt","rw");   

       //先读出来

       String temp =raf.readLine();

          

      

       //raf.writeUTF(temp);

       raf.write(temp.getBytes());

       raf.write("vxyz".getBytes());

       raf.close();

          

       raf.close();

    } catch (FileNotFoundException e) {

       // TODOAuto-generated catch block

       e.printStackTrace();

    }catch (IOException e) {

       // TODOAuto-generated catch block

       e.printStackTrace();

    }