JAVA期末复习

第一章

1、java的体系结构

Java编程语言、java类文件格式、java API和JVM（虚拟机）。

2、javac的作用是将源程序（.java文件）编译成（.class文件）。Java源程序的后缀名必须是java。

第二章

1、数据类型

Java一共有八中基本数据类型，4种整型，2种浮点型，表示字符单元的char型以及boolean类型。 2、进制数的表示

十进制 int number = 20; int number = 25;

八进制（在Java中，当需要使用八进制表示数时，需要在该数前面放置一个0） int octnum1 = 04;//表示八进制4 int octnum2 = 010;//表示八进制8 int octnum3 = 030;//表示八进制24

十六进制（在java中，当需要使用十六进制数的时候，需要在该数前面放置一个0X或0x）

int hexnum1 = 0X01;//表示十六进制1 int hexnum2 = 0X7FFFF;//F也可以小写 3、浮点型

浮点型数据默认为double型，因此要使用float型字面常量时，必须后面添加后缀F或者f。

float y = 12.3456F;

而使用double类型的时候，可以添加后缀D或者d，也可以不添加。 4、char型

在java中，字符的编码不是使用ASCLL码，而是使用Unicode编码

一般情况下，char类型数据被表示为用一对单引号包含的单个字符，如： Char c1 = „n‟; Char c2 = „@‟; 常用的转义字符：

\\n：换行 \\r：回车 \\b：退格 \：制表 \\”：双引号 /‟：单引号 \\\\：反斜杠

5、基本数据类型值间的转换

顺着箭头的方向有路径的均可进行自动转换。

强制类型转换

目标变量 = （转换的目标类型）待转换的变量或者数值； 如double d = 4.998;

Int i = (int)d; //i的值变为4；不会进行四舍五入；

6、变量名命名规范

·必须是一个合法的标识符；

·不能是关键字或者保留字（如true、false或者null）； ·在同一个作用域中必须是唯一的。

Java语言规定标识符由字母、下划线（_）、美元符（$）和数字组成，且第一个字符不能是数字。其中，字符也包括大小写的字母和汉字。

7、final变量 final变量的数值在初始化之后不能再进行改变。 Final float a = 3.14159; 8、运算符

·使用“+”、“-”、“*”、“/”表示加减乘除。另外还有求余运算符“%”，还有自增自减运算符。

·当加减乘除运算的时候，满足类型提升规则。即如果参与运算的两个数级不低于int型或者int型，则结果是int型，如果其中一个级别比int型高，则运算结果要与级别高的数类型相同。

·除法运算分为整数除和浮点除

1、整数除 结果将得到一个整数，把小数部分截断

2、浮点除 两个浮点数或者一个浮点数与一个整数畸形除法运算，结果将得到一个浮点数，即便结果是一个整数。

3、与整数除不同的是，在浮点除中，如果除数是0，则不会报错。在浮点除中，如果被除数是一个正浮点数（非0），结果为infinity（正无穷），如果被除数是负数，那么结果将得到-infinity（负无穷）；浮点数0.0/0则得到NaN；

·取余运算 将左边的操作数除以右边的操作数，取其余数，也遵循类型自动提升的规则。 Mod = 15%-4 结果是3 结果符号与右边操作数无关；

Mod = -15%4 结果是-3 结果由左边操作数决定； Mod = 6.8%6.3 结果是0.5，浮点数一样能求余数； ·自增自减运算符 op++：自增1，在自增之前计算op的值

++op：自增1，在自增之后计算op的值 op--：自减1，在自减之前计算op的值

--op：自减1，在自减之后计算op的值

·关系和逻辑运算符

·其他运算符 “？：” 该运算符是一个条件运算符，相当于一个简化的if-else语句。其一般形式是：（<逻辑表达式>）？<结果表达式1>：<结果表达式2>

首先计算逻辑表达式的值，若为true，则返回结果1，否则返回结果2。 9、控制结构

程序的结构大致可以分为3类：顺序、选择和循环。 ·条件语句

（1）if条件语句

（2）Switch分支语句 ·循环语句

（1）while语句 （2）Do-while语句 （3）For语句 ·跳转语句

