java笔记心得2

以下是几乎是java阶段的所有重点知识点：当我忘记某个知识点时简单的查阅下，就可以想到自己学时的情景，希望可以帮助到有需要的人：

一、java不同于c语言，它是一种面向对象的语言

二、类的定义

[修饰符1，修饰符2.。]class类名{

//类体；

}

类名：遵循标识符的命名规则及习惯

2、类中的内容：

包括：属性和方法

（1）属性定义：

[修饰符1，修饰符2]数据类型 属性名[=赋值]

（2）方法定义：

[修饰符1，修饰符2.。。]返回值类型  方法名称【参数列表】{。。。}

3.构造器（也叫构造方法）

（1）命名格式：

【修饰符】类名（【参数列表】）{。。}

（2）作用：用于初始化类中的对象

（3）默认构造器

①如果在一个类中没有定义任何构造器，系统会为该类添加一个默认的无参数构造器

②注意：如果类中已定义一个有参数的构造器，默认的构造器会被消除

③构造器支持重载

三、对象的创建及使用

（1）使用new关键字，表示“给我一份新的对象”

（2）写法：

Mobile mobile=new Mobile（）；

（3）对象的作用：

①对象调用属性：mobile.type

②对象调用方法：mobile.method()；

	存储器	存储内容
栈	RAM	对象的地址，基本数据类型
堆	RAM	对象的内容，String类型内容仅存其地址
常量存储	ROM	1.String值2.String表达式

1.基本数据类型传递的是值得副本

2.引用数据类型传递的是对象的引用，而非内容

一、引入：类中的属性为该类特有的，不建议在其它类中直接操作属性

二、写法：

1、使用private修饰属性

2、创建共有的方法封装属性，方便其它类进行调用方法使用属性

举例：

private int age;

public void setAge(int age)

{

this.age==age;

}

public int getAge()

{

return age;

}

一、使用规则

1、使用static 修饰的方法为静态方法，在静态方法中不能使用非静态的成员变量及方法

2、在非静态方法中，可以使用静态的成员变量及方法

3、在静态方法中，默认的为静态变量，所以在静态方法中不能使用static关键字

二、作用

如果在一类中，对象公有的属性和方法，可将其定义为静态的

三、调用

类名：属性

类名：方法

注意：也可以通过对象调用静态的属性和方法，但不推荐

四、不能再静态的方法中使用this和super关键字

一、写法：

static{

。。。}

二：特点

1、在运行程序时调用，优先于构造器

2、只能被执行一次

三、用途

初始化静态成员变量

一、基本语法

【修饰符】class 类名 extends 父类名{。。}

二、特点

1、面向对象的重要特点

2、实现代码的复用

3、子类可以继承父类的课件属性和方法

4、构造器不能继承

三、单继承

在java中，一个类中只能继承一个父类

修饰符的访问权限

修饰符	在同一个类中	同一个包中	子类中	全局
public	√	√	√	√
protected	√	√	√
default	√	√
private	√

一、用法

1、可以作为本类引用，访问本类的属性和方法，若有父类，还可以访问父类的可见属性和方法

2、可以访问本类构造器，访问构造器时需要放在首行，此时不会调用默认的super（）构造器

3、可以作为参数进行传递

一、写法

{

。。
}

二、特点

在类加载时执行，优先构造器执行

三、用途

初始化成员变量，包括静态及非静态

对象的构造过程

new 构造器→判断所属类是否有父类→有父类→先执行父类代码块，在执行父类中相应的构造方法

→无父类→先执行子类代码块，在执行子类中的构造器→①有重载构造器先重载无重载直接执行该构造器

一、java中为 每个基本数据类型配备对应的封装类

二、自动装箱

基本数据类型→封装类型

integer i=100;

三、自动拆箱

封装类型→基本数据类型

四、自动装箱的取值范围

byte、boolean的所有值

整型：-128~127（int short long ）

字符型：\u0000~\u007F

一、Object类是所有类的父类

二、常用方法

1、hashCode（）：每个对象都有一个hashCode

①、String类型为一串整数

②、Integer类型为值本身

③、Long整型为一串数字，但不是值本身，，不是小数

④、Float和Double类型为一串整数，不是小数

注意：如果Float和Double的值相等但是其hashCode不同

⑤。Character类型为ASCII码

⑥、普通对象为无规则整数

2、getClass（）：将对象变为字符串，比如Integer。Double等

对于普通类型的对象，可以通过重写toString（） 方法获取指定内容

4、equals（）：

①普通对象：即没有重写equals（） 方法，判断的是两个对象的地址

②以重写equals（） 方法对象，比如String 、Integer等判断的是两个对象的内容

一、使用abstract修饰符定义的类为抽象类，抽象类是一个模板

二、抽象类的使用规则

1、抽象类不能被实例化，可以创建一个抽象子类，使用子类调用抽象类中的可见属性和方法

2、抽象方法的的定义规则：只能声明不实现

格式：【修饰符】abstract 返回值类型 方法名称（【参数列表】） ；

3、抽象类中不一定有抽象方法，如果该类中定义了抽象方法，必须为定义抽象类

4、抽象类中可以有普通方法、静态方法、构造方法，变量、常量等

5、构造方法、静态方法、私有方法、final方法不能被定义为抽象方法

6、子类继承抽象方法、如果抽象类中有抽象方法，子类可以实现这些抽象方法，如果不实现则子类也要定义为抽象类

一、定义：方法和常量值的集合

二、接口的定义格式：

【修饰符】interface接口名{。。。}

三、接口的使用规则：

1、一个接口可以继承多个接口，比如：

