java for意外的标记 java标记上具有语法错误

 

第一章

1. 跨平台性：

（平台无关性）一个应用程序能运行于不同的操作系统平台

 

 

1. JAVA文件的命名方式（主类名.java）
   Public  class  Hello{}   Hello类名

1. 编译和运行java程序的流程，生成的文件
1. 创建一个带有文件扩展名 *.java 的源文件
2. 使用java编辑器（javac.exe）编译源文件生成文件扩展名为 *.class 的字节码文件（一个类对应一个字节码文件）
3. 使用java解释器（ java.exe ）运行字节码
 
Java的 Applet应用程序能够嵌入浏览器运行。
实现TCP Socket通信，导入包的语句是import java.net.*

第二章
1. 标志符的命名规则
以字母开头的字母数字序列，0~9；大小写英文字母、下画线_和符号$；字母区分大小写；不能用关键字；长度不受限制。
关键字、变量、对象、方法、包等名字通常全部字母小写；
由多个单词构成的标识符，首字母小写，其后单词首字母大写，如toString；
类名首字母大写；常量名全部字母均大写。
 
1. 数据类型分类：
①引用数据类型：数组、类（class）和接口（interface）
 ②基本数据类型：8种：byte、short、int、long、float、double、char、boolean
整数类型：byte(1字节，-2^7~2^7-1，-128~127)，short(2)，int(4)，long(8)
浮点数类型：float（4字节），double（8）
布尔类型：boolean（true，false） 
字符类型：char（\u0000～\uFFFF 或 单引号）
强制类型转换：  c=Integer.parseInt(a)；或者用c=Integer.valueOf(a)
 
设byte b=127;，表达式b+"+1="+(++b)的运算结果是127+1=-128
 
1. 字符类型
字符类型char表示Unicode字符，一个字符占用2字节，范围是0～65535。
字符常量有两种表示法：
①单引号将可见ASCII字符括起来；
②Unicode值表示，前缀为’\u’，表示范围\u0000～\uFFFF（0~65535），\u0041为’A’。
不可见的ASCII控制字符用转义字符表示“\”。
 
1. 运算符与表达式
（1）算术运算符：+（正）、-（负）、++（自增）、--（自减） 、+（加）、-（减）、*（乘） 、/（除）、%（取余） 
【例2.1】 求明天是星期几。 
(week+1)%7     //明天，若week=6，结果0  
(week-1+7)%7   //昨天，若week=0，(w-1)%7=-1，(w-1+7 )%7=6 （结果符号与被除数相同，+7防止有负数）
 
①用%表示当前月份month的下月和上月？
下月：month%12+1 ；  上月：(month-2+12)%12+1 
②如何求出一个三位数n的各位数字？
百位：n/100 ； 十位：n/10%10  或  n%10/10  ； 个位：n%10
 
（2）关系运算符：==、!=、>、<、>=、<=     例如'a' < 'A' ，结果是false
（3）位运算符：~（非）、&（与）、|（或）、^（异或）、<<（左移位）、>>（右移位）、>>>（无符号右移位） 
~4              //求反，~0…00100=1...11011（求补=0...00101=5）
6 ^ 2            //异或=4
1<<2          //左移2位=4，乘法 1*2²
-8>>2          //右移2位，高位以符号位1填充=-2，除法 -8/2²
-1>>>30         //无符号右移30位，高位以0填充，0...00011=3，共32位

 

 

 

（4）逻辑运算符：&（与）、|（或）、!（非）、∧（异或）、&&（条件与）、||（条件或） 。
（5）赋值运算符：= 、+=等
（6）强制类型转换符：（数据类型）表达式
（7）条件运算符：表达式1  ?  表达式2  :  表达式3
【思考题2-2】设char ch表示16进制的一个数字字符，写出获得ch对应整数值的表达式。
(ch>='0' && ch<='9') ? ch-'0' : ((ch>='a' && ch<='f') ? ch-'a'+10 : ch-'A'+10)
（8）括号运算符：()、[]
（9）字符串连接运算符：+  ：System.out.println("max = "+max);
（10）点运算符：.
（11）对象运算符：instanceof   
（12）new运算符：申请数组的存储空间，创建对象。
%
System.out.println(""+(i=1, j=2));      //语法错，表达式不能包含逗号
 
