java实验总报告（理工）

 

 

 

 

  

软件与微电子学院

 

 

实 验 报 告

（2017-2018第一学期）

 

 

 

 

 

 

 

 

 

 

课程名称：面向对象程序设计（JAVA） 

 

班   级：                    

 

学   号：                

 

姓    名：                   

 

 

 

实验名称	Java运行环境的搭建以及Eclipse的开发环境的使用			专  业	软件工程
姓    名		学  号		班  级

 

• 实验目的：

 

•掌握Eclipse集成开发环境的基本使用以及简单Java应用程序的编写

•掌握java的基本语法

–数值计算

–循环

–跳转

–熟练开发环境

–文本编辑器+jdk

–eclipse

 

• 实验内容：

 

实验内容1

•计算两个整数相除，两种形式输出结果：

–相除的结果是商和余数

–相除的结果是以实数表示的值

–要求：

•判断分母不为0

实验内容2

•计算1+2+3+……100的和，三种方式实现：

–For循环

–While循环

–递归（选做）

实验内容3

•创建长度为20的double数组，存放n个人的身高

•Double[] heights = {165,160,170,…,….};

•任务为计算以下四个值：

–最大值(Max)

–最小值(Min)

–平均值(Mean)

–中值(Median)（选做）（中值也叫中位数，自己百度一下中值的定义）

 

• 实验设备及软件环境：

Microsoft Word

Eclipse

 

 

• 实验过程及结果：

 实验内容1

  代码：

  package com.zrrd.zln;

 

import java.util.Scanner;

 

public class ShiYan {

public static void main(String[] args)

  {      int a,b;  

  float c;

  Scanner in=new Scanner(System.in);  

  a=in.nextInt();   

  b=in.nextInt();  

  if(b!=0)

  {    System.out.println("商："+a/b+"  余数；"+a%b);

  c=(float)a/(float)b;   

  System.out.println("实数："+c);}

  else   

  System.out.println("分母不能为零");   }

  

 

}

运行结果截图：

 

 

 

 

实验内容2

  For循环

代码：

package com.zrrd.zln;

 

import java.util.Scanner;

 

public class ShiYan {

public static void main(String[] args)

  {    

 

{       int a,sum1=0;   

for(a=1;a<101;a++)

sum1+=a;  

System.out.println("for循环；"+sum1);   }    }

  }

  

 

实验结果截图

 

While循环

代码：

package com.zrrd.zln;

 

import java.util.Scanner;

 

public class ShiYan {

public static void main(String[] args)

  {    

 

{      int b=1,sum2=0;  

while(b<101)

{

sum2+=b;  

b++;    }    

System.out.println("while循环："+sum2);

}

}

}

  

 

实验结果截图：

实验内容3：

代码：

package com.zrrd.zln;

 

import java.util.Scanner;

 

public class ShiYan {

public static void main(String[] args)

  {    

float hight[];   

hight=new float[20];    

Scanner in=new Scanner(System.in);    

System.out.println("输入人数（最多20人）");   

int i,j,n=in.nextInt();    

float max=0,min=0,mean,sum=0,t,med;   

for(i=0;i<n;i++)   

{    hight[i]=in.nextFloat();    

sum+=hight[i];    }    

for(i=0;i<n-1;i++)   

{    for(j=i+1;j<n;j++)    

{     if(hight[i]>hight[j])     

{      t=hight[i];      

hight[i]=hight[j];      

hight[j]=t;

 }     

}    

}   

min=hight[0];  

max=hight[n-1];  

mean=sum/n;   

if(n%2!=0)   

{       med=hight[n/2];

  }  

else   

{    med=(hight[n/2]+hight[n/2-1])/2;    }    

System.out.println("最大值；"+max+"  最小值："+min+"  平均值；"+mean+"  中位数："+med);   }    

}

 

 

 

实验结果截图：

 

 

 

 

• 总结：

 

    在这次实验中，因为最初接触eclipse的编译器，所以对编译环境的调试和建立程序和包就遇到了问题，最后通过询问老师和同学，成功的熟悉了编译器，录入代码的过程中，首先是思维问题，对于老师发布下来的问题，我进行了思路的梳理，这个过程就像是曾经学的C，C++等语言解题的过程，让我意识到了各类语言的互通性，而后通过各类的调试，出现结果的一刻，会感到莫大的成就感，也许学习的过程就是这样，总会有各类的问题，需要不断地去解决，最后才能获得结果

 

 

 

 

 

 