public interface A extends  B,C,D{。。。}

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

3、一个类可以实现多个接口，实现接口关键字为implements

4、接口中所有的数据成员默认为public static final 修饰，所以接口中不能够定义变量

5、接口中所有的方法都是public abstract 修饰，所以不能再接口中使用：

static final  sychonized   private protected 等关键字修饰方法

6、接口中不能被实例化，需要通过子类对象调用接口中的常量和方法

1、final修饰变量为常量，只能被赋值一次，常量必须被赋值

2、final修饰方法不能被子类重写

3、final修饰类不能被继承

一、多态的分类

1、静态多态（编译时多态），方法重载实现

2、动态多态（运行时多态），通过向上转型来实现

二、动态多态的特点

Person p=new Teacher ();Person是Teacher的父类

p为Teacher对象，可以访问父类的可见属性和方法，也可以访问重写的父类方法，但不能访问子类自己的属性格方法

作用：判断一个对象是否为一个类的对象，返回值为boolean类型

写法：对象 instanceof类名

1、向上转型：子类对象——》父类对象 程序自动完成

父类 父类变量=new 子类构造器

2、向下转型：父类对象——》子类对象：强制转换完成

子类 子类对象=（子类）父类变量

一、定义：在一个类中定义一个类，该类为内部类

二、格式：

【修饰符】class类名{//外部类

【修饰符】class类名{

//内部类

}

}

三、分类：

1、成员内部类：定义在类的内部

实用注意：

①内部类持有外部类引用，可以访问外部类的所有成员变量及方法

②不能使用static关键字修饰变量

③调用格式：

Outer outer=new Outer();

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

④编译后会生成.class文件，名称为：外部类名$内部类名.class

2.、静态内部类：

（1）使用static修饰的内部类

（2）使用注意：

①：不持有外部类的引用，可以直接访问通过外部类进行访问

②：可以访问外部类的静态成员变量，如果访问外部类非静态的非成员变量，必须创建外部类对象进行调用

③：调用格式：

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

3、局部内部类

（1）定义在方法内部

（2）使用注意：

①：不能使用private protected  和public修饰符

②：作用访问仅在方法内部有效

③：不能包含静态内部类

4、匿名内部类：

（1）定义：没有名字的内部类

（2）使用注意：

①：格式：使用new关键字直接产生一个对象

名new 类（）{。。。}；

②：匿名内部类常用于抽象类和接口

③：编译后会产生.class文件，文件名为外部类名$编号.class，编号为1,2,3,4.。。

四、内部类的应用场景

1、成员内部类、局部内部类和匿名内部类可用于实现接口，比如按钮监听器等

2、静态内部类用于Builder构建器

一、数组的定义：存储一组相同数据类型元素的数据集合

二、一维数组的声明格式：

数据类型[] 数组名 = new 数据类型[大小]；或数据类型 数组名[] = new 数据类型[大小]

注意：声明数组时不要初始化数组大小，例如：int[ 5] arr;//错误

三、数组初始化

1.静态初始化：声明数组时就初始化数组大小和元素

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

2.动态初始化：声明与初始化分开进行

int arr[] = new arr[10];

arr[0] = 1;

或

for(int i = 0;i < 10;i++){

    arr[i] = i;

}

四、数组的存储

1.基本数据类型数组

栈：存数组名

堆：存数组中的元素

2.引用数据类型数组

栈：存数组名

堆：存数组元素的地址，如果为String则存常量池地址，如果为普通对象则在堆里再创建空间存值

五、数组的默认值

1.基本数据类型为对应数据类型的默认值，比如:int → 0

2.引用数据类型都为null

六、数组下标

1.下标可以为整型常量或表达式

2.小标从0开始

七、获取数组长度属性——length，如果获取的数组元素超出数组长度，会报数组越界异常

一、冒泡排序

1.特点：给定一个数组，它是进行两两比较，将较大数放到最后，直至数组元素有序

2.代码：

public static void bubbleSort(int[] a) {

    int n = a.length;

    //总共进行n-1轮的比较

    for (int i = 0; i < n; i++) {

        for (int j = 1; j < n - i ; j++) {

            if (a[j-1] > a[j]) {//交换

                int temp = a[j-1];

                a[j-1] = a[j];

                a[j] = temp;

            }

        }

    }

}

二、选择排序

1.特点：给定一个数组，先遍历出该数组中最小值，将其放到特定位置，然后再次遍历最小值，直至数组元素有序

2.代码：

public static void selectionSort(int[] a) {       

    for(int i = 0; i < a.length - 1; i++) {// 做第i趟排序

        int k = i;

        for(int j = k + 1; j < a.length; j++){// 选最小的记录

            if(a[j] < a[k]){

                k = j; //记下目前找到的最小值所在的位置

            }

        }

        if(i != k){  //交换a[i]和a[k]

            int temp = a[i];

            a[i] = a[k];

            a[k] = temp;

        }

    }   

}

三、插入排序

1.特点：给定一个数组，先取出数组中两个值进行比较，然后按升序（或降序）排列，再从原数组中取出第三个数据元素，跟原数列进行比较，生成一个升序（或降序）数列，直至数据元素全部取出，最终生成一个有序序列。

2.代码：

public static void insertSort(int[] a) {

    for (int i = 1; i < a.length; i++) {

        for (int j = i; j > 0; j--) {

            if (a[j] < a[j - 1]) {

                int temp = a[j];

                a[j] = a[j - 1];

                a[j - 1] = temp;

            } else {break;}

        }

    }

}

一、顺序查找

1.特点：给定一个数组和需要查找的数字，在数组中依次对各个数据元素进行比较，直至找到需要查找的数字