1. Instanceof用途用法
判断一个实例是否属于指定类， 如new Person() instanceof MyDate；
 
1. 一维数组、二维数组的定义及使用方法
一维数组：
①声明： 数据类型[] 数组变量
数据类型 数组变量[]     //[]中没长度，则数组未获得内存空间
②申请数组所需的内存单元：数组变量= new 数据类型[长度]
③数据占用的存储单元个数：数组变量.length
④数组变量[下标]：下标取值0~a.length-1
⑤声明时赋初值：int a[]={1,2,3,4,5}
⑥数组元素的初始化：
、short、int、long：0 ；
char：‘\u0000’ ；
float：0.0f ；
boolean：false；
double：0.0；
引用数据类型：null。
⑦for语句作用于数组的逐元循环：for(类型 变量 : 数组)
⑧数组的引用模型  
 
二维数组，声明：
int mat[][], m=4, n=5;
mat = new int[m][n];
int[][] mat = new int [3][4];
int[][] mat = { {1,2,3},{4,5,6} };  多层括号不能省略

 

1. 数组引用模型（引用赋值）

对数组的操作只能用下标，不能用指针。

引用数据类型与基本数据类型变量的不同：存储单元的分配方式不同，变量间的赋值方式不同。

  ①基本数据类型变量的传值赋值

变量获得存储单元的方式是静态的，声明变量，变量占据了存储单元，变量保存数据值，两个变量之间赋值，传递值。

  

②数据变量的引用赋值

变量获得存储单元的方式是动态的，必须用new申请并动态获得存储单元。引用变量保存地址、长度、引用计数等特性。

数组是引用数据类型。两个数组之间赋值称为引用赋值，传递的值是数组引用，无申请新的存储空间。

 

 

 

 

1. 维数表示（length）

mat.length      返回二维数组的长度，列的长度=行数

mat[0].length    返回一维数组的长度，行的长度=列数

 

1. 不规则二维数组的表示

二维数组的每一个一维数组是分散存储的，占用存储空间容量可不相同，需要多次申请。

      

 

 

 

 

 

1. String类型数据的定义形式，字符串不是字符数组

字符串常量由双引号括起来，可包含转义字符。字符串不能换行。长度=字符个数。

默认字符串常量的数据类型：java.lang.String类，重载了“=”、“+”、“+=”。

字符串常量 “abc”，“at”是“data”的子串

（1）字符串常量，默认数据类型是String类  （2）赋值运算和连接运算   

（3）引用模型（引用赋值）

    

（4）不是字符数组

str1[0]='a';      //语法错误，没有str[0]格式
 
1. String类常用方法（获得第一个字符string.charAt(i)，一个字符串string.substring()）
      char charAt(int i)                  //第i（≥0）个字符
     boolean equals(Object obj)         //比较串是否相等
      String substring(int begin, int end)  返回从begin开始到end-1的子串
     String substring(int begin)         从begin到串尾的子串
字符串变量.方法([参数列表])：
 
①设String s=”abcefgh"，执行结果为字符’d’的调用语句是s.charAt(3)，
执行结果为子串"d"的调用语句是s.substring(3,4)
②正确的是 (D) String s='a'+"";字符串双引号，且无下标0
③在main 方法中，以下声明错误的是C：(A) final int i;  (B) int i;   (C) static int i=0;   (D) final int i=0;
static静态) 依托于类的定义，只能是类中的方法和变量。不能声明方法的局部变量为static
④表达式(byte)127+(byte)127的运算结果是254，其数据类型是int。
〖解释〗Java的整数默认是int类型。所有byte和short整数运算仍然是int类型运算，运算结果是int类型。
⑤设int a[]=new int[5], b[]=a; 执行语句b[0]=99;后，a中各元素值为{99,0,0,0,0}。//Java的数组是引用数据类型
⑥表达式'a'+1的运算结果是98，(char)('a'+1)的运算结果是'b'。//算数运算，取较长数据类型，a char，1 int

 