实验成绩：                 指导教师：               年    月    日

 

 

 

 

 

 

实验名称	面向对象Java语言实验二			专  业	软件工程
姓    名		学  号		班  级

 

一、实验目的：

 

学习使用类来封装对象的属性和功能

掌握类变量与实例变量、类方法与实例方法的区别

掌握package和import语句

掌握继承的代码复用方式

 

二、实验内容：

内容1：编写一个Java应用程序，其中有包含5个类：

Shape（形状）

Triangle（三角形）

Square（正方形）

Rectangle（长方形）

Circle（圆形）

要求：

设计成员变量，考虑四中图形的基本要素和满足的条件，设计三个方法，计算图形的周长，计算图形的面积，根据面积比较图形的大小

public int compareTo(Shape shape)

内容2（选做）

百度一下设计模式中的工厂模式

自己实现一个工厂模式，用于创建Triangle、Square、Rectangle、Circle四个字类的对象

 

百度一下Random类的用法，使用Random来随机创建四个图形的对象，思路如下：

随机生成0~3 4个数字

如生成的数字是0，则创建Triangle

如生成的数字是1，则创建Square

如生成的数字是2，则创建Rectangle

如生成的数字是3，则创建Circle

 

 

三、实验设备及软件环境：

 

Microsoft Word

Eclipse

 

 

 

四、实验过程及结果：

内容1：

class Trangle  

{  

   double sideA,sideB,sideC,area,length;

   boolean boo;

   public  Trangle(double a,double b,double c)

   {

    sideA=a;

    sideB=b;

    sideC=c;

    // 参数a, b, c分别赋值给sideA, sideB, sideC

    if((a+b)>c&&(a+c)>b&&(b+c)>a)   //a, b, c构成三角形的条件表达式

     {

       boo=true;// 给boo赋值

     }    

    else

     {

        boo=false;// 给boo赋值

     }

   }

   double getLength() 

   {   

    length=sideA+sideB+sideC;// 方法体，要求计算出length的值并返回

   }

   public double  getArea()

   {  

      if(boo)

        {

          double p=(sideA+sideB+sideC)/2.0;

          area=Math.sqrt(p*(p-sideA)*(p-sideB)*(p-sideC)) ;

          return area;

        }

      else

        {

          System.out.println("不是一个三角形,不能计算面积");

          return 0;

        }

   }

   public void setABC(double a,double b,double c)

   {

    sideA=a;

    sideB=b;

    sideC=c;

   // 参数a, b, c分别赋值给sideA, sideB, sideC

     if((a+b>c)&&(a+c>b)&&(b+c)>a)  // a, b, c构成三角形的条件表达式

     {

       boo=true;//给boo赋值。

     }    

    else

     {

        boo=false;// 给boo赋值

     }

   }

}

class Lader

{   

    double above,bottom,height,area;

    Lader(double a,double b,double h)

    {

      above=a;

      bottom=b;

       height=h;// 方法体

    }

    double getArea( )

    {

      area=(above+bottom)*height/2.0;

      return area;// 方法体，,要求计算出area返回

    }

}

 

class Circle

{  

    double radius,area;

    Circle(double r)

    {

        radius=r; // 方法体

    }

    double getArea( )

    {  

       area=3.14*radius*radius;

       return area;// 方法体，要求计算出area返回

    }

    double getLength( )

    {  

       double length=2*3.14*radius;

       return length;// getArea方法体的代码,要求计算出length返回

    }

    void setRadius(double newRadius)

    {  

       radius=newRadius;

    }

    double getRadius( )

    {

        return radius;

    }

}

public class AreaAndLength

{  

    public static void main(String args[ ])

    {

       double length,area;

       Circle circle=null;

       Trangle trangle;

       Lader lader;

       circle=new Circle(2.0); //创建对象circle

        trangle=new Trangle(3,4,5);  //创建对象trangle

        lader=new Lader(1,5,4); //创建对象lader

       length=circle.getLength();// circle调用方法返回周长并赋值给length

        System.out.println("圆的周长:"+length);

       area=circle.getArea() ;// circle调用方法返回面积并赋值给area

        System.out.println("圆的面积:"+area);

       trangle.getLength();// trangle调用方法返回周长并赋值给length

        System.out.println("三角形的周长:"+length);

       trangle.getArea() ;// trangle调用方法返回面积并赋值给area

        System.out.println("三角形的面积:"+area);

      lader.getArea() ;// lader调用方法返回面积并赋值给area

        System.out.println("梯形的面积:"+area);

       trangle.setABC(12, 34, 1);// trangle调用方法返修改三个边的代码，要求将三个边修改为12，34，1

       trangle.getArea(); // trangle调用方法返回面积并赋值给area

        System.out.println("三角形的面积:"+area);

       trangle.getLength();// trangle调用方法返回周长并赋值给length

        System.out.println("三角形的周长:"+length);

    }

}