2.代码：

public static int search(int[] a, int num) {       

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

        if(a[i] == num){

            return i;

        }

    }

    return -1;

}

二、二分查找

1.特点：给定一个 有序的数组和需要查找的数字，先根据首尾索引的一半，找到一个数字进行比较，如果需要查找的数字大于该数字，则在该数字的右半部分再进行二分查找；反之则在该数字的左半部分进行二分查找，直至找到该数字。

2.代码：

public static int binarySearch(int[] a, int num) {

    int low = 0;                                  // 起点

    int upper = a.length - 1;              // 终点

    while (low <= upper) {

        int mid = (low + upper) / 2;     // 中间点

        if (a[mid] < num) {                  // 中间点的值小于要查找的值

            low = mid + 1;                    // 更改查找的起点为中间点位置后一位

        } else if (a[mid] > num) {        // 中间点的值大于要查找的值

            upper = mid - 1;                 // 更改查找的终点为中间点位置前一位

        } else {                                   // 中间点的值等于要查找的值

            return mid;                         // 返回该位置

        }

    }

    return -1;

}

注意：-1表示该数组没有此数值

一、二维数组的定义

用来表示行和列数据的数据结构

二、二维数组的声明

int[][] a;

int a[][];

注意：声明时不能给初始大小

比如：int a[3][4];//非法的

 三、二维数组的初始化

1.静态初始化

int a[][] = {{1,2},{3,4,5},{6,7}};

注意：采用静态初始化时，该数组的行数为花括号里子花括号个数，列数为子花括号中最大数值个数

2.动态初始化

①单独给指定的元素赋值

    a[0][0] = 3;

②给指定的行添加列数

    a[0] = new int[2];

3.缺省值初始化

  对于未满足列个数的行自动补类型默认值

  比如： int[][] a = new int[3][];

4.length

length在一维数组中返回该数组的长度，而在二维数组中：

在数组名的后面：返回该数组行数

在行数的后面：返回该行的列数

示例：

public class Test{

    public static void main(String args[]){

        int [][] a = { {1,2}, {2,3,4,5}, {5,6,7}};

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

            for(int j = 0; j < a[i].length; j++) {

                System.out.println("a["+ i + "][" + j+ "]=" + a[i][j] + ", ");

            }

            System.out.println();

        }

    }

}

一、数组拷贝

当不使用arrayCopy()方法，直接对整个数组进行拷贝时，

目标数组和源数组使用的是 同一份数据

二、arrayCopy()

1.参数：

◦ src  -  源数组。

◦ srcPos  -  源数组中的起始位置。

◦ dest  -  目标数组。

◦ destPos  -  目标数据中的起始位置。

◦ length -  要复制的数组元素的数量。

2.使用arrayCopy()方法，是将源数组中的值复制一份给目标数组，而非是源数组和目标数组使用同一份数据

一、异常的定义

异常是因编程错误或外在因素导致程序无法运行的事件。

二、异常的分类

1.Error

动态链接错误，比如JVM错误，这种错误不需要程序员干预，不需要捕获

2.Exception

①运行时异常

就是程序运行时出现的错误，这种错误是认为造成的，比如1/0，空指针异常等

②非运行时异常

是在编写代码时报出的错误，这种错误需要程序员及时处理，

比如：文件未找到异常

三、常见异常

} RuntimeException

◦ ArithmeticException ：数学计算异常

◦ NullPointerException ：空指针异常

◦ NegativeArraySizeException ：负数组长度异常

◦ ArrayIndexOutOfBoundsException ：数组索引越界异常

◦ ClassNotFoundException ：类文件未找到异常

◦ ClassCastException ：造型异常

} IOException

◦ FileNotFoundException ：文件未找到异常

◦ EOFException ：读写文件尾异常

◦ MalformedURLException ： URL 格式错误异常

◦ SocketException ： Socket 异常

◦ IOException

四、异常处理机制

执行代码时会抛出异常类对象→JRE处理异常类对象→如果该异常可以处理，则进行捕获；如果无法处理，则程序退出

五、捕获异常

try{...}catch{...}【finally{...}】

1.try块

①捕获多个异常可以使用1个try块

②try块内可以放有异常代码，还可以放无异常代码

2.catch块

①1个catch块只能捕获一种异常，当出现多个异常时，可以使用多个catch块进行捕获

②catch块里出现的异常对象的方法

   a.getMessage():打印该异常对象的信息

   b.printStackTrace():打印错误信息，建议使用

③如果没有异常，则不走catch块

④catch块内异常类顺序，子类→父类依次往下

3.finally

①无论该段代码有没有错误，都去执行finally块

②作用：进行资源清理工作

③finally块可有可无

一、throws关键字

1.作用：抛出异常，不做处理

2.声明：位于方法名后

比如：public void method()  throws Exception{...}

二、throw和throws

不同点	throw	throws
位置	方法内部	方法名后
作用	抛出异常对象	抛出异常类

1.throw使用注意：

当抛出一个非运行时异常对象时，需要通过throws先抛出该异常

2.throws使用注意：

①当一个方法抛出异常，则调用该方法的方法也需要抛出该异常

②当子类复写父类方法时，只能抛出比父类少的异常

一、Exception

非运行时异常，这类异常需要编写代码时及时处理

二、RuntimeException

可以不处理，交由JVM处理

一、创建自定义异常类

1.创建一个类，继承Exception

2.复写Exception类的方法

二、使用自定义异常类

同Exception

一、方法

1.valueOf () ，返回该封装类型

2.parseXXX，返回该封装类型（Character没有此方法）