第三章

1. 类的构造方法和析构方法

构造方法：与类同名，通过new运算符调用。

一个类可声明多个构造方法，构造方法不需要返回值类型，返回的是类的一个实例。
JAVA自动提供一个无参数的构造方法，若已声明，则JAVA不再提供。
析构方法：（只有一个，不能重载）
public void finalize() {语句序列;}
 
1. 拷贝构造方法
public MyDate(MyDate date)
{    this.year = date.year;  ……}
一个类的拷贝构造方法指参数是该类对象的构造方法，将创建的实例初始化为形式参数的实例值，实现对象复制功能。
调用语句： MyDate d2 = new MyDate(d1); 功能相当于：MyDate d2 = new MyDate();   d2.set(d1);

 

1. this的用途用法，举例

this引用

①指代对象本身

②访问本类的成员变量和成员方法：

this.成员变量；

this.成员方法([参数列表])；

③调用本类重载的构造方法：this([参数列表])，无.点

 

1. *JAVA类与成员的访问权限

（1）类的访问控制权限（2种）

公有：public，被所有包中的其他类访问。

缺省：无修饰符，仅被当前包（当前文件夹）中的其他类访问。

一个源程序可以声明多个类。但public修饰的类只有一个，且该类名与文件名相同。

 

（2）类中成员的访问控制权限（4种）

一个类的所有成员都可被本类的代码访问。

      

1. 子类对父类成员的访问权限问题，可以访问哪些权限的父类成员

①子类不能访问父类的私有成员（private）。

但可以调用父类的公有成员方法间接访问父类私有成员变量。

②子类能够访问父类的公有成员和保护成员。

③子类对父类的缺省权限成员的访问控制，以包为界分两种情况：

可以访问当前包中父类的缺省权限成员，

 

1. static的用途

用static修饰符修饰的方法是属于类的静态方法，又称为类方法。静态方法实质是属于整个类的方法，而不加static修饰符的方法，是属于某个具体对象的方法。

不能声明方法的局部变量为static，包括main()方法

静态方法中不能使用super引用

1. super（）的用途用法

①使用super()调用父类构造方法：super([参数列表])，且必须是第一句。  调用构造方法没有点.

②默认执行super()，分为两种情况：

1. 无声明构造方法，提供默认构造方法，调用super()执行父类无参数的构造方法。

一个类通常需要声明无参数的构造方法，即使自己不用，也要为子类准备着。

1. 若子类的构造方法没有调用super()或this()，将默认执行super()。

子类构造方法逐个调用成员对象和父类的构造方法

 

 

 

 

 

1. 例题3.3，3.5

1. 父类对象引用子类实例问题，父类对象不可引用子类中自己定义的方法

子类对象即是父类对象：

new Student()子 instanceof Person 父   //true；      new Person()父 instanceof Student 子  //false
父类对象引用子类实例：
Person per父 = new Student()子;     //赋值相容
Student stu子 = new Person()父;     //错 子类对象不能引用父类实例
 
①设Object obj = "abc",下列语句的错误原因是Object类的obj对象不能调用子类String的length()方法
System.out.println(obj.toString()+"长度为"+obj.length());
②设Person类有私有成员变量name, Student 是Person的子类，在Student类中以下引用错误的是
(A) super.toString()    (B) super()    (C)super.name   (D) super.finalize()
③  Object obj= “abc”;
Sytem.out. Println(obj.toString());     //执行Integer类的toString方法 
obj=new Integer(2),              
Sytem.out. Println(obj.toString());     //执行String类的toString方法
 
