21{
22System.out.println（args[i]）;
23}
24}
25}
静态代码块
被率先执行
static
{
System.out.println（"2.Person类的静态代码块被调用！
"）;
}
与静态方法的区别：
一般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的；
需要在项目启动的时候就初始化，在不创建对象的情况下，其他程序来调用的时候,需要使用静态方法，这种代码是被动执行的。
静态方法在类加载的时候就已经加载可以用类名直接调用比如main方法就必须是静态的，这是程序入口
两者的区别就是；静态代码块是自动执行的;静态方法是被调用的时候才执行的；
构造方法的私有
方法依需要，可分为public与private。
同样的，构造方法也有public与private之分。
到目前为止，所使用的构造方法均属于public，它可以在程序的任何地方被调用，所以新创建的对象也都可以自动调用它。
如果构造方法被设为private，则无法在该构造方法所在的类以外的地方被调用。
构造方法虽然被私有了，但并不一定是说此类不能产生实例化对象，只是产生这个实例化对象的位置有所变化，即只能在本类中产生实例化对象。
对象数组
Personp[]=newPerson[3];
p[0]=newPerson（"Gaoqi",23）;
p[1]=newPerson（"wang",14）;
p[2]=newPerson（"wulin",28）;
内部类
内部类可声明成public或private。
当内部类声明成public或private时，对其访问的限制与成员变量和成员方法完全相同。
可以发现由于使用了内部类操作，所以程序在调用score属性的时候减少了创建对象的操作，从而省去了一部分的内存开销，但是内部类在声明时，会破坏程序的结构，在开发中往往不建议读者去使用。
外部类是无法找到内部类中所声明的属性。
而内部类则可以访问外部类的属性。
在类外部引用内部类
在方法中定义内部类
javadoc标记
范例：
PersonJavaDoc.java
/**
*Title:
PersonJavaDoc
*Description:
通过PersonJavaDoc类来说明Java中的文档注释
*Copyright:
（c）2004
*Company:
sunjava
*@authorlixinghua
*@version1.00
*/
类的继承
在java中只允许单继承，不允许多重继承
子类对象在实例化时会默认先去调用父类中的无参构造方法，之后再调用本类中的相应构造方法。
如果父类中存在自定义的构造函数，那么，系统不会自动生成无参的构造函数，那么子类在创建对象时，就会出错；所以，就需要在父类中添加一个无操作的无参的构造函数。
Super关键字
super主要的功能是完成子类调用父类中的内容，也就是调用父类中的属性或方法。
程序在编译时不再去找父类的无参构造函数了。
用super调用父类中的构造方法，只能放在程序的第一行。
当然，也可以用super调用父类中的属性。
classStudentextendsPerson
{
Stringschool;
publicStudent（Stringn,inta,Strings）
{
super.name=n;
super.age=a;
System.out.println（say（））;
this.school=s;
}
}
父类的属性，方法限制子类访问
Private
子类在继承父类时，会继承父类中的全部的属性与方法。
复写
当一个子类继承一父类，而子类中的方法与父类中的方法的名称，参数个数、类型都完全一致时，就称子类中的这个方法复写了父类中的方法。
同理，如果子类中重复定义了父类中已有的属性，则称此子类中的属性复写了父类中的属性。
抽象类
abstractclassPerson
专门用来当作父类，不能直接由抽象类创建对象，只能通过抽象类派生出新的类，再由它来创建对象。
可以有抽象方法，也可以有非抽象方法。
抽象类定义规则
·抽象类和抽象方法都必须用abstract关键字来修饰。
·抽象类不能被实例化，也就是不能用new关键字去产生对象。
·抽象方法只需声明，而不需实现。
·含有抽象方法的类必须被声明为抽象类，抽象类的子类必须复写所有的抽象方法后才能被实例化，否则这个子类还是个抽象类。
在抽象类中，也可以拥有构造方法，但是这些构造方法必须在子类中被调用。
在抽象类定义的语法中，方法的定义可分为两种：
一种是一般的方法，它和先前介绍过的方法没有什么两样；另一种是“抽象方法”，它是以abstract关键字为开头的方法，此方法只声明了返回值的数据类型、方法名称与所需的参数，但没有定义方法体。
那么子类中需要复写实现这个抽象方法。
publicabstractStringtalk（）;//只有声明，没有函数体，在子类中复写
与一般类相同，在抽象类中，也可以拥有构造方法，但是这些构造方法必须在子
类中被调用。
Object类
所有类的父类，如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个类就默认继承Object类。
Final关键字
1、final标记的类不能被继承。
2、final标记的方法不能被子类复写。
3、final标记的变量（成员变量或局部变量）即为常量，只能赋值一次。
接口interface
接口（interface）是Java所提供的另一种重要技术，它的结构和抽象类非常相似，具有数据成员与抽象方法，
1、接口里的数据成员必须初始化，且数据成员均为常量，且不可更改。
2、接口里的方法必须全部声明为abstract，也就是说，接口不能像抽象类一样保有一般的方法，而必须全部是“抽象方法”。
在java中接口是用于实现多继承的一种机制，也是java设计中最重要的一个环节，每一个由接口实现的类必须在类内部复写接口中的抽象方法，且可自由地使用接口中的常量。
既然接口里只有抽象方法，它只要声明而不用定义处理方式，那么无法用它来创建对象。
利用接口打造新的类的过程，称之为接口的实现（implementation）。
InterfacestudentextendsPerson
接口是java实现多继承的一种机制，一个类只能继承一个父类，但如果需要一个类继承多个抽象方法的话，就明显无法实现，所以就出现了接口的概念。
一个类只可以继承一个父类，但却可以实现多个接口。
接口与一般类一样，均可通过扩展的技术来派生出新的接口。
原来的接口称为基本接口或父接口，派生出的接口称为派生接口或子接口。
通过这种机制，派生接口不仅可以保留父接口的成员，同时也可加入新的成员以满足实际的需要。
接口间的继承通过关键字extends实现。
接口可以继承多个接口，
一个类可以实现多个接口，接口间用“,”隔开，且需要复写所有接口的全部抽象方法。
如下：
classstudentimplementsPerson,Person1
{
publicStringsay（）
{
return"复写接口person的abstract方法say（）";
}
publicStringsay1（）
{
return"复写接口person1的abstract方法say1（）";
}
}
对象多态性
子类实例化对象可以转换为父类实例化对象
向上转型，父类对象通过子类对象去实例化。
向下转型，父类的对象可以转换为子类对象，这时则必须要进行强制的类型转换。
一、向上转型可以自动完成；用子类实例化时，调用子类和父类相同的函数时，先调用子类的；如果调用只有父类的函数时，则显示父类的函数。
publicstaticvoidmain（String[]args）
{
Personp=newstudent（）;
p.fun1（）;
p.fun2（）;
}
二、向下转型必须进行强制类型转换，
publicstaticvoidmain（String[]args）
{
Personp=newstudent（）;
students=（student）（p）;
s.fun1（）;
s.fun3（）;
}
instanceof关键字的使用
用于判断一个类是否实现了某个接口，也可以用它来判断一个实例对象是否属于一个类。
instanceof的语法格式为：
对象instanceof类（或接口）
它的返回值是布尔型的，或真（true）、或假（false）。
接口对象的实例化
接口是可以被实例化的，但是不能被直接实例化，通过接口的子类对其进行实例化。
classstudentimplementsPerson
Personp=newstudent（）;
使用接口就是定义一个统一的标准。
例如：
interfaceUSB
{
publicabstractvoidstart（）;
publicabstractvoidstop（）;
}
classMP3implementsUSB
{
publicvoidstart（）
{
System.out.println（"MP3devicestart"）;
}
publicvoidstop（）
{
System.out.println（"MP3devicestop"）;
}
}
classMoveDiskimplementsUSB
{
publicvoidstart（）
{
System.out.println（"MoveDiskdevicestart"）;
}
publicvoidstop（）
{
System.out.println（"MoveDiskdevicestop"）;
}
}
classcomputer
{
publicvoidwork（USBu）
{
u.start（）;
u.stop（）;
}
}
publicclassinterfacestandard
{
publicstaticvoidmain（String[]args）
{
newcomputer（）.work（newMP3（））;
newcomputer（）.work（newMoveDisk（））;
}
}
异常处理
异常处理方法
1交由java默认的异常处理机制做处理，这种方法只输出异常信息，并终止程序。
2自行编写异常处理模块。
异常类的继承架构
Exception类扩展出数个子类，其中IOException、RunntimeException是较常用的两种。
RunntimeException即使不编写异常处理的程序代码，依然可以编译成功，而这种异常必须是在程序运行时才有可能发生。
IOException一定要编写异常处理的程序代码才行，它通常用来处理与输入/输出相关的操作，如文件的访问、网络的连接等。
抛出异常throw
抛出异常有下列两种方式：
1、程序中抛出异常
2、指定方法抛出异常
包及访问权限
包（package）
Package名称；
定义了包以后，执行程序有一定的变动。
如下：
javac–d.package1.java//生成一个demo文件夹
javademo.java.package1
import语句的使用
如果几个类分别属于不同的package时，在某个类要访问到其它类的成员时，则必须做下列的修改：
若某个类需要被访问时，则必须把这个类公开出来，也就是说，此类必须声明成public。
若要访问不同package内某个public类的成员时，在程序代码内必须明确地指明“被访问package的名称.类名称”。
importpackage名称.类名称；
将某个package内的整个类导入，后续访问时就不需要再写包名称了。
在java中有这样的规定：
导入全部类或是导入指定的类，对于程序的性能是没有影响的。
importdemo.java.a.Person改成importdemo.java.a.*，
JDK中常见的包
java.lang—包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能
java.awt—包含了构成抽象窗口工具集（abstractwindowtoolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面（GUI）。
javax.swing—此包用于建立图形用户界面。
java.applet—包含applet运行所需的一些类。
—包含执行与网络相关的操作的类。
java.io—包含能提供多种输入/输出功能的类。
java.util—包含一些实用工具类，如定义系统特性、与日期日历相关的函数。
类成员的访问控制权限
Private只能在类内部访问
Public
Protect
默认访问权限default默认的访问控制成员可以被这个包中的其它类访问。
如果一个子类与其父类位于不同的包中，子类也不能访问父类中的默认访问控制成员。
命名习惯
◆包名中的字母一律小写，如：
demo.java。
◆类名、接口名应当使用名词，每个单词的首字母大写，如：
TestPerson。
◆方法名，第一个单词小写，后面每个单词的首字母大写，如：
talkMySelf。
◆常量名中的每个字母一律大写，如：
COUNTRY。
多线程
进程一次性执行完毕原子性动态执行
多进程操作系统能同时运行多个进程，cpu具有分时机制，所以每一个进程都能循环获得分配给自己的时间片。
线程（Thread）比进程更小的执行单位，可以在进程内部同时执行。
实现并发程序控制
单一线程
多线程
通过继承Thread类来实现。
通过实现Runnable接口实现多线程
Thread类也是Runnable接口的一个子类，但其无法实现资源共享。
但是Runnable接口实现的子类可实现。
一个类继承了Thread类后，该类的一个对象无论调用多少次start（）方法，都只有一个线程在运行。
如果运行多个线程对象的start（）方法，就会相应的执行多少个线程，而且，这些线程独占各自的资源。
实现Runnable接口的类，启动多个线程对象，操作的是同一个资源，实现了资源共享。
Thread类
Runnable接口
一个线程对象.start（）方法
多个线程对象.start（）方法
多个资源
一个资源
占用资源
独占
共享
可见，实现Runnable接口相对于继承Thread类来说，有如下显著的优势：
（1）、适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU（线程）同程序的代码、数据有效分离，较好地体现了面向对象的设计思想。
（2）、可以避免由于Java的单继承特性带来的局限。
开发中经常碰到这样一种情况，即：
当要将已经继承了某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么就只能采用实现Runnable接口的方式了。
（3）、增强了程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。
当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码。
多个线程可以操作相同的数据，与它们的代码无关。
当共享访问相同的对象时，即共享相同的数据。
当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。
事实上，几乎所有多线程应用都可用第二种方式，即实现Runnable接口。
线程状态
五种状态：
创建Threadth=newThread（）;
就绪调用start（）方法，启动线程，此时线程进入就绪状态，等待CPU的调度；
运行自动调用线程对象的run（）方法，run（）定义了线程的操作和功能；
阻塞一个正在运行的线程，在某些情况下
升级会员 