Java期末考试资料.doc

Java程序的后缀名.Java,编译后为.class。
一、第一第二章的概念
二、处理GUI组件上的XxxEvent事件的步骤：(简答题)
1、 首先要编写一个实现了XxxListener接口的事件监听类。
2、 然后在XxxListener类和要处理的具体事件情况相对应的方法中编写处理程序代码。
3、 最近将类XxxListener创建的对象通过addXxxListener方法注册到GUT组件上。
4、 Xxx可以是各种不同的事件，如Window,Mouse,Key,Action等。
5、 所有事件监听器方法返回的返回类型都是Void。
三、 嵌套类innerclassDemo.java与非嵌套类innerclassDemo1.java的改写
四、 P105页例题—自定义异常
先捕捉自定义异常，然后再捕捉算数异常，最后是exception异常。
class MyException extends Exception{
String message;
MyException(int n){
message=n+"不是正数";
}
public String getMessage(){
return message;
}
}
class A{
public void f(int n) throws MyException{
if(n<0){
MyException ex=new MyException(n);
throw(ex); //抛出异常，结束方法f的执行
}
double number=Math.sqrt(n);
System.out.println(n+"的平方根:"+number);
}
}
public class Example5_19{
public static void main(String args[]){
A a=new A();
try{
a.f(28);
a.f(-8);
}
catch(MyException e){
System.out.println(e.getMessage());
}
}
} class

五、 PPT里的内容：
Java 是什么？
一个开发环境；
一种程序设计语言；
一个应用程序的运行环境。
面向对象的特点：封装、继承、多态。

“一次编译，到处运行”的原理
JVM虚拟机类似Windows操作系统
Java虚拟机可以是硬件 ,也可以是软件
Java跨平台的原因
Java兼顾解释性与编译性语言的特点
“Java一次编译到处运行的原理”

P6 JAVA运行平台 P7 系统环境变量Path、Classpath的设置 P8 JAVA程序开发 P11 JavaApplet的开发
2、Java语言特点 （1）平台无关性（2）面向对象（3）多线程(5) 可移植性(6) 分布性(7) 高性能（相对于其他解释型语言）(8) 健壮性
Java的开发环境的搭建（1）
什么是JDK(Java Development Kit)
Classpath的设置
n 实际操作讲解classpath的作用
n Java解释器是如何处理当前目录的
n 如何解决当前目录的问题
n 配置classpath的几个注意事项
体验Java编程的过程
n 编辑工具的简要介绍
n MyFirstJavaApplication.java源文件的解释
n 用Javac编译源文件（可能碰到的问题）
n 用Java 运行编译后的字节码文件

– 开发工具，Javac及基础核心类
– 运行环境， java及基础核心类
按Java的应用环境划分
– J2EE(Java 2 Platform Enterprise Edition )
– J2SE（Java 2 Platform Stand Edition）
– J2ME(Java 2 Platform Micro Edition )
Java的开发环境的搭建（2）
JDK的安装及目录结构
使用Javac与java中碰到的路径问题
- 直接运行Java进行检查
- 运行Java –verbose进行检查

java的变量类型

整数类型(byte, short, int, long)

数值型

浮点类型(float, double)

字符型(char)

数据类型
基本数据类型
数组
类(class)
接口(interface)
引用数据类型

布尔型（boolean）

“>>”和“>>>” 区别的实例分析
public class ShiftTest
{
public static void main(String [] args)
{
int x=0x80000000;
int y=0x80000000;
x=x>>1;
y=y>>>1;
System.out.println(“0x80000000>>1 = ” Integer.toHexString(x));
System.out.println(“0x80000000>>>1 = ” + Integer.toHexString(y));
}
}
运行结果如下：
0x80000000>>1 = c0000000
0x80000000>>>1 = 40000000

十六进制与二进的对比
0x8000000016 =1000,0000, 0000, 0000, 0000, 0000, 0000, 00002
0xc000000016=1100,0000, 0000, 0000, 0000, 0000, 0000, 00002
0x4000000016 =0100,0000, 0000, 0000, 0000, 0000, 0000, 00002
程序的流程控制 ：顺序结构、选择结构、循环结构、

