成都理工《Java程序设计》实验报告

更新时间：2023-12-24 11:24:01 阅读量：教育文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

JAVA程序设计推荐度：
相关推荐

本科生实验报告

实验课程学院名称专业名称学生姓名学生学号指导教师实验地点实验成绩

管理科学学院

6C402

二〇一五年九月二〇一五年十二月

实验1-1 面向对象程序设计(1)

【实验目的】

1. 理解面向对象的的程序设计思想。

2. 掌握通过Java类、对象、继承等面向对象程序设计方法。

【实验内容】

1. 程序填空，练习类、对象、继承的定义和实现方法。 2. 根据程序运行结果，补充完整程序。

【实验要求】

（1）TestStu0.java的输出结果如下，请补充完整程序

学号：0401398 姓名: 杨小明性别：男年龄：20 学号：0401399 姓名: 张大红性别：女年龄：18 输出修改后的信息学号：0401398 姓名: 杨小明性别：男年龄：19 学号：0401399 姓名: 李大红性别：女年龄：18 源程序

class student {

private String id; private String name; private String sex;

private int age;

student(String id , String name, String sex, int age) { this.id = id;

this.name = name;

this.sex=sex; //初始化性别 this.age=age; //初始化年龄 }

public String getId()

{return id; }

public String getName() { return name; } public String getSex()

{ return sex; }//获取性别 public int getAge()

{return age; }//获取年龄

void setAge(int age)//修改年龄 { this.age = age; }

void setName(String newName)

{this.name=newName; } //修改姓名 public String printInfo()

{ String s= \学号：\姓名: \性别：\年龄：\ System.out.println(s); return s; } }

public class TestStu0

{ public static void main(String args[])

{ student stuOne = new student(\杨小明\男\ stuOne.printInfo();

student stuTwo = new student(\张大红\女\创建对象stuTwo，学号“0401399\姓名\张大红\性别 \女\年龄18);

stuTwo.printInfo();

stuOne.setAge(19); //修改第一个同学的年龄为19

stuTwo.setName(“李大红”); //修改第二个同学的名字为李大红 System.out.println(\输出修改后的信息\ stuOne.printInfo(); stuTwo.printInfo(); } }

（2）TestStu1的运行结果如下，请补充完整程序TestStu1.java

学号：001 姓名：苏轼英语：56.0 数学：87.0 计算机：95.0 总分：238.0 评测成绩：79.33 学号：002 姓名：杜甫英语：86.0 数学：75.0 计算机：80.0 总分：241.0 评测成绩：80.33 学号：005 姓名：欧阳修英语：87.0 数学：95.0 计算机：56.0 总分：238.0 职位：数学代表评测成绩：82.33 学号：006 姓名：王安石英语：98.0 数学：87.0 计算机：36.0 总分：221.0 职位：英语代表评测成绩：76.67 学号：002 姓名：李白英语：89.0 数学：87.0 计算机：87.0 总分：263.0 职位：班长评测成绩：92.67 源程序：

import java.text.*; //(1) 创建学生类Stu1 class Stu1 {

String id; String name;

float scoreOfenglish; float scoreOfmath; float scoreOfcomputer; float scoreOfsum;

//构造方法

Stu1(String aid,String aname,float ascoreOfenglish,float ascoreOfcomputer)

{

ascoreOfmath,float

this.id=aid;

this.name=aname;

this.scoreOfenglish=ascoreOfenglish; this.scoreOfmath=ascoreOfmath;

this.scoreOfcomputer=ascoreOfcomputer;

//this.scoreOfsum=ascoreOfenglish+ascoreOfmath+ascoreOfcomputer; this.scoreOfsum=sum(); }

//sum方法 float sum() {

return(this.scoreOfenglish+this.scoreOfmath+this.scoreOfcomputer); }

//testScore测评成绩（平均分） float testScore() {

return(this.scoreOfsum/3); }

//6个get方法 String getid() {

return(id); }

String getname() {

return(name); }

float getscoreOfenglish() {

return(scoreOfenglish); }

float getscoreOfmath() {

return(scoreOfmath); }

float getscoreOfcomputer() {

return(scoreOfcomputer); }

float getscoreOfsum() {

return(scoreOfsum); }

//5个set方法

void setid(String newid){ this.id=newid; }

void setname(String newname){ this.name=newname; }

void setscoreOfenglish(float newscoreOfenglish){ this.scoreOfenglish=newscoreOfenglish; this.scoreOfsum=sum(); }

void setscoreOfmath(float newscoreOfmath){ this.scoreOfmath=newscoreOfmath; this.scoreOfsum=sum(); }

void setscoreOfcomputer(float newscoreOfcomputer){ this.scoreOfcomputer=newscoreOfcomputer; this.scoreOfsum=sum(); }

//toString方法

public String toString() {

return(\学号：\姓名：\英语：\数学：\计算机：\总分：\

} }

//(2）声明StudentXW(学习委员)类为Student类的子类。

//在StudentXW类中增加责任属性，并重写testScore方法（评测成绩=三门课平均分+3）

class StudentXW extends Stu1 {

String responsibility; //构造方法

StudentXW(String aid,String aname,float ascoreOfenglish,float ascoreOfmath,float ascoreOfcomputer,String aresponsibility)

{

super(aid,aname,ascoreOfenglish,ascoreOfmath,ascoreOfcomputer); responsibility=aresponsibility; }

//testScore测评成绩/平均分 float testScore() {

return(this.scoreOfsum/3+3); }

//toString方法

public String toString() {

return(\学号：\姓名：\英语：\数学：\计算机：\总分：\职位：\

} }

//(3）声明StudentBZ类为Student类的子类

//在StudentBZ类中增加责任属性，并重写testScore方法（评测成绩=三门课平均分+5）

class StudentBZ extends Stu1 {

String responsibility; //构造方法

StudentBZ(String aid,String aname,float ascoreOfenglish,float ascoreOfmath,float ascoreOfcomputer,String aresponsibility)

{

super(aid,aname,ascoreOfenglish,ascoreOfmath,ascoreOfcomputer); responsibility=aresponsibility; }

//testScore测评成绩/平均分 float testScore() {

return(this.scoreOfsum/3+5); }

//toString方法

public String toString() {

return(\学号：\姓名：\英语：\数学：\计算机：\总分：\职位：\

} }

//4）声明测试类，生成若干个Student类、StudentXW类及StudentBZ类对象，并分别计算它们的评测成绩。

public class testStu1 {

public static void main(String args[]) {

Stu1 su=new Stu1(\苏轼\ Stu1 du=new Stu1(\杜甫\

StudentXW ou=new StudentXW(\欧阳修\数学代表\ StudentXW wang=new StudentXW(\王安石\英语代表\ StudentBZ li=new StudentBZ(\李白\班长\

System.out.print(su); System.out.println(\评测成绩：\DecimalFormat(\

System.out.println();

System.out.print(du); System.out.println(\评测成绩：\DecimalFormat(\

System.out.println();

System.out.print(ou); System.out.println(\评测成绩：\DecimalFormat(\

System.out.println();

System.out.print(wang); System.out.println(\评测成绩：\DecimalFormat(\输出王安石信息

System.out.println();

System.out.print(li);

System.out.println(\评测成绩：\//输出李白信息

System.out.println(); }

}

（3）在第（2）题的基础上，增加两个方法：

方法compare用于比较两个同学的总分大小，方法equal用于比较两个同学的学号是否相等。运行结果如下

源程序（新增加部分用红色标注的） import java.text.*;

//（1）创建学生类Stu1 class Stu1 {

String id; String name;

float scoreOfenglish; float scoreOfmath; float scoreOfcomputer; float scoreOfsum;

//构造方法

Stu1(String aid,String aname,float ascoreOfenglish,float ascoreOfmath,float ascoreOfcomputer) {

this.id=aid;

this.name=aname;

this.scoreOfenglish=ascoreOfenglish; this.scoreOfmath=ascoreOfmath;

this.scoreOfcomputer=ascoreOfcomputer;

//this.scoreOfsum=ascoreOfenglish+ascoreOfmath+ascoreOfcomputer; this.scoreOfsum=sum(); }

//sum方法 float sum() {

return(this.scoreOfenglish+this.scoreOfmath+this.scoreOfcomputer); }

//testScore测评成绩（平均分） float testScore() {

return(this.scoreOfsum/3); }

//6个get方法 String getid() {

return(id); }

String getname() {

return(name); }

float getscoreOfenglish() {

return(scoreOfenglish); }

float getscoreOfmath() {

return(scoreOfmath); }

float getscoreOfcomputer() {

return(scoreOfcomputer); }

float getscoreOfsum() {

return(scoreOfsum); }

//5个set方法

void setid(String newid){ this.id=newid; }

void setname(String newname){ this.name=newname; }

void setscoreOfenglish(float newscoreOfenglish){ this.scoreOfenglish=newscoreOfenglish; this.scoreOfsum=sum(); }

void setscoreOfmath(float newscoreOfmath){ this.scoreOfmath=newscoreOfmath; this.scoreOfsum=sum(); }

void setscoreOfcomputer(float newscoreOfcomputer){ this.scoreOfcomputer=newscoreOfcomputer; this.scoreOfsum=sum(); }

//toString方法

public String toString() {

return(\学号：\姓名：\英语：\数学：\计算机：\总分：\ }

//equals方法/比较两个学生学号是否相等 void equals(Stu1 y){ if(this.id.equals(y.id))

System.out.println(this.getname()+ \和\学号相同\ else

System.out.println(this.getname()+ \和\学号不相同\ }

//compare方法/比较两个学生总分（根据总分大小分别输出大于小于相等三种情况） void compare(Stu1 x){

if(this.getscoreOfsum()>x.getscoreOfsum())System.out.println(this.getname()+\总分大于\

if(this.getscoreOfsum()

else System.out.println(this.getname()+\总分等于\ } }

//(2）声明StudentXW(学习委员)类为Student类的子类。

//在StudentXW类中增加责任属性，并重写testScore方法（评测成绩=三门课平均分+3）

class StudentXW extends Stu1 {

String responsibility;

//构造方法

StudentXW(String aid,String aname,float ascoreOfenglish,float ascoreOfmath,float ascoreOfcomputer,String aresponsibility) {

super(aid,aname,ascoreOfenglish,ascoreOfmath,ascoreOfcomputer); responsibility=aresponsibility; }

//testScore测评成绩/平均分 float testScore() {

return(this.scoreOfsum/3+3); }

//toString方法

public String toString() {

return(\学号：\姓名：\英语：\数学：\计算机：\总分：\职位：\ } }

//(3）声明StudentBZ类为Student类的子类

//在StudentBZ类中增加责任属性，并重写testScore方法（评测成绩=三门课平均分+5）

class StudentBZ extends Stu1 {

String responsibility; //构造方法

StudentBZ(String aid,String aname,float ascoreOfenglish,float ascoreOfmath,float ascoreOfcomputer,String aresponsibility) {

super(aid,aname,ascoreOfenglish,ascoreOfmath,ascoreOfcomputer); responsibility=aresponsibility; }

//testScore测评成绩/平均分 float testScore() {

return(this.scoreOfsum/3+3); }

//toString方法

public String toString() {

return(\学号：\姓名：\英语：\数学：\计算机：\总分：\职位：\ } }

//4）声明测试类，生成若干个Stu1类、StudentXW类及StudentBZ类对象，并分别计算它们的评测成绩。 public class testStu1 {

public static void main(String args[]) { Stu1 su=new Stu1(\苏轼\

Stu1 du=new Stu1(\杜甫\ StudentXW ou=new StudentXW(\欧阳修\数学代表\ StudentXW wang=new StudentXW(\王安石\英语代表\ StudentBZ li=new StudentBZ(\李白\班长\ System.out.print(su); System.out.println(\评测成绩：\ System.out.println(); System.out.print(du); System.out.println(\评测成绩：\ System.out.println(); System.out.print(ou); System.out.println(\评测成绩：\ System.out.println(); System.out.print(wang); System.out.println(\评测成绩：\DecimalFormat(\输出王安石信息 System.out.println(); System.out.print(li); System.out.println(\评测成绩：\DecimalFormat(\//输出李白信息 System.out.println(); su.compare(li); su.compare(wang); su.compare(ou); //比较苏轼和欧阳修的成绩 System.out.println(); du.equals(su);

du.equals(li); //比较杜甫和李白的学号是否相等 System.out.println(\修改李白的学号为007\ li.setid(\ du.equals(li); } }

< 请提交程序的java源文件，存于文件夹1-1 >

实验1-2 面向对象程序设计(2)

【实验目的】

1. 理解面向对象的的程序设计思想。

2. 掌握继承、抽象类、覆盖等概念及实现方法。

【实验内容】

1. 编写一个继承与覆盖的程序。 2. 编写一个抽象类的程序。

【实验要求】

（1）设计一个汽车Auto类，包括汽车颜色，车身重量等成员变量。并通过构造方法创建实例。至少要求汽车有以下功能：加速，减速，停车。再设计一个小轿车类Car，继承Auto，并添加空调温度、音箱个数等成员变量，覆盖加速，减速的方法。创建一个带main方法的测试Test1类，分别创建Auto和Car对象，输出成员变量信息，测试成员方法。 class Auto { int sum = 4;

String color = \ float Weight = 1.0f; float Speed = 0.0f;

Auto (int sum, String color, float Weight, float Speed) { this.sum = sum; this.color = color; this.Weight = Weight; this.Speed = Speed; }

public void addSpeed (float Speed) { this.Speed += Speed; getSpeed(); }

public void redSpeed (float Speed) { this.Speed -= Speed; getSpeed(); }

public void Stop () { Speed = 0.0f;

System.out.println(\已停车\ }

public void getSpeed () {

System.out.println(\汽车当前速度为：\ } }

class Car extends Auto {

String AirConditioning = \无\ String CD = \无\ Car (int sum, String color, float Weight, float Speed, String AirConditioning, String CD) {

super(sum, color, Weight, Speed);

this.AirConditioning = AirConditioning; this.CD = CD; }

public void addSpeed (float Speed) { this.Speed += Speed; getSpeed(); }

public void redSpeed (float Speed) { this.Speed -= Speed; getSpeed(); } }

public class Test_5 {

public static void main (String[] args) { Scanner sc = new Scanner(System.in); Scanner ss = new Scanner(System.in);

System.out.println(\请输入汽车轮胎数量：\ int sum = sc.nextInt();

System.out.println(\请输入汽车颜色：\ String color = ss.nextLine();

System.out.println(\请输入汽车重量：\ float Weight = sc.nextFloat();

System.out.println(\请输入汽车当前速度：\ float Speed = sc.nextFloat();

Auto a = new Auto(sum, color, Weight, Speed); System.out.println(\请输入要加速多少KM/H：\ float addSpeed = sc.nextFloat(); a.addSpeed(addSpeed);

System.out.println(\请输入要减速多少KM/S\ float redSpeed = sc.nextFloat(); a.redSpeed(redSpeed); a.Stop();

System.out.println(\请输入汽车轮胎数量：\ sum = sc.nextInt();

System.out.println(\请输入汽车颜色：\ color = ss.nextLine();

System.out.println(\请输入汽车重量：\ Weight = sc.nextFloat();

System.out.println(\请输入汽车当前速度：\ Speed = sc.nextFloat();

System.out.println(\请输入汽车是否有空调或空调种类：\

}

String AirConditioning = ss.nextLine();

System.out.println(\请输入汽车是否有CD：\String CD = ss.nextLine();

Car c = new Car(sum, color, Weight, Speed, AirConditioning, CD); System.out.println(\请输入要加速多少KM/H：\addSpeed = sc.nextFloat(); c.addSpeed(addSpeed);

System.out.println(\请输入要减速多少KM/S\redSpeed = sc.nextFloat(); c.redSpeed(redSpeed); c.Stop();

（2）

package jftr;

public class car extends Vehicle{ public String DispWheels(){ String R=\四轮车\; return R; } }

public class Motorbike extends Vehicle{ public String DispWheels(){ String S=\双轮车\; return S; } }

public abstract class Vehicle{ public abstract String DispWheels();

}

public class Test{

public static void main(String[] args){ car Car=new car();

Motorbike motuo=new Motorbike();

System.out.print(\下面显示小汽车轮子数量：\); System.out.println(Car.DispWheels()); System.out.print(\下面显示摩托车轮子数量：\); System.out.println(motuo.DispWheels()); } }

实验1-3 面向对象程序设计(3)

【实验目的】

1. 理解面向对象的的程序设计思想。

2. 掌握继承、接口、匿名类、异常类等概念及实现方法。

【实验内容】

1. 编写一个输出英文字母表和希腊字母表的程序。 2. 关于接口的程序填空 3. 关于异常类的程序修改

【实验要求】

（1）编写一个父类father，该类创建的对象可以调用方法fun1输出英文字母表，然后

再编写一个该类的子类son，要求子类son必须继承father类的方法fun1(不允许重写)，子类创建的对象不仅可以调用方法fun1输出英文字母表，而且调用子类新增的方法fun2

调用方法fun1输出英文字母表: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z 调用方法fun2输出希腊字母表: Α Β Γ Γ Δ Ε Ζ Θ Η Κ Λ Μ Ν Ξ Ο Π Ρ ? Σ Τ Φ Υ Φ Χ α β γ δ ε δ ε ζ η θ ι κ λ μ ν π ξ ζ η υ θ χ ψ ω 输出希腊字母表。输出结果如下所示：（提示：输出字母A的语句是 System.out.print((char)65); //65是字母A的unicode

编码

A--Z 编码：65--90 a--z 编码：97—122

希腊字母对应的编码是：913—929,931—937,945—961,963—969）

package jkjk;

public class jkl {

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

B b=new B(); b.fun1(); b.fun2(); }

catch(Exception e) {

System.out.print(e.toString()); } }

}

class B extends jklk {

void fun2() {

for (int i=913;i<969;i++)

if((i==930) || (i>937 && i<945) || (i>961 && i<963)) {} else {

System.out.print((char)i+\); }

System.out.println(\); } }

class jklk {

void fun1() {

for (int i=0;i<26;i++)

System.out.print((char)(65+i)+\); for (int i=0;i<26;i++)

System.out.print((char)(97+i)+\); System.out.println(\); } }

（2）根据下面输出结果，完成程序填空

这是一个实现接口的匿名类 package ctc;

interface IA{

void test(); }

public void method(IA ia){

ia.test(); }

TestInnerClass obj = new TestInnerClass(); obj.method(new IA() {

public class TestInnerClass {

public static void main(String[] args) {

public void test() {

}

System.out.println(\这是一个实现接口的匿名类\); }

});

（3）下面的参考程序实现了负数开平方根的异常处理，请修改该程序实现除数为0的异常处理，运行结果如下：

100除以28.0的结果是3.5714285714285716

100除以0.0是不对的，因为0不能做除数的

package serh;

class MyException extends Exception{ String message;

MyException(double m,double n){

message=m+\除以0不对，因为0不能做除数的\; }

public String getMessage(){ return message; } }

class A{

public void f(double m,double n) throws MyException{ if(n==0){

MyException ex=new MyException(m, n);

throw(ex); //抛出异常，结束方法f的执行 }

double number=m/n;

System.out.println(m+\除以28的结果是:\+number); } }

public class test{

public static void main(String args[]){ A a=new A(); try{

a.f(100.0,28.0); a.f(100.0, 0); }

catch(MyException e){

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

}

实验1-4 面向对象程序设计(4)

【实验目的】

1. 理解面向对象的的程序设计思想。

2. 掌握继承、接口、匿名类、异常类等概念及实现方法。

【实验内容】

综合运用面向对象的继承、接口、匿名类、异常类【实验要求】

请按照以下步骤完成程序

1、建立一个Java抽象类Drink，应当：

a、声明一个抽象方法taste()，该方法负责输出饮料的味道； b、声明int型常量来代表不同的饮料类型（咖啡、啤酒、牛奶），如：

c、声明静态方法getDrink(int drinkType)，根据传入的参数创建不同的饮料对

象，并返回该对象，建议使用switch语句。该方法要求声明DrinkNotFoundException，当没有相对应的饮料类型时，抛出该异常。

2、建立Drink的具体子类：

a、分别建立Drink的子类：Coffee（代表咖啡），Beer（代表啤酒），Milk（代表

牛奶）;

b、实现taste()方法，要求在控制台打印各自的味道特征。 3、建立异常类DrinkNotFoundException

a、继承Exception

b、在Drink的方法getDrink(int drinkType)中声明引发

DrinkNotFoundException异常，当传入的参数没有相对应的饮料类型时，抛出异常。

c、在使用getDrink方法的类中捕捉该异常。 4、建立Test测试类，测试以上内容的正确性

a、编写main方法，在程序代码设置几种不同饮料的类型。

b、在main方法中，调用Drink类的getDrink方法，获得相应的饮料对象。注意

捕获DrinkNotFoundException。

c、然后调用该饮料对象的taste()方法，输出该饮料的味道。 5、编译程序，并运行。

package dhjj;

public class Test{

public static void main(String[]args){

try{

for(int i = 1;i<=4;i++){ }

Drink.getDrink(i).taste();

} }

}catch(DrinkNotFoundException dnfe){ }

dnfe.printStackTrace();

abstract class Drink{ }

final static int COFFEE = 1; final static int BEER = 2; final static int MILK = 3; public abstract void taste();

public static Drink getDrink(int drinkType)throws }

class DrinkNotFoundException extends Exception { }

class Coffee extends Drink{ }

class Beer extends Drink{ }

class Milk extends Drink{

public void taste(){

System.out.println(\我是牛奶，要长高就来喝我哦！\);

DrinkNotFoundException{

switch(drinkType){ }

case Drink.COFFEE:{ }

case Drink.BEER:{ }

case Drink.MILK:{ }

default:{ }

throw new DrinkNotFoundException(); return new Milk(); return new Beer(); return new Coffee();

public void printStackTrace(){

System.out.println(\没有相应的饮料类型！\); }

public void taste(){

System.out.println(\我是咖啡，我的味道有点苦但是香醇！\); }

public void taste(){

System.out.println(\我是啤酒，年轻人的最爱啊！\); }

}

实验1-5 面向对象程序设计(5)

【实验目的】

1. 理解面向对象的的程序设计思想。

2. 掌握数组，Java面向对象基本设计方法。

【实验内容】

根据要求扑克牌和模拟枪战的程序设计【实验要求】

1. 扑克牌程序。

? 请定义一个名为Card的扑克牌类，该类有两个private访问权限的字符串变量face和

suit，分别描述一张牌的牌面值和花色。

– 定义Card类中的public访问权限的构造方法，为类中的变量赋值； – 定义protected访问权限的方法getFace()，得到扑克牌的牌面值； – 定义protected访问权限的方法getSuit()，得到扑克牌的花色； – 定义方法toString()，返回表示扑克牌的花色和牌面值字符串。

? 若应用程序的main方法中，定义字符串数组f和s；分别表示扑克牌的牌面值和花色；

定义52个元素的Card类型数组deck，用来存放4个花色的52张牌，如下所示、string f[]={“A”,”2”,…..’”K”} string s[]={“黑桃”,”红桃”,”梅花”,”方块”} Card[] deck=new Card[52];

? 使用Card类的构造方法给deck数组的52张牌赋值，要求数组中先存放黑桃花色的A、

2、3…..K；然后是红桃花色的A、2、3…..K；梅花花色的A、2、3…..K；方块花色的A、2、3…..K；把所有的牌信息打印出来。

? 编写模拟洗牌的程序段，即把数组deck中的扑克牌随机打乱存放程序，分发给4人。 (该题截图较多)

package sdg;

public class Card {

private String face; private String suit;

public Card(String suit, String face) {

this.face = face; this.suit = suit; }

protected String getFace() { return face; }

protected String getSuit() { return suit; }

public String toString() {

return suit + \ + face; }

public static void shuffle(Card[] deck, int startIndex, int size, int { //shuffle洗牌

System.out.println(\ + startIndex); if (splitIndex * 2 > size) { //if rand is 30

Card.swap(deck, startIndex, splitIndex, size - splitIndex);

splitIndex)

//[52]、0、30、22 shuffle(deck, size - splitIndex, splitIndex, size - splitIndex); //[52]、22、30、22 }

else if (splitIndex * 2 < size) { //if rnd is 10

Card.swap(deck, startIndex, size - splitIndex, splitIndex); shuffle(deck, startIndex, size - splitIndex, splitIndex); //[52]、

//[52]、0、42、10 0、42、10 }

else

{ Card.swap(deck, startIndex, splitIndex, splitIndex); } }

public static void swap(Card[] deck, int srcIndex, int dstIndex, int

size) { //交换 //SRC是在本位置显示：source的缩写，源的意思 HREF是点击后连接的目标：HyperlinkReference，超链接引用 String face = \;

String suit = \;

for (int i = 0; i < size; i++) { face = deck[srcIndex + i].face; suit = deck[srcIndex + i].suit;

deck[srcIndex + i].face = deck[dstIndex + i].face; deck[srcIndex + i].suit = deck[dstIndex + i].suit; deck[dstIndex + i].face = face; deck[dstIndex + i].suit = suit; }

} /** * @param args */ public static void main(String args[]) { //第一问解答

Card[] deck = new Card[52];

String f[] = {\, \, \, \, \, \, \, \, \, \, \,

\, \};

String s[] = {\黑桃\, \红心\, \梅花\, \方块\}; for (int i = 0; i < s.length; i++)

{

for (int j = 0; j < f.length; j++) {

deck[i * 13 + j] = new Card(s[i], f[j]); //依次存入数组之中，每13

张一回合 }

} //第二问解答 int rnd = 0;

int numOfShuffle = 10;

for (int i = 0; i < numOfShuffle; i++) {

rnd = (int) Math.abs(Math.random() * 52); //Math.random()返回大于或

等于 0.0 但小于 1.0 的伪随机 double 值。 Card.shuffle(deck, 0, deck.length, rnd); }

}// Test /*

for (int i=0; i

System.out.print(deck[i]+\ );}

}

(由于在运行界面无法截图，所以我把结果先复制下来，放在文本文档中，再截图)

2. 模拟枪战的程序

? 在CS枪战游戏中，有Ak47和USP两种枪，每种枪弹夹的子弹数和发射子弹数都不一样。设计一个枪战游戏程序，

? 定义一个Gun类，该类具有枪名称的属性name，子弹数量的名称num，枪手的编号id和记录当前枪手数量的属性count(静态)，

? 具有num和name属性的getter和setter方法和发射的方法fire(); ? 一个构造方法为属性赋初始值，Gun.count++;// 计数器累加 this.id = Gun.count；name = \

? 设计一个Ak47类，由Gun类继承而来，每发射一次消耗3发子弹，每装一个弹夹，上30发子弹；

? 设计一个USP类，由Gun类继承而来，每发射一次消耗１发子弹，每装一个弹夹，上12发子弹；

? 设计一个主类，分别创建不同的Ak47和USP对象，对象调用类里面的方法，装子弹，程序模拟连续发射8次，显示枪里面还有多少子弹？

package qiang;

abstract class Gun { String name; int num; int id;

public static int count=0; Gun(String name,int num) { this.name=name; this.num=num;

this.id=Gun.count++;

}

public void setter()

{

System.out.println(\枪名：\+this.name+\Id:\+id); }

public String getter_1() { return name;

}

public int getter_2() { return num; }

public abstract void fire(int y);

}

class Ak47 extends Gun { Ak47(String name,int num) { super(name,num);

}

public void fire(int y) { for(int x=1;x<=y;x++) { num-=3;

}

子弹数：\+num+\枪手

}

System.out.println(\此时还剩的子弹为：\+num); }

class Usp extends Gun { }

class Test9 { }

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

Ak47 ak=new Ak47(\,30); ak.setter(); ak.fire(8);

Usp usp=new Usp(\,12); usp.setter(); usp.fire(8);

Usp(String name,int num) { }

public void fire(int y) {

for(int x=1;x<=y;x++) { }

num-=1; super(name,num);

System.out.println(\还剩的子弹是：\+num); }

实验2-1 可视化程序设计(1)

【实验目的】

1. 掌握可视化程序设计中常用组件和容器的使用方法。 2. 掌握事件监听及响应的方法。

【实验内容】

1. 模仿windows自带的计算器功能，设计一个简单计算器； 2. 至少要求实现整数和小数的加、减、乘、除、清零功能。

3. 其他计算功能，请参考windows自带的计算器，尽可能多的实现

【实验要求】

以下设计内容给出的只是范例，请同学们根据自己编写的程序内容进行填写 1.程序功能设计

（1）实现整数和小数的加、减、乘、除、清零功能

（2）通过点击按钮输入运算数据和符号，点击等号计算结果，并且显示输入的数据和运算结果

2.程序界面设计

3.类、接口及方法的声明

（1）public class calcTest//主类，完成主方法的调用

{ public static void main(String[] args)；//主方法，定义并实例化计算器窗口对象}

（2）class calc extends JFrame implements ActionListener //计算器窗口类，实

现计算器运算功能，实现按钮的监听

{ public calc ()；//构造方法，实现了界面的布局，给按钮加载监听器

public void actionPerformed(ActionEvent e)；//实现对监听事件的响应，根据产生事件的不同数据源，做出对应的处理。

public void num(int i)；//实现文本框里输入的数字的处理 public void sign(int s)；//实现对不同运算符号的处理}

【测试数据与实验结果】

1.测试方案1

测试数据：整数小数加法1+2.2

测试结果：1+2.2=3.2

2.测试方案2

测试数据：整数小数乘法3*2.1 测试结果：3*2.1=6.3

3.测试方案3 测试复位

4.测试方案4 测试删除

实验2-2 可视化程序设计(2)

【实验目的】

1. 掌握Java绘图和菜单基本功能。 2. 掌握事件监听及响应的方法。

【实验内容】

1. 完成一个鼠标响应绘图的程序。鼠标按下时，窗口背景变成蓝色，并且显示鼠标按下的位置的坐标。

2. 功能扩展：添加菜单，从菜单项选择窗口的背景色为红色或者绿色。

【实验要求】

1. 写出每一个类或者接口的名字，这个类中的方法的名字，以及它们各自功能作用。以下设计内容给出的只是范例，请同学们根据自己编写的程序内容进行填写 (1)public class calcTest//主类，完成主方法的调用

public static void main(String[] args)；//主方法，定义并实例化计算器窗口对象

（2）class calc extends JFrame implements ActionListener //计算器窗口类，实现计算器运算功能，实现按钮的监听

public calc ()；//构造方法，实现了界面的布局，给按钮加载监听器

public void actionPerformed(ActionEvent e)；//实现对监听事件的响应，根据产生事件的不同数据源，做出对应的处理。

public void num(int i)；//实现文本框里输入的数字的处理 public void sign(int s)；//实现对不同运算符号的处理}

2. 程序运行结果截图及说明

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setBounds(150,150,600, 600); frame.setVisible(true);

}

class x1 implements ActionListener { public void actionPerformed(ActionEvent e) { //ArcsPanel ti = new ArcsPanel(); tp.nNum += speed; tp.repaint(); }

}

public void actionPerformed(ActionEvent arg0) { // TODO Auto-generated method stub

} }

class ArcsPanel extends JPanel{ int i=3; double fAngle; int nCentreX,nCentreY; static double Pi=3.1415926; int nNum =0,nMaxNum = 180; Color[] c;

protected void paintComponent(Graphics g){ super.paintComponent(g); int xCenter = getWidth()/2;//296 int yCenter = getHeight()/2; //239

int radius = (int)(Math.min(getWidth(), getHeight())*0.4); //191 int x = xCenter - radius; //105 int y = yCenter - radius; //50 c=new Color[10];

g.setColor(Color.blue);

g.drawOval(x,y,2*radius,2*radius);

// g.drawOval(x+radius/2,y+radius/2,radius,radius); c[0] = new Color(0,255,255); c[1] = new Color(0,255,255); c[2] = new Color(0,255,255); c[3] = new Color(0,255,255); c[4] = new Color(0,255,255); c[5] = new Color(0,255,255); c[6] = new Color(0,255,255); c[7] = new Color(0,255,255); c[8] = new Color(0,255,255); fAngle = 2*Pi/nMaxNum*nNum; int fa= 360/nMaxNum*nNum; for(int k=0;k

nCentreX = (int)((radius/2)*Math.cos(fAngle+2*k*Pi/i)); nCentreY = (int)((radius/2)*Math.sin(fAngle+2*k*Pi/i));

g.fillArc(xCenter-(radius/2-nCentreX),yCenter-nCentreY-radius/2, radius,radius,(int)fa+k*360/i,180);

}

} }

实验2-4 可视化程序设计(4)

【实验目的】

1. 掌握可视化程序设计中树型结构和表格的使用方法。 2. 掌握事件监听及响应的方法。

【实验内容】

完成如图所示的界面设计，点击左边的树型结构上的节点选择班，在右边的表格中显示该班学生的相关信息

【实验要求】

public static void main(String[] args)；//主方法，定义并实例化计算器窗口对象

（2）class calc extends JFrame implements ActionListener //计算器窗口类，实现计算器运算功能，实现按钮的监听

public calc ()；//构造方法，实现了界面的布局，给按钮加载监听器

public void actionPerformed(ActionEvent e)；//实现对监听事件的响应，根据产生事件的不同数据源，做出对应的处理。

public void num(int i)；//实现文本框里输入的数字的处理 public void sign(int s)；//实现对不同运算符号的处理}

2. 程序运行结果截图及说明

public class MC { }

import javax.swing.event.TreeSelectionEvent; import javax.swing.event.TreeSelectionListener; import javax.swing.tree.*; import javax.swing.*; import java.awt.*;

public class SetExcel extends JFrame

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

SetExcel school=new SetExcel();

{

FlowLayout flowlayout=new FlowLayout(FlowLayout.LEFT); JSplitPane jsplitpane=new JPanel t=new JPanel(); JPanel e=new JPanel();

Container c=getContentPane();

JTree C;

DefaultMutableTreeNode zy=new DefaultMutableTreeNode(\专业\);

DefaultMutableTreeNode xj=new DefaultMutableTreeNode(\信息与计算科学DefaultMutableTreeNode x1=new DefaultMutableTreeNode(\信计1班\); DefaultMutableTreeNode x2=new DefaultMutableTreeNode(\信计2班\);

DefaultMutableTreeNode ys=new DefaultMutableTreeNode(\应用数学系\); DefaultMutableTreeNode y1=new DefaultMutableTreeNode(\应数1班\); DefaultMutableTreeNode y2=new DefaultMutableTreeNode(\应数2班\);

String X; int B;

public SetExcel() { }

public void sett() {

jsplitpane.setRightComponent(e); jsplitpane.setLeftComponent(t);

jsplitpane.setOneTouchExpandable(true);

c.add(jsplitpane); t.setLayout(flowlayout); t.setBackground(Color.WHITE); zy.add(xj); xj.add(x1); xj.add(x2);

zy.add(ys); ys.add(y1);

JSplitPane(JSplitPane.HORIZONTAL_SPLIT,true);

系\);

sett();

setBounds(100,100,640,240);

setTitle(\实验2杠4\);

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setVisible(true);

}

ys.add(y2);

C=new JTree(zy); t.add(C);

C.addTreeSelectionListener(new TreeSelectionListener() {

@Override

public void valueChanged(TreeSelectionEvent e) { }

DefaultMutableTreeNode if(node.isLeaf()) { }

String str=node.toString(); if(str==\信计1班\) { }

if(str==\信计2班\) { }

if(str==\应数1班\) { }

if(str==\应数2班\) { }

if(str==null) { }

sete(\,0); sete(\,2); sete(\,1); sete(\,2); sete(\,1);

node=(DefaultMutableTreeNode)C.getLastSelectedPathComponent();

});

public void sete(String X,int B)//这个用来画表格 {

e.removeAll();

JTable date=new JTable(new Class_date(X,B)); JScrollPane scroll = new JScrollPane(date); e.add(scroll);

e.setBackground(Color.WHITE);

}

e.setLayout(flowlayout);

import javax.swing.table.AbstractTableModel;

public class Class_date extends AbstractTableModel{

Object[][] data=new Object[2][5];

public String[] top={\学号\,\姓名\,\性别\,\出生年月\,\班级\};

public String[] idx11={\,\全日光\,\男\,\,\信public String[] idx12={\,\邢凯\,\男\,\,\信计public String[] idx21={\,\周国发\,\男\,\？\,\信计2班\}; public String[] idx22={\,\高源\,\男\,\,\信计2public String[] idy11={\,\张三\,\男\,\,\应数1班\}; public String[] idy12={\,\李四\,\男\,\,\应数1班\}; public String[] idy21={\,\王五\,\女\,\,\应数2班\}; public String[] idy22={\,\赵六\,\女\,\,\应数2班\}; public Class_date(String m,int n) {

if(m==\) { }

if(m==\) {

if(n==1) {

for(int i=0;i<5;i++) {

data[0][i]=idy11[i];

计1班\}; 1班\};

班\};

if(n==1) { }

if(n==2) { }

for(int i=0;i<5;i++) { }

data[0][i]=idx21[i]; data[1][i]=idx22[i]; for(int i=0;i<5;i++) { }

data[0][i]=idx11[i]; data[1][i]=idx12[i];