Intn=a[j];a[j]=a[i];a[i]=n;
}
}
}
System.out.printf（“%d,%d,%d,%d,%d”,a[0],a[1],a[2],a[3],a[4]）;
结果如下-6,1,2,3,4
第四章
1、方法使用：
（1）构造方法是一种特殊方法，它的名字必须与它所在的类的名字完全相同，并且不返回任何数据类型（无void，没有类型，无return）。
构造方法可重载
（2）静态变量或类变量在内存空间里只有一份
（3）静态成员使用时除了可以用对象名表示外还可用类直接使用
如：
classChinese
Chinese.country
Chinesech1=newChinese（）;
ch1.country
2、静态代码块
classStaticCode{
staticStringcountry;
{
System.out.println（"aaa"）;
}
static
{
country="China";
System.out.println（"StaticCodeisloading"）;
}
StaticCode（）{
System.out.println（"Constructoriscalling."）;
}
}
classTestStaticCode{
static
{
System.out.println（"TestStaticCodeisloading"）;
}
publicstaticvoidmain（String[]args）{
newStaticCode（）;
newStaticCode（）;
}
}
运行结果如下:
3、单态设计模式
classChinese{
privatestaticChineseobjRef=newChinese（）;
privatestaticintcount=0;
Stringname;
intage;
privateChinese（）{
System.out.println（++count）;
}
publicstaticChinesegetInstance（）{
returnobjRef;
}
}
classTestChinese{
publicstaticvoidmain（String[]args）{
Chineseobj1=Chinese.getInstance（）;
Chineseobj2=Chinese.getInstance（）;
System.out.println（obj1==obj2）;
}
}
4、
方法名
适用范围
参数
返回类型
访问权限
方法重载
相同
所有类中
不同
无所谓
无所谓
方法重写
相同
继承关系中
相同
相同
不能降低
现有重载方法：
publicvoidinfo（Stringname,doublecount）
publicvoidinfo（Stringname,intcount）
5、this作用
（1）publicclassPerson
{
Stringname;
intage;
Person（Stringname）
{
this.name=name;
}
Person（Stringname,intage）
{
this（name）;
this.age=age;
}
}
将屏蔽的成员变量用this表示
（2）在一个构造方法里调用其他重载的构造方法
6、包
-d指定生成的字节码文件所在的目录
如果源文件没有包名，使用参数-d可以将字节码文件存放到你指定的有效目录中，例如：
javac–dF:
\tsinghua\1000MyFile.java
将源文件MyFile.java生成的全部字节码文件存放到F:
\tsinghua\1000。
使用import语句可以引入包中的类
java.lang可不用import语句引入包中的类
7、装箱、拆箱
publicclassWrapperDemo03{
publicstaticvoidmain（String[]args）{
Integeri=30;//自动装箱成Integer
Floatf=30.3f;//自动装箱成Float
intx=i;//自动拆箱为int
floaty=f;//自动拆箱为float
}
}
8、构造块优先于构造方法被执行
第五章
1、java不支持多重继承，只支持单继承
2、super的作用：
（1）子类使用super调用父类的构造方法
注：
必须是子类构造方法中的头一条语句
（2）子类使用super调用被子类隐藏的成员变量和方法
（3）调用父类中被重写的方法
3、子类的构造过程
Student（）{
构造子类的父类部分
再构造子类的新增部分
}
4、final类适用场合：
（1）用于修饰类，不能被继承
（2）修饰方法，方法不能重写
（3）修饰变量，变为常量
5、上转型对象
privateintn=40;
voidcrySpeak（Strings）{
System.out.println（s）;
}
}
publicclassMonkeyextendsMammal{
voidcompute（intaa,intbb）{
intcc=aa*bb;
System.out.println（cc）;
}
voidcrySpeak（Strings）{
System.out.println（"**"+s+"**"）;
}
publicstaticvoidmain（Stringargs[]）{
Mammalmammal=newMonkey（）;
//mammal是Monkey类对象的上转型对象
mammal.crySpeak（"Ilovethisgame"）;
Monkeymonkey=（Monkey）mammal;
//把上转型对象强制转化为子类的对象
pute（10,10）;
}
}
例:
classA{
doublen;
intm;
voidf（）{
System.out.printf（"子类继承方法f（）,n=%f,m=%d\n",n,m）;
}
voidg（）{
System.out.printf（"你好，n=%f,m=%d\n",n,m）;
}
}
classBextendsA{
intn=12;
voidg（）{
System.out.printf（"子类重写方法g（）,n=%d,m=%d\n",n,m）;
}
voidcry（）{
System.out.printf（"子类新增的方法,n=%d,m=%d\n",n,m）;
}
}
publicclassExample5_8{
publicstaticvoidmain（Stringargs[]）{
Aa;
a=newB（）;
a.n=0.618;
a.m=200;
a.f（）;
a.g（）;
Bb=（B）a;
b.n=555;
b.cry（）;
}
}
运行结果如下：
6.构造方法不被继承
7.抽象类和抽象方法
Java语言中，用abstract关键字来修饰一个类时，这个类叫做抽象类。
一个abstract类只关心它的子类是否具有某种功能，并不关心该功能的具体实现,功能的具体行为由子类负责实现的。
例如：
publicabstractclassDrawing{
publicabstractvoiddrawDot（intx,inty）;
publicvoiddrawLine（intx1,inty1,intx2,inty2）{
…………
}
}
用abstract来修饰一个方法时，该方法叫做抽象方法。
与final类和方法相反，abstract类必须被继承，abstract方法必须被重写。
抽象类中可以包含抽象方法，为所有子类定义一个统一的接口，对抽象方法只需声明，而不需实现，因此它没有方法体。
其格式如下：
abstract返回类型抽象方法名（[参数列表]）；
abstractclassA
{
abstractintaa（intx,inty）;
//用分号来代替方法体的定义
}
Ø一个抽象类可以有一个或多个抽象方法。
Ø含有抽象方法的类必须被声明为抽象类，抽象类的子类必须重写所有的抽象方法后才能被实例化，否则这个子类还是个抽象类。
Ø注意:
含有抽象方法的类一定是抽象类，抽象类中的某个方法不一定是抽象的。
Ø声明一个既是abstract又是final的类是不合法的，因为抽象类本身是不完整的，它依靠它的子类提供完整的实现。
final与abstract不能同时修饰一个类
8.接口两大类成员：
常量和抽象方法
9.接口回调在线程中自动完成
10.内部类
（1）可以有自己的成员
（2）外部类不能直接调用内部类的成员，但内部类能使用外部类的任何成员
（3）内部类可以声明为抽象类
11.匿名类
匿名类不可能用匿名类声明对象，但却可以直接用匿名类创建一个对象。
假设Hello是类（已存在），那么下列代码就是用Hello的一个子类（匿名类）创建对象：
newHello（）
{
匿名类的类体
}
12.捕获异常try-catch-finally
13.
publicclassTry{
publicstaticvoidmain（Stringargs[]）{
inti=0;
inta[]={5,6,7,8};
for（i=0;i<5;i++）{
try{
System.out.print（"a["+i+"]/"+i+"="+（a[i]/i））;
}
catch（ArrayIndexOutOfBoundsExceptione）{
System.out.print（"CatchArrayIndexOutOfBoundsException"）;
}
catch（ArithmeticExceptione）{
System.out.print（"CatchArithmeticException"）;
}
catch（Exceptione）{
System.out.print（"捕获"+e.getMessage（）+"异常!
"）;
}
finally{
System.out.println（"i="+i）;
}
}
System.out.println（"continue"）;
}
}
运行结果如下:
14.System.exit（0）：
非函数调用，程序彻底结束。
15.声明异常关键字：
throws
16.泛型类
设置上限关键字：
extends
设置下限关键字：
super
第六章
1.Strings类
创建字符串对象
（1）使用String类的构造方法创建字符串对象：
例如：
Strings;
s=newString（"wearestudents"）；
声明和创建可用一步完成：
Strings=newString（"wearestudents"）;
（2）也可以用一个已创建的字符串创建另一个字符串，如：
Stringtom=String（s）;
String类还有两个较常用构造方法：
（1）String（chara[]）：
用一个字符数组a创建一个字符串对象，如：
chara[]={‘b’,’o’,’y’};
Strings=newString（a）;
（2）String（chara[],intstartIndex,intcount）：
提取字符数组a中的一部分字符创建一个字符串对象，参数startIndex和count分别指定在a中提取字符的起始位置和从该位置开始截取的字符个数，例如：
chara[]={‘s’,’t’,’b’,’u’,’s’,’n’};
Strings=newString（a,2,3）;
Strings=newstring（“20”）；
S=“Hello”这是错误的命名方式
2.“==”与“equals”的区别
classCompare{
publicstaticvoidmain（String[]args）{
Stringstr1=newString（"abc"）;
Stringstr2=newString（"abc"）;
Stringstr3=str1;
if（str1==str2）
System.out.println（"str1==str2"）;
else
System.out.println（"str1!
=str2"）;
if（str1==str3）
System.out.println（"str1==str3"）;
else
System.out.println（"str1!
=str3"）;
}
}
classCompare{
publicstaticvoidmain（String[]args）{
Stringstr1=newString（"abc"）;
Stringstr2=newString（"abc"）;
Stringstr3=str1;
if（str1.equals（str2））
System.out.println（"str1equalstr2"）;
else
System.out.println（"str1notequalstr2"）;
if（str1.equals（str3））
System.out.println（"str1equalstr3"）;
else
System.out.println（"str1notequalstr3"）;
}
}
3.publicStringsubstring（intstart,intend）方法获得一个当前字符串的子串，该子串是从当前字符串的start处截取到end处所得到的字符串，但不包括end处所对应的字符。
例如：
StringTom=“IloveTom”；
Strings=Tom.substring（2,5）；
则s为“lov”
4.Student类重写toString（）方法，TV类没有重写toString（）方法。
importjava.util.Date;
publicclassExample6_3{
publicstaticvoidmain（Stringargs[]）{
Datedate=newDate（）;
Studentstu=newStudent（"张三",89）;
TVtv=newTV（"电视机",8776）;
System.out.println（date.toString（））;
System.out.println（stu.toString（））;
System.out.println（tv.toString（））;
}
}
classStudent{
Stringname;
doublescore;
Student（Stringname,doublescore）{
this.name=name;
this.score=score;
}
publicStringtoString（）{
return"姓名:
"+name+",分散:
"+score;
}
}
classTV{
Stringname;
doubleprice;
TV（Stringname,doubleprice）{
this.name=name;
this.price=price;
}
}
第八章
1.两种创建线程的方法：
（1）继承法
publicclassThreadDemo1{
publicstaticvoidmain（Stringargs[]）{
newTestThread（）.start（）;
while（true）{
System.out.println（"main:
"+Thread.currentThread（）.getName（））;
}
}
}
classTestThreadextendsThread{
publicvoidrun（）{
while（true）{
System.out.println（"run:
"+Thread.currentThread（）.getName（））;
}
}
}
（2）接口法
publicclassThreadDemo{
publicstaticvoidmain（Stringargs[]）{
TestThreadtt=newTestThread（）;//创建TestThread类的一个实例
Threadt=newThread（tt）;//创建一个Thread类的实例
t.start（
升级会员 