java，

java，

Java语言概述（源文件的名称必须与主类名(含有main方法的类)一致）
Java命名规范
package的命名
Package的名字应该都是由小写字母组成。
Class的命名
Class的名字必须由大写字母开头而其他字母都小写的字符串组成
Class变量的命名
变量的命名必须用一个小写字母开头，后面的字符串以大写字母开头。
Static final 变量的命名
Static Final变量的名字应该都大写，并且指出完整含义。
参数的命名
参数的名字必须和变量的命名规范一致。使用有意义的参数命名，如果可能的话，使用和要赋值的字段一样的名字。
数组的命名
数组应该总是以下面的方式命名：
Byte[] buffer;
方法的名
方法的命名第一个字母用小写字母开头,之后的字母以大写字母开头.
Java是区分大小写的
计算机的程序均由两类元素组成：代码和数据。
面向对象的编程，是围绕“谁将受到影响”进行，即以代码的相关数据为核心点进行程序编写。面向对象的编程着眼于它的数据（即对象）和为此数据严格定义的接口来组织程序，程序实际上是用数据控制对代码的访问。

面向对象系统的三大特性：封装性、继承性、多态性。
封装性
封装（Encapsulation）是将代码及其处理的数据绑定在一起的一种编程机制，该机制保证了程序和数据都不受外部干扰且不被误用。Java封装的基本单元是类。一个类定义了将一个对象集共享的结构和行为（代码和数据）。类定义的数据称为成员变量（member variables）。操作数据的代码称为成员方法（member methods）。

继承性
继承（Inheritance）是一个对象获得另一个对象的属性的过程。
 
多态性
多态即允许一个接口被多个同类动作所使用的特征，具体使用哪一个动作与应用场合有关。所谓多态性就是当不同的对象收到相同的消息时，产生不同动作的特性。多态性就是使用一个名称来定义不同的方法，这些方法执行类似的但又不同的操作，即以相同的接口来访问功能不同的函数，从而实现“一个接口，多种方法”。

Java是一种解释执行的程序。
Java语言中定义了三种注释形式：
//单行注释---注释到行尾
/*单行或多行注释*/
/**可以用于文档化处理的单行或多行注释*/

Java分隔符
▉Java分隔符组成
分号—“；”
花括号—“{}”
空格—“”
▇jJava分隔符作用
Ø    Java语句必须以分号作为结束标Ø    记
Ø    Java允许用花括号”{}”将一组语句括起来，Ø    形成一个语句块（block）
Ø    Java程序源代码中各组成部分之间可以以插入任意数量的空格，Ø    包括换行。
第一个java程序
Public class HelloWorldApp {
   Public static void main （string args[]）
   {
      System.out.printin(“Hello World!”);
   }
}


在java中可以编写两类程序：应用程序（applications）和Java Applet (小应用程序)
两者的区别：Java Applicaton是完整的程序，需要独立的解释器来解释运行，而Java Applet则是嵌在HTML编写的Web页面中的非独立程序，由Web浏览器内部包含的Java解释器来解释运行。

使用变量的注意事项
变量命名不能重复
Java区分大小写
变量必须先定义，再使用
1、只有定义过，才能为其分配相应数量的存储单元
2、一旦定义，变量类型才能确定，才能检查其运算的合法性
变量定义的例子
 
public class JavaDemo02
{
    // 主方法
    public static void main(String args[])
    {
        // 变量定义的格式：变量的类型 变量的名称 = 初值 ;
        int x = 30 ;
        int y = 20 ;
        // 修改x的内容：变量名称 = 新值
        x = 50 ;
        // 打印 x + y的值
        System.out.println(x + y) ;
    }
};     


