Java运行环境的安装、配置与运行实验报告

一．实验目的及要求

1．掌握JDK1.6软件包、eclipse IDE工具的下载、安装 2．掌握设置Java程序运行环境的方法 3．掌握编写与运行Java程序的方法

4．掌握Java基本数据类型、运算符与表达式、数组的使用方法

5．理解Java程序语法结构，掌握顺序结构、选择结构和循环结构语法的程序设计方法

6．掌握运行Java程序的步骤 二．实验内容及步骤

1．从sun公司网站（http://java.sun.com/javase/downloads/index.jsp）下载jdk1.6程序包java jdk1.6.0.02.exe并将jdk安装到C:\\program files\\Java\\jdk1.6（公共jre可以不安装），从apache jarkart公司主页下载tomcat6.0，程序包

apache-tomcat-6.0.18.zip，并解压到

C:\\

apache-tomcat-6.0.18，从相关网站下载java IDE环境，程序包MyEclipse_6.0.1GA_Eclipse3.3.1_Full.exe，下载安装editplus3.0作为java源程序编辑器，并设置相应的系统环境变量。

1）新建或设置系统环境变量值（path变量名已经存在）如下： java_home=C:\\Program Files\\Java\\jdk1.6 catalina_home=C:\\apache-tomcat-6.0.18

classpath=.;%java_home%\\lib\\dt.jar;%java_home%\\lib\ools.jar --类路径很重要

path=%path%;%java_home%\\bin;%java_home%\\lib;%catalina_home%\\bin;%catalina_home%\\lib

之后，可以进DOS窗口分别输入javac命令，set命令进行检查。

2）针对editplus编辑器，依次单击Tools―>Preferences„－>Files，将default encoding改成UTF-8，将UTF-8 signature改成always remove UTF-8 signature，保存即可。

3）针对Eclipse3.3.1 IDE环境，进行如下设置：

3.1) 添加jdk路径

Menu（主菜单）->Window（窗口）->Preferences（首选项）->java->Installed JREs（已安装的jre），点Add（添加）。 3.2)设置Server

菜单栏中选择“窗口(window)”－－“首选项...(preference)” ——“MyEclipse”－－“Servers”－－“Tomcat”——Tomcat6.x，将Tomcat Server设置为“Enable”，并将“Tomcat Home Directory”设置为Tomcat6.0的安装目录，其他目录选项将会自动生成, 接着选择Tomcat6.x ——JDK，在Tomcat JDK name那选择之前添加的jdk。

3.3)配置默认编码

仍然是菜单栏中的“窗口(window)”－－“首选项...(preference)”——“常规(General)”－－“内容类型(Content Types)”－－“文本(text)”。然后在“缺省编码(Default encoding)”中输入“UTF-8”，点击“更新(Update)”，将“Java类文件(Java Properties File)”及其他字符编码均“更新(Update)”为“UTF-8”。 3.4)设置编辑器字体/输出内容字体

依次进“窗口(window)”－－“首选项...(preference)”——“常规(General)”－－\"皮肤(Appearance)\" Java 实验内容及报告要求

－－“颜色和字体(colors and fonts)”－－\"Java\"－－“java editor text font(set to default text font)”，再单击“change...”，在上述列表框中选择\"part title font\"后,可修改编辑器下方的输出面板的标题字体。

依次进“窗口(window)”－－“首选项...(preference)”——“常规(General)”－－\"皮肤(Appearance)\"－－“颜色和字体(colors and fonts)”－－\"Debug\"－－\"console font (overrides default: text font)\可修改控制台输出内容的字体。 4）在editplus中新建一个简单的java源程序，编辑，文件保存为firstJava.java。然后分别执行如下操作。

4.1）打开一个DOS控制台窗口，进入firstJava.java文件所在目录，然后依次输入命令，

..>javac firstJava.java

..>java firstJava

观察编译是否通过，运行是否通过。

4.2）运行myeclipse6.0.1，之后新建一个java工程，工程名可为chp1，按照向导进行逐级选择，最后单击“完成”。可看到自动生成chp1，src，bin等目录，从文件夹窗口中将4.1）中已建好的firstJava.java文件复制一份到src目录下，切换到myeclipse主界面，右单击chp1，选择“刷新”，可以看到firstJava.java程序添加到工程中了，然后编译、运行这个java程序，直到正确为止。

5）编写一个java源程序，文件名为chp2Basic.java，功能包括建立基本类型和数组类型的变量，对它们进行赋值（包括字符串变量赋值），运算（包括逻辑与&&,&，位与&，常量和变量的无符号右移）以及输出变量值。