④public class Sin extends java. lang.Math  //不正确，Math是最终类
⑤以下Student类声明正确的是A
(A) abstract class Student extends Person   (B) private class Student extends Person
(C) final class Student extends Person,Object  (D) protected class Student extends Person
类只有2种访问权限：公有、缺省（当前包访问），若abstract final class Person 错，抽象类不能被声明为最终类。
⑥public static void main(String args[]){  public String s1=";  static String s2=''; }  错，局部变量不能声明访问权限和static。

 

1. 运行时多态概念和用法

程序运行时，JAVA从实例所属的类开始寻找匹配的方法执行，若当前类无匹配方法，则沿着继承关系逐层向上。父类对象只能执行那些在父类中声明、被子类覆盖的子类方法，不能执行子类增加的成员方法。

 

 

 

 

1. *多态的tostring()方法的用法

类声明以下，作用是为子类提供默认toString()方法。 
public String toString()                                        //返回当前对象的描述字符串
{  return this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());  }
不能满足子类的个性要求。所以一个类需要覆盖父类或Object类的toString()方法，给出符合自己类需求的方法实现。 
 
1. *多态的equals()方法的定义
类声明equals(Object)方法
public boolean equals(Object obj)
{  return this == obj;}                                        // 两个对象是否引用同一实例
作用是：
①为子类提供默认equals(Object)方法。②为子类覆盖提供方法声明，运行时多态。 
String类覆盖equals(Object)方法。
(2) 子类覆盖Object类的equals(Object)方法
类不需要声明equals(Person)方法,
boolean equals(Person per)                     //Person类声明，比较对象值
boolean equals(Object obj)                     //继承Object，比较对象引用
两者重载，编译时多态，调用如下：
Person per1 = new Person("李小明", …));
Person per2 = new Person(per1);          //深拷贝 
per1.equals(per2)                      //调用equals(Person)，结果true，正确
Object obj = new Person(per1);           //深拷贝 
per1.equals(obj)                       //调用equals(Object)，结果为false，
//逻辑错误，仅比较对象引用，算法不适合子类（单步调试）
<2> Person类必须覆盖equals(Object)方法
public boolean equals(Object obj)
{  
if (this==obj)
         return true;
当obj引用实例属于Person及其子类，包含Student实例
       if (obj  instanceof  Person)
      {    
强制类型转换
谁的？      
      }
       return false;
}
（3）子类扩展父类的equals(Object)方法
//Student类覆盖equals(Object)方法，与父类对象不可比
public boolean equals(Object obj)
{
    if (this==obj)   
return true;
不包含Person实例
    {  
Student s = (Student)obj;                 
        return super.equals(s) &&
               this.department.equals(s.department) &&
               this.speciality.equals(s.speciality) &&
               this.number.equals(s.number) &&
               this.member==s.member;
    }
    return false;
}
stu1.equals(per)   //执行Student比较规则，参数是Person实例，不是要找的对象，不用比较成员变量，结果为false 
 
【习题解答习3.5】  Object类为什么要声明equals(Object)方法？
设Person类声明equals(Person)
比较当前对象与对象per是否相等
<1> Student类继承父类的equals(Person)
Person per = new Person("李小明", …));
Student stu1 = new Student(…),
             stu2 = new Student(…);
stu1.equals(per)                           //子类对象调用父类方法
stu2.equals(stu1)                          //语义错，没有比较自己的变量
<2> Student类声明equals(Student)方法
设Person类声明equals(Person) 
public boolean equals(Student stu)         //重载
{   return this==stu || stu!=null && super.equals(stu) &&this.department.equals(stu.department) &&  ……;}
stu1.equals(per)                        //执行equals(Person)，由父类提供比较规则
stu2.equals(ser1)                       //执行equals(Student)，由子类提供比较规则
结论：
① 不必要，因为Person参数可接受Student实例。
② 不能运行时多态
Person per1 = new Student(…),            //父类对象引用子类实例
…);       
per1.equals(per2)                        //编译时多态，执行equals(Person)，语义错
<3> Student类覆盖equals(Person)方法
解决，两者合而为一。Student类声明如下：
boolean equals(Person per)    //覆盖，运行时多态
推而广之，每个类应该覆盖父类的equals()方法，参数是父类对象。
①Person类覆盖Object类的equals(Object)方法；
②Student类再覆盖父类的equals(Object)方法。
所以，每个类应该覆盖父类或祖先类Object的equals(Object)方法，表现运行时多态。
 