3.XXXvalue()，返回该封装类型的简单数据类型

一、定义： 不可改变的字符序列

二、初始化：

1.String a = "abc";//直接访问常量池的地址

2.String b = new String("abc");//先在堆里开辟一个空间，存的是该字符串在常量池里的地址

建议：使用1这种方式给字符串赋值

三、“+”连接符

1.当一个变量和一个字符串相加，则为字符串，比如“abc” + 1，结果为abc1

2.可以将一个简单数据类型变为字符串，比如1 + “”，结果1为字符串

四、String为final类型修饰的类，所以没有子类

五、常用方法

length()：返回该String的大小

equals：比较两个字符串的内容；==：是比较两个字符串的地址

比较方法：

搜索方法

修改

正则表达式

一、定义： 可以改变的字符序列

二、构造器：

1.无参构造器：默认分配16个字符

2.有参构造器：除了本身字符串所占空间，额外再分配16个空间

注意：当增加超出16个空间，系统会再分配空间给该对象

三、方法

一、包括： 提供了一系列基本数学运算和几何函数的方法。

二、Math类也是一个final类，它不能有子类，其中所有的成员变量和成员方法都是静态的

三、常用属性和方法

1.属性：PI

2.方法：

一、作用：生成随机数

二、构造器：

1.无参构造 器:Random(),创建一个新的随机数生成器(使用当前时间毫秒值为种子)

2.有参构造器:Random(long seed), 使用单个 long 种子创建一个新随机数生成器

注意：使用有参构造器，可以使随机数相同，即seed相等

三、方法

一、Date

1创建的对象是返回当前的日期

2.方法：

①getTime();返回当前时间的毫秒数

②toString();把Date转换成String格式

二、DateFormat，对日期进行格式化，比如：yyyy年MM月dd日 EEE hh:mm:ss

用法：

①日期→格式化

SimpleDateFormat sdf = new SimpleDateFormat(日期格式化字符串);

sdf.format(date);

②格式化→日期

Date date2 = sdf.parse( 日期格式化字符串 );

三、 Calendar（日历类，为抽象类）

1.获得对象

①Calendar.getInstance();

②调用它的子类GregorianCalendar的构造方法

一、定义

Java API所提供的一系列类的实例，可以用于动态存放多个对象

二、集合框架

①Collection→ List →ArrayList、LinkedList、vector、Stack

                     → Set→HashSet、TreeSet、LinkedHashSet

②Iterator→ListIterator

③Map→HashMap、TreeMap、Hashtable、properties、WeakHashMap、IdentityHashMap

④Collections集合类工具类

一、它是一个接口，定义了存储对象的方法

二、方法

◦int size();　返回此collection中的元素数。

◦boolean isEmpty();　判断此collection中是否包含元素。

◦boolean add(Object element);　向此collection中添加元素。

◦boolean addAll(Collection c);将指定collection中的所有元素添加到此collection中

◦boolean contains(Object obj);　判断此collection是否包含指定的元素。

◦boolean containsAll(Collection c);　判断此collection是否包含指定collection中的所有元素。

◦boolean remove(Object element); 从此collection中移除指定的元素。

◦boolean removeAll(Collection c);　移除此collection中那些也包含在指定collection中的所有元素。

◦void clear();　移除些collection中所有的元素。

◦boolean retainAll(Collection c);　仅保留此collection与c的交集元素，其他删除，此方法与removeAll()正好相反。

◦Iterator iterator();　返回在此collection的元素上进行迭代的迭代器。

◦Object[] toArray();　把此collection转成数组。

一、特点：有序（有索引，从0开始），可重复，

二、方法：

•public Object get(int index)　

–返回列表中的元素数

•public Object add(int index, Object element);　

–在列表的指定位置插入指定元素.将当前处于该位置的元素（如果有的话）和所有后续元素向右移动

•public Object set(int index, Object element) ;　

–用指定元素替换列表中指定位置的元素

•public Object remove(int index)      

–移除列表中指定位置的元素

•public ListIterator listIterator()      

–返回此列表元素的列表迭代器

一、功能：迭代器，主要是遍历集合

二、使用：

①初始化对象：Iterator it = 集合.iterator();

②遍历：

while(it. hasNext()){//判断是否有下一个元素

        it.next();//移动指针，向下遍历一个元素

}

 it.remove();//只能删一次

三、使用增强for循环可以代替迭代器

一、特点： 使用数组结构实现的List集合

二、优点： 根据索引取元素，效率高

三、缺点：进行插入和删除元素效率较低，因为会移动后面每一个元素

四、vector：与ArrayList使用方法相同，区别在于vector为线程安全的，占资源较多

一、定义： 在定义一个集合时就指定集合存储的对象的数据类型

二、优点：将类作为一个参数，简化集合的使用

一、特点：以链表的形式存储元素

二、优点：进行插入和删除元素，效率高，原因是每删除或插入一个元素，只改变临近两个元素的首尾指针，对其他元素没有影响。

三、缺点：不方便查找，每查找一次，都需要从头开始遍历

一、特点：无序（TreeSet除外），不可重复的集合

二、方法：常用方法与List集合相同

一、特点：

1.根据每一个对象的hashCode()，通过固定的算法算出索引

  ①如果hashCode()不等，则直接放入散列表中

  ②如果hashCode()相等，则需要通过equals()进行比较

2.根据索引存到散列表中，这里需要通过equals()进行比较，如果内容相同，则不存储，反之，存储

二、注意： 对于要存放到 Set 集合中的对象，对应的类一定要重写 equals() 和 hashCode (Object   obj ) 方法 以实现对象相等规则。

