1、含有 main()方法的类称为主类，一个.java 文件中可以有多个类，但
只能有一个主类。
2 、 转义字符：对于 ‘ 和 \ ,需在前面加上\，即用 char a = '\'’,b='\\'表
示。\n 表示回车换行；\t 表示水平制表；\b表示退格；\v 表示水平制
表;\r 表示回车；\a 表示警铃
3 、 标识符：Java 程序中自定义的类名、方法名、参数都是标识符，
Java 语言中规定标识符由字母（区分大小 写）、数字、下划线、$自由
组合而成，但不能以数字开头，标识符长度不限。
4 、 基本数据类型：分 4 大类——整数（byte：1字节/int：4 字节
/short：2 字节/long：8 字节）、浮点数（float：4 字节/double：8 字
节）、字符型（char:2 字节）、布尔型（boolean:1 字节）。
5 、 整形变量注意：16 进制数以 0x 开头，8 进制数以 0 开头。
6 、 浮点型变量注意：如果数字未加任何字母，则默认为 double类
型，赋值时须注意数据类型匹配问题。
7 、 数组的定义：char array1[];和 char [ ] array2;都可以。
8 、 双目运算符：+ - * / 对于整形和浮点数有效（float x = 1f/3f;的运行
结果是 x=0.）,但%只对整形运算。
9 、 逻辑运算符：逻辑运算是对布尔型变量进行运算，结果也是布尔
型。^表示异或运算（a^b 表示 a 和 b 真假不同时，值为真）。&&和||
是短路的（对于 a&&b,如果 a 为假，则不再计算 b 的值），&和|是非
短路的，a 和 b 的值都要计算。
10 、 位运算符：&位与、|位或、~位反、^位异或、<<左移、>>右移、
>>>无符号右移(忽略了符号位扩展，0 补最高位)。
11 、 位运算注意：JAVA 进行移位运算中因为 int 是占 32 位,进行移位
的数是 32 的模,long 占8 字节也就是 64 位,所以移位的数是 64 的模，
byte、short 进行右移位运算，会自动转换成 int 类型。
12 、 左移运算：value << num：左移 num 位，丢弃最高位，0 补最低
位，如果移动的位数超过了该类型的最大位数，那么编译器会对移动
的位数取模(根据被移位数的类型而定模的大小)。运算规则：a.当左移
的运算数是 int 类型时，每移动 1 位它的第 31 位就要被移出并且丢
弃；b.当左移的运算数是 long类型时，每移动 1 位它的第 63 位就要被
移出并且丢弃。c.当左移的运算数是 byte 和 short 类型时，将自动把这
些类型扩大为 int 型。d.在数字没有溢出的前提下，对于正数和负数，
左移一位都相当于乘以 2 的 1次方，左移 n 位就相当于乘以 2 的 n 次
方
13 、 右移运算：value >> num：符号位不变，左边补上符号位；运算
规则：a.按二进制形式把所有的数字向右移动对应的位数，低位移出
(舍弃)，高位的空位补符号位，即正数补零，负数补 1;b.当右移的运算
数是byte 和 short 类型时，将自动把这些类型扩大为 int 型。
14 、 三目运算符（条件表达式）： x?y:z;表示 x 为真时，表达式的值
是 y 的值，否则取 z 的值。int x=1,y=2,z=3; int i = x<0?y:z;则 i 的取值就
是 3.
15 、java中提供了四种转移语句：break、continue、return、throw
break:在 Java 中，break 语句有 3 种作用。第一，你已经看到，在
switch 语句中，它被用来终止一个语句序列。第二，它能被用来退出
一个循环。第三，它能作为一种“先进”的 goto 语句来使用（break label;
标签 label 是标识代码块的标签。当这种形式的 break 执行时，控制被
传递出指定的代码块。被加标签的代码块必须包围 break 语句，但是它
不需要是直接的包围 break 的块。这意味着你可以使用一个加标签的
break 语句退出一系列的嵌套块。但是你不能使用 break 语句将控制传
递到不包含 break 语句的代码块 ）。
16、 continue:类似 break，不带标签的 continue 是终止当前循环结
构，转而直接进入下一轮循环。而 continue label;则是把程序直接转到
label 所指向的那一个循环结构的下一轮循环，而不管被它嵌套的及
continue 语句所在的循环结构运行到了哪一轮。
17 、 方法的调用及参数的传递：一个是传值（要求实际参数必须是简
单类型的变量），一个是传递地址(数组)。
18 、 类与对象：类是对对象的抽象,而对象是对类的具体化或实例化。
19 、 类头说明：类名第一个字母大写并体现该类的功能或特征。类的
修饰符分两种：一是访问控制符，如 public；一是类型说明符，类型说
明符只有两个：abstract 和 final。
20 、类的访问控制符：一个是 public，可以被所有的类访问和引用，
其他包用 import 语句引入后可调用；一个是默认的，也就是没有控制
符，也称为友好的 friendly,包中的类能用——而不能被其他包中的类访
问或使用（import 引入也不行）。注意：import语句引入的类必须是
public 修饰的类，Java 规定一个.java 文件可以有多个类，但必须有一
个而且最多有一个 public 类，因而文件中的其他类只能是友好访问控
制符。
21 、属性和方法的访问控制符：public、private（私有访问控制符，只
能被该类自身所访问或调用）、protect（保护访问控制符，它可被同
一个包中的其他类、不同包中的该类的子类及自身调用）、private
protect（只能被该类自身及该类的子类访问和引用）、默认访问控制
符（具有包内访问性，只能被同一个包中的其他类访问或引用，不在
同一个包中的类不能访问它，即使用import 语句引入也不行）
22 、static：只能修饰属性和方法，修饰的属性和方法不用实例化，可
以用类直接调用。
23 、多个修饰符放在一起使用：abstract 不能与 final 共同修改一个
类；abstract 不能与 private,static,final 和 native 共同修饰一个方法；
abstract 类中不能有私有属性和方法。
24、另一种创建对象的方法：假设一个类名为 Text，它有一个方法名
为 print()，则可以直接用下面的语句创建对象并其方法：new
Text().print(); 不过这个对象是无名，所以不能被再次调用。
25、构造函数：构造函数名字必须与类名完全相同，没有返回值也不
用 void 指明，还可以通过重载实现不同的初始化方法。
26、Java 允许类的嵌套：因此类的默认访问控制符有两个：一个是友
好类 default，一个是类中类，一个友好类编译后能后生一个独立
的.class 文件，如 Input.class，而类中类却产生
Judge$Imput.class ，所以只能被包含它的类使用。
27、命令行参数：main()方法是通过 String args[] 这个字符串数组来接收
命令行参数的。
28、继承：一个子类只能继承一个父类，这样继承关系就形成了一棵
树。继承能够使子类拥有父类非私有的属性和方法。子类通过 super
来调用父类的属性和方法。
29、多态：指一棵继承树的类中可以有多个同名但不同方法体以及不
同形参的方法。分两种情况——覆盖和重载。 覆盖是在子类中直接定义和父
类同样的属性和方法，而重载是指在同一个类定义中有多个同名的方法，但有不同的
形参。
覆盖：子类与父类的关系，是在子类中直接定义和父类同样的属性和
方法，但重新编写了方法体，即子类与父类的形参与返回值都相同，
但内部处理不同。通过调用它的对象 来决定调用哪个方法。
重载：同一个类内部多个方法间的关系，是指在同一个类定义中有多
个同名的方法，但不同的形参，而且每个方法有不同的方法体，调用
时根据形参的个数和类型来决定调用的是哪个方法。通过形参 表来决定
调用哪个方法。
30、在 Java 技术中，另一个必须要求有重载存在的原因是构造函数。
31、 继承了父类的属性表示子类被创建时另外开辟了新的空间来存储从父类继承而来
的属性，其初值应该是父类中属性的初值，但之后双方的相同属性彼此相互独立。
32、final 修饰的方法不能被子类覆盖，但可以被重载。abstract 修饰
的方法必须被子类覆盖。
33、this 的使用：this 关键字（只能在方法内部使用）可以为调用了自己的方法
的那个对象生成相应的地址，可以像对待其他任何对象地址一样对待。
public class Leaf {
private int i=0;
Leaf increment(){
i++;
return this; // 将当前对象的地址作为返回值返回
}
void print(){
System.out.println("i= "+i);
}
public static void main(String[] args){
Leaf x = new Leaf();
x.increment().increment().increment().print(); //多次调用方
法//increment()，返回的都是对象 x 的地址，i 值表示调用次数
}
}
34、super 的作用：它并不是父类对象的地址，它专门用来指代父
类，也就是说 super 的含义是被修饰的属性和方法将使用父类的定
义，而非子类本身的定义，因此子类的对象想使用它父类中的同名属
性和方法时，就可以使用 super 。
35 、构造函数：如果定义了多个构造函数，创建对象时必须使用其中之一，因为系统
不再定义默认的空构造函数了。
构造函数的简化(调用)：用构造函数间的调用可以实现定义的简化， 就
是先调用定义好的构造函数完成部分属性的初始化，再加上其他属性的赋值。
public class Leaf {
private String lname;
private int lnum;
Leaf(int num){
lnum = num;
}
Leaf(int$num,String$ name){
this($num); //调用上一个构造函数，等同于 lnum = $num;
lname =$ name;
}
public static void main(String[] args){
Leaf x = new Leaf(20,"good");
System.out.println("lnum= "+x.lnum+" lname="+x.lname);
Leaf y = new Leaf(22);
System.out.println("lnum="+y.lnum);
}
}
调用其他构造函数时，必须加上 this 代替函数名，但这时的 this 不代
表地址，只用来表示构造函数的名称，也就是类名;注意要在实际参数
名前加上$ 作为开参名，这样既区别于实际参数名，又能反映形参的含义。
构造函数的继承：A 、子类只能继承父类的默认构造函数，即无形参构造函数，并
且在创建对象时先调用这个构造函数对对象进行初始化，再调用子类自己定义的构造
函数。
B 、如果父类没有默认构造函数，子类将不能从父类继承到任何构造函数，并且子类
也不能定义自己的无参数构造函数。
C、如果子类想调用父类的非默认构造函数，必须使用 super 来实现。
例如调用父类的构造函数并加入自己的定义：
NormalStudent($stuFlag,$sName,$sSex,$ reduceFlag){
super($stuFlag,$sName,$sSex); //此处调用的是父类的构造函数
对形参$stuFlag,$sName,$sSex 初始化。
reduceFlag=$ reduceFlag;
}
D、子类的构造函数的形参表只能使用父类构造函数中用过的形参表，
或者是对它的扩展。例如父类的构造函数只有一个：Super(int i,
String s){……｝,那么它的子类只能定义这样的构造函数：subbie(int
i,String s,char c){ ……｝等。
36、最终类成员 A 用 final 修饰的方法是不能被该类的子类所重载的方法。
B、用 final 修饰的简单变量相当于常量，不管这个变量是属性还是自
变量，这时相当于编程者用一个名称来代替一个常量。如果类的属性
是常量，那么它的各个对象的这个值一定相同，所以 final 通常和
static 放在一起修饰属性，以节省内存空间；另外 final 的修饰的简单
变量通常是所有字母大写 ，以表示它是常量。
37、 静态变量、动态变量区别
A、对于静态变量在内存中只有一个拷贝（节省内存），JVM 只为静
态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用
类名直接访问（方便），当然也可以通过对象来访问（但是这是不推
荐的）。B、对于实例变量，每创建一个实例，就会为实例变量分配一
次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。
38、 对象在继承关系中的改变：
A、 子类实例可以被当作父类的一个对象使用，而父类实例不能被当作子类的一个对
象使用。子类对象可赋予父类对象，父类对象赋予子类对象则出错
B、如果一个父类对象通过赋值指向的地址是子类对象所在的地址，按
照前一条规则，这个对象仍然是父类的对象。但它可以通过强制类型
转换变成子类对象 ，这种转换只能用在对象间赋值时，不能单独使用强制转换。
以上规则可以这样理解：子类对象所占的内存在一般情况下比父类对象所占的内存空
间大，父类对象中的成员都可以在子类对象的地址中找到对应部分，所以可以把子类
对象当作父类的一个对象用。而相反时，子类对象的成员并不一定能在父类对象地址
中找到对应部分，这样就可能造成成员丢失。
而强制类型转换则是因为父类对象本身就与子类对象的地址相对应
（从子类转换而来), 当然可以把这个对象转换成子类的对象，而不造成成员的丢
失。
public class ObjectConvert {
public static void main(String[] args){
SuperClass superA = new SuperClass(),superB;
Subbie subA = new Subbie(),subB;
// 用子类对象作为实际参数传递给应是父类对象的形参
(new ObjectConvert()).useSubAsSuper(subA);
superB = subA;// 把子类对象赋予父类对象
System.out.println("superB.getX()"+superB.getX());
//如果输出中仍用方法 getY() 将出错。
//System.out.println(superB.gety());
// subB = superA;// 把父类对象赋予子类对象将出错
//把指向子类对象地址的父类对象 superB 强制转换成子类对象，并赋予 subB
subB = (Subbie)superB;
System.out.println(subB.getX()+""+subB.getY());//子类对象还相当于是原来的子类对象 subA
}
public voiduseSubAsSuper(SuperClass x){
System.out.println(x.getX()+"!!!!");
}
}
class SuperClass{
private int x = 100;
public int getX(){
return x;
}
}
class Subbie extends SuperClass{
private int y = 200;
public int getY(){
return y;
}
}
39、抽象类：抽象类的属性和方法是它的子类的公共属性和方法的集
合。A、用 abstract 修饰的方法是抽象方法，所有的抽象方法都必须
在抽象类中，抽象方法只有方法头而无方法体。定义格式如下：
abstract 返回值类型方法名([形参 ]);
B、抽象类可以包含抽象方法和一般方法，继承它的非抽象子类必须实
现其所有的抽象方法（注意是覆盖而不是重载），对于抽象类中的一
般方法的继承和普通的继承一样，只要该方法是非 private 的就可以继
承。
C、抽象类的实例：抽象类不能有实例，但有一种情况例外，就是定义
一个抽象类的对象名（引用）指向它的非抽象子类的对象。这也就是
38(B)中介绍的情况，这时的抽象类实例只含有父类所有的方法，而没
有子类新增加的方法。可以这样理解：一个对象名或方法名相当于一
个指针，父类的对象指向了子类的实例对象，因此父类对象的方法找
到了指针的目标，就是子类对象中的同名方法，而对于子类对象中私
有的方法 C(),父类对象中没有指针指向 C()，也即父类对象根本不知道
有方法 C()的存在，所以父类对象不能调用子类对象方法 C() 。
D、抽象类可以有抽象方法也可以没有抽象方法; 但是如果一个类有抽象方
法，那这个类只能定义为抽象类。
E、如果是抽象类实现一个接口，那么抽象类中可以不具体实现接口的
方法(保持其抽象性) ，而由其子类去实现。
40、接口：接口在语法上和类很相似，它的属性都是常量（用 final
修饰），方法都是抽象方法（abstract），没有方法体 ，接口间也可以形
成继承关系。
定义：
[public] interface 接口名[extends 父接口名 1，父接口名 2，……] ｛
[publicstatic final]属性数据类型属性名1=值；// 必须给出属性值
……
[publicabstract][native]返回值类型方法名（形参表）[throw 例外名
列表 ];
……
｝
说明：1、puiblic 表示它可以被不同包中的类或接口使用，没有用
public 表示它是友好的（default），具有包内访问性。Interface 的
修饰符只能为 public 或默认（default ）。
2 、子接口将继承所有父接口的所有属性和方法
3、接口的属性必须是 public static final（静态常量）修饰的，这是
被系统默认的，所以可以不写，但一般写出 final（所以接口的属性必
须给出属性值 ）
4、接口的方法系统默认为 public abstract 的，一般不写修饰符
5 、一个接口可以没有任何接口体，但大括号不能省略，这种接口一般是接口
继承结构中一个最顶层的父接口
接口与抽象类的区别：
接口中不能有非抽象的方法，但抽象类中可以有
一个类能实现多个接口，但只能有一个父类
接口与继承无关，所以无关的类可以实现同一个接口。
接口的实现：必须在类的定义时用关键字 implements 来声明
一个类声明实现某个接口后必须实现该接口的全部方法（包括该接口的所有父类的方
法），被实现的方法和接口定义的方法有完全一样的方法名、返回值和形参表。
被实现的方法的访问控制符必须显式地使用 public 修饰，因为
接口的方法都是 public 的。
41、适配器：当我们只需要使用某个接口中的少部分方法时，可以继
承与之相对应的抽象类（抽象类不用实现所有的方法？？）。java 类
库为所有的接口都提供了与之相对应的抽象类，我们称之为适配
器。？？？42、例外：java 允许我们声明抛出一个并没有发生的例外，可将其
作为一个“占位符”来理解。
A、java 提供了一个名为 Throwable 的类，所有的例外都必须是它或
它子类的实例。Throwable 有两个子类：Error 和 Exception，其中
Error 代表编译期和系统错误，我们一般不用特意捕获它们。
Exception是可以从任何标准 Java 库的类方法中招聘的基本例外类，
它们亦可以从我们自己的方法或者在运行期偶发事件中抛出。java 定
义的例外类都是 Exception 的子类。 -
B、catch 的括号内定义的对象名必须是 try 块中可能抛出的例外类的
同一个类或父类、甚至祖先类。因此说用 catch(Exception e)能捕获
所有例外 就不奇怪了。
C、异常的继承结构：基类为 Throwable，Error 和 Exception 继承
Throwable，RuntimeException 和 IOException 等继承
Exception，具体的RuntimeException 继承 RuntimeException。
D、Error 和 RuntimeException 及其子类成为未检查异常？？？？
（unchecked），其它异常成为已检查异常（checked ）
E、例外在继承关系中的特殊性：子类方法只能抛出被父类方法所能抛
出的例外所属的例外类或它的衍生类，如果父类方法未定义成抛出例
外，那么子类覆盖方法也不能抛出例外，如果父类方法声明抛出例
外，子类方法可以不声明抛出例外。 但是，父类的构造函数如果声明抛出例
外，则子类的构造函数也必须声明抛出，子类也可以抛出根本不存在的例外。
43、RuntimeException 介绍
1)、NullPointerException（值为空）：见的最多了，其实很简单，
一般都是在 null 对象上调用方法了。
String s=null;
boolean eq=s.equals(""); // NullPointerException
这里你看的非常明白了，为什么一到程序中就晕呢？
public int getNumber(String str){
if(str.equals("A")) return 1;
else if(str.equals("B")) return 2;
}
这个方法就有可能抛出 NullPointerException, 我建议你主动抛出异常，因
为代码一多，你可能又晕了。
public int getNumber(String str){
if(str==null)
{throw new NullPointerException("参数不能为空 ");}
// 你是否觉得明白多了
if(str.equals("A")) return 1;
else if(str.equals("B")) return 2;
}
2)、NumberFormatException：继承 IllegalArgumentException，
字符串转换为数字时出现。比如 int i= Integer.parseInt("ab3");
3)、ArrayIndexOutOfBoundsException:数组越界。比如 int[] a=new
int[3]; int b=a[3];
4)、StringIndexOutOfBoundsException：字符串越界。比如 String
s="hello"; char c=s.chatAt(6);
5)、ClassCastException:类型转换错误。比如 Object obj=new Object();
String s=(String)obj;
6)、UnsupportedOperationException: 该操作不被支持。如果我们希望不
支持这个方法，可以抛出这个异常。既然不支持还要这个干吗？有可能子类中不想支
持父类中有的方法，可以直接抛出这个异常。
7)、ArithmeticException：算术错误，典型的就是 0 作为除数的时候。
8)、IllegalArgumentException ：非法参数，在把字符串转换成数字的时候经
常出现的一个异常，我们可以在自己的程序中好好利用这个异常。
44、Java 基本类库介绍：
∙ Class 类：它是一个特殊的类，它的对象将伴随每个类，当一
个类 X 被编译后，就有一个特殊的对象（class 对象）产生，它
隐藏在 X.class 文件中，Class 对象是由编译系统自动生成的。
∙ Class.forName(String className)，这个方法是静态方法，
所以用 Class直接调用，方法的返回值是形参指示的类的 Class
对象。
∙ 类的加载都是在对象创建的时候进行。
45、String 与 StringBuffer
String 类用于处理那些值不会发生改变的字符串；而StringBuffer （变
长字符串）类用于那些可能发生变化的字符串的处理。
3988
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