（1）break语句 （2）Continue语句

（3）Return语句（只能用于方法内部，返回值可有可无）

10、字符串（包括字符串常量和字符串变量）

·String字符串的创建(可以有三种创建方式)

String str1 = “hello”;

String str1 = new string(“hello”);

Char str[] = {„h‟,‟e‟,‟l‟,‟l‟,‟o‟};//以字符数组方式声明

String str[] = {“hello”,”jaya”,”!”};//以字符串数组的方式声明 ·string类型字符串的操作

Substring(int begin,int end 返回值为string 该方法用于提取调用方法的字符串中的子串，并返回新的子串

String str1 = “java_learning”，str2; Str2 = str.substring(4,9);

System.out.printiln(str2);//输出_learn

indexOf、lastIndexOf：用于对字符串建立索引，返回字符串的位置 Int indexOf（string str） Int lastIndexOf(string str)

A.indexOf（B）A.lastindexOf(B) 比如：

String s1 = “java_learning”,s2 = “ear”; Int retVal1 = str1.indexOf(s2); Int retVal2 = str1.lastIndexOf(s2);

System.out.println(“indexOf:” + retVal1); //输出结果为 6 System.out.println(“lastindexOf:” + retVal2);//输出结果为 6

·stringBuffer类型

（1）stringbuffer对象的创建 stringbuffer name = new stringbuffer(“张三”)； （2）方法 方法 Capacity Append Insert Delete Reverse 11、数组

·数组的声明（维数和方括号的数目一致，而且方括号可以位于数组左边也可以位于其右边。）

·创建数组对象（new） Int[] k;

String [][] s;

//将数组k指向长度为5的int型一维数组对象 k = new int[5];

//将数组s指向第一维长度为6第二维长度为5的string型二维数组对象 s = new string[6][5];

·数组的初始化（默认初始化、利用循环初始化、枚举初始化） ·数组的常用操作(import java.util.Arrays)

（1）数组的排序

//对指定数组进行排序，排序结果存放到原数组中 Public static void sort(X[ ] a)

//对指定数组的区间进行排序，fromindex与toindex用来指定区间 Public static void sort(X[ ] a,int fromindex,int toindex) （2）查找指定元素

Public static int binarysearch(X[ ] a,X key) （3）比较数组中的元素

Int[] pra1 = {}; Int[] pra2 = {};

Boolean flag = Arrays.equals(pra1,pra2);

System.out.prinfln(“结果：”+((flag)? ”相等”：”不相等”);

12、命名规范

·字母包括大小写字母、“_”、“$”，以及一些希腊字母 ·数字包括0~9

·“+”等特殊符号不能出现在标识符中，空格也不行。 ·标识符中的字符大小写敏感，而长度没有限制 ·不能将java中的关键字用作标识符名。 13、注释

·单行注释（//）

·区域注释(/* */) ·文档注释(/** */)

参数 （） （string） （int，char） (int,int) () 返回值 Int String String String String 第三章

1、面向对象程序概述

·对象、类、继承、接口、封装（可能会考论述题） ·优点（可重用性、可扩展性、易于管理和维护） 2、java面向对象的特性

·类的所有信息都被存放到一个单独的文件中（后缀为.class）

·在java中，不允许定义多继承、即一个子类，只能有一个父类，不能有多个。但是一个类可以实现多个接口。 3、类的定义和对象的创建

·类之间的关系（“USES-A”、“HAS-A”、“IS-A”） HAS-A关系实例 Public class car{

Private tyre t = new tyre();//汽车对象拥有了轮胎对象，所以就能拥有轮胎对象中一切对象和方法；

Public tyre gettyreinfo() {

Return t; } }

Public class tyre{

}

4、构造函数

·构造函数的特点

（1）具有和它所在的类完全一样的名字 （2）构造函数没有返回类型

（3）构造函数的主要作用就是完成对象的初始化工作。 （4）构造方法不能由编程人员调用，而要系统调用

（5）一个类可以定义多个构造方法，如果在定义类的时候没有定义构造方法，则编译系统会自动插入一个无参数的默认构造器。

（6）构造方法可以重载，以参数的个数、类型或排列顺序区分 比如用初始化函数初始化汽车的各项参数 Public class car{

Private string color; Private string brand; //无参构造函数 Pubic car(){

This.color = “黑色”; This.brand = “奥迪”; }

//有参构造函数

Pubic car(string co,string br){

This.color = co; This.brand = brand;

}

Public string getcolor(){

Return this.color; }

Public string getbrand(){

Return this.brand; } }

5、方法

（1）方法的定义

返回值类型 方法名（参数序列） {

方法体 }

（2）方法体中的return

·代表已经完成方法功能，可以离开此方法返回

·如果该方法产生一个值需要返回，则这个值需要放在return语句的后面 （3）返回值类型

·可以再具有对象引用返回类型的方法中返回null，但是基本数据类型作为返回类型时，不能返回null；

·对象也可以作为返回值，比如数组

·在具有基本数据返回类型的方法内，可以返回任何值，只要该值能够自动转换为返回值类型。比如返回值类型为double，返回整数4是可以的，但是如果是返回值类型是int，返回12.34则报错

·void没有任何返回值

·在具有对象引用返回类型的方法内，可以返回任何类型的对象引用，只要返回的引用于返回类型相同或可以自动转换为返回类型即可。 （4）方法重载

·重载的方法参数列表各不相同；

·重载方法的返回值类型、访问限制没有特别的要求，可以相同也可以不同。

（5）重载方法的匹配（由参数序列决定调用哪个方法）

如 public int add(int i,int j){

System.out.print(“两个int参数的方法被调用”); Return i + j; }

public int add(double i,double j){

System.out.print(“两个double参数的方法被调用”); Return i + j; }

A.add(7,8);//这里7和8 都是int型的参数，则很显然调用第一个方法；

A.add(5,3.8);//这里5是int型的，3.8是double型的，没有直接匹配的方法，但是int型能够自动提升为double型的，所以调用的是第二个方法（PS只能进行类型的提升，无法下降）

（6）对于引用性参数，当调用重载的方法时，若与某个重载方法的参数完全匹配，则调用该方法；若没有完全匹配的方法，则寻找重载方法的参数类型中哪个最能兼容传递的参数。

6、静态函数（用static关键字把成员声明为静态成员）

（1）静态变量叫类变量，非静态变量叫做实例变量；静态方法叫类方法，非静态方法叫做实例方法。

Public class staticdemo{

Public static string s = “我是静态变量”; Public static void printinfo() {

System.out.println(“我是静态方法”)； } }

Public class sample {

Pubic static void main(string args[]){

//调用staticdemo中的prinfinfo方法和s变量时，不需要创建新的对象，直接访问即可

Staticdemo.printinfo();

System.out.println(staticdemo.s); } }

（2）静态成员的访问

Public class sample{

Static int staticVar = 13;

Public static void main(string args[]) {

//直接用名称staticVar调用了静态成员变量staticVar，在静态成员所在的同一个类中是可以的。在其他类中调用要使用类名，或相应的对象引用，受访问限制级别的约束。

Sample.staticVar = 16;

System.out.println(staticVar); } }

①静态方法访问非静态成员

Public class sample {

Int staticVar = 13;

Public static void main(string args[]){

System.out.println(“数值为：”+staticVar); } }

编译报错。因为main函数本身就是一个静态方法，而staticVar是非静态成员。由于静态成员不依赖于该类的任何对象，而非静态成员属于对象。所以

静态方法将不知道关于其所属类对象的信息，即静态方法不能访问非静态成员。

同样的，在静态方法中是不能使用this预定义对象引用的。 ②非静态方法访问静态成员

Public class sample{

Static int s = 100;

//在非静态方法中调用静态成员s Public void showstatic() {

System.out.println(“非静态方法成功调用静态成员s，其值为：” +sample.s); }

Public static void main(string args[]){

Sanple sa = new sample; Sa.showstatic(); } }