一、特点：使用红黑树的结构存储元素，存入的元素已排序

二、方法：

①ceiling

②contains

③first

④floor

⑤headSet

⑥tailSet

⑦subSet

⑧pollFirst

⑨pollLast

一、特点：用于对象的比较，是一个接口

二、使用：

①使需要比较的类实现Comparable接口

②重写compareTo()方法

◦public int compareTo(Object obj);　该方法如果

–返回 0，表示 this == obj

–返回正数，表示 this > obj

–返回负数，表示 this < obj

三、局限性

只限于本类对象进行比较，且只能执行一种比较

一、特点：集合类，与Collection不同，它里面定义了一些静态方法，主要用来为集合提供工具

二、方法：

◦ void sort(List list)　根据元素的自然顺序 对指定List列表按升序进行排序。List列表中的所有元素都必须实现 Comparable 接口。

◦void shuffle(List list)　对List列表内的元素进行随机排列

◦void reverse(List list)　对List列表内的元素进行反转

◦void copy(List dest, List src)　将src列表内的元素复制到dest列表中，dest元素数需大于等于src的元素数

◦List synchronizedList(List list)  返回指定列表支持的同步(线程安全的)列表

一、特点： 实现Map接口的集合类用来存储“键-值”映射对

二、键的存储特点：

①Map实现类中存储的“键-值”映射对是通过键来唯一标识，Map底层的“键”是用Set来存放的。

②所以存入Map中的映射对的“键”对应的类必须重写hashcode()和equals()方法。

三、Map.Entry

以一个键值对为一个对象

四、Map的常用方法

◦Object  put(Object key, Object value);　//将指定的“键-值”对存入Map中

◦Object  get(Object key);　　//返回指定键所映射的值

◦Object  remove(Object key);　//根据指定的键把此“键-值”对从Map中移除。

◦boolean  containsKey(Object key);   //判断此Map是否包含指定键的“键-值”对。

◦boolean  containsValue(Object value);　    //判断此Map是否包含指定值的“键-值”对。

◦boolean  isEmpty();　　//判断此Map中是否有元素。

◦int  size();　  //获得些Map中“键-值”对的数量。

◦Set  keySet(); 　  //返回此Map中包含的键的Set集。

◦Collection values();　  //返回此Map中包含的值的Collection集。

◦void  clear();　  //清空Map中的所有“键-值”对。

一、HashMap（ 常用）

特点：对键以Set集合方式存放，元素存放到散列表中

二、TreeMap

特点：对键以红黑树方式进行排序，所以键必须可以“排序”

三、Hashtable

特点：与HashMap相同，区别在于它线程安全的，占资源较多

四、Properties

特点：① 表示了一个持久的属性集。Properties 可保存在流中或从流中加载。

           ②属性集中每个键及其对应值都是一个字符串。

           ③不支持泛型操作

ArrayList<HashMap<Integer,String>> list = new ArrayList<HashMap<Integer,String>>();
一、定义：代表文件包括：文件和目录

二、构造器：

public File(String path){..}

path:为路径，windows 系统分隔符\,比如：C:\\

                    其他系统（Android）为：/