Java语言基础
1、标识符（Identifier）是赋给类、方法或者变量的名称。可以由大写/小写字母、数字、下划线、美元符号按照一定的顺序组合而成，但不能以数字开头。
2、关键字是指被系统所保留使用的标识符。这些标识符不能被编程人员用作变量名、类名或方法名。
3、字面量是指由文字所表示的取值，也可以称为常量。它能在程序中的任何地方被它所允许的类型直接使用，代表的是所属类型的一个实在值。
4、基本数据类型：
整数类型：字节型（byte）、短整型（short）整型（int）、长整型（long）都是有符号整数。
浮点类型：浮点型（float）和双精度型（double）他们代表有小数精度要求的数值。
字符类型：字符型（char）它代表字符集的符号。
布尔类型：布尔型（Boolean）


类名称首字母需要大写

Java数据类型的划分：
基本：数值、小数（浮点）、字符、Boolean
引用：类、接口、数组

Int类型它所能存储多大的数字：Integer MAX­_VALUE；Integer MIN­_VALUE；
Java字符采用Unicode编码，每个字符占两个字节，因而可用十六进制编码形式表示
Java语言中还允许使用转义字符“/”来将其后的字符转变为其它的含义

转义字符
/n: 表示换行
/t: 制表符，按下TAB键一样
/”:打印“””
/’:打印“‘“
/b: 退格
//: “/”

逻辑运算符返回的都是Boolean值

注意：在程序中“=“表示赋值，”==“是表示逻辑运算，判断两个数值是否相等

短路逻辑运算符应用
&&：第一个操作数为假则不判断第二个操作数
||：第一个操作数微真则不判断第二个操作数

扩展赋值运算符
运算符：+=   用法举例  a+=b  等效的表达式 a=a+b
分支循环语句
If…else语句
 
public class JavaDemo02
{
    public static void main(String rags[])
    {
        float score = 59 ;
        if(score>=60)
        {
            System.out.println("成绩合格。") ;
        }
        else
        {
            System.out.println("成绩不合格。") ;
        }
    }
};     
if…elseif…else
 
public class JavaDemo04
{
    public static void main(String args[])
    {
        float score = 55 ;
        if(score>=90&&score<=100)
        {
            System.out.println("等级为A等。") ;
        }
        else if(score>=80&&score<90)
        {
            System.out.println("等级为B等。") ;
        }
        else if(score>=70&&score<80)
        {
            System.out.println("等级为C等。") ;
        }
        else if(score>=60&&score<70)
        {
            System.out.println("等级为D等。") ;
        }
        else
        {
            System.out.println("等级为E等。") ;
        }
    }
};     
Switch…case
 
public class JavaDemo05
{
    public static void main(String args[])
    {
        int i = 4 ;//此处也可以使用char型，char型可以自动转换为int型
        switch(i)
        {
            case 1:
                System.out.println("条件1满足。") ;
                // 表示退出switch语句
                break ;
            case 2:
                System.out.println("条件2满足。") ;
                break ;
            case 3:
                System.out.println("条件3满足。") ;
                break ;
            default:
                // 如果一切条件都不满足了，则执行default语句
                System.out.println("没有任何条件满足。") ;
                break ;
        }
    }
};     

分支语句：
If、if…else、if…elseif…else
Switch、case、default、break

一般在以下情况下要使用for循环：
当明确知道循环次数的时候，使用for循环
如果不知道要循环多少次，则使用另外一种循环——while循环
For循环语句6
 
public class JavaDemo08
{
    public static void main(String args[])
    {
        // 打印1~100
        for(int i=1;i<=100;i++)
        {
            System.out.print(i+"/t") ;
        }
    }
};     
While循环
 
public class JavaDemo12
{
    public static void main(String args[])
    {
        /*
        for (int i=0;i<100 ;i++ )
        {
            System.out.print("*") ;
        }
        */
        // 用while循环进行打印
        int i = 1 ;
        while(i<100)
        {
            System.out.print("*") ;
            // 编写一段代码用于循环的条件改变
            // i += 1 ;    // i++
        }
    }
};     
Do…while循环语句
 
public class JavaDemo13
{
    public static void main(String args[])
    {
        int i = 0 ;
        do
        {
            // 先执行循环体一次，之后再进行条件的判断
            System.out.print("*") ;
            i++ ;
        }while(i<100) ;
    }
};     
Break的使用
 