内容2：

class A

{   

   float a;       // 声明一个float型实例变量：a

   static float b;        // 声明一个float型类变量：b

    void setA(float a)

    {  

      this.a=a;  // 将参数a的值赋值给成员变量a

    }

    void setB(float b)

    {  

    this.b=b;     // 将参数b的值赋值给成员变量b

    }

    float getA( )

    {  

       return a;

    }

    float getB( )

    {  

       return b;

    }

    void inputA( )

    {

       System.out.println(a);

    }

    static void inputB( )

    {

       System.out.println(b);

    }

}

public class Example

{   

    public static void main(String args[ ])

    {

      A.b=100; // 通过类名操作类变量b,并赋值100

      A.inputB();      // 通过类名调用方法inputB( )

       A cat=new A( );

       A dog=new A( );

       cat.setA(200);// cat对象调用方法setA(int a)将cat的成员a的值设置为200

       cat.setB(400);// cat调用方法setB(int b)将cat的成员b的值设置为400

    dog.setA(200); // dog对象调用方法setA(int a)将dog的成员a的值设置为100

      dog.setB(400);// dog调用方法setB(int b)将dog的成员b的值设置为200

       cat.inputA(); // cat调用inputA( )

       cat.inputB();// cat调用inputB( )

       dog.inputA(); // dog调用inputA( )

       dog.inputB();// dog调用inputB( )

    }

}

 

内容3：使用package语句与import语句

package tom.jiafei;

public class Trangle  

{  

   double sideA,sideB,sideC;

   boolean boo;

   public Trangle(double a,double b,double c)

   {

     sideA=a;sideB=b;sideC=c;

     if(a+b>c&&a+c>b&&c+b>a)

     {

        System.out.println("我是一个三角形");

        boo=true;

     }    

    else

     {

        System.out.println("我不是一个三角形");

        boo=false;

     }

   }

 public void 计算面积( )

   {    

       if(boo)

        {

          double p=(sideA+sideB+sideC)/2.0;

          double area=Math.sqrt(p*(p-sideA)*(p-sideB)*(p-sideC)) ;

          System.out.println("是一个三角形,能计算面积");

          System.out.println("面积是:"+area);

        }

      else

        {

           System.out.println("不是一个三角形,不能计算面积");

        }

   }

 public void 修改三边(double a, double b, double c)

   {

     sideA=a;sideB=b;sideC=c;

     if(a+b>c&&a+c>b&&c+b>a)

     {

        boo=true;

     }    

    else

     {

        boo=false;

     }

   }

}

import tom.jiafei.Trangle;

import java.util.Date;

class SunRise

{

  public static void main(String args[ ])

  {

    Trangle trangle=new Trangle(12,3,104);

            trangle.计算面积( );

            trangle.修改三边(3,4,5);

            trangle.计算面积( );

    Date date=new Date( );

    System.out.println(date);

  }

}

 

 

 

五、总结：

 

    在这次实验中我学会了如何建立类和对象，分别输出其中包含的成员值；以及分别引用各方法，实现不同的操作。在该程序中，我进一步了解了如何定义成员方法和成员属性以及相关方法的调用。特别是我掌握了利用构造方法对成员属性赋初始值。值得一提的是，掌握了使用类来封装对象的属性和功能，类是创建对象的模板，创建对象也叫类的实例化，学习类变量与实例变量、类方法与实例方法的区别，最后掌握了package和import语句，掌握继承的代码复用方式，这一次的学习，让我感受到了java语言的魅力，让我明白了java学习领域中的各个技巧还有很多，需要学习和提升的空间还甚是广大

 

 

 

 

 

 

 

实验成绩：                 指导教师：               年  月  日

 

 

 

 

 

 

 

实验名称	实验三 接口回调、异常处理			专  业	软件工程
姓    名		学  号		班  级

 

一、实验目的：

 