分隔符常量：public static final String seperator(可以根据不同的系统使用，跨平台分隔符）

三、方法：

v 访问File对象的属性：

◦  public boolean canRead() //可读

◦  public boolean canWrite() //可写

◦  public boolean exists() //是否存在

◦  public boolean isDirectory() //是不是一个目录

◦  public boolean isFile()

◦  public boolean isHidden()

◦  public long lastModified()

◦  public long length() //以字节为单位

◦  public String getName()

◦  public String getPath()//返回此File对象的相对路径名

◦  public String getAbsolutePath() //返回此File对象的绝对路径名

◦  public File getAbsoluteFile()//结果同上方法，区别是返回的是File对象

◦  public String getParent()//返回上级目录，返回相对路径的上级目录为null 

v  对文件的操作：

◦  public boolean createNewFile() //不存在时创建此文件对象所代表的空

文件

◦  public boolean delete()　//删除文件。如果是目录必须是空才能删除

◦  public boolean mkdir() 　//创建此抽象路径名指定的目录

◦  public boolean mkdirs()　//创建此抽象路径名指定的目录，包括所有

必需但不存在的父目录

◦  public boolean renameTo(File dest) //重新命名此抽象路径名表示的

文件

v  浏览目录中的文件和子目录

◦  public String[] list() //返回此目录中的文件名和目录名的数组

◦  public File[] listFiles() //返回此目录中的文件和目录的File实例数组

◦  public File[] listFiles(FilenameFilter filter) //返回此目录中满足指定

过滤器的文件和目录

–  java.io.FilenameFilter接口：实现此接口的类实例可用于过滤文件名

FilenameFilter过滤器的使用：

1.创建一个类，实现FilenameFilter接口

2.重写accept方法

3.listFiles（new 过滤器子类）

一、作用：支持随机读取文件内容的类，内含指针

二、打开模式：

r：只读打开，不可写入

rw：可读可写

用法：new RandomAccessFile（file，”rw”）；

三：方法

一、定义：I---->输入，input读操作

                 O----->输出，output写操作

二、流的分类

1、按流向分

①：输入流：程序读取数据

②：输出流：程序写数据

2、按传输单位分

①：字节流：以字节为单位传输

②：字符流：以字符为单位传输

3.按功能分

①：节点流：直接操作文件

②：处理流：需要套接节点流间接操作文件

三、四个抽象流类

InputStream，OutputStream，Reader，Writer

四、使用步骤

一般操作文件时，无论是字节流还是字符流，都可以按以下步骤使用：

1、使用FIle找到执行操作的文件（内存流除外）

2.、通过File类的对象实例化字节流或字符流的子类

3、拿到对象后进行读操作，写操作，写操作要注意flush

4、关闭流（内存流除外）

一、作用：用于向程序输入数据，读操作

二、单位：8位，一字节

◦  public abstract intread() throws IOException

–  从输入流中读取数据的下一个字节, 返回读到的字节值.若遇到流的末尾,

返回-1

◦  public intread(byte[] b) throws IOException

–  从输入流中读取 b.length 个字节的数据并存储到缓冲区数组b中.返回

的是实际读到的字节总数

◦  public intread(byte[] b, intoff, int len) throws IOException

–  读取 len 个字节的数据,并从数组b的off位置开始写入到这个数组中

◦  public void close() throws IOException

–  关闭此输入流并释放与此流关联的所有系统资源  

◦  public intavailable() throws IOException

–  返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）

的估计字节数

◦  public skip(long n) throws IOException

–  跳过和丢弃此输入流中数据的n 个字节，返回实现路过的字节数。

一：作用：程序向外输出数据，写数据

二、单位：8位，一字节

三。方法

◦  public abstract void write(intb) throws IOException

–  将指定的字节写入此输出流

◦  public void write(byte[] b) throws IOException

–  将 b.length 个字节从指定的byte 数组写入此输出流

◦  public void write(byte[] b, intoff, int len) throws

IOException

–  将指定byte 数组中从偏移量off 开始的 len 个字节写入此

输出流

◦  public void flush() throws IOException

–  刷新此输出流并强制写出所有缓冲的输出字节

◦  pulbicvoid close() throws IOException

–  关闭此输出流并释放与此流有关的所有系统资源

一：作用：程序输入数据，读操作

二、单位：一个字符，2个字节，16位

三、方法：

◦  public int read() throws IOException

–  读取单个字符，返回作为整数读取的字符，如果已到达流的

末尾返回-1

◦  public int read(char[] cbuf) throws IOException

–  将字符读入数组，返回读取的字符数

◦  public abstract int read(char[] cbuf, int off, int len)    

throws IOException

–  读取 len 个字符的数据，并从数组cbuf的off位置开始写入到

这个数组中

◦  public abstract void close() throws IOException

–  关闭该流并释放与之关联的所有资源

◦  public long skip(long n) throws IOException

–  跳过n个字符。

21

一：作用：程序输出数据，写数据

二、单位：一个字符，2个字节，16位

三、方法：

◦  public void write(int c) throws IOException

–  写入单个字符

◦  public void write(char[] cbuf) throws IOException  

–  写入字符数组

◦  public abstract void write(char[] cbuf, int off, int len) throws

IOException

–  写入字符数组的某一部分

◦  public void write(String str) throws IOException

–  写入字符串

◦  public void write(String str, int off, int len) throws IOException

–  写字符串的某一部分

◦  public abstract void close() throws IOException

–  关闭此流，但要先刷新它

◦  public abstract void flush() throws IOException

–  刷新该流的缓冲，将缓冲的数据全写到目的地

一、分类

FileInputStream

FileOutputStream

构造器：FileOutputStream(file)//向文件写入数据，每次写入都会替换掉之前的数据

              FileOutputStream（File，true)//追加写入，不会替换掉之前的数据

用途：用于文件的拷贝，下载文件等

FileReader

FileWriter

构造器：FileWriter（File）//向文件写入数据，每次写入都会替换掉之前的数据

              FileWriter(File,true)//追加写入，不会替换掉之前的数据

用途：用于读取，拷贝文件中中的文本内容，中文不会乱码

二、它们都是节点流，可以直接操作数据

一、分类

ByteArrayInputStream

ByteArrayOutputStream

二、操作步骤

1、写入内存

将数据通过ByteArrayOutputStream的write方法写入到内存

2、读内存

将数据ByteArrayInputStream的read方法将内存中的数据读取出来

三、用途：

当程序执行下载或本地拷贝时，先将这些数据放入内存，再讲内存中的数据取出来放到SD卡或者应用程序中，中转用

四：内存流为节点流，可直接操作数据，并且不需要使用File，也可以不用关闭流

一。分类（都是处理流，需要套接对应的节点流）

BufferedInputStream       →inputStream

BufferedOutputStream     →OutputStream

BufferedWriter                →Reader

BufferedReader               →Writer

 

二、新增方法：

readLine（）：读取一行数据

newLine（）：写入时换行

三：特点

先将数据放入到缓冲区，然后在进行读写操作，优点是安全，读写快

四、注意：

在执行写操作时，在close之前要执行flush

一、分类

InputStreamReader：将字节输入流→字符输入流

OutputStreamWriter：将字节输出流→字符输出流

 

二、特点

完成字节→字符的转化

三、它们都是处理流，需要套接相应的字节流，与缓冲流配合较多

一、System.in：属于InputStream类型，对应键盘输入，接受键盘的输入数据

二、System.out：属于PrintStream类型，对应显示器输出，将数据显示到控制台

一、分类

DataInputStream：对应InputStream

DataOutputStream：对应OutputStream

二、特点

提供跟平台无关的数据操作，按照一定的格式输出，在网络传输数据时经常使用

一。分类

PrintStream→OutputStream

PrintWriter→Writer

二、注意

1、输出操作不用捕获IO异常

2、System.out是PrintStream的一个实例

3、打印流既是处理流也是节点流

4、输出操作既可以向文件写入内容，也可以向控制台打印输出

一。分类

