Java数组与对象实验报告

实验六Java对象和数组

一实验目的

1．掌握Java中对象和引用变量的概念

2．掌握Java数组的使用和本质

3．掌握数组相关常用算法

二实验内容

1．类的定义和对象创建

定义类MyPoint用以包含属性x,y表示一个点的坐标。在类中编写main()方法，在其中声明两个MyPoint类型的对象start和end，分别创建对象并赋值给对象名start和end。将对象start的成员x和y分别赋值为10，将对象end的成员x和y分别赋值为20。

【程序代码】

package exp6;

public class MyPoint {

int x,y;

public MyPoint( int x,int y){

this.x=x;

this.y=y;

}

public static void main(String [] args){

MyPoint start;

MyPoint end;

start=new MyPoint(10,10);

end=new MyPoint(20,20);

}

}

1.1输出两个对象的字符串表示。用两种方法实现

（1）System.out.println("Start MyPoint = x："+start.x + "y"+ start.y);

（2）通过改写toString()方法来实现，然后使用System.out.println(start);

【写出toString()方法的全部代码】

public String toString() {

return"x="+x+" "+"Y="+y;

}

1.2 在main()方法中增加代码，以完成下列操作：

声明一个新的MyPoint类型对象stray。将对象end的赋值给stray，随后输出end和stray 变量的成员x和y的值。将对象stray的成员x和y赋任意新值，输出end和stray的成员的值。将start对象的成员x和y赋予新的值（任意），再次输出start和end的成员值。分析程序输出结果，得出相应结论。

【程序代码和分析：填写增加部分的代码即可】

MyPoint start=new MyPoint(10,10);

MyPoint end=new MyPoint(20,20);

MyPoint stray;

stray=end;

System.out.println(end);

System.out.println(stray);

stray=end;

stray.x=30;

stray.y=30;

System.out.println(end);

System.out.println(stray);

start.x=50;

start.y=50;

System.out.println(end);

System.out.println(start);

运行结果：

x=20 Y=20

x=20 Y=20

x=30 Y=30

x=30 Y=30

x=30 Y=30

x=50 Y=50

分析程序：

(1)、将对象end的赋值给stray，则将引用变量end的内存地址赋给stray，两者指向同一数组。所以输出X=20 Y=20

(2)、将对象stray的成员x和y赋任意新值，则将引用变量stray指向新的内存，输出X=30 Y=30

(3)、将start对象的成员x和y赋予新的值（任意），则将引用变量start指向新的内存，输出X=50 Y=50

2．一维数组的使用

2.1 定义一个BasicArray类，在main()方法中声明（非创建）两个整型数组，thisArray和thatArray。创建一个数组，它的初值是1至10。将这个数组的引用赋值给变量thisArray。使用for循环输出thisArray数组的所有值。如何控制循环的次数？编译并运行程序，记下输出结果。

【程序代码和分析】

package exp6;

public class BasicArray {

public static void main(String[] args) {

int thisArray[];

int thatArray[];

int arrayNew[]={1,2,3,4,5,6,7,8,9,10};

thisArray=arrayNew;

for(int i=0;i

System.out.println(thisArray[i]);

}

}

}

运行结果：1 2 3 4 5 6 7 8 9 10

分析程序：

声明数组thisArray，thatArray，声明数组arrayNew并初始化。将arrayNew赋给thisArray，则将arrayNew的内存地址赋给thisArray，两者指向同一数组。最后用for循环输出thisArray指向的数组。

2.2 对每个thisArray的元素，把它的值赋值为下标值的阶乘。并输出数组的所有元素。重新编译并运行程序。

【程序代码和分析：填写增加部分的代码即可】

for(int i=0;i

int j;

for( j=1,thisArray[i]=1;j<=i;j++){

thisArray[i]*=j;

}

System.out.println("thisArray["+i+"]="+thisArray[i]);

}

运行结果：

thisArray[0]=1

thisArray[1]=1

thisArray[2]=2

thisArray[3]=6

thisArray[4]=24

thisArray[5]=120

thisArray[6]=720

thisArray[7]=5040

thisArray[8]=40320

thisArray[9]=362880

分析程序：

因为将thisArray的赋值为下标的阶乘，所以thisArray指向的数组其元素将被重新赋值。