public class JavaDemo15
{
    public static void main(String args[])
    {
        for (int i=1;i<=100;i++)
        {
            if(i>=50)
            {
                // 程序中断，不再被执行
                // break一般与if语句联用
                break ;
            }
            if(i%2==0)
            {
                System.out.print(i+"/t") ;
            }
        }
    }
};     
Continue的使用
 
public class JavaDemo16
{
    public static void main(String args[])
    {
        for (int i=1;i<=10;i++)
        {
            // 如果是5，则不打印
            if(i==5)
            {
                // 不打印
                continue ;
            }
            System.out.print(i+"/t") ;
        }
    }
};



public class JavaDemo17
{
    public static void main(String args[])
    {
        for (int i=1;i<=100;i++)
        {
            if(i>=40&&i<=50)
            {
                continue ;
            }
            if(i%2==0)
            {
                System.out.print(i+"/t") ;
            }
        }
    }
};     

三目运算符
一般形式：Boolean表达式1？表达式2：表达式3
三目运算符
 
public class JavaDemo06
{
    public static void main(String args[])
    {
        int i = 20 ;
        int j = 50 ;
        // 将i 和j 中的最大值赋值给max
        int max = 0 ;
        /*
        if(i>j)
        {
            max = i ;
        }
        else
        {
            max = j ;
        }
        */
        max = i>j?i:j ;
        System.out.println("最大值 MAX = "+max) ;
    }
};     

方法与数组
方法名称编写时：第一个单词首字母小写，之后每个单词首字母都要大写。
如果要定义一个有返回值的方法，则将viod改为相应的类型

方法的重载就是指通过相同的方法名称，根据传入参数的类型或个数不同，完成的功能也不同，例如：System.out.print（）方法就可以接收各种类型的参数。

方法名称相同
参数的个数或类型不同
方法就是一段可以重复调用的代码段
方法的定义
 
public class JavaDemo06
{
    public static void main(String args[])
    {
        printTab() ;
    }
    // 定义一个方法，此方法用于打印Hello World
    // public static必须加上，因为是由主方法直接去调用
    // void：表示此方法不需要任何返回值
    // print：表示方法的名称，可以任意编写
    // 方法名称编写时：第一个单词首字母小写，之后每个单词的首字母大写
    public static void printTab()
    {
        System.out.println("************************") ;
        System.out.println("*      Hello World     *") ;
        System.out.println("*      www.mldn.cn     *") ;
        System.out.println("************************") ;   
    }
};     

Public static 方法返回值 方法名称（[参数列表]）
{
         语句；
         [return 返回值]
}

由主方法直接去调用的方法在定义是必须加上public static

方法名称编写时：第一个单词首字母小写，之后每个单词首字母都要大写。
如果要定义一个有返回值的方法，则将viod改为相应的类型

方法的重载就是指通过相同的方法名称，根据传入参数的类型或个数不同，完成的功能也不同，例如：System.out.print（）方法就可以接收各种类型的参数。

1方法名称相同
2参数的个数或类型不同
例如：方法的重载
 
public class JavaDemo08
{
    public static void main(String args[])
    {
        add(10.0f) ;
    }
    public static void add()
    {
        System.out.println("** 1、无参的add方法.") ;
    }
    public static void add(int i)
    {
        System.out.println("** 2、有一个参数的add方法。") ;
    }
    public static void add(int i,int j)
    {
        System.out.println("** 3、有两个参数的add方法。") ;
    }
    public static void add(float i)
    {
        System.out.println("** 4、float参数的add方法。") ;
    }
};     

    方法的重载也称为一种多态性——方法的多态性，通过同一个方法名称完成的功能不同。

一维数组声明
Type var[]或type[]var
Java语言中声明数组时不能指定其长度（数组中元素的个数）
引用类型的数据在声明是，默认的初始化值是“null“
Null：此数据没有，暂时不能使用
引用的数据类型都必须开辟空间——new开辟空间