掌握接口回调技术。

学习怎样定义异常类以及抛出异常。

 

二、实验内容：

 

编写一个Java应用程序，要求有一个ComputeTotalSales接口，它有一个方法public double totalSalesByYear（）,有三个实现接口的类：Television、Computer和Mobile，分别给出自己的年销售额。

要求声明定义两个Exception的异常子类：NoLowerLetter和NoDigit，再声明一个People类，该类中两个方法分别抛出NoLowerLetter和NoDigit异常类对象。

 

     

三、实验设备及软件环境：

 

Microsoft Word

Eclipse

 

四、实验过程及结果：

内容一：

interface ComputeTotalSales

{

public double totalSalesByYear();

}

class Television implements ComputeTotalSales

{

 public double totalSalesByYear()

 {

 return 500;

 }

}

 class Computer implements ComputeTotalSales

{

 public double totalSalesByYear()

 {

 return 300;

 }

}

class Mobile implements ComputeTotalSales

{

public double totalSalesByYear()

{

return 100;

}

}

class Shop

{

ComputeTotalSales[]goods;

double totalSales=0;

Shop(ComputeTotalSales[]goods)

{

this.goods=goods;

}

public double giveTotalSales()

{

totalSales=0;

for (int i=0;i<goods.length;i++)

{

totalSales=totalSales+goods[i].totalSalesByYear();

}

return totalSales;

}

}

public class HappySale

{

public static void main(String args[])

{

ComputeTotalSales[] goods=new ComputeTotalSales[1123];

for(int i=0;i<goods.length;i++)

{

if(i%3==0)

goods[i]=new Television();

else if(i%3==1)

goods[i]=new Computer();

else if(i%3==2)

goods[i]=new Mobile();

}

Shop shop=new Shop(goods);

System.out.println("商店年销售额："+shop.giveTotalSales());

}

}

内容二：

class NoLowerLetter extends Exception{

    public void print(){

        System.out.printf("%c",'#');

    }

}

class NoDigit extends Exception{

    public void print(){

        System.out.printf("%c",'*');

    }

}

class People {

   

    public void printLetter(char c)throws NoLowerLetter{

        if(c<'a'||c>'z'){

            NoLowerLetter noLowerLetter = new NoLowerLetter();

            throw (noLowerLetter);

        }

        else

            System.out.print(c);

    }

   

    public void printDigit(char c)throws NoDigit{

        if(c<'1'||c>'9'){

            NoDigit noDigit = new NoDigit();

            throw (noDigit);

        }

        else

            System.out.print(c);

    }

}

 

public class ExceptionExample {

    public static void main(String args[]){

        People people=new People();

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

            try {people.printLetter((char)i);}

            catch (NoLowerLetter e) {e.print();}

           

        }

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

            try {people.printDigit((char)i);}

            catch (NoDigit e) {e.print();}

           

        }

    }

}

 

 

 

 

 

 

 

五、总结：

 

    在这次实验中我体会到了接口回调的作用，可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中，那么该接口变量就可以调用被类实现的接口方法。接口调用我感觉对java项目的书写中提供了很大的便捷性和技巧性，还有java中异常处理机制，当发生错误时，程序不至于崩溃。当发生错误时，可以在短时间内找到错误所在行，能节省时间。这样独特的机制，使java项目的安全性得到了保证，当有异常出现时，也不会至于让编码员崩溃。Java语言包罗万象，对于任何一种危急情况似乎都有自己的保护和预防机制，我感受到，自己以后在编码或者人生的道路上，不仅要对整体有规划性，更要考虑周全，去思考如果出现各类问题又将如何面对，这样才是做事尽善尽美的状态。

 

 

 

 

 

实验成绩：                 指导教师：               年  月  日

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

实验名称	实验4   多线程、读写基本数据类型			专  业	软件工程
姓    名		学  号		班  级

 

一、实验目的：

 

二、实验内容：

 

. 编写一个Java应用程序，创建三个线程同步的实现将若干个基本数剧写入到一个文件，再顺序读出。

 

     

三、实验设备及软件环境：

 

Microsoft Word

Eclipse

 

四、实验过程及结果：

package com.zrrd.hcl;

class Tortoise extends Thread

{

   int sleepTime=0,liveLength=0;

   Tortoise(int sleepTime,String name,int liveLength)

   {

      this.sleepTime=sleepTime;

      this.liveLength=liveLength;

      setName("Tortoise");  // 设置线程的名字为name

   }

