java 上机练习题

一、将Vehicle 和VehicleDriver两个文件用自己的文本编辑器重新编辑并编译和运行，掌握类和对象的定义和使用

1、Vehicle.java   （注意：以下代码有几个错误的地方，需要同学自己把他们找出来并更正过来）

public class Vehicle{

    public float journey; 

    public int wheelNum；  

    public int loadNum;   

    public int driveSpeed;  

    /**

    *Vehicle 类构造函数，设定初始值

    */

    public Vehicle（）{

        journey=100.3f;

        wheelNum=4;

        loadNum=1;

        }

    /**

     *Vehicle类的driveAt行驶方法

      */

    public void driveAt(int speed){

     if (speed>=60){

            System.out.println("行车速度太快，容易造成事故");

            //如果要求的车速太快，则机动车自动以40单位速度行驶

            driveSpeed=40;

            }

        else {

            System.out.println("你在安全行驶速度内行驶");

            driveSpeed=speed;

            }

        }

    }

2、VehicleDriver.java

     public class VehicleDriver{

    public String name;   //定义司机的名字

    /**

    *VehicleDriver 类构造函数 

    */

    public VehicleDriver(){

        name="TOM";

        }

    /**

    *VehicleDriver 类对象的work方法

    */    

    public void work(){

        Vehicle v=new Vehicle();   //生成Vehicle类的对象v

        v.driveAt(70);             //调用v对象所固有的driveAt()方法

        }

    public static void main(String args[]){

        //生成VehicleDriver类的对象vb

        VehicleDriver vd=new VehicleDriver();

        vd.work();                 //调用vd对象所固有的work()方法

        }    

    }

二、将Vehicle 和VehilceDriver 两个类放在一个.java文件中，文件名称取名为

Vtogether.java （注意：需将Vehicle 或 VehicleDriver中某一个类的名称改名为Vtogether，具体更改哪一个由同学根据实际情况来判断），编译和运行该文件

三、将上课布置的课后作业在机器上实现出来

运算公式：z=4*x*x+2*x*y+5*y*y

要求：设计两个类，在第一个类中定义一个方法，该方法主要实现z=4*x*x+2*x*y+5*y*y的运算过程，其中x，y作为形参，在本方法中不给出具体的值，只有当其他方法调用该㎡方法时才给出x，y的具体值，z是在这个方法运行之后的返回值，需要将这个数据返回给调用这个方法的语句。在第二个类中定一个main()方法，该方法的主要过程就是调用之前所建类中的方法，并将返回值在屏幕上显示出来

四、一个程序里面，定义了，两个整型变量a和b，使用构造函数初始化a为10，b为5，求出a与b的和、差、积、商

上机练习二

一、判断以下程序的结果，并把它改称两个类的形式，其中一个类专门处理运算。

   public class Excer{

    public static void main(String args[]){

        Excer ex=new Excer();

        ex.math();

        }

    void math(){

        int x=130,y=45;

        System.out.println("x="+x+" ,y="+y);

        System.out.println("x+y="+plus(x,y));

        System.out.println("x-y="+minus(x,y));

        System.out.println("x*y="+multi(x,y));

        System.out.println("x/y="+div(x,y));

                }

    int plus(int a,int b){

        return(a+b);

        }            

    int minus(int a,int b){

        return(a-b);

        }

    int multi(int a,int b){

        return(a*b);

        }

    float div(int a,int b){

        return ((float)a/b);

        }

    }

二、将第一题中x和y的值改为从程序的命令行参数中取（将字符串转换为整形的语句格式为 Integer.parseInt(string) ）

三、创建一个汽车类CarModel.java，它里面有2个不同的构造函数，CarManufactory.java可以应用这些构造方法创建不同类型的汽车

CarModel.java设计要求如下：

定义style(String),color(String),category(String)注：括号中为变量类型

创建第一个构造函数，分别给以上变量赋值，要求为该构造函数定义三个形参，分别赋给相应的变量，形参的值在对象创建时给出

创建第二个构造函数，此构造函数过程为空

定义三个方法，分别返回style,color,category的值

CarManufactory.java设计要求如下：

使用不同的构造函数创建两辆汽车

