Java语言实验报告

Java语言实验一

一、实验目的

1、掌握下载Java SDK软件包。

2、掌握编写与运行Java程序的方法。

3、实现简单的算法设计。

二、实验题目

1、打印出所有的“水仙花数”，所谓的“水仙花数”，是指一个3位数，其各位数字的立方和等于该数字本身，例如：153是一个“水仙花数”，153=13+53+33

2、编程求Fibonacci数列的前20项，并判断2178309是不是Fibonacci数列中的数，如果是判断它是第几个数。

3、回文是指正向读和反向读都一样的一段文字或数字。请编写程序判断一个5位数是否是回文数。试想如何判断任意一个数是否是回文数？

4、编程实现如下图形：

1

1 2 1

1 2 4 2 1

1 2 4 8 4 2 1

1 2 4 8 16 8 4 2 1

1 2 4 8 16 32 16 8 4 2 1

1 2 4 8 16 32 64 32 16 8 4 2 1

1 2 4 8 16 32 64 128 64 32 16 8 4 2 1

1 2 4 8 16 32 64 128 256 128 64 32 16 8 4 2 1

试问：如何实现可以输出任意多行？

三、实验程序

package Test;

import java.util.Scanner;

public class MyTest01

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

narcNum();

fibNum(20); }

/*打印出所有的“水仙花数”，所谓的“水仙花数”，是指一个3位数，

其各位数字的立方和等于该数字本身*/

public static void narcNum()

{ for(int x=100;x<1000;x++){

int temp=x%10;

int temp1=(x/10)%10;

int temp2=x/100;

if(x==(temp*temp*temp+temp1*temp1*temp1+temp2*temp2*temp2))

{System.out.println(x);}

}

}

/*编程求Fibonacci数列的前20项，

* 并判断2178309是不是Fibonacci数列中的数，

* 如果是判断它是第几个数。*/

public static void fibNum(int n)