数组
为什么有数组？
n 堆内存和栈内存
n int [] x;
x = new int[100]; x=null;
的内存状态变化情况

函数的调用
函数调用的格式
在函数中使用return提前返回
函数调用的过程分析

对象的产生
Person p1 = new Person();执行完后的内存状态

对象的使用
创建新的对象之后,我们就可以使用“ 对象名.对象成员 ”的格式，来访问对象的成员（包
括属性和方法）
class TestPerson
{
public static void main(String[] args)
{
Person p1 = new Person();
Person p2 =new Person();
p1.age = -30;
p1.shout();
p2.shout();
}
}
上面程序运行的内存布局如下图

对象的生命周期

对象的比较
“==”运算符与equals()方法的区别

怎样比较两个数组对象的内容是否相等
P46 构造方法与对象的创建
p3=new Person(“Tom”,18) 的内存状态变化过程分析

this是什么？

如果func2方法被调用 ，一定是事先已经有了一个存在的对象，func2被作为那个对象的方法被使用。
在func2内部能引用别的对象 ，同样也能引用func2所属的那个对象。
在func2中，自己所属的那个对象的引用名称是什么呢？ this关键字在java程序里的作用和它的词义很接近，它在函数内部就是这个函数所属的对象的引用变量。
this引用句柄的存放位置
每个成员方法内部，都有一个this引用变量，指向调用这个方法的对象，类中的成员方法与this之间的关系如图

函数的参数传递
—基本数据类型的参数传递

函数的参数传递
—引用数据类型的参数传递

函数的参数传递
—引用参数传递的一个问题分析

内部类 —在类中直接定义的内部类
嵌套类可以直接访问嵌套它的类的成员，包括private成员，但是嵌套类的成员却不能被嵌套它的类直接访问。
在内部类对象保存了一个对外部类对象的引用，当内部类的成员方法中访问某一变量时，如果在该方法和内部类中都没有定义过这个变量，内部类中对this的引用会被传递给那个外部类对象的引用。

内部类 —在类中直接定义的内部类
如果函数的局部变量（函数的形参也是局部变量），内部类的成员变量，外部类的成员变量重名，我们应该按下面的程序代码所使用的方式来明确指定我们真正要访问的变量。
public class Outer
{
private int size;
public class Inner
{
private int size;
public void doStuff( int size)
{
size++; // 引用的是doStuff函数的形参
this.size++; //引用的是Inner类中的成员变量
Outer.this.size++; // 引用的Outer类中的成员变量
}
}
}
内部类
—在方法中定义的内部类
嵌套类并非只能在类里定义，也可以在几个程序块的范围之内定义内部类。例如，在方法中，或甚至在for循环体内部，都可以定义嵌套类 。
在方法中定义的内部类只能访问方法中的final类型的局部变量，用final定义的局部变量相当于是一个常量，它的生命周期超出方法运行的生命周期。

Java程序
ArrayPassReg.java
class ArrayPassReg
{
public static void main(String [] args)
{
int [] x = new int[1];
Compare1.java
class Compare1
{
public static void main(String[] args)
{
String str1 = new String("abc");
String str2 = new String("abc");
String str3 = 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");
}
}
结果：str1！=str2　str1=str3

x[0]=5;
change(x);
System.out.println(x[0]);
}
public static void change(int[] x)
{
x[0] = 3;
}
}

结果：3

pre_student.java
{
public String name;
public int age;
public String getInfo()
{
}
}
public class Student extends Person
{
public String school;
public String study()
{
}
}
结果：类Preson是公共的，应在名为Preson.java的文件中声明
类Student是公共的，应在名为Student.java的文件中声明
exception in thread=”main” Java.lang.NoSuch MethodError=main
Compare2.java
class Compare2
{
public static void main(String[] args)
{
String str1 = new String("abc");
String str2 = new String("abc");
String str3 = str1;
if(str1.equals(str2))
System.out.println("str1 equal str2");
else
System.out.println("str1 not equal str2");
if(str1.equals(str3))
System.out.println("str1 equal str3");
else
System.out.println("str1 not equal str3");
}
}
结果 str1 equal str2
str1 equal str3