显示两辆车相关的属性，属性的值要从CarModel的相关方法中取出

四、编程实现以下要求：

（1）写一个类，他的实例表示从一幅牌中打出牌

（2）写一个类，他的实例代表一幅牌

（3）利用上面的两个类写一个程序，演示一幅牌中所有的牌，结果如下：

Ace of Diamonds

Two of Diamonds

Three of Diamonds

……….

Ten of Diamonds

Jack of Diamonds

Queen of Diamonds

King of Diamonds

Ace of Clubs

……..

King of Clubs

Ace of Hearts

…….

King of Hearts

Ace of Spades

…….

King of Spades

五、在Vehicle类的基础上创建一个Tractor（拖拉机）类，他不大拥有journey,wheelNum,loadNum,driveSpeed 四种属性和driveAt()方法，而且还拥有自己的plough(耕地)方法，在该方法中要求能够显示journey,wheelNum,loadNum三个属性的值，在这个类中还要创建一个main()方法，分别调用plough()和driveAt方法

public class Vehicle{

    public float journey;        

    public int wheelNum;         

    public int loadNum;         

    public int driveSpeed;      

    public Vehicle(){

        journey=100.3f;

        wheelNum=4;

        loadNum=1;

        }

    public void driveAt(int speed){

     if (speed>=60){

            System.out.println("行车速度太快，容易造成事故");

            //如果要求的车速太快，则机动车自动以40单位速度行驶

            driveSpeed=40;

            }

        else {

            System.out.println("你在安全行驶速度内行驶");

            driveSpeed=speed;

            }

        }

     }

六、在以下程序中出现了属性的覆盖，编译运行下面程序，掌握产生属性覆盖时属性的变化规则

public class Father{

    int a=100;

    public void miner(){

        a--;

        }

    public static void main(String[] arg){

        Father x=new Father();

        Son y=new Son();

        System.out.println("a of son is :" +y.a);

        System.out.println("a of son's super is :" +y.getA());

        y.miner();

        System.out.println("a of son is :"+y.a);

        System.out.println("a of son's super is :" +y.getA());

        }

    }

class Son extends Father {

      int a=0;

      public int getA(){

        return super.a;

        }

}

上机练习三

一、完成上机练习二中的作业

二、阅读以下程序，判断程序的运行结果，给打* 的语句写上注释，掌握方法的重载与覆盖

    class Cleanser{

    private String s=new String("Cleaner");

    * public void append(String a){s=s+" "+a ;}

    public void dilute(){append("dilute()");}

    *public void apply(){append("apply()");}

    public void scrub(){append("scrub()");}

    public void print(){

        System.out.println(s);

        }

    public static void main(String[] args){

        Cleanser x=new Cleanser();

        x.dilute();

        x.apply();

        x.scrub();

        * x.print();

        }

    }

public class Detergent extends Cleanser{

public void  scrub(){

* append("Detergent.scrub()"); super.scrub();} 

* public void foam(){append("foam()");}

public static void main(String arg[]){

Detergent x=new Detergent();

System.out.println("Subclass has :");

* x.dilute();

* x.scrub();

x.foam();

* x.print();

System.out.println("Super class has:");

     * Cleanser.main(arg);

    }

}

三、创建一个汽车类（Car）,为其定义两个属性：颜色和型号，为该类创建两个构造函数：

第一个为无形参的构造函数，其过程是将颜色和型号初始化为红色、轿车

第二个须定义两个形参，并将形参的值分别赋给颜色和型号，为该类创建两个方法，分别用来显示颜色和型号。

创建一个（Car1）类，让其继承Car类，并且在该类中再定义一个属性（生产厂商），为该类创建三个构造函数：

第一个构造函数须定义三个形参，在这个构造函数中要调用Car类的第二个构造函数，将前两个参数赋给该构造函数，第三个参数用来给生产厂商赋值。

第二个构造函数带一个形参，把该参数值赋给颜色属性，并将生产厂商属性初始化为“上海大众”

第三个构造函数无形参，在该构造函数中要求能调用上面所建的第二个构造函数（无形参只需要调用this这个方法来声明）

在该类中定义一个main()方法，分别用上面的三个构造函数创建三个对象，并显示相关对象的各个属性