2.3将thisArray赋值给thatArray。输出thatArray的所有元素。编译并运行程序，分析程序运行结果。

【程序代码和分析：填写增加部分的代码即可】

thatArray=thisArray;

int length=thatArray.length;

for(i=0;i

System.out.println("thatArray[i]"+thatArray[i]);

运行程序：

thatArray[0]=1

thatArray[1]=1

thatArray[2]=2

thatArray[3]=6

thatArray[4]=24

thatArray[5]=120

thatArray[6]=720

thatArray[7]=5040

thatArray[8]=40320

thatArray[9]=362880

分析程序：

因为thisArray赋值给thatArray，所以thisArray，thatArray将指向同一数组。

2.4 任意修改thisArray数组的某些元素，输出thatArray数组的值。编译并运行程序，分析运行结果。

【程序代码和分析：填写增加部分的代码即可】

thisArray[4]=4444;

thatArray=thisArray;

int length=thatArray.length;

for(i=0;i

System.out.println("thatArray[i]"+thatArray[i]);

2.5 创建一个长度为20个元素的整型数组。将新数组的引用给变量thatArray，输出thatArray 的值。编译并运行程序，记录输出结果并分析原因。

【程序代码和分析：填写增加部分的代码即可】

int[] otherArray= new int[20];

thatArray=otherArray;

for(int i=0;i

System.out.print(thatArray[i]+" ");

}

运行结果：0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

分析程序：因为创建了一个数组但是没有初始化，所以输出的时候输出的是该数组的数据类型的默认值

2.6使用arraycopy方法将thisArray数组的值给thatArray数组。输出thatArray数组中元素的值。编译并运行程序。分析程序运行结果。

【程序代码和分析：填写增加部分的代码即可】

int thisArray[];

int thatArray[];

int arraynew[]={1,2,3,4,5,6,7,8,9,10};

thisArray=arraynew;

int[] otherArray= new int[20];

thatArray=otherArray;

System.arraycopy(thisArray, 0, thatArray, 1,thisArray.length);

for(int i=0;i

System.out.print(thatArray[i]+" ");

}

运行结果：

0 1 2 3 4 5 6 7 8 9 10 0 0 0 0 0 0 0 0 0

分析程序：

使用arraycopy()方法将thisArray的值赋给thatArray，arraycopy()方法中的参数的意思是：将thisArray数组从下标为0的元素开始，复制到thatArray数组的下标为1的元素，一共复制thisArray.length个元素，其余的元素不变。

2.7 改变thatArray数组中某些元素的值，输出thisArray和thatArray数组的所有元素。编译并运行程序。分析程序运行结果。

【程序代码和分析：填写增加部分的代码即可】

thatArray[15]=15;

System.out.print("thisArray:");

for(int i=0;i

System.out.print(thisArray[i]+" ");

}

System.out.println("");

System.out.print("thatArray:");

for(int i=0;i

System.out.print(thatArray[i]+" ");

}

运行结果：thisArray:1 2 3 4 5 6 7 8 9 10

thatArray:0 1 222 3 4 5 6 7 8 9 10 0 0 0 0 0 0 0 0 0

3．在文本文件中存放着一系列的整数，整数与整数之间用逗号分隔。编写程序将这些整数读入程序，然后对数组进行特定处理后输出。

提示：可以使用Scanner类的nextLine()方法得到一个字符串line，其中存放着所有的整数。然后用String arr[]=line.split(“,”); 可将逗号作为分隔符分离出一个数组，数组的长度即为整数的个数，每一个数组元素可通过Integer.parseInt()转换为整型数据存放到新创建的整型数组中（数组长度即为arr的长度）。

3.1 将数据读取分析功能单独设计为一个方法

public static int[] readData();

【写出方法代码】

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.BufferedWriter;

import java.io.IOException;

import java.util.Scanner;

public static int[] readData()throws FileNotFoundException{

Scanner sc=new Scanner(new BufferedReader(new FileReader("E:\\实验备份\\百度云同步盘\\Java\\workspace\\source.txt")));

String st=sc.nextLine();

String arr[]=st.split(",");

int arrLength=arr.length;

int intArr[] = new int[arrLength];

int i;

for(i=0;i

intArr[i]=Integer.parseInt(arr[i]);

}

return intArr;

}

3.2 将读取到的整数使用冒泡排序法按升序排序，写出方法代码。方法原型为

public static void bubbleSort(int a[],int n); //n为元素个数

public static void bubbleSort(int a[],int n) throws FileNotFoundException{ int j;

for(j=0;j

boolean flag=true;

for(int i=0;i

if(a[i]>a[i+1]){

int temp=a[i];

a[i]=a[i+1];

a[i+1]=temp;

flag=false;

}

}

if(flag==true)break;

}

for(j=0;j

System.out.print(a[j]+" ");

}

}

public static void main(String[] args) throws FileNotFoundException { bubbleSort(readData(),readData().length);

}

运行结果：98 94 91 90 89 89 88 78 75 60

3.2 将读取到的整数使用选择排序法按升序排序，写出方法代码。方法原型为

public static void selectSort(int a[],int n); //n为元素个数

public static void selectSort(int a[],int n) throws FileNotFoundException{ int i;

for(i=0;i

int lowIndex = i;

for(int j=i+1;j

if(a[j]>a[lowIndex]){

lowIndex = j;

}

}

int temp = a[i];

a[i] = a[lowIndex];

a[lowIndex] = temp;

}

for(i=0;i

System.out.print(a[i]+" ");

}

}

运行结果：60 75 78 88 89 89 90 91 94 98

3.3 将读取到的整数使用Arrays类中的sort方法进行排序，写出方法代码。

public static void ArraySort(int x[]) throws FileNotFoundException{

Arrays.sort(x);

for(int i=0;i

}

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

ArraySort(readData());

}

3.4 对读取到的整数进行分析，求出最大值、最小值、平均值并输出。同样设计为一个单独的方法。

public static void aboutArray(int a[],int n){

int max=0,min=100,sum=0;

int i;

float ave;

for(i=0;i

if(a[i]>max)

max=a[i];

if(a[i]

sum+=a[i];

// System.out.print("最大值"+max+" "+"最小值"+min);

}

ave=sum/(float)n;

System.out.println("最大值:"+max+" "+"最小值:"+min+" "+"平均值:"+ave);

}

4. 定义MyDate类，包含year,month,day三个成员。在MyDate类中改写toString()方法，equals 方法并实现Compareable接口。在大小比较时，返回两个日期相差的天数。为了计算相差的天数，设计方法int order()返回日期在该年的序号，设计函数int diff(MyDate ad)计算本日期和ad日期之间相差的天数。

package exp6;

public class MyData {

int year;

int month;

int day;

public MyData(int x,int y,int z){

year=x;

month=y;

day=z;

}

public void setYear(int x){

year=x;

}

public void setMonth(int y){

month=y;

}

public void setDay(int z){

day=z;

}

public int getYear(){

return year;

}

public int getMonth(){

return month;

}

public int getDay(){

return day;

}

public String toString(){ //重写toString()

return year+"年"+month+"月"+day+"日";

}

public boolean isLeapYear(){

if((year%4==0&&year%100!=0)||year%400==1)

return true;

else return false;

}

public int order(){

int j=0;

int numOfMonth[]={0,0,31,28,31,30,31,30,31,31,30,31,30};

int numOfMonth2[]={0,0,31,29,31,30,31,30,31,31,30,31,30};

if(isLeapYear()){//计算这天在这年中的次序

for(int i=1;i<=month;i++)//闰年的计算方法

j+=numOfMonth2[i];

}

else

for(int i=1;i<=month;i++)//平年的计算方法

j+=numOfMonth[i];

return j+day;

}

public int numOfYear(MyData md){

if(md.isLeapYear())

return 366;

else return 365;

}

public static int diff(MyData md1,MyData md2){

int sd=md1.getYear()-md2.getYear();

int numOfLeap=(sd-2)/4;//两个日期之间的闰年个数

int different;

different

=numOfLeap*366+(sd-numOfLeap-1)*365+md1.order()+(md2.numOfYear(md2)-md2.ord er());

return different;

}

public static void main(String[] args) {

MyData md = new MyData(2008,3,1);

MyData md2= new MyData(2004,3,1);

System.out.println(diff(md,md2));

}

}

【实验小结】