Student.java
class Person
{ public String name="unknown";
public int age=-1;
/*public person()//如果不写这个构造函数，看看对类Student有什么影响。
{
}*/
public Person(String name,int age)
{ this.name=name;
this.age=age;
System.out.println("name="+name+",age="+age);
}
PassRef.java
class PassRef
{
int x ;
public static void main(String [] args)
{
PassRef obj = new PassRef();
obj.x = 5;
change(obj);
System.out.println(obj.x);
}
public static void change(PassRef obj)
{
obj.x=3;
}
}
结果：3
public void getInfo()
{ System.out.println(name);
System.out.println(age);
}
}
class Student extends Person
{
public String school="unknown";
public void study()
{ System.out.println("Studying");
}
public Student()
{/*super();*/
super("zhangsan",15);
}
public Student(String name,int age)
{super(name,age);
}
public Student(String name,int age,String school)
{this(name,age);
this.school=school;
}
}
class TestStudent
{public static void main(String[] args)
{Student s=new Student("zhangsan",20,"清华大学");
/*s.name="student";
结果：name=zhangsan,age=20
Zhangsan
20
Studying

s.age=16;*/
s.getInfo();
s.study();
}
}
InnerClassDemo.java
class Outer
{ int outer_i = 100;
void test()
{Inner in = new Inner();
n.display();
}
class Inner
{ void display()
{
System.out.println("display: outer_i = " + outer_i);
}
}
PassReg1.java
class PassRef
{
int x ;
public static void main(String [] args)
{
PassRef obj = new PassRef();
obj.x = 5;
change(obj);
System.out.println(obj.x);
}
public static void change(PassRef obj)
{
obj = new PassRef();
obj.x=3;
}
}
结果：5
}
class InnerClassDemo
{ public static void main(String[] args)
{
Outer outer = new Outer();
outer.test();
}
}//Demo2结果：display:outer_i = 100

InnerClassDemo1.java
class Outer
{ int outer_i = 100;
void test()
{ Inner in = new Inner(this);
in.display();
}
}
class InnerClassDemo
{ public static void main(String[] args)
{ Outer outer = new Outer();
outer.test();
}
}
class Inner
{ Outer outer;
public Inner(Outer outer)
{
this.outer=outer;
}
void display()
{
System.out.println("display: outer_i = " +outer.outer_i);
}
}结果：display:outer_i = 100