ObjectInputStream：反序列化

ObjectOutputStream：序列化，需要让模型类实现Serializable接口

二、属性

transient：不能序列化

eg：private transient int  num=0；

static：不能被序列化

serialVersionUID=1L，创建序列化模型类自动生成的ID号

一、引入

1、进程：每个独立的程序

2、线程：程序中维持运行的分支

举例：人→操作系统，吃→进程，线程：睁眼，用手，张嘴吃

3、多进程：

在操作系统中同时运行多个程序

4、多线程

在同一个进程（应用程序）中同时执行多个线程

二、区别

比较点	进程	线程
代码和数据空间	每个进程独立	同一个进程中数据共享
切换开销	大	小

一、创建和启动方式

方式一：继承Thread类

步骤：①创建一个类，继承Thread

          ②重写run方法，线程体语句卸载该方法中

          ③使用Thread类对象调用start（）方法

方式二、实现Runnable接口

步骤：1、创建一个类，实现Runnable接口

          2、重写run方法。线程体语句卸载该方法中

          3、使用Thread类对象调用start（）方法，Thread类对象需要通过Runnable子类对象实例化

二、两种方式的比较

比较点	Thread	Runnable
多继承	单继承，有局限性	可以多继承，灵活易扩展
数据	每个线程都有独立数据	多个线程共享同一份数据

三、扩展知识

1、Thread类在lang包下

2、程序启动后会创建两个线程：①主线程②垃圾回收器线程

3、关于run（）份

①该方法为线程体，当启动线程时会调用该方法，执行线程体

②启动线程需要使用start（）方法，此时线程进入RUNNABLE状态

③在启动线程时不需要直接调用run（）方法，因为它没有提体现多线程机制

public void start()

◦  使该线程开始执行

v  public staticThread currentThread()

◦  返回对当前正在执行的线程对象的引用

v  public final boolean isAlive()

◦  测试线程是否处于活动状态

v  public Thread.State getState()

◦  返回该线程的状态

v  public final String getName()

◦  返回该线程的名称

v  public final void setName(String name)

◦  改变线程名称

一、线程状态的分类

new：创建一个线程：比如：MyThread mt=new MyThread();

RUNNABLE:可运行状态：比如：mt.start();

WAITING/TIMED_WAITING:阻塞状态，比如：mt.sleep();

BLOCKED:锁定状态，如果当前线程被解锁，还可以再次执行

TERMINATED：终止状态，线程体结束

二、设置线程的优先级

1、范围：1-10

2、常量

MAX_PRIORITY----->10

MIN_PRIORITY------>1

NORM_PRIORITY----->5

3、方法：

setPriority(int);

getPriority();

一、引入

当一个进程有多个线程时，会发生多线程抢占资源的问题，引入同步可以解决这些问题

二、关键字synchronized

使用：

1、锁对象

synchronized（obj）{

//代码块

}

注意;多个线程需要锁相同的对象才会产生同步，否则每个线程都会异步执行各自的代码

2、锁方法

修饰符synchronized返回值类型 方法名（）

{

//方法体

}

一、引入

线程1锁住资源A等待资源B，线程2锁住资源B等待资源A，两个线程都在等待自己需要的资源，而这些资源被另外的线程锁住，这些线程你等我，我等你，都不愿意让出资源，这样死锁就产生了

二、解决

在定义锁时，也就是定义synchronized时，需要考虑当前资源被锁后，其他线程该资源也被锁

一、线程本地化变量（Thread Local Variable，简称TLV）

二、作用：将变量保存袋某一线程中，当需要时再从该线程中取出变量

三、方法

set（变量）：将变量存入当前 线程中

get（）：从当前线程中取出对应的变量

Collections.synchronizedList(list);将List集合变为同步，避免了多线程同时操作同一个集合

附加：

正则表达式：所谓正则表达式，就是一个可以匹配N个字符串的字符串模板

java正则表达式功能不强：（regex  （regular Expressing））jdk1.4才加进来的

String 里加如下方法与正则表达式有关

matches（String regex）replaceAll（"\\.","*");replaceAll(String regex,String replacement)

正则表达式所支持的通配符：

.  ——可匹配任意字符

\s ——代表任意一个空白（空格，Tab）

\S——代表任意一个非空白

\d——代表任意一个数字                                   digital

\D——代表任意 一个非数字

\w——代表一个单词字符                                  word

\W——代表一个任意的非单词字符

方括号表达式

枚举：【ax中】——代表a或x或中其中任意一个字符

范围：【a-f】——代表啊a,b,c,d,e,f其中任意一个字符

枚举与范围共存：【a-f5-7】——代表a,b,c,d,e,f，5,6,7其中任意一个字符

表示求否：【^a-f】:只要不是字符中a,b,c,d,e,f的任意一个字符即可

表示求交：【a-g&&[^b-d]]：只要不是a,e,f,g字符的任意一个字符即可

表示出现的次数的“副词”

？表示它前面的东西可出现0到1次

* 表示它前面的东西可出现 0到N次