数组声明 例：
//声明了一个数组
Int I[]=null;
//使用数组
I=new int[10];
数组名称在栈内存中定义，开辟空间是在堆内存中开辟的

引用传递指的就是传递的内存地址的使用权
在Java中为了避免出现数组越界的错误，准备了一个length属性，可以通过其求出数组的大小。例如：a.length指明数组a的长度（元素个数）。

数组是引用数据类型，传递的是地址->方法已经明确验证，方法没有任何的返回值，靠的是修改内存空间。
数组的声明与使用
 
public class JavaDemo03
{
    public static void main(String args[])
    {
        // 声明了一个数组
        int i[] = null ;
        // 使用数组？
        i = new int[10] ;
        // i[0]  ~ i[9]
       
        for (int x=0;x<10;x++)
        {
            i[x] = x * x ;
        }
        System.out.println("--------- 改变之前------------------") ;
        for (int x=0;x<10;x++)
        {
            System.out.println("i["+x+"] = "+i[x]) ;
        }
        // 为开辟的堆内存空间声明一个别名
        int y[] = i ;
        // 将y中的内容进行修改
        for (int x=0;x<10;x++)
        {
            y[x] = x + 1 ;
        }
        System.out.println("--------- 改变之后------------------") ;
        for (int x=0;x<10;x++)
        {
            System.out.println("i["+x+"] = "+i[x]) ;
        }
    }
};     
二维数组
 
public class JavaDemo05
{
    public static void main(String args[])
    {
        int a[][] = {{1,3},{2,3,4,5},{2,3,4}} ;
        for(int i=0;i<a.length;i++)
        {
            for(int j=0;j<a[i].length;j++)
            {
                System.out.print(a[i][j]+"/t") ;
            }
            System.out.println("") ;
        }
    }
};     
数组与方法的结合使用
 
public class JavaDemo10
{
    public static void main(String args[])
    {
        int i[] = init(20) ;
        // 调用init方法就可以为数组初始化
        // init(i) ;
        // 打印数组
        print(i) ;
    }
    // 声明一个方法，要求此方法可以为数组中的内容初始化内容
    // 0--> 1、1--> 2
    // 把堆内存空间的内容取出，之后在方法中进行加工
    // 表示数组开辟的大小
    public static int[] init(int len)
    {
        // java中的数组是可以动态开辟的
        int x[] = new int[len] ;
        // 进行数组的初始化
        for (int y=0;y<x.length;y++)
        {
            x[y] = y + 1 ;
        }
        return x ;
    }
    // 定义第二个方法，此方法用于打印数组
    public static void print(int x[])
    {
        for (int y=0;y<x.length;y++)
        {
            System.out.println("数组["+y+"] = "+x[y]) ;
        }
    }
};     
数组的拷贝
 
public class JavaDemo11
{
    public static void main(String args[])
    {
        int source[] = {1,2,3,4,5,6} ;
        int dest[] = {11,22,33,44,55,66,77,88,99} ;
        System.out.println("------- dest数组拷贝之前 ---------") ;
        printArray(dest) ;
        // 进行数组的拷贝
        System.arraycopy(source,0,dest,0,source.length) ;
       
        System.out.println("------- dest数组拷贝之后 ---------") ;
        printArray(dest) ;
    }
    public static void printArray(int x[])
    {
        for (int i=0;i<x.length;i++)
        {
            System.out.println("数组["+i+"] = "+x[i]) ;
        }
    }
};     

面向对象
类是对某一类事物的描述，是抽象的、概念上的定义；对象是实际存在的该类事物的每个个体，因而也称实例（instance）
类是对象的模板，对象是类的具体实现。
            类的定义格式
Class 类名
{
          属性：
          方法：
}
属性也叫成员变量
方法也叫成员方法
            对象的产生
格式：类名 对象名=new 类名（）
例如：Person pI=new Person（）；
 