四、阅读下面的程序，程序中黑体字的那一条语句进行拆分，要求连着三次运行increment()方法，最后再运行print()方法，掌握this的使用方法

public class Testthis{

private int i=0;

//Testthis 

int increment(){

i++;

return this;

}

void print(){

System.out.println("i="+i);

}

public static void main (String args[]){

Testthis x=new Testthis();

x.increment().increment().increment().print();

}

}

五、阅读下面的程序,找出错误,并将其改正,掌握对象间关系的转换

class SuperClass{

    private int x=100;

    public int getx(){

        return x;

        }

    }

class Subbie extends SuperClass{

    private int y=200;

    public int gety(){

        return y;    

        }

    }

public class ObjectConvert{

    public static void main(String arg[]){

        SuperClass superA=new SuperClass(),superB;

        Subbie subA=new Subbie(),subB;

        (new ObjectConvert()).useSubAsSuper(subB);

        superB=subA;

        System.out.println("superA.getx():"+superB.gety());

       System.out.println("superA.getx():"+superb.y);

        subB=superB;

        System.out.println(subB.getx()+"  "+subB.gety());

        System.out.println(subB.x+"  "+subB.y);

        }

        public void useSubAsSuper(SuperClass x){

            System.out.println(x.gety()+"!!!!!!");

            }

    }

六、定义一个复数类，可以通过构造函数给复数对象赋值，实部和虚部是该类的私有属性，必须有获取和修改属性的方法，并定义它与复数、实数相加和相减及复数间乘、除的方法

上机练习四

一、指出下列程序当中的错误，改正程序，并上机验证

(1)

public class Exercise1{

    int i;

    public static void main (String args){

        System.out.println("i="+i);

        }

    }

   (2)

     public class Excercise2{

    public static void main(String args[]){

        int i=10;

        short j;

        int k=j;

        j=i;

        System.out.println(j);

        }

    }

   (3)

     public class Exercise3{

    public static void main(String args[]){

        int i[];

        System.out.println(i);

        }

    }

   (4)

     public class Exercise4{

    public static void main(String args[]){

        int i,j;

        boolean k;

        k=i&j;

        System.out.println(k);

        }

    }

二、编写程序实现下述逻辑

(1)计算11的阶乘

(2)声明一个二维数组，给其赋值成为一个对角线为1，其他元素为0的n阶矩阵，并将其各元素显示出来

(3)计算500到800区间素数的个数cnt,并按所要求素数的值从大到小的顺序排列，再计算其间隔加、减之和，即第一个素数-第二个素数+第三个素数-第四个素数+第五个素数…….的值sum,请编写方法countValue()实现程序的要求，最后使用main()方法把结果cnt 和sum 在屏幕上显示出来

(4)找出所有100以内（含100）满足I, I+4 ,I+10都是素数的整数I的个数cnt以及这些I之和sum.,并将cnt和sum 在屏幕上显示出来

三、以电话为父类，移动电话和固定电话为两个子类，并使移动电话实现接口：可移动。固定电话又有子类：无绳电话。定义着及各类，明确他们的继承关系

上机练习五

一、创建一个Vehicle类它有三个属性：public  int  journey、

private static int wheelNum、private  int    loadNum，

他还有一个main()方法。

在Vehicle类的内部创建一个静态类Car，在Car的内部有两个属性：String color 和 String style，一个默认构造函数（分别给color和style赋初值）它还有一个

drive（） 方法，该方法的作用是分别显示Vehicle类的三个属性

在Vehicle 类的外面创建一个Car1 类，该类继承了Car类，有一个构造函数（对color重新赋值，style保持原值不变）在这个类中有一个main()方法，该方法的作用是创建一个Car1对象，在创建这个对象时要求能调用父类的默认构造函数，并显示这个对象的style和color的值。

最后在原先Vehicle类的main()方法中分别调用Car类的drive()方法和Car1类中的mai() 方法

二、在一的基础上创建一个fuel接口，在该接口中有一个burning方法和一个price属性，要求这个price 能够随着市场的变化而改变，但是对于所有实现该接口的类而言，price的值应该保持一致。