{ long []arr=new long[n];

arr[0]=1;

arr[1]=1;

for(int x=2;x

{ arr[x]=arr[x-1]+arr[x-2]; }

for(int x=0;x

{ if(x==2178309)

{System.out.println("2178309是Fibonacci数列的"+x+"项"); }

System.out.println(x);}

}

/*回文是指正向读和反向读都一样的一段文字或数字。

* 请编写程序判断一个5位数是否是回文数。试想如何判断任意一个数是否是回文数？*/

public static void palindrome(){

Scanner sc=new Scanner (System.in);

System.out.println("请输入数字。用来判断是否为回文数");

String str =sc.nextLine();

sc.close();

StringBuffer buff=new StringBuffer(str);

buff.reverse();

String str1=buff.toString();

if(str.equals(str1))

{ System.out.println(str+"是回文数");

}

else

{ System.out.println("你输入不是回文数");}

}

/*4、编程实现如下图形：

1

1 2 1

1 2 4 2 1

1 2 4 8 4 2 1

1 2 4 8 16 8 4 2 1

1 2 4 8 16 32 16 8 4 2 1

1 2 4 8 16 32 64 32 16 8 4 2 1

1 2 4 8 16 32 64 128 64 32 16 8 4 2 1

1 2 4 8 16 32 64 128 256 128 64 32 16 8 4 2 1

试问：如何实现可以输出任意多行？*/

public static void print()

{ Scanner sc=new Scanner (System.in);

System.out.println("请输入行数");

int n=sc.nextInt();

sc.close();

for (int x=1,y=n;x<2*n;x=x+2,y--)

{ int [] arr=new int [x];

arr[0]=arr[arr.length-1]=1;

if(x>1)

{for (int sta=1,end=arr.length-2;sta<=end;sta++,end--)

{ arr[sta]=arr[end]=2*arr[sta-1];}

}

for (int s=0;s

{System.out.print("\t");}

for(int i=0;i

{ System.out.print(arr[i]+"\t");}

System.out.println(); }

}

}

四、实验结果

1、所有的水仙花数有153、370、371、407。

2、Fibonacci数列的前20项：0、1、1、2、

3、5、8、13、21、3

4、5

5、89、144、233、377、610、987、1597、2584、4181

2178309是Fibonacci数列中的数，第32个数

Java语言实验二

五、实验目的

掌握字符串和数组的基本方法。

六、实验题目

1、利用二维数组实现杨辉三角的存储和打印。图示如下

1

1 1

1 2 1

1 3 3 1

1 4 6 4 1

1 5 10 10 5 1

1 6 15 20 15 6 1

1 7 21 35 35 21 7 1

1 8 28 56 70 56 28 8 1

1 9 36 84 126 126 84 36 9 1

2、编程实现魔方阵。魔方阵是指方阵的每一行、每一列和对角线之和均相等。魔方阵的排列方法如下：如3×3的魔方阵：

8 1 6

3 5 7

4 9 2

魔方阵的排列规律如下：

(1)将1放在第一行中间一列；

(2)从2开始直到n×n止各数依次按下列规则存放；每一个数存放的行比前一个数的行数减1，列数加1（例如上面的三阶魔方阵，5在4的上一行后一列）；

(3)如果上一个数的行数为1，则下一个数的行数为n(指最下一行);例如1在第一行，则2应放在最下一行，列数同样加1；

(4)当上一个数的列数为n时，下一个数的列数应为1，行数减去1。例如2在第3行最后一列，则3应放在第二行第一列；

(5)如果按上面规则确定的位置上已有数，或上一个数是第一行第n列时，则把下一个数放在上一个数的下面。例如按上面的规定，4应该放在第1行第2列，但该位置已经被占据，所以4就放在3的下面；

(6)然后实现5阶魔方阵

七、实验程序

package Test;

import java.util.Scanner;

public class MyTest02

{ public static void main(String[] args)

{ //fun();

Magic m=new Magic(0);

m.printMagic();}

/*1、利用二维数组实现杨辉三角的存储和打印。*/

public static void fun()

{ Scanner sc=new Scanner (System.in);

System.out.println("请输入行数");

int num = sc.nextInt();

sc.close();

int[][] m=new int [num][];

for(int i=0;i

{ m[i]=new int[i+1];

m[i][0]=1;m[i][i]=1;

for(int j=0;j

{ if(j>=1&&i>1)

m[i][j]=m[i-1][j-1]+m[i-1][j]; }

}

for(int i=0;i

{ for(int j=0;j

{ System.out.print(m[i][j]);

System.out.print('\t'); }

System.out.println(); }

}

/*编程实现魔方阵。魔方阵是指方阵的每一行、每一列和对角线之和均相等。*/ class Magic

{ private int n;

private int[][] I;

private int[][] J;

public Magic(int n)

{ this.n = n; }

public int[][] getMagic()

{ int[][] M=null;

if(n<=2)return M;

if(n%2==1)

{ meshGrid();

M=new int[n][n];

for(int i=0;i

for(int j=0;j

{ int a=mod(I[i][j]+J[i][j]-(n+3)/2,n);

int b=mod(I[i][j]+2*J[i][j]-2,n);

M[i][j]=n*a+b+1;}

}

else if(n%4==0)

{ meshGrid();

M=reshape();

for(int i=0;i

for(int j=0;j

{ int a=(int)Math.floor(mod(I[i][j],4)/2.0);

int b=(int)Math.floor(mod(J[i][j],4)/2.0);

if(a==b)

{ M[i][j]=n*n+1-M[i][j]; }

}

}

Else

{ int p=n/2;

Magic magic=new Magic(p);

int[][] temp=magic.getMagic();

M=new int[n][n];

for(int i=0;i

{ for(int j=0;j

{ M[i][j]=temp[i][j];

M[i][j+p]=temp[i][j]+2*p*p;

M[i+p][j]=temp[i][j]+3*p*p;

M[i+p][j+p]=temp[i][j]+p*p; }

}

int k=(n-2)/4;

for(int j=0;j

{ for(int i=0;i

{ int t=M[i][j];

M[i][j]=M[i+p][j];

M[i+p][j]=t; }

}

for(int j=n-k+1;j

for(int i=0;i

int t=M[i][j];

M[i][j]=M[i+p][j];

M[i+p][j]=t;}

}

int t=M[k][0];M[k][0]=M[k+p][0];M[k+p][0]=t; t=M[k][k];M[k][k]=M[k+p][k];M[k+p][k]=t;}

return M; }

private void meshGrid()

{ if(n>2)

{ I=new int[n][n];

J=new int[n][n];

for(int i=0;i

for(int j=0;j

{ I[i][j]=i+1;

J[i][j]=j+1;}

}

}

private int[][] reshape(){

if(n>2){

int[][] M=new int[n][n];

for(int i=0;i

for(int j=0;j

{ M[i][j]=i*n+j+1;}

return M; }

return null;}

private int mod(int a,int n)

{ int m=a%n;

if(m<0)

m+=n;

return m;}

public void printMagic()

{ this.getMagic();

int[][] a=this.getMagic();

for(int i=0;i

for(int j=0;j

{ System.out.print(a[i][j]+"\t");} System.out.println();}

}

}

四、实验结果

五阶魔方阵： 15 8 1 24 17

16 14 7 5 23

22 20 13 6 4

3 21 19 12 10

9 2 25 18 11

Java 语言实验三

一、实验目的

1、掌握Java 对象序列化。

2、掌握用Java 语言编程用辗转相除法求两数的最大公约数。

二、实验题目

1、编写一个方法实现将一个整数逆序输出，并测试这个方法：

public static int reverse(int number)

例如 reverse(3456)返回值是6543。

2、编写一个方法实现下面的序列： )1

21121131111917151311(4)(++---+-+-+-=i i i m 3、编写程序求两个整数的最大公约数，方法的头部如下：

public static int gcd(int m,int n)

测试这个方法。

三、实验程序

package Test;

import java.util.Scanner;

public class MyTest03 {

public static void main(String[] args) {

//测试第一个方法

int num=56;

System.out.println(reverse(num));

//测试第二个方法

System.out.println(sum());

//测试第三方法

System.out.println(gcd(56, 57));

}

/*

* 1、编写一个方法实现将一个整数逆序输出，并测试这个方法： public static int reverse(int number) 例如

* reverse(3456)返回值是6543。

*/

public static int reverse(int number) {

StringBuffer buff = new StringBuffer(number + "");

return Integer.parseInt(buff.reverse().toString());

}

/* 2、编写一个方法实现下面的序列： */

public static double sum() {

Scanner sc = new Scanner(System.in);

System.out.println("请输入数字");

int n = sc.nextInt();

sc.close();

double sum;

sum = 1.0 - 2.0 / ((2 * n - 1) * (2 * n + 1));

return 4 * sum;

}

/* 编写程序求两个整数的最大公约数辗转相除法*/

public static int gcd(int m, int n) {

int r;

while (n > 0) {

r = m % n;

m = n;

n = r;

}

return m;

}

}

四、实验结果

1、reserve（12345）=54321

2、i=3 m(i)=52/15

3、m=16 n=20 r=4

Java 语言实验四

一、实验目的

1、掌握Java 基本语法，重点是面向对象的思想和语法。

2、掌握继承、多态的概念与实现方法。

3、掌握构造函数的概念和使用。

二、实验题目

1、编写一个类计算箱子的体积，要求如下：

1)类中有三个属性，长度，高度和宽度;

2)类中的每个属性提供相应的set/get方法;

3)要有一个无参构造方法;

4)要有一个构造方法初始化三个属性；

5)要有一个方法计算箱子的体积；

6)定义一个dispInfo方法，显示类的信息。

测试之。

2、编写一个Point类，要求如下：

1)类中有两个属性，x，y;

2)类中的每个属性提供相应的set/get方法;

3)要有一个无参构造方法;

4)要有一个构造方法初始化两个属性；

5)要有一个方法distance(Point p1,Point p2)计算两者直接的距离；

6)定义一个dispInfo方法，显示类的信息。

测试之。

三、实验程序

1、编写一个类计算箱子的体积

package Test;

public class MyTest04

{ public static void main(String[] args)

{ jstj s=new jstj(50,55,89);

s.calcult();

System.out.println( s.displnfo());}

}

/*1、编写一个类计算箱子的体积。*/

class jstj

{ private double length;

private double width;

private double height;

{ public double getLength()

return length;}

public void setLength(double length)

{ this.length = length;}

public double getWidth()

{ return width;}

public void setWidth(double width)

{ this.width = width;}

public double getHeight()

{ return height;}

public void setHeight(double height)

{ this.height = height;}

jstj(double length, double width, double height)

{super();

this.length = length;

this.width = width;

this.height = height;}

jstj()

{super();}

public String displnfo() {

return "jstj [length=" + length + ", width=" + width + ", height="

+ height + "]";}

public void calcult()

{ double sum=length*width*height;

System.out.println("体积为："+sum);}

}

2、编写一个Point类

package Test;

public class MyTest0402

{ /**

* @param args

*/

public static void main(String[] args)

{ Point p1=new Point(3.0,4.0);

Point p2=new Point(3.0,3.0);

System.out.println(p1.distance(p1, p2));

System.out.println(p1.dispInfo());}

}

/*、编写一个Point类，要求如下：

1)类中有两个属性，x，y;

2)类中的每个属性提供相应的set/get方法;

3)要有一个无参构造方法;

4)要有一个构造方法初始化两个属性；

5)要有一个方法distance(Point p1,Point p2)计算两者直接的距离；

6)定义一个dispInfo方法，显示类的信息。

测试之。*/

class Point

{private double x;

private double y;

Point(double x, double y)

{super();

this.x = x;

this.y = y;}

Point()

{super();}

public double getx()

{return x;}

public void setx(double x)

{this.x=x;}

public void sety(double y)

{ this.y=y;}

public double gety()

{return y;}

public String dispInfo(){

return "Point : x="+x+"y="+y;}

public double distance(Point p1,Point p2){

return Math.hypot((p1.x-p1.x), (p1.y-p2.y));} }

四、实验结果

1、编写一个类计算箱子的体积

请输入长：5

请输入宽：7

请输入高：9

长方体的体积为:315

2、编写一个Point类

Please input x for point 1:0

Please input y for point 1:3

Please input x for point 1:4

Please input y for point 1:0

The distance is: 5.0