/*
定义格式：
class 类名称
{}

标准的命名规范：首字母大写
*/
class Person
{
    // 名字
    String name ;
    // 年龄
    int age ;
};
// 要使用类需要通过对象
public class OODemo01
{
    public static void main(String args[])
    {
        // 格式：类 对象名 = new 类() ;
        // 声明一个对象 lxh1
        // 在方法中声明对象时必须赋值
        Person lxh1 = null ;
        // 为对象实例化，开辟堆内存空间
        lxh1 = new Person() ;
        lxh1.name = "李兴华" ;
        lxh1.age = 28 ;

        Person lxh2 = null ;
        // 对象的引用传递
        lxh2 = lxh1 ;

        lxh2.name = "魔乐先生" ;
        lxh1.age = 20 ;

        // 试着输出：
        System.out.println("姓名："+lxh1.name) ;
        System.out.println("年龄："+lxh1.age) ;
        System.out.println("*********************************") ;
        System.out.println("姓名："+lxh2.name) ;
        System.out.println("年龄："+lxh2.age) ;
    }
};     

程序之中，不再有任何指向的空间称为垃圾空间→JVM回收，垃圾收集（GC）→自动完成
栈→对象名
堆→对象属性
全局代码区→所有的方法

构造方法
特征：它具有与类相同的名称
      它不含返回值类型的定义
      它不能在方法中用return语句返回一个值
构造方法的定义及 使用
构造方法的定义：
Class Person{
 Public Person（）{}
}
构造方法调用时机
—构造方法在实例化对象时被自动调用，主要用来为类中的属性初始化
构造方法的重载
—与一般方法重载类似，只要参数的个数类型不同即可

对象产生的格式：
类 对象名 = new 类（）；
类（）：调用类中的构造方法
  在JAVA中每个类必须有一个构造方法，如果没有构造方法，则会自己生成一个无参的什么都不做的构造方法，因为所有的对象产生是都必须调用构造方法。
  如果程序中已经明确写出了构造方法，则不会再产生一个无参的什么都没有的构造方法。
结论：无论采用那种方法为类中的属性赋值，最好都经过setter方法，由setter方法输入的内容进行检测，而getter方法只是将内容简单的返回。

String是一个类，
String name1=new String（“刘虎琪”）：→开辟了两个空间，其中有一个是垃圾空间
String name2=“刘虎琪”；→只开辟了一个空间
比较字符串是否相等使用equals方法
使用“==”与“equals”的不同？
• equals：可以比较内容，是两个字符串内容的比较
• ==：数值比较，比较的是内存地址的值是否相等

String的另外一个特殊之处：String使用了JAVA中的共享设计模式
String类型的对象是不可改变的

This的使用
可以调用本类中的方法
—一般方法
—构造函数
   调用构造方法时，this（）要放在构造方法的首行
可以调用本类中的属性
可以表示当前对象

使用this完成构造方法间的相互调用
 
class Person
{
    private String name ;
    private int age ;
    /*
        程序要提供一个无参的构造方法，此构造方法用于打印创建person对象的信息
        程序要再提供一个设置姓名的方法，年龄的默认值为1，但此方法也要打印对象创建信息
        程序要再提供一个有两个参数的构造方法，用于设置姓名和年龄，但要求也打印对象创建信息
    */
    public Person()
    {
        System.out.println("** 创建了一个Person对象。") ;
    }
    public Person(String name)
    {
        // 调用本类中的无参构造方法
        this() ;
        this.setName(name) ;
        this.setAge(1) ;
    }
    public Person(String name,int age)
    {
        this(name) ;
        this.setAge(age) ;
    }
    public void setName(String name)
    {
        this.name = name ;
    }
    public void setAge(int age)
    {
        this.age = age ;
    }
    public int getAge()
    {
        return this.age ;
    }
    public String getName()
    {
        return this.name ;
    }
};
public class OODemo16
{
    public static void main(String args[])
    {
        Person per = new Person("张三",30) ;
    }
};     

对象数组的创建
一、创建格式：
  类名 对象名[]=new 类名[个数]
二、实例化对象数组
  对象名[索引]=new 类名（）；