让Car1除了继承Car外，还要实现该接口，在main（）方法中使用相关语句将price改为3， 同时显示出price的值

三、对以下程序使用异常处理机制使其能正常运行，使用相关方法判断该异常所属的异常类，并显示该异常类的名称

  public class Ex1{

    int x;

    public static void main(String ar[]){

        int y;

        Ex1 c=new Ex1();

        y=3/c.x;

        y=y+1;

        System.out.println("program ends ok");

        System.out.println(y);

        }

    }

三、创建一个Example类，该类有一个result() 方法，在result()方法内部有两个多项式A=4x-4  、 B=2*x*x-4*x*y+y*y；C=A/B ，最后返回C的值

要求：x和y的值作为该方法的形参，在计算C值以前，先判断A和B的值，当A或B等于零时抛出一个ArithmeticException异常，使用ArithmeticException捕获该异常，在创建ArithmeticException异常时须使用其带形参的构造函数，给形参赋值为“A 或 B =0”，使用getMessage()显示该字符串。

当A、B都不等于零时抛出一个Exception异常，使用Exception捕获该异常，在创建Exception异常时也须使用其带形参的构造函数，给形参赋值为“program is ok!”,使用getMessage()显示该字符串

最后不管A、B是否等于零，都须显示”program is end”（注：使用finally）

为这个类创建一个main()方法，生成两个20以内的整形随机数，调用result（）方法，将这两个随机数赋给x和y.，显示最后结果。

上机练习六

一、编程实现以下功能：

1、现在有一个文件名：TestString.class 

试着编写一个小程序取出这个文件的扩展名，并在屏幕上显示

2、通过键盘输入一个字符串，判断每一个字符，如果是小写字母，将其转换为大写，如果是大写则转换为小写；如果是数字，转换为“0”；其他字符转换为”#”；将转换后的字符串在屏幕上显示（以下程序可实现键盘输入功能）

import java.io.*;

public class ReadIn{

    public static void main(String[] args){        

        String s=new String();        

        try{

               BufferedReader br = new BufferedReader(

                                    new InputStreamReader(

                                        System.in));

             s = br.readLine();

            }catch(Exception e){}

    }

}

3、使用Math类的random方法产生一个随机数，将其转换为字符串，取小数点后三个字符，得到一个“0.xxx”的字符串，再将其转换成double型，对这个数据进行相关计算，使其取值范围在0~~200之间，最后分别调用Math 类的ceil、floor 、sqr等方法，并显示结果

二、以下三个文件是我们上次的习题，在C盘根目录建立一个文件夹test,将三个文件放在该目录下，对他们进行打包，将Vehicle.class放到a.b.v包中，将Car1.class和fuel.class放到a.b.c包中

注意：Car1 和 Vehicle 是互相访问的，他们存放在不同的包中，使用时须引入

试着编译三个文件，并运行结果

1、Vehicle.java

public class Vehicle{

       public int journey;

       private static int wheelNum;

       private  int loadNum;

       public static void main(String arg[]){

        Car c=new Car();

         c.drive();

        Car1.main(arg);

        }

      public static class Car{

        public String color;

        public String style;

      public  Car(){

            color="White";

            style="micor car";

            }

        public void drive(){

            Vehicle v=new Vehicle();

            System.out.println(v.journey);

            System.out.println(wheelNum);

            System.out.println(v.loadNum);

            }

        }

    }

2、Car1.java

public class Car1 extends Vehicle.Car implements fuel{

    Car1(){

        super();

        color="red";

        }

       public void burning(){}

     public static void main(String ar[]){

        Car1 c1=new Car1();

        System.out.println(c1.color);

        System.out.println(c1.style)  ;

        Car1.p.setprice(3);

        System.out.println(fuel.p.getprice());      }

}   

3、fuel.java

public interface fuel{

    void burning();

       class Price{

        int price;

        int getprice(){

            return price ;}

        void setprice(int x){

            price=x;}

        }

       Price p=new Price();

    }

上机练习七

一、使用Runnable接口实现以下类的功能：

     public class testThread extends Thread{

    public testThread(){}

    public void run(){

        System.out.println("run()方法运行....");

        }

    public static void main(String arg[]){

        testThread t=new testThread();

        System.out.println("start() 开始运行...");

        t.start();

        }

    }