1. *abstract的用途，抽象类，抽象方法意义用途
①声明：抽象方法只有方法声明没有方法体。抽象方法以“；”结束。
②特点：
1. 构造方法、静态成员方法不能被声明为抽象方法。
2. 一个非抽象类必须实现从父类继承来的所有抽象方法。
3. 不能创建抽象类的实例。
4. 抽象类可不包含抽象方法，但包含抽象方法的类必须被声明为抽象类。
若一个方法需要被子类覆盖，则必须声明为抽象方法。
 
1. Final的用途用法
最终类不能被继承，即不能有子类。
public final class Math                  //数学类，最终类
public class MyMath extends Math       //语法错
public final class Circle extends Ellipse     //最终类
最终方法不能被子类覆盖。最终类中包含的都是最终方法，非最终类也可以包含最终类。
public class Square extends Ellipse    //非最终类
{  public final double area()   }     //最终方法
 
第四章
1. 接口的定义形式，接口中方法的申明，属性的定义，实现接口的方法（implements），接口的基本性质（接口不可用new运算符进行实例化），接口编译后生成的文件。
是什么： 接口interface是一组抽象方法、常量和内嵌类型的集合。
作用  ：接口提供方法声明与方法实现相分离的机制，使得接口中声明的抽象方法能够在实现接口的类中表现运行时多态。
 
接口不能被实例化，因为接口是声明的是抽象方法，没有方法体。
接口中不能写构造方法，因为构造方法不能声明为抽象方法。
①声明接口：（接口不能被实例化）
[public]  interface  接口  [extends  父接口列表 ]
{
    [public] [static] [final] 数据类型 成员变量=常量值;
    [public] [abstract] 返回值类型 成员方法[(参数列表)];
}
②声明实现接口的类
修饰符]  class  类<泛型>  [extends  父类]  [implements 接口列表]
例如， public abstract class ClosedFigure extends Figure implements Area, Perimeter
实现接口的非抽象类必须实现所有接口中的所有抽象方法，否则声明为抽象类。
 
③接口是引用数据类型
一个类所继承的父类以及所实现的全部接口，称为它的父类型。
该类是其父类型的子类型，接口也是其继承的全部父接口（父类型）的子类型。
子类型包含父类型的全部属性和功能。
一个父类对象可以引用子类实例，一个接口对象可引用实现该接口的类及其子类实例。
父类对象cfig引用椭圆子类实例
Area ar = cfig;                     //Area接口对象ar引用实现Area接口的ClosedFigure类的Ellipse子类实例，类型多态
ar.area()                                      //计算椭圆面积，运行时多态
Cylinder cylinder = new Cylinder(cfig,10);           //椭圆柱
ar = cylinder;                                 //ar引用实现Area接口的Cylinder类的实例 
ar.area()                                     //计算椭圆柱面积，运行时多态
④接口是多继承的
一个接口可以继承多个父接口。
public interface Solid extends Area,Volume          //立体接口，继承Area和Volume接口
public class Globe extends Object implements Solid   //球类，实现Solid接口

    

 

 

⑤接口的作用：实现该接口的多个类中表现运行时多态

1. 具有内部类、内部接口的类，编译后生成的所有类的文件名
内嵌类型的两个目的：类型的嵌套和对象的嵌套。
       静态内嵌类型用于定义类型的嵌套结构，实例内嵌类型用于定义对象的嵌套结构。
（1）内部类作为类型的特性：
①内嵌类型不能与外层类型同名。
②内部类中可声明成员变量和成员方法，内部类成员可与外部类成员同名，内部接口中可以声明成员常量和抽象成员方法。
③内部类可以继承父类或实现接口。
④可以声明内部类为抽象类，该抽象类必须被其他内部类继承；内部接口必须被其他内部类实现。
（2）内部类作为成员的特性：
    ①使用点运算符“.”引用内嵌类型：外层类型.内嵌类型，Pixel.Color