PassValue.java
class PassValue
{
public static void main(String [] args)
{
int x = 5;
change(x);
System.out.println(x);
}
public static void change(int x)
{
x = 3;
}
}
结果：5
InnerClassDemo2.java
class Outer
{ int outer_i=100;
void test()
{ Inner inner=new Inner();
inner.display();
}
class Inner
{ int y=10;
void display()
{ System.out.println("display:outer_i="+outer_i);
}
}
void showy()
{ System.out.println(y);
}
}
结果：
InnerClassDemo3.java
class Outer
{
int outer_i=100;
void test()
{
Inner inner=new Inner();
inner.display();
}
static class Inner
{ int y=10;
void display()
{ System.out.println("display:outer_i="+outer_i);
}
}
}
class InnerClassDemo
{ public static void main(String[] args)
{ Outer outer=new Outer();
outer.test();
}
}//next:Outer_Inner_Value
结果：无法从静态上下文中引用非静态变量outer_i
Polimophism.java
class A
TestChar.java
public class TestChar {

public static void main(String[] args)
{
//char c=97;
//String c=5+new Integer(1)+ "2" +‘4’+ new Long(11);
int x=2;
c = 1<< x;
System.out.println(c);
//char ch='x';
// System.out.print(ch);
//byte b=129;
//float f=3.5;
/* byte b;
int x=266;//将b改为266进行调试;
b=(byte)x;
System.out.println(b);*/
/* byte b=3;//表达式自动提升问题
b=b-1;//byte→int
System.out.println(b);*/
/* System.out.println('a'+1);//char→int
System.out.println(""+'a'+1);*/

}
}
结果：a
10
双斜线//和/*都是注释
{ public void func1()
{
System.out.println("A func1 is calling");
}
public void func2()
{ func1();
}
}
class B extends A
{public void func1()
{
System.out.println("B func1 is calling");
}
public void func3()
{
System.out.println("B func3 is calling");
}
}
class D extends A
{ public void func1()
{
System.out.println"D func1 is calling");
}
}
class C
{
public static void main(String [] args)
{
/*B b=new B();
A a = b;*/
D d=new D();
A a=d;
callA(a);
}
public static void callA(A a)
{
a.func1();
a.func2();
}
} 结果：D func1 is calling
D func1 is calling
TestException.java
class Test
{
public int devide(int x, int y) throws Exception
{
if(y<0)
throw new DevideByMinusException("被除数为负",y);
int result = x/y;
this2.java
class A
{
String name;
public A(String x)
{
name = x;
}
public void func1()
{
System.out.println("func1 of " + name +" is calling");
}
public void func2()
{
A a2 = new A("a2");
this.func1();//使用this关键字调用func1方法
a2.func1();
}
}
class TestA
{
public static void main(String [] args)
{
A a1 = new A("a1");
a1.func2();
}
}
结果：func1 of a1 is calling
func1 of a2 is calling
return x/y;
}
}
class DevideByMinusException extends Exception
{
int devisor;
public DevideByMinusException(String msg,int devisor)
{
super(msg);
this.devisor=devisor;
//System.out.println(devisor);
}
public int getDevisor()
{
return devisor;
}
}
public class TestException
{
public static void main(String [] args)
{
try
{
//int result = new Test().devide( 3, 0 );
int result = new Test().devide( 3, -1 );
//int result = new Test().devide( 3, 1 );
System.out.println("the result is " + result );
}
catch(DevideByMinusException e)
{
System.out.println("program is running into"+
"DevideByMinusException");
System.out.println(e.getMessage());
System.out.println("the devisor is " +
e. getDevisor());
//return;
//System.exit(0);
}
catch(ArithmeticException e)
{
System.out.println("program is running into"+
"DevideByMinusException");
System.out.println(e.getMessage());
}
catch(Exception e)
{
System.out.println("program is running into"+
"other unknowned Exception");
System.out.println(e.getMessage());
}
finally
{
System.out.println("finally is running");
}
System.out.println("program is running here ,that is normal !");
}
}
结果：program is running into DevideByMinusException
被除数为负数
the devisor is -1
finally is running
program is running here ,that is normal !

father_son.java

class A
{
public void func1()
{
System.out.println("A func1 is calling");
}
public void func2()
{
func1();
}
}
class B extends A
{
public void func1()
{
System.out.println("B func1 is calling");
}
public void func3()
{
System.out.println("B func3 is calling");
}
}
class C
{
public static void main(String [] args)
{
B b=new B();
A a = b;
callA(a);
//callA(new B());
}
public static void callA(A a)
{
B b=(B)a;
b.func1();
b.func2();
b.func3();
}
}
结果：B func1 is calling
B func1 is calling
B func3 is calling

instanceof.java
class A
{
public void func1()
{
System.out.println("A func1 is calling");
}
public void func2()
{
func1();
}
}
class B extends A
{
public void func1()
{
System.out.println("B func1 is calling");
}
public void func3()
{
System.out.println("B func3 is calling");
}
}
class C
{
public static void main(String [] args)
{
B b=new B();
A a = b;
callA(a);
//callA(new A());
}
public static void callA(A a)
{
if(a instanceof B)//判断a是否是B类的一个实例对象
{
B b=(B)a;
b.func1();
b.func2();
b.func3();//a是类B的实例对象打印func3();
}
else
{
a.func1(); //a不是B类的实例对象
a.func2();
}
}
}
结果：B func1 is calling
B func1 is calling
B func3 is calling

son_father.java
class A
{
public void func1()
{
System.out.println("A func1 is calling");
}
public void func2()
{
func1();
}
}
class B extends A
{
public void func1()
{
System.out.println("B func1 is calling");
}
public void func3()
{
System.out.println("B func3 is calling");
}
}
class C
{
public static void main(String [] args)
{
B b=new B();
A a = b;
callA(a);
//callA(new B());
}
public static void callA(A a)
{
a.func1();
a.func2();
//a.func3();
}
}
结果：B func1 is calling
B func1 is calling

19