\\d{6}19\\d{2}[01]{  

+表示它前面的东西可出现1~N次

{n，m}表示它前面的东西可出现n~m次

{，m表示它前面的东西可出现最多m次

{n，}表示它前面的东西可出现最少n次

{n}表示它前面的东西可出现n次

特殊字符：（用的时候要用转义字符\）

（ ）

 { }

 [ ]

\

?

*

+

^——代表一行的开头

$——代表一行的结尾

|

Pattern---代表正则表达式模板

matcher------代表匹配工具类

find（）——查找下一个与正则表达式的子串

group（）——取出上一次与正则表达式的子串

如果你想用到正则表达式更复杂的功能，可使用Pattern和Matcher

邮箱的正则表达式：[a-zA-Z0-9_]{2,}@[a-zA-Z0-9]{2,}\\.(com|org|cn|net);

模板方法设计模式：

在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，

那么这时候就将不确定的部分暴露i出去，由该类的子类完成，提高了扩展性和复用性

abstract class GetTime

{

public final void getTime()//子类不让重写final修饰

{
long start=System.currentTimeMillis();

runcode();

long end=System.currentTimeMillis()

System.out.println("毫秒"+(end-start));

}

public abstract void runcode();抽象方法子类实现

}

class SubTime extends GetTime//子类

{

public void runcode()

{

for(int x=0;x<400;x++)

{

System.out.println(x);

}

}

}

public interface MyAction()

{
void eeat();

}//事件接口

//main方法

public class ActionNotify{

private boolean isHappened;

private MyAction myAction;

public ActionNotify(MyAction myAction){

this.myAction=myAction;

}

public boolean isHappened(){

return isHappend;

}

public void setHappend(boolean isHappend)

{

this.isHappend=isHappend;

}

public void doAction(){
if(isHappend){

//调用eat（）方法

myAction.eat();

}else{

//不调用eat方法

System.out.pritnln("没到时间不能吃放");

}

}

}

//触发事件的通知类

public  class CallBack implements MyAction{

private ActionNotify an;

public CallBack()

{
an=new ActionNotify(this);

}

public ActionNotify getAn()

{
return an;

}

public void setAn (ActionNotify an)

{

this.an=an;

}

public static void main(String args[])
{
CallBack callBack=new CallBack();

callBack.getan().doAction();

callBack.getAn().setHappend(true);

callBack.getAn().doAction();

public void eat()

{
Syso("到时间了，该吃饭了。。");

}

}

1、 final修饰成员变量时，修饰的成员变量必须初始化其值，修饰的局部变量不需要有初始值。

2、内部类实例化类的格式

Outer outer =new Outer();

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

静态内部类实例化格式

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

**局部（区域）内部类中的变量必须是final修饰（why）

2.可以直接访问外部类中的成员，因为还持有外部类类中的引用。但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量

v 局部内部类也叫区域内嵌类

v 局部内部类与成员内部类类似，不过，区域内嵌

类是定义在一个方法中的内嵌类，所以类的作用

范围仅限于该方法中，而类生成的对象也只能在

该方法中使用。另外，由于是在方法中定义，因

此区域内嵌类不能加上private，protected

，public中的任何一个修饰符

v 不能包含静态成员 

3、 **局部变量不能修饰为静态的

class ArrayTest

{

public static void main(Stringargs[])

{

toBin(-6);

}

//十进制转二进制

public static void toBin(int num)

{

trans(num,1,1);

}

//十进制转八进制

public static void toOct(int num)

{

trans(num,7,3)

}

//查表法通用写法

public static void trans(int num,int base,int offse)

{

if(num==0)

{

System.in.out.println(0);

return ;

}

char[] chs={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f';

char[] arr=enw char[32];

int pos=arr.length;

while(num!=0;

{

int temp=num&base;

arr[--pos]=char[temp];

num=num>>>offset;

}

for(int x=pos;x<arr.length;x++)

{

System.out.println(arr[x]);

}

}

}

public Test NeiMingNeiBuLei{

public static void main(String args[])

{
new A{

void aa(){

Systen.out.println("我是匿名内部类");

}

}.aa();

}

}

 interface A{

void aa();

}

写法：new接口或类名（）

{

重写的方法;}

重写类或接口中的方法

调用：在}结尾处调用重写的方法

返回：匿名内部类返回的是类或接口中的一个实例

作用：方便使用接口或抽象类中的方法，无须再创建一个类

package org.mobiletrain.singlefactory;

//父类Food

public interface Food {

 public void getInfo();

}

//子类Chicken

package org.mobiletrain.singlefactory;

public class Chicken implements Food{

 private static Chicken chicken=new Chicken();

 private Chicken()

 {

 

 }

 public static Chicken getInstance()

 {

  return chicken;

 }

 @Override

 public void getInfo() {

  // TODO Auto-generated method stub

  System.out.println("给我鸡块");

 }

 

}

//子类Clips

package org.mobiletrain.singlefactory;

public class Clips implements Food{

 private static Clips clips=new Clips();

 private Clips()

 {

 

 }

 public static Clips getInsance()

 {

  return clips;

 }

 @Override

 public void getInfo() {

  // TODO Auto-generated method stub

  System.out.println("给我薯条");

 }

 

}

//工厂

package org.mobiletrain.singlefactory;

public class foodFactory {

 public static Food getFood(String type)

 {

  if(type.equals("chicken"))

  {

   return Chicken.getInstance();

   //Chicken c=new Chicken();

   //return c;

   //给小明一个麦香鸡

  }

  else if(type.equals("clips")){

   //是给小明一袋薯条

   return Clips.getInsance();

  }

  return null;

 }

}

//Test

package org.mobiletrain.singlefactory;

public class TestFactory {

 public static void main(String[] args) {

  // TODO Auto-generated method stub

  //Chicken chicken =(Chicken) //foodFactory.getFood("chicken");

Food Chicken =foodFactory.getFood("Chicken");

  Food clips =foodFactory.getFood("clips");

//注意这里用Food接口来接受，屏蔽了子类的信息，用户看不见子类信息，及工厂模式的主要作用

（好像用了转型）看不太明白）

  chicken.getInfo();

  clips.getInfo();

 }

}