②内嵌类型具有类中成员的4种访问控制权限。当内部类可被访问时，才能考虑内部类中成员的访问控制权限。
③内嵌类型与其外层类型彼此信任，能访问对方的所有成员。
④内部接口总是静态的。内部类可声明是静态的或实例的，静态内部类能够声明静态成员，但不能引用外部类的实例成员；实例内部类不能声明静态成员。
    ⑤在实例内部类中，使用以下格式引用或调用外部类当前实例的成员变量或实例成员方法：
外部类.this.成员变量                //引用外部类当前实例的成员变量
外部类.this.实例成员方法(参数列表)   //调用外部类当前实例的成员方法
 
Color内部类和ColorConstant内部接口编译生成的字节码文件名分别为Pixel$Color.class和Pixel$ColorConstant.class
 
1. Java默认包（lang包）、object类为Java中所有类的父类，其对象引用可以指向任何一个类的对象实例、且在lang包中
包是Java语言的核心类库，包含Java语言必不可少的系统类定义，如object类、基本数据类型包装类、数学类、字符串类、线程类、异常类等。
 
1. getCLass()、getSuperClass()、getPackage()、getName()方法的用途
public class Package { public String getName() } //返回包名字符串
this.getClass().getName()                //当前实例的类名字符串
this.getClass().getSuperclass().getName()   //返回当前对象所属类的父类名字符串
this.getClass().getPackage().getName()     //返回当前对象所属类所在的包名字符串
 
System.out.println(new java.util.Date().getClass().getSuperClass().getName());               java.lang.0bject
System.out.println(new java.util.Date().getClass().getSuperClass().getPackage().getName());    java.lang
 
1. *Comparable接口的用途、功能，compareTo()方法的功能，对象不可直接用大于小于符号进行比较
    public interface Comparable<T>
{   int compareTo(T tobj)  //比较对象大小 }   其中，<T>是Comparable接口的参数，表示一个类。
返回值为-1、0、1，表示小于、等于、大于。
MyDate类对象比较大小
 public class MyDate implements Comparable<MyDate>
{   ……
public int compareTo(MyDate d)
       {  if (this.year==d.year && this.month==d.month && this.day==d.day)
            return 0;
        return (this.year>d.year || this.year==d.year &&this.month>d.month || this.year==d.year &&
 this.month==d.month && this.day>d.day) ? 1 : -1;
    }}
②Person类按生日比较对象大小 
public class Person implements Comparable<Person>
{   public String name;  
    public MyDate birthdate;  
public int compareTo(Person per)
比较日期大小，调用MyDate类的compareTo()
    }}
③ClosedFigure抽象类按面积比较对象大小
public abstract class ClosedFigure implements Comparable<ClosedFigure>
{   public abstract double area();             //计算面积，抽象方法
按面积比较对象大小
    {   return (int)(this.area() - cfig.area());
 }}
④public class Student implements java.lang.Comparable<Student>
{   public String name;  
    public MyDate birthdate;  
    public String department,speciality,number;
public int compareTo(Student s)
    {   return this.number.compareTo(s.number);  }}
 
 
1. 基本数据包装类有哪些，八个基本数据类型的包装类名称
、Short、Integer、Long、Float、Double、Character、Boolean。
 