Static关键字的使用
在类中写的一个属性，如果使用static声明，则 表示此属性为公有属性，即：所有对象都可以访问此属性。

Final关键字的使用：
全局常量：public static final String NAME=“MLDN”；
呗final标记的变量成为常量
在JAVA之中被final标记的变量最好用大写表示

抽象类：就是包含一个抽象方法的类
   抽象方法就是一个只有声明而没有实现的方法
抽象类与普通类之间的差别:
比普通类的定义中多出一个抽象方法，普通类的所有定义在抽象类中都可以使用
在类的声明处需要用abstract声明微抽象类，抽象方法也必须用abstract来声明。

抽象类的使用规则
抽象类不能被直接实例化，也就是不能直接用new关键字去实例化对象。
抽象方法只需声明，而不需实现。
含有抽象方法的类必须被声明为抽象类，抽象类的子类必须复写所有的抽象方法。
抽象类必须有子类，即子类中要去完全的覆写抽象类中的抽象方法。

接口与包
接口：是抽象方法和常量的集合
定义接口
[访问说明符] interface 接口名称 [extends 接口列表]
{
     //方法和静态常量的定义
}
接口与类的定义格式三点差异：
在创建接口时所定义的方法没有指出具体实现部分，而只是声明方法返回值类型和参数表，也就是说接口的方法不能拥有方法体。具体细节是由继承该接口的之类负责实现的。
接口中说明的变量是不可改变的，并且总是公有的、静态的和最终的。
在extends关键字之后指出继承关系时，接口可有多个父接口，用逗号隔开。
▉实现接口的类中必须覆盖接口中的每个方法。

包：是一组相关的类和接口的集合，类似于其他语言中函数库的功能。
将类或接口添加至包中
使用package语句，并将它放置java源程序文件的第一条语句
Package 包名称
访问包中的类或接口
Import 包名称.类名
Import 包名称.接口名
Import 包名称.*    表示程序可以引入包中的所有类和接口

Java类库的常用类和接口

一个类可以同时实现多个解接口
接口的实现使用关键字：implements
子类要实现接口中全部的抽象方法
接口中访问权限永远是：public
接口在程序中叫做实现，即一个接口必须通过子类实现

接口的使用规则：
一个新的接口用extends关键字去继承一个已有的接口，实现接口的多继承
例：interface接口A extends 接口1，接口2{}
多态性：
方法的多态性（重载），同一个方法名称根据传入参数的不同，完成的功能也不同
对象的多态性
对象多态性是在继承应用上的一种扩展，所以程序要先有继承关系才能够去使用多态性

向上转型：子类→父类，自动
如果一个方法被子类覆写了，则子类与父类之间发生转换时，自动去调用已经被覆写的方法（也就是子类中的方法）
向下转型：父类→子类，强制

两个常见的错误：ClassCastException（两个对象之间没有任何关系而进行转换）、NullPointerException

Instanceof的使用
对象 instanceof 类
例：a instanceof B
如果对象a是类B的实例则返回true,反之则返回false

对象多态性最核心的部分就是方法的覆写与继承的关系，只要有继承关系，只要有覆写过的方法，则子类向父类进行转型时，肯定调用被子类覆写过的方法（核心）。

开发建议：不要去继承一个已经实现好的类


接口与抽象类
 
    抽象类    接口      
相同    对象不能直接实例化，通过多态性，可由其子类实例化      
不同     包括一般方法、抽象方法、变量、常量    包括常量、抽象方法      
     可以有构造方法    不能有构造方法      
     抽象类可以实现多个接口    接口不能继承一个抽象类      
     继承时，单继承会有局限    解决单继承甙类的局限     
接口中都是抽象方法，则子类必须全部覆写接口中的全部抽象方法，如果不需要全部覆写，则可以：
 
interface A
{
    public void fun1() ;
    public void fun2() ;
    public void fun3() ;
}
abstract class B implements A
{
    public void fun1()
    {}
    public void fun2()
    {}
    public void fun3()
    {}
};
class C extends B
{
    public void fun1()
    {
        System.out.println("HELLO MLDN ...") ;
    }
};
public class OODemo06
{
    public static void main(String args[])
    {
        A a = new C() ;
        a.fun2() ;
    }
};     