   public void run()

   {

      while(true)

      {

          liveLength--;

          System.out.printf("@");

          try

            {

           Thread.sleep(80); // 让线程调用 sleep方法进入中断状态，sleepTime毫秒后线程

// 重新排队，等待CUP资源

            }

          catch(InterruptedException e)

            {

            }

           if(liveLength<=0)

            {

                System.out.printf(getName()+"进入死亡状态\n");

          return;  // 结束run方法的语句

            }

      }

   }

}

class Rabbit extends Thread

{

   int sleepTime=0,liveLength;

   Rabbit(int sleepTime,String name,int liveLength)

   {

      this.sleepTime=sleepTime;

      this.liveLength=liveLength;

     setName("Rabbit");   // 设置线程的名字为name

   }

   public void run()

   {

      while(true)

      {

          liveLength--;

          System.out.printf("*");

          try

            {

           Thread.sleep(80); // 让线程调用 sleep方法进入中断状态，sleepTime毫秒后

// 线程重新排队，等待CUP资源

            }

          catch(InterruptedException e)

            {

            }

           if(liveLength<=0)

            {

                System.out.printf(getName()+"进入死亡状态\n");

             return;  // 结束run方法的语句

            }

      }

   }

}

public class ThreadExample

{

   public static void main(String args[ ])

   {

       Rabbit  rabit;

       rabit=new Rabbit(50,"R1",50);     // 新建线程rabit

       Tortoise tortoise;

       tortoise=new Tortoise(20,"T2",70);   // 新建线程tortoise

       rabit.start();    // 启动线程tortoise

       tortoise.start(); // 启动线程rabit

   }

}

 

 

 

package com.zrrd.hcl;

 

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

 

public class NumberExample

{  

   public static void main(String args[])

   {

       int a1=12,a2=1180;

       long b=808080;

       float x1=3.14F,x2=12.456F;

       double d=1234.9876;

       boolean boo1=true,boo2=false;

       char c='我';

       File f=new File("c:\\123.text");   //创建文件。

       try  

        {  

           FileOutputStream fos=new FileOutputStream(f);        // 创建指向f文件输出流

           DataOutputStream out_data= new DataOutputStream(fos);   // 创建指向fos 的数据输出流

           out_data.writeInt(a1); // out_data将数据a1写入到文件

           out_data.writeInt(a2);     // out_data将数据a2写入到文件

           

           out_data.writeLong(b);

           out_data.writeFloat(x1);

           out_data.writeFloat(x2);  

           out_data.writeDouble(d);  

           out_data.writeBoolean(boo1);

           out_data.writeBoolean(boo2);

           out_data.writeChar(c);

           out_data.close();

           fos.close();

         }

       catch(IOException e){}

       try

         {

            FileInputStream fis=new FileInputStream(f);         // 创建指向f文件输入流

            DataInputStream in_data= new DataInputStream(fis);    // 创建指向fis 的数据输入流

            System.out.println(in_data.readInt());         // in_data读取int整数

            System.out.println(in_data.readInt());         // in_data读取int整数

            System.out.println(in_data.readLong());         // in_data读取long整数

            System.out.println(in_data.readFloat());         // in_data读取float数

            System.out.println(in_data.readFloat());         // in_data读取float数

            System.out.println(in_data.readDouble());         // in_data读取double数

            System.out.println(in_data.readBoolean());         // in_data读取boolean数据

            System.out.println(in_data.readBoolean());         // in_data读取boolean数据

            System.out.print(in_data.readChar());             // in_data读取char数据

          }

        catch(IOException e){}

   }

}

•  

    

 

• 总结：

   对于多线程问题，我在做报告的时候在百度上查询了很多的相关资料，关于多线程最开始我的理解还比较浅薄，无法理解它的具体作用，通过一系列的查询，并且和同学的交流，最后明白了多线程的实际应用，线程可以把任务分块执行，分块后可以同时进行而不用等待。 这样效率更高，就比如下载文件，通过多线程就可以实现多文件下载，这让我明白了在学习过程中，首先需要具备基本的学习技能，当你积攒够足够的基础知识，你需要做的是提高效率，省时省力，真正让自己做出来的程序服务于用户，科技的作用是为了便捷人类的生活方式，也在这里真切地体会出来了

 

    

 

 

 

 

 

实验成绩：                 指导教师：               年     月     日