6）编写一个java源程序，文件名为chp2Loop.java，功能包括建立一个5×5×5的整型数组，用元素所在的位置序号（从1开始）对所有数组元素进行赋值，然后使用三层循环只对那些任一个下标值对2求余不为0时的数组单元值加1，其余不变，要求使用continue label语法，可以加上break label语法。 三．实验小结

实验二 面向对象编程

一．实验目的及要求 1． 掌握如何创建类和对象

2． 掌握构造方法的执行过程与对象的创建 3． 掌握成员变量的定义，隐藏规则

4． 掌握成员方法的定义，重载以及覆盖规则

5． 掌握java中引入包命名机制和带包名的java程序的运行 6． 掌握抽象类/接口的定义，抽象方法的声明 7． 掌握java中异常处理机制和异常处理方法 二．实验内容及步骤

1． 创建一个飞行器抽象类，名称为absAircraft，并以它为父类分别创建飞机（airplane），鸟（bird），以及超人（superman）三个子类，所有的飞行器类具有不同的尺寸，长L，宽W，高H；不同的体重（weight），速度（speed），体积（volume）。

要求以不同的长宽高三个参数构造相应的飞行器对象，将计算飞行器体积的方法在抽象类中实现并返回默认值0.0。它可以起飞，飞行，着陆，将这三个功能在一个接口中声明，接口名为infAircraft，方法名分别为takeoff，fly，landfall，上述三个子类实现这个接口；还可以发出不同的声音，将发出不同声音的方法在抽象类中申明为抽象方法。另外，鸟和超人还会吃（eat）。所有这些功能要求使用类的继承，方法重载和方法覆盖，接口声明和实现予以实现，编写一个主类，名称为oopDemo.java，在main函数中创建三个子对象，并以子类引用变量或父类引用变量方式调用这些方法，观察在各种情形下程序能否正常运行。 要求编写符合java编程规范的源程序以及对程序作必要的注释。 package sn.exp;

public abstract class AbsAircraft { protected double width = 0.0D; protected double height = 0.0D; protected double length = 0.0D; protected double speed = 0.0D; protected double weight = 0.0D; protected double volume = 0.0D; abstract public void sound();

public AbsAircraft(double width, double height, double length) { }

public double getWidth() { }

public void setWidth(double width) { }

this.width = width; return width; this.width = width; this.height = height; this.length = length;

public double getHeight() { }

public void setHeight(double height) { }

public double getLength() { }

public void setLength(double length) { }

public double getSpeed() { }

public void setSpeed(double speed) { }

public double getWeight() { }

public void setWeight(double weight) { }

public double getVolume() { }

public void setVolume(double volume) {

this.volume = volume; return volume; this.weight = weight; return weight; this.speed = speed; return speed; this.length = length; return length; this.height = height; return height;

} }

package sn.exp;

import sn.exp.inf.InfAircraft;

public class Airplane extends AbsAircraft implements InfAircraft{ public Airplane(double width, double height, double length) { } @Override

public void sound() { }

public void fly() { }

public void landfall() { }

public void takeoff() { } @Override

public double getVolume() { } }

package sn.exp;

import sn.exp.inf.InfAircraft;