二、假设一个银行的ATM机，它可以允许用户存款也可以取款。现在一个账户上有存款200元，用户A和用户B都拥有在这个账户上存款和取款的权利。用户A将存入100元，而用户B将取出50元，那么最后账户的存款应是250元。

实际操作过程如下：

1、先进行A的存款操作：

（1）得到账户的存款数额200，耗时2s。

（2）将账户数额增加100，耗时忽略不计

（3）将新生成的账户结果300返回到ATM机的服务器上，耗时2s

2、在进行B的取款操作： 

（4）得到增加后账户存款数额300，耗时2s。

（5）将账户数额减少50，耗时忽略不计。

（6）将新生成的账户结果250返回到ATM机的服务器上，耗时2s。

请同学们根据以上要求，编写一个Java程序实现该功能

注：将A的操作和B的操作分别用线程来表示

三、请使用已近学过的Java知识来编写一个程序，实现一个简单的摩天大楼的电梯模型

1、程序的背景描述：

程序是以一座摩天大楼的多个电梯为背景，用线程、流程控制、随机函数等知识来模拟它。

2、电梯的描述：

电梯是日常生活中经常要遇到的一种载客工具，在载客任务结束之后，他是停止在当前的楼层的。如果有乘客在某一个楼层点击了请求按钮，电梯开始运作，或者是向上或者是向下到达响应的楼层停止，然后打开门，等乘客进入电梯之后关上门，在得知乘客前往楼层的目的地之后再继续运作，直到完成乘客的请求之后，电梯重新进入到停止状态等待新请求的到来。

电梯决定是向上运动还是向下运动这一判断过程很复杂，并不是随便哪一楼层有请求就马上去响应的，这样有可能电梯就只在某两个楼层里来回运动而无法完成其它楼层乘客的请求。一个电梯在运作的时候，他最少有两个消息存储器来存储不同的消息，一个消息就对电梯的楼层请求，这表示某一楼层有乘客需要用这台电梯，一个电梯可能同时会收到很多个楼层的使用电梯请求，电梯一般的原则是响应最接近自己当前楼层的请求，但是这也需要和电梯实际运动的方向以及该楼层的请求是向上还是向下相联系的，其他楼层是否同时也有请求响应也是对电梯的运动方向起着重要的作用。另一种电梯存储的消息就是电梯当前的任务消息，在乘客进入到电梯之后，乘客指示电梯需要到达的目的地，当没有外面楼层请求消息的时候，电梯一般是先将当前方向上的任务完成，当有外面楼层请求消息的时候，电梯还要依据请求消息的具体内容来判断电梯是不是需要停下来，来接待发出请求消息的乘客。

3、电梯运动方向的判断准则：

判断电梯向上还是向下的操作会相当的麻烦，这是有一定的电梯算法的，这个电梯算法可以处理一个电梯的方向判断也可以处理多个建立关联的电梯对请求响应的判断。在这里电梯具体实现的算法并不是要谈到主要内容，所以只需了解电梯一般的判断准则就可以了，这个准则总结起来有以下各个点：

（1）电梯在停止的时候，如果请求消息队列和任务队列都为空，电梯相应地一个发出请求的楼层，依据楼层和电梯当前楼层的高度来决定电梯的初始运动方向。

（2）电梯在向某一个方向运动的时候，如果任务列表中有电梯到达的楼层，则电梯需要停止等待乘客出电梯并且迎接可能有的新乘客；如果电梯的任务列表中没有当前到达的楼层，但是受到了该楼层的电梯运动方向一致的运动方向请求的时候，电梯停止等待乘客的进入，如果请求的方向和电梯运动的方向不一致，电梯将不加理会。

（3）在完成某一个运动方向的任务之前，电梯将不理会反运动方向的楼层请求，只是将这个请求保存起来等带电梯反方向的运动来处理他们，当楼层的任务结束之后，电梯完成了一个方向的运动而将做反方向运动。依据接收道的同方向的请求，电梯到达指定的楼层完成载客的操作。

（4）当电梯的任务列表和请求列表都为空的时候，电梯重新回到了停止状态，等待新的请求的到来