Objiect类
所有的类都必须继承自Object类
复写equals（）方法
复写toString（）方法
tostring（）：在对象打印时默认调用，但是默认情况下调用的是Object类中的toString（），如果一个类希望按自己的方式打印对象，则可以通过覆写的方式，将toString()方法覆写掉。

异常
 
class MathDemo
{
    // 此方法有没有可能发生异常？
    public int div(int i,int j) throws Exception
    {
        if(j==0)
        {
            throw new Exception("被除数不能为零。") ;
        }
        return i / j ;
    }
};

public class OODemo11
{
    public static void main(String arg[])
    {
        try
        {
            System.out.println(new MathDemo().div(10,0)) ;
        }
        catch (Exception e)
        {
            System.out.println(e) ;
        }
    }
};     
常见的异常
ArithmeticException
ArraylndexOutOfBandsException
ArrayStoreException
IOException
FileNotFoundException
NullPointerException
NumberFormatException
 
// 编写一个类继承自Thread类
class Demo implements Runnable
{
    // 因为多线程需要一个程序的主体
    // 子类要覆写Thread类中的run方法
    private String info ;
    public Demo(String info)
    {
        this.info = info ;
    }
    public void run()
    {
        for(int i=0;i<10;i++)
        {
            System.out.println(this.info+"：i = "+i) ;
        }
    }
};
public class ThreadDemo03
{
    public static void main(String args[])
    {
        // 因为实现的是Runnable接口，所以需要通过Thread类启动多线程
        Demo d1 = new Demo("线程1") ;
        Demo d2 = new Demo("线程2") ;
        Demo d3 = new Demo("线程3") ;
        Thread t1 = new Thread(d1) ;
        Thread t2 = new Thread(d2) ;
        Thread t3 = new Thread(d3) ;
        // 启动多线程
        t1.start() ;
        t2.start() ;
        t3.start() ;
    }
};     

线程名称的设置及取得
1、    取得当前运行的线程
public Static Thread currentThread()
2、    取得线程名3、    称
   在Thread API中，使用getName方法读取当前的名字
3、设置线程名称
   在Thread API中，使用setName()方法可以显示指定Thread对象的名字

 
方法    功能      
isAlive()    判断线程是否还“活”着，即线程是否还未终止      
getPriority()    获得线程的优先级数值      
setPriority()    设置线程的优先级数值      
Thread.sleep()    将当前线程睡眠      
join()    调用某线程的该方法，将当前线程与该线程“合并”，即等待该线程结束，再恢复当前线程的运行      
wait()    当前线程进入对象的wait pool      
Notify()/notifyAll()    唤醒对象的wait pool中的一个/所有等待线程     
 
// 实现Runnable接口
class Demo implements Runnable
{
    public void fun()
    {
        for(int i=0;i<10;i++)
        {
            try
            {
                Thread.sleep(1000) ;
            }
            catch (Exception e)
            {
            }
            System.out.println(Thread.currentThread().getName()+" --> 在运行。。。") ;
        }
    }
    public void run()
    {
        this.fun() ;
    }
};
public class ThreadDemo10
{
    public static void main(String args[])
    {
        Demo d = new Demo() ;
        Thread t1 = new Thread(d,"线程1") ;
        Thread t2 = new Thread(d,"线程2") ;
        t1.start() ;
        t2.start() ;       
    }
};     
查看线程的中断状态
可以在Thread对象上调用isInterrupted()方法来检查任何线程的中断状态Public Boolean isInterrupted()

多线程问题—资源协调
1、用synchronized来标识的区域或方法即为监视器监视的部分。
2、一个类或一个对象由一个监视器，如果一个程序内有两个方法使用synchronized标志，则他们在一个监视器管理之下。
3、一般情况下，只在方法的层次上使用关键区