public class Bird extends AbsAircraft implements InfAircraft{

return width * height * length; System.out.println(\"Airplane takeoff\"); System.out.println(\"Airplane landfall\"); System.out.println(\"Airplane fly\");

System.out.println(\"Airplane sound\"); super(width, height, length);

public Bird(double width, double height, double length) { } @Override

public void sound() { }

public void fly() { }

public void landfall() { }

public void takeoff() { }

public void eat(){ }

public double getVolume() { } }

package sn.exp;

import sn.exp.inf.InfAircraft;

public class Superman extends AbsAircraft implements InfAircraft{ public Superman(double width, double height, double length) {

super(width, height, length); return width + height + length; System.out.println(\"Bird eat\"); System.out.println(\"Bird takeoff\"); System.out.println(\"Bird landfall\");

System.out.println(\"Bird fly\"); System.out.println(\"Bird sound\"); super(width, height, length);

} @Override

public void sound() { System.out.println(\"Superman sound\");

}

public void fly() { System.out.println(\"Superman fly\");

}

public void landfall() { System.out.println(\"Superman landfall\"); }

public void takeoff() { System.out.println(\"Superman takeoff\"); }

public void eat(){ System.out.println(\"Superman eat\"); }

public double getVolume() { return width + height - length; } }

package sn.exp;

import sn.exp.inf.InfAircraft; public class OopDemo {

public static void main(String[] args) { Bird bird = new Bird(1.0D, 2.0D, 3.0D);

Airplane airplane = new Airplane(4.0D, 5.0D, 6.0D); Superman superman = new Superman(7.0D, 8.0D, 9.0D);

AbsAircraft [] absAircrafts = new AbsAircraft[]{bird, airplane, superman};

for(AbsAircraft aircraft : absAircrafts){ }

InfAircraft [] infAircrafts = new InfAircraft[]{bird, airplane,

System.out.println(aircraft.getVolume());

superman}; } }

package sn.exp.inf;

public interface InfAircraft { public void takeoff(); public void fly(); public void landfall(); }

2． 编写一个带包名的java源程序，包名为chp3.test，三个类名分别为类cAccess，cAccess的子类subAccess，以及非子类anotherAccess，且用public修饰类cAccess，注意此时的源程序名必须为cAccess.java。定义在类cAccess中的成员变量a，b，c，d分别用private，default（不修饰），protected和public修饰。在cAccess类和subAccess类中的公共方法access中要求访问这些变量的值，在anotherAccess类的access方法中以新建一个cAccess对象的形式调用它的access方法，最后在anotherAccess类的main方法中新建三个类的对象，并分别调用它们的access方法，注意观察在各种情形下的访问是否成功。另外，在DOS控制台窗口

for(InfAircraft infaircraft : infAircrafts){ }

bird.eat(); superman.eat();

infaircraft.takeoff(); infaircraft.fly(); infaircraft.landfall();

下运行这个带包名的java程序，想想此时待运行的程序名是什么？ package Chp3.test; public class CAccess { private double a; double b;

protected double c; public double d;

public CAccess(double a, double b, double c, double d) { }

public void access() { } }

package Chp3.test;

public class SubAccess extends CAccess {

public SubAccess(double a, double b, double c, double d) { } }

package Chp3.test;

public class AnotherAccess {

super(a, b, c, d);

System.out.println(\"a=\" + a); System.out.println(\"b=\" + b); System.out.println(\"c=\" + c); System.out.println(\"d=\" + d); System.out.println(); this.a = a; this.b = b; this.c = c; this.d = d;

public static void main(String[] args) { }

public void access(){ } }

3． 编写一个包含try-catch-finally语句块的java源程序，文件名为testExceptionProc.java，类名为testExceptionProc，其中方法process接收一个整型参数，该参数对应的实参值分别是1，2，3，在传入值1时，没有任何异常出现；传入值2时，执行一个除法运算，当除数为0时，则抛出ArithmeticException，要捕捉此异常；在传入3时，要求能够捕捉数组下标越界异常，即ArrayIndexOutOfBoundsException，请设计此时的语句块，最后还可以捕捉Exception异常。另外，将上述process方法申明抛出ArithmeticException，ArrayIndexOutOfBoundsException，并由此方法的调用者对这些异常进行处理，请设计实现上述两种情形下的异常处理程序。 public class TestExceptionProc{ public void process(int i) {

int tem; if(i==1)

tem=1+2;

CAccess ca=new CAccess(9.0,10.0,11.0,12.0); ca.access();

CAccess ca=new CAccess(1.0,2.0,3.0,4.0); SubAccess sa=new SubAccess(5.0,6.0,7.0,8.0); AnotherAccess anotheraccess =new AnotherAccess(); ca.access(); sa.access();

anotheraccess.access();

if(i==2)

tem=2/0;

} }

if(i==3){ }

int []a=new int[2]; a[4]=4;

public class Main {

public static void main(String[] args) { } }

三．实验小结

实验三 常用系统类的使用，Java多线程编程

一．实验目的及要求

TestExceptionProc tep=new TestExceptionProc(); tep.process(1); try{

tep.process(2);

}catch(ArithmeticException e){ } try{ }

catch(ArrayIndexOutOfBoundsException e){ }

System.out.println(\"数组下标越界\"); tep.process(3);

System.out.println(\"除数为0\");

1． 掌握字符串类的使用方法

2． 掌握不同类型的输入输出流类，标准数据流、文件流、数据输入输出流、对象流等

3． 理解多线程机制，掌握线程对象的创建方法

4． 掌握线程调度方法，包括线程优先级，线程等待、睡眠、唤醒、中断、终止方法

5． 理解多线程之间的互斥和同步 二．实验内容及步骤

1． 创建一个基本类型以及对象类型应用的源程序basicType.java，要求使用String类的变量先后指向两个相同的字符串常量，观察这个变量的值和所指向串的值，使用equals方法判定两个串的内容是否相等。使用Scanner类的变量从键盘上接收若干个整型数据，计算其总和并输出，能够处理非数值的情形并允许再次输入下一个数值。使用FileReader类/FileWriter类结合File类的变量执行先将整型、长整型、char和String类型变量值保存到文件test.txt，再输出该文件中的内容，观察此时程序的输入输出。使用FileWriter类/BufferedWriter类向文件test2.txt中写入dobule类型，char类型，以及String类型的变量值，再使用FileReader类/BufferedReader类读出这些变量的值，观察此时程序的输入输出情况。 import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Scanner; public class BasicType {

public static final String CONSTANT_STRING = \"Java String\"; public static void main(String[] args) { // testEqualsString(); // testScanner();

// testfile(); }

public static void testEqualsString(){

String stringA = CONSTANT_STRING; String stringB = CONSTANT_STRING;

System.out.println(\"stringA == stringB :\" + (stringA == stringB)); System.out.println(\"stringA.equals(stringB):\"

+

test2Buffered();

(stringA.equals(stringB))); }

public static void testScanner(){ }

public static void testfile(){

File fileTest1 = new File(\"test1.txt\"); FileWriter fw = null; try{

fw = new FileWriter(fileTest1); fw.write(String.valueOf(1234)); fw.write(String.valueOf(1234567890L)); Scanner s = new Scanner(System.in); int count = 0; int sum = 0; int num = 0;

System.out.print(\"Input Integers num :\" ); num = s.nextInt();

System.out.print(\"Input \"+ num +\" Integers；\" ); for(count=0;countsum = sum + s.nextInt();

System.out.print(\"sum : \" + sum);

}

fw.write('A'); fw.write(\"String\");

catch(IOException e){ } finally{ }

FileReader fr = null; try{ }

catch(IOException e){ } finally{

System.out.println(e.getMessage()); String fileText1 = null; fr = new FileReader(fileText1); int charread;

while( (charread = fr.read()) != -1){ }

System.out.print((char)charread); if(fw != null){ }

try{ }

catch(IOException e){ }

System.out.println(e.getMessage()); fw.close();

System.out.println(e.getMessage());

if(fr != null){ }

try{ }

catch(IOException e){ }

System.out.println(e.getMessage()); fr.close();

} }

public static void test2Buffered(){

File filetest1=new File(\"test2.txt\"); FileWriter fw=null; BufferedWriter bw=null; try{ }

catch(IOException e){ } finally{

if(bw != null){

try{

bw.close();

System.out.println(e.getMessage()); fw =new FileWriter(filetest1); bw =new BufferedWriter(bw); bw.write(String.valueOf(123.4D)); bw.write('a' ); bw.write(\"string\"); bw.flush();

}

}

}

catch(IOException e){ }

System.out.println(e.getMessage());

FileReader fr=null; BufferedReader br = null; try{

fr=new FileReader(\"filetest1\"); br=new BufferedReader (fr); String line = br.readLine(); while( line != null){

System.out.println(line); line=br.readLine();

} }

catch(IOException e){ } finally{

if(br != null){

try{ }

catch(IOException e){ } }

System.out.println(e.getMessage()); br.close();

System.out.println(e.getMessage());

} }

}

public class test { }

2． 创建一个有关线程应用的源程序threadDemo.java，其中两个具有包访问权限的类thread1，thread2分别以两种不同的方式定义，且都重写线程的run方法，每个线程类的run方法中重复10次输出本线程对象的名称，并执行Thread.sleep方法。每个线程类的构造方法均要求带一个String类型的参数，用来指出当前线程对象的名称，然后在主类threadDemo的main方法中分别创建上述两种方式下的线程对象，对于同一种类型的线程类也创建两个不同名称的对象，将这些线程对象都启动，运行程序，观察程序的运行情况。讨论在什么情况下可以使用线程的stop方法，wait方法，yield方法，join方法，notify方法。

3． 有关临界资源的互斥访问问题。分析如下程序段，当两个线程对象在同时使用同一个stack上的对象时，能不能保证数据的有序入栈出栈？如果不行，应该如何

public static void main(String args[]){ }

outer: for(int i=1;i<10;i++){ }

for(int j=1;j<10;j++){ }

System.out.println();

if(j>i){ }

System.out.print(\" \" +(i*j));

System.out.println(); continue outer;

修改？并写出修改的理由。 class stack{ int idx=0;

char[ ] data = new char[6]; public void push(char c){ data[idx] = c; idx++; }

public char pop(){ idx--;

return data[idx]; } }

三．实验小结