7、包（package <包名>）

（1）每个源文件中最多有一句package语句。 （2）类的导入

Import <包名>.* Import<包名>.类名

（3）如果两个包中有同名类，但只用到其中一个及其他不同名的类

例如，java.util 和java.sql包中都有名称为date的类，但只用到前者包中的date类。

可以使用import java.util.*

Import java.util.date 解决

（4）两个包中有同名类，但是都要使用

这时候真正的解决办法是在使用同名类的时候使用全称类名 Java.util.date d1 = new java.util.date(); Java.sql.date d2 = new java.sql.date();

8、成员的访问控制

公共类型（public）

当一个成员被声明为public时，所有其他类，无论该类属于哪个包，均能访问该成员。

私有类型（private）

标志为私有类型的成员后，其不能被该成员所在类之外的任何类中的代码访问。

第四章

1、方法的继承与覆盖

（1）方法的继承

Public class father {

Public void show() {

System.out.println(“该类为public类型，方法被成功继承”); }

}

Public class son extends father{

Pubic void getshow() {

System.out.print(“子类内代码调用结果：”);

This.show();//子类继承了父类的show方法。输出到屏幕上就是

子类内代码调用结果：该类为public类型，方法被成功继承 } }

Public class sample{

Public static void main(string args[]){

Son a = new son();

System.out.print(“子类外代码调用结果：”); S.show(); //对象s调用父类中show方法 S.getshow(); } }

（2）方法的覆盖

Class vehicle {

Public void startup() {

System.out.println(“一般交通工具的启动方法”); } }

Class car extends vehicle {

Public void startup() {

System.out.println(“轿车的启动方法”); } }

Public class sample{

Public static void main(string args[]){

Car c = new car();

System.out.println(“实际调用的方法：”); C.startup(); } }

输出结果为

实际调用的方法：轿车的启动方法

如果子类重写了父类的方法，则调用子类重写的方法，否则调用父类的方法。

如果

Public static void main(string args[]){

Vehicle v= new car();

System.out.println(“实际调用的方法：”); v.startup(); }

因为子类和父类中都有show方法，所以编译能够通过（若只是子类中有的方法，则报错。）

这种情况下，结果和之前的一样。说明了当父类的引用指向子类对象时，若访问被重写的方法，则将访问在子类中被重写的方法。

若构成重写，需要遵循以下如下规则： ·返回类型若为基本数据类型，则返回类型必须完全相同；若为对象引用类型，那么必须与被重写方法返回类型相同。

·访问级别的限制一定不能比被覆盖方法的限制窄，可以比被重写方法的限制宽

·不能重写被表示为final方法

·覆盖是基于继承的，如果不能继承一个方法，则不能构成重写。

（3）this与super

This常用来引用当前对象，而super常用来引用父类对象。 ·this

Public class sample {

Private string s = “haha”; Public string getstring() {

String s = “kaka”;

System.out.println(“方法中：”+s); Return this.s; }

Public static void main(string args[]){

Sample g = new sample();

System.out.println(g.getstring());

} }

输出结果： 方法中：kaka Haha Getstring（）中声明变量s，并输出s的内容，而利用this引用当前类中的private变量作为方法的返回值。运行后，结果显示输出该类的私有变量s中的内容，而不是getstring（）方法中的s变量。

引用当前类对象之外，this更多地用来将当前对象的引用作为参数传递给方法或者对象。

·super

用来引用父类的成员，包含父类的构造函数、属性以及方法。

Public class person{

Public string info = “我是父类”;

Public static void printmessage(string s) {

System.out.println(s); }

Public person(){

Printmessage(“A person.”); }

Public person (string name) {

Printmessage(“A person name is:” + name); } }

Public class sample extends person{ Public sample() { Super();

Printmessage(“相关信息：”); System.out.println(super.info); }

Public sample(string name) { Super(name); Printmessage(“名字：”+name); }

Public sample(string name,int age) { This(name); Printmessage(“年龄：”+age)； }

Public static void main(string[] args){ Sample cn = new sample(); Cn = new sample(“张三”);

Cn = new sample（“张三”,22）; } }

运行结果如下： A person 相关信息： 我是父类

A person name is：张三 名字：张三

A person name is：张三 名字：张三 年龄：22

Sample继承父类之后，用super关键字引用了父类中的构造函数。

（4）强制类型转换（继承过程中发生引用类型的转换） 引用均能指向自身类型的对象实例；

父类的引用变量还可以指向由其派生出的直接或间接子类的对象。 如：vehicle v = new car(); v = new truck(); car c = new truck(); 由父类派生出来的子类，具有了父类的特征和行为，可以将子类对象看做父类对象。 Pubic class car {

String aMember = “我是汽车类的成员变量”; }

Public class truck extends car{

String aMember = “我是卡车类的成员变量，汽车类也有”; }

Public class sample{ Public static void main(string[] args) { Car c = new truck(); System.out.println(“访问的成员是：”+c.aMember); } } 运行结果

访问的成员是：我是汽车类的成员变量

可以看到的是，即使Car c = new truck(); 但是打印的还是父类的成员变量。这是因为在运行时，对于成员变量的访问，系统接收的是引用类型，引用哪个类的，系统就访问哪个类的成员。

所以我们可以将System.out.println(“访问的成员是：”+c.aMember);改为 System.out.println(“访问的成员是：”+（（truck）c）.aMember); 然后运行结果就可以变为

访问的成员是：我是卡车类的成员变量，汽车类也有 2、终止继承：final类和final方法

当关键字final用来修饰时，其含义是该类不能再派生子类，其他任何类都不能继承用final修饰的类。

用final修饰的方法 Public class father{

Public final void show() { System.out,println(“final方法可以被继承但是无法被重写”); }

Public class son extends father{ }

Public class sample{

Public static void main(string[] args) Son s = new son(); S.show();

}

运行结果是

final方法可以被继承但是无法被重写 如果在子类中修改show方法，编译报错

3、抽象类（用abstract关键字声明抽象类和抽象方法）

·抽象类永远不能实例化，其唯一的用途就是用于继承扩展。

·不能把一个类同时标志位abstract和final。前者的类表示很多类的事物总称，可以再分子类，后者的类一定不能再分子类。

·抽象的方法。只有方法名，没有方法体。 抽象类中可以有非抽象的方法。只要有抽象方法，那么一定就是抽象类。 当某类继承自抽象类时，如果其本身不是抽象类，则必须实现所继承抽象类中的抽象方法。抽象类的第一个非抽象子类必须实现其父类所有的抽象方法，其中也包括父类继承的抽象方法。

第五章

1、接口的使用

Public interface employee {}

Public interface manager {}

Public class person implements employee,manager {}

2、接口与抽象类的区别（P149，太多了，自己看去吧„„） 3、内部类

·内部类是指在一个外部类的内部在定义一个类。内部类作为外部类的一个成员，依附于外部类而存在。

·内部类可以为静态的，可以用protected和private修饰。

·为什么要使用内部类？（每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个接口的实现，对于内部类都没有印象。内部类提供可以继承多个具体的或抽象的类。内部类有效地实现了“多重继承”）。

·内部类分为成员内部类（作为外部类的一个成员存在，与外部类的属性、方法并列）、局部内部类（在方法中定义的内部类，能访问当前代码块内的常量，和此外部类的所有成员）、匿名内部类（没有名字的局部内部类）、静态内部类（不需要内部类对象与其外围类对象之间有联系）。

·定义内部类的基本方法 Class<外部类名> {

[<成员访问限制修饰符号>] [static] class <内部类名> {

//内部类的成员 }

//外部类的其他成员 }

第六章

1、系统输入流

Import java.io.* Public class sample {

Public static void main(string[] args) {

Try { //将System.in返回的InputStream字节流转换成字符流 InputStreamReader is = new InputStreamReader(System.in); //将转换后的字符流封装成BufferedReader流 BufferedReader br = new BufferedReader(is); //定义字符串引用 String s = null;

System.out.print(“请输入一行内容（直接回车退出程序）>”); //测试输入的内容是否为空

While((s = br.readline()) != null && s.length() != 0) { //若不为空则显示输入的内容，并进入下一次输入 System.out.println(“您输入的内容为：”+s); System.out.println(“请输入一行内容（直接回车退出程序）”); } }

Catch(IOException e) {

e.printStackTrace(); } } }

2、文件操作

Import java.util.*; Import java.io.*; Public class sample{ Try {

//创建一个表示不存在子目录的File对象 File fp = new File(“MyFile”)； //创建该目录 fp.mkdir();

//创建一个描述MyFile目录下的文件的FIle对象 File fc = new File(fp,”childfile.txt”); //创建该对象

fc.createNewFile();

//创建输出流

FileWriter fo = new FileWriter(fc);

BufferedWriter bw = new BufferedWriter(fo); PrintWriter pw = new PrintWriter(bw); //向文本中写入5行文本 For(int i = 0;i<5;i++) {

Pw.println(“[”+i+”]Hello World!!!你好，本文由程序创建！！！”); }

pw.close();

System.out.println(“恭喜你，目录以及文件成功建立，数据成功写入！”); }

Catch(Exception e) {

e.printStackTrace(); } }

3、异常处理

·异常是针对方法来说的，抛出、声明抛出、捕获和处理异常都是在方法中进行的。 ·Java异常处理通过5个关键字try、catch、throw、throws、finally进行管理。

·基本过程是用try语句块包住要监视的语句，如果在try语句块内出现异常，则异常会被抛出，你的代码在catch语句块中可以捕获到这个异常并做处理;

·可以通过throws关键字在方法上声明该方法要抛出异常，然后在方法内部通过throw抛出异常对象。

·finally语句块会在方法执行return之前执行 一般结构如下： try{

程序代码

}catch(异常类型1 异常的变量名1){ 程序代码

}catch(异常类型2 异常的变量名2){ 程序代码 }finally{ 程序代码

} PS

·catch语句可以有多个，用来匹配多个异常，匹配上多个中一个后，执行catch语句块时候仅仅执行匹配上的异常。

·catch的类型是Java语言中定义的或者程序员自己定义的，表示代码抛出异常的类型，异常的变量名表示抛出异常的对象的引用，如果catch捕获并匹配上了该异常，那么就可以直接用这个异常变量名，此时该异常变量名指向所匹配的异常，并且在catch代码块中可以直接引用。

4、如何定义和使用异常类

1、使用已有的异常类，假如为IOException、SQLException。 try{ 程序代码

}catch(IOException ioe){ 程序代码

}catch(SQLException sqle){ 程序代码 }finally{ 程序代码 }

2、自定义异常类

创建Exception或者RuntimeException的子类即可得到一个自定义的异常类。例如:

public class MyException extends Exception{ public MyException(){}

public MyException(String smg){ super(smg); }

}

3、使用自定义的异常

用throws声明方法可能抛出自定义的异常，并用throw语句在适当的地方抛出自定义的异常。例如： 在某种条件抛出异常

public void test1() throws MyException{ ... if(....){

throw new MyException(); }

}

将异常转型(也叫转译)，使得异常更易读易于理解

public void test2() throws MyException{ ... try{ ...

}catch(SQLException e){ ...

throw new MyException(); } }

第七章

1、Swing和AWT之间的关系（P210） 2、事件处理

①事件源是指触发事件的空间，如按钮、窗体、列表、表格等。 ②监听器则是指实现了专门的监听接口的类的对象 ③监听器与事件源之间是“多对多”的关系。 P213 事件处理的过程

创建图形用户界面

Import javax.swing.JFrame; Import javax.swing.JLable;

Public class sample extends JFrame{ Public sample(){}

Public sample(boolean b) {

//向窗体添加一个标签

This.add(new JLabel(“这是一个窗体，演示了JFrame类的基本功能”)); //设置窗体标题

This.settitle(“自定义窗口”)； //设置窗体的大小

This.setbounds(80,80,480,180);

//根据接受的boolean设置窗体是否可以调整大小 this.setResizaable(b); //设置窗体的可见性 this.setVisible（true）;

}

Public static void main(string[] args) {

//创建对象，并传递false值使得窗体不能调整大小 New sample（false）; } } 布局管理

采用一定的策略来管理额容器中各个控件的大小，位置和属性。

1、流布局（FlowLayout）

按照控件添加的顺序，依次将控件从左至右，从上至下进行摆放，若一行不能放完则自动转至下一行。

2、网格布局（GridLayout）

尽量依照给定的行数和列数排列所有的控件，添加到该布局容器中的控件都将自动调整为相同尺寸，其填充的规则是尽量使现有控件形成矩形。