代码块（四种）
普通代码块（直接写在方法之中的）
 
public class Demo01
{
    public static void main(String args[])
    {
        int x = 0 ;
        {
            x = 100 ;
        }
        System.out.println("x = "+x) ;
    }
};     
构造块：直接写在类之中的
 
class Person
{
    {
        System.out.println("构造块。") ;
    }
    public Person()
    {
        System.out.println("构造方法。") ;
    }
};
public class Demo02
{
    public static void main(String args[])
    {
        new Person() ;
        new Person() ;
    }
};     
3、静态块：使用static关键字括起来的代码块叫做静态块，只折行一次。
 
class Person
{
    static
    {
        System.out.println("静态块") ;
    }
    {
        System.out.println("构造块。") ;
    }
    public Person()
    {
        System.out.println("构造方法。") ;
    }
};
public class Demo03
{
    public static void main(String args[])
    {
        new Person() ;
        new Person() ;
    }
};     
同步代码块：使用sychronized关键字括起来的代码块表示同步代码块
同步代码块需要一个同步对象
 
class Demo implements Runnable
{
    private int ticket = 10 ;
    public void run()
    {
        while(ticket>0)
        {
            // 加入同步块
            synchronized(this)
            {
                if(this.ticket>0)
                {
                    try
                    {
                        Thread.sleep(100) ;
                    }
                    catch (Exception e)
                    {
                    }
                    System.out.println(Thread.currentThread().getName()+" --> 卖票："+this.ticket--) ;
                }
            }
        }
    }
};
public class ThreadDemo15
{
    public static void main(String args[])
    {
        Demo d = new Demo() ;
        Thread t1 = new Thread(d,"售票点 A") ;
        Thread t2 = new Thread(d,"售票点 B") ;
        Thread t3 = new Thread(d,"售票点 C") ;

        t1.start() ;
        t2.start() ;
        t3.start() ;
    }
};     



JAVA IO操作
分为三大类：
File类，文件操作类
File类是IO包中唯一代表磁盘文件本身的对象，File类定义了一些与平台无关的方法来操纵文件，通过调用File类提供的各种方法，能够创建、删除、重命名文件，判断文件的读写权限及是否存在，设置和查询文件的最近修改时间。

直接与文件操作有关的类
 
import java.io.* ;

public class IODemo01
{
    public static void main(String args[])
    {
        File f = new File("f://mldn.txt") ;
        try
        {
            f.createNewFile() ;
        }
        catch (Exception e)
        {
            System.out.println(e) ;
        }
    }
};     
 
import java.io.* ;

public class IODemo05
{
    public static void main(String args[])
    {
        File f = new File("F://testjava//iodemo") ;
        // 列出此目录下的全部文件
        // 列出之前最好先判断给出的是不是一个目录
        if(f.isDirectory())
        {
            String str[] = f.list() ;
            for(int i=0;i<str.length;i++)
            {
                System.out.println(str[i]) ;
            }
        }
        else
        {
            System.out.println("不是目录。。") ;
        }
    }
};     
问题：用递归的方法使用File类去取出D盘下的全部文件
 
import java.io.* ;

public class IODemo06
{
    public static void main(String args[])
    {
        loop("d://") ;
    }
    public static void loop(String dir)
    {
        File f = new File(dir) ;
        String str[] = null ;
        if(f.isDirectory())
        {
            str = f.list() ;
            for(int i=0;i<str.length;i++)
            {
                loop(dir+"//"+str[i]) ;
            }
        }
        else
        {
            System.out.println(dir) ;
        }
       
    }
};     

字节操作类
字符操作类


RandomAccessFile
RandomAccessFile类支持“随机访问”方式，可以跳转到文件的任意位置处读写数据。
RandomAccessFile对象类有个位置指示器，指向当前读写处的位置，当读写n个字节后，文件指示器指向这n个字节的下一个字节处，该类仅限于操作文件。
new RandomAccessFile（f，“rw”）；  //读写方式
new RandomAccessFile（f，“r”）；  //只读方式