1. parseInt方法的声明（同8）
2. 字符串转化为整数、浮点数的方法
public final class Integer extends Number implements Comparable<Integer>
{   public static final int MIN_VALUE=0x80000000;   //最小值-231
最大值231-1
私有最终变量，构造时赋值
构造方法
只此处赋值一次
由字符串构造整数对象
    public int intValue()  {   return value;    }                           //返回当前对象中的整数值
public static int parseInt(String s) throws NumberFormatException          //将串s按十进制转换为整数，静态
public static int parseDouble(String s) throws NumberFormatException      //将串s按十进制转换为浮点数，静态
    public static int parseInt(String s, int radix) throws NumberFormatException   //radix进制转换为正整数，radix取值为2～16
 
1. 获得年月日的方法
 Calendar. getInstance().get(Calendar.YEAR)
 
①以下 C 不是Color常量。
（A）Color.blue  （B）new Color(0,0,0) （C）new Color(0,256,0) （D）new Color(255,255,255)
 
第五章
1. 为何异常处理、如何异常处理，能解决哪些问题，不能解决哪些问题
异常处理使程序具有处理错误的能力（1分）。
采用try-catch-finally语句实现异常处理（1分）。
异常处理机制只能解决异常（1分）。
不能够处理程序中遇到的错误、虚拟机错误、内存溢出等（1分）。
如果当前方法没有能力处理异常，可以将异常转交给调用者处理（1分）。
 
1. *7个运行时异常名字，主要功能
  RuntimeException运行异常类，运行异常都是其子类。
  ①ArithmeticException 算术异常
3/0    //整除，除数为0，算术异常  ；3.0/0   //实数除，除数为0，无穷大Infinity或不确定NaN
  ②NullPointerException 空对象异常
int x[] = null;  x[0] = 1;           //对空数组中的元素进行操作，产生空对象异常
String str = null;  str.length()      //空对象调用方法，产生空对象异常
  ③ClassCastException 类型强制转换异常
Object obj = new Object();
String str = (String) obj;   //类型强制转换异常
只有当obj引用String实例时，可以强制转换：Object obj =”abc”;  String str = (String) obj;
  ④NegativeArraySizeException 负数数组长度异常
int x[] = new int [-1];   //申请存储空间时，指定数组长度为负数
⑤ArrayIndexOutOfBoundsException 数组下标越界异常
⑥StringIndexOutOfBoundsException 字符串序号越界异常
"abc".charAt(-1)       
  ⑦NumberFormatException 数值格式异常
public static int parseInt(String str) throws NumberFormatException
public static double parseDouble(String str) throws NumberFormatException
不能将字符串转换，产生异常
int i = Integer.parseInt(“123a"); 
double x = Double.parseDouble("123.45x");
 
1. Try{}catch{}finally{}应用，例题5.1         
try {
调用声明抛出异常方法
}
catch(NumberFormatException ex)     //捕获异常对象
{  System.out.println(str+"字符串不能转换为整数");
}
catch(Exception ex)                 //捕获所有异常对象
{  ex.printStackTrace();             //显示异常栈跟踪信息
}
 
1. Throws、throw语句
throw语句
throw  异常对象
      void set(int year, int month, int day)
{   if (month<1 || month>12)
月份错误");}
   ②方法声明抛出异常的throws子句
     方法抛出的异常，由该方法的调用者处理。
修饰符]  返回值类型  方法([参数列表])  [throws  异常类列表]
public static int parseInt(String s) throws NumberFormatException
public void set(int year, int month, int day) throws Exception
public MyDate(int year, int month, int day) throws Exception
{    this.set(year, month, day);}
public static void main(String[] args) throws Exception
 
第六章 编程重点
1. 滚动窗格JScrollPane和分割窗格JsplitPane，微调文本行(Jspinner)，JtextArea（文本区）
2. Component类（填空）
public abstract class Component extends Object implements ImageObserver, MenuContainer
{
宽度
高度
宽度和高度
位置的X坐标值
位置的Y坐标值
坐标位置，原点在左上角
坐标位置和宽度、高度
文本颜色
    void setForeground(Color color)
背景颜色
    void setBackground(Color color)
字体
    void setFont(Font font)
是否显示
是否有效
}
1. JOtionPane的用途和主要方法，返回值
①消息对话框JOptionPane.showMessageDialog(this, "请重新输入!"); 
②确认对话框int i=JOptionPane.showConfirmDialog(this, “删除？");
③输入对话框String password = JOptionPane.showInputDialog(this, "密码"); 
1. 图形用户界面（编程题），包括：框架、面板、文本行、普通按钮、复选按钮等组件，事件处理（按钮事件等的响应），异常处理（比如数值格式异常的处理）例6.6

 第七章
1. Thread和runnable的定义、用法，run()和start()方法的用途与含义
接口
public interface Runnable          //运行接口 
{   public abstract void run();  }   //描述线程操作
Thread线程类
public class Thread extends Object implements Runnable
{   public Thread()                              //构造方法
指定线程名
指定线程的目标对象
    public Thread(Runnable target, String name)
    public void run()                          //描述线程操作的线程运行方法
返回线程名
设置线程名
当前活动线程数
当前执行线程
线程的字符串信息
    public void start()                         //启动线程
}

1. *线程状态图，改变和判断线程状态的方法

 

（1）线程启动

public void start()               //启动线程对象
public final boolean isAlive()      //是否活动状态 
（2）线程睡眠
public static void sleep(long millis) throws InterruptedException
（3）线程中断
public void interrupt()           //设置中断标记
public boolean isInterrupted()     //判断是否中断
 
1. 线程对象的设置优先级的方法、获得优先级的方法及优先级范围
2. *多线程应用，例题7.3run()、start()、sleep()用法
3. *交互线程的竞争，synchronized含义功能
synchronized用于声明一段程序为临界区，使线程对临界资源采用互斥使用方式。
两种用法：①声明一条语句；②声明一条方法。
（1）同步语句：互斥锁定一段程序
synchronized (对象)             //锁定〈对象〉，被互斥访问，临界资源
语句                    //临界区，描述线程对临界资源的操作
（2）同步方法：互斥锁定一个方法
方法声明
{   synchronized (this)//被锁定的临界资源是调用该方法的对象this 
方法体  }}
 
1. Java的线程通信方式（三个）功能
类声明以下线程阻塞和唤醒方法，用于管程。
public final void wait() throws InterruptedException              //等待，最终方法
public final void wait(long timeout) throws InterruptedException    //等待指定时间
public final native void notify()      //唤醒一个等待当前临界资源的线程
public final native void notifyAll()    //唤醒所有等待当前临界资源的线程 
声明为最终方法，不被子类覆盖。
 
第八章
1. 流的含义和用途，使用的场合，Java的两大类流，举例说明。流与文件操作的关系，文件属性使用的类。
1. 数据字节流类及主要方法和用途
数据字节流提供从字节流读取或写入8种基本数据类型的方法。
数据字节流以拆分字节方式从字节流中读写指定长度的基本类型数据。
DataInputStream数据字节输入流类 （返回值不同，不能重载）
public class DataInputStream extends FilterInputStream implements DataInput
{  public DataInputStream(InputStream in)             //构造方法
       public final byte readByte() throws IOException       //byte整数，1字节，最终方法
       public final short readShort() throws IOException      //2字节
       public final int readInt() throws IOException          //4字节
       public final long readLong() throws IOException       //8字节
       public final float readFloat() throws IOException
       public final double readDouble() throws IOException
       public final char readChar() throws IOException       //2字节
       public final boolean readBoolean() throws IOException
}
public class DataOutputStream extends FilterOutputStream implements DataOutput
{   public DataOutputStream(OutputStream out)          
       public final void writeByte(int v) throws IOException
       public final void writeShort(int v) throws IOException
       public final void writeInt(int v) throws IOException    
       public final void writeLong(long v) throws IOException
       public final void writeFloat(float v) throws IOException
       public final void writeDouble(double v) throws IOException
       public final void writeChar(int v) throws IOException  
       public final void writeBoolean(boolean v) throws IOException
       public final void writeChars(String s) throws IOException
}
1. *例题8.2使用数据流读写整数文件，理解程序含义，读和写的方法要会写
2. *例题8.3对象字符输入输出流类名称，主要方法
3. *例题8.4管道流接受数据的线程
4. lastIndexof()的用途
5. 例题8.5使用字符流读写文本文件
P234 标准输入输出常量属于什么类
P238 FILE文件类的用法，主要方法的含义
P241-242 文件选择对话框组件名称，主要方法功能
P222，例8.2  数据字节流+文件字节流的用法，文件相关的几个异常处理