实验2 OO基础（6学时）

（个人意见，仅供参考，类名、包名可以自己定义进行替换，如有错误，还望指出）

1. 设计一个名为figure的图形软件包（package）。包中包含三角形、矩形、圆三个类。要求：（1）每个类都要构造方法并为成员设置get和set方法；（2）每个类都要有计算周长和面积的成员方法；（3）完成该软件包后的编码后，在另一个包的含有main方法的类中编写代码，分别使用图形软件包中的三个类，生成三个对象，并打印出其周长和面积。
   ①圆类

   package figure;
   import java.math.*;
   public class Circle {
   	private double radius;
   	public Circle() {
   		
   	}
   	public Circle(double radius){
   		this.radius=radius;
   	}
   	public double getRadius() {
   		return radius;
   	}
   	public void setRadius(int radius) {
   		this.radius = radius;
   	}
   	public double getCircumference() {
   		return radius*Math.PI*2;
   	}
   	public double getArea() {
   		return radius*Math.PI*Math.PI;
   	}
   }
   

   ②矩形类
    

   package figure;
   
   public class Rectangle {
   	private double length,width;
   	public Rectangle() {
   		
   	}
   	public Rectangle(double length,double width){
   		this.width=width;
   		this.length=length;
   	}
   	public double getLength() {
   		return length;
   	}
   	public void setLength(double length) {
   		this.length = length;
   	}
   	public double getWidth() {
   		return width;
   	}
   	public void setWide(double wide) {
   		this.width = wide;
   	}
   	public double getCircumference() {
   		return (length+width)*2;
   	}
   	public double getArea() {
   		return length*width;
   	}
   	
   }
   

   ③三角形类
    

   package figure;
   import java.math.*;
   public class Triangle {
   	private double a,b,c;
   	public Triangle() {
   		
   	}
   	public Triangle(double a,double b,double c) {
   		this.a=a;
   		this.b=b;
   		this.c=c;
   	}
   	public double getA() {
   		return a;
   	}
   	public void setA(double a) {
   		this.a = a;
   	}
   	public double getB() {
   		return b;
   	}
   	public void setB(double b) {
   		this.b = b;
   	}
   	public double getC() {
   		return c;
   	}
   	public void setC(double c) {
   		this.c = c;
   	}
   	public double getCircumference() {
   		return a+b+c;
   	}
   	public double getArea() {
   		double p=(a+b+c)/2;
   		double S=Math.sqrt(p*(p-a)*(p-b)*(p-c));
   		return S;
   	}
   	public boolean judge() {
   		if(a+b<=c||a+c<=b||b+c<=a||Math.abs(a-b)>=c||Math.abs(a-c)>=b||Math.abs(b-c)>=a||a<=0||b<=0||c<=0) {
   			return false;
   		}
   		else {
   			return true;
   		}
   	}
   
   }
   

   ④测试类：

   package Main;
   import figure.*;
   import java.util.Scanner;
   public class Main {
   	static Scanner cin=new Scanner (System.in);
   	public static void main(String[] args) {
   			Triangle tri=new Triangle(1,2,3);
   			System.out.println("Triangle:");
   			if(tri.judge()==true) {
   				System.out.println("Circumference: "+tri.getCircumference());
   				System.out.println("Area         : "+tri.getArea());
   			} else {
   				System.out.println("不能构成三角形");
   			}
   			Rectangle rec=new Rectangle(1,1);
   			System.out.println("Rectangle:");
   			System.out.println("Circumference: "+rec.getCircumference());
   			System.out.println("Area         : "+rec.getArea());
   			Circle cir=new Circle(1);
   			System.out.println("Circle:");
   			System.out.println("Circumference: "+cir.getCircumference());
   			System.out.println("Area         : "+cir.getArea());
   	}
   
   }
   

    

 2.设计一个带表头的双向链表（链表中数据的具体类型可以随意），提供以下方法：（1）insert：在某个位置插入对象；（2）insert：在链表的最后插入对象；（2）delete：在某个位置删除对象；（3）delete：删除链表中与x相同的元素；（4）size：返回当前链表中对象的个数；（5）isEmpty：判断链表是否为空；（6）traverse：遍历链表，打印出所有的元素；（7）getData：取得某个位置的对象。构造main函数进行测试。

①DLinkList类

package LinkList;
import java.util.*;
public class DLinkList {

	private class Node {
		private Node prior;
		private Node next;
		private Object data;

		public Node() {
			this.data = null;
			this.prior = null;
			this.next = null;
		}

		public Node(Object data, Node prior, Node next) {
			this.data = data;
			this.prior = prior;
			this.next = next;
		}
	}

	private int size;
	private Node head;
	private Node tail;

	/*
	 * 初始化链表
	 */
	public DLinkList() {
		head = new Node(null, null, null);
		tail = new Node(null, head, null);
		head.next = tail;
		// head=head.next;
		size = 0;
	}

	/*
	 * 查找第index个节点并返回
	 */
	public Node getNode(int index) {
		if (index < 0 || index >= size) {
			throw new IndexOutOfBoundsException();
		}
		Node p = head;
		for (int i = 0; i < index; i++) {
			p = p.next;
		}
		
		return p;
		
		
	}

	/*
	 * （1）insert：在某个位置插入对象；
	 */
	public int insert(int index, Object data) {
		if (index < 0 || index >= size) {
			throw new IndexOutOfBoundsException();
		}
		if (index == 0) {
			Node p = new Node(data, head, head.prior);
			head.next.prior = p;
			head.next = p;
			size++;
			return 1;
		}
		Node q = getNode(index - 1);
		Node p = new Node(data, q, q.next);
		q.next.prior = p;
		q.next = p;
		size++;
		return 1;
	}

	/*
	 * （2）insert：在链表的最后插入对象；
	 */
	public int insert(Object data) {
		Node p = new Node(data, null, null);
		tail.prior.next = p;
		p.prior = tail.prior;
		p.next = tail;
		tail.prior = p;
		size++;
		return 1;
	}

	/*
	 * （2）delete：在某个位置删除对象；
	 */
	public int delete(int index, Object data) {
		if (index < 0 || index >= size)
			throw new IndexOutOfBoundsException();
		Node q = getNode(index);
		q.prior.next = q.next;
		q.next.prior = q.prior;
		size--;
		return 1;
	}

	/*
	 * （3）delete：删除链表中与x相同的元素；
	 */
	public int delete(Object data) {
		Node q = head;
		for (int i = 0; i < size; i++) {
			if (q.data.equals(data)) {
				this.delete(i, data);
			}
			q = q.next;
		}
		return 1;
	}

	/*
	 * （4）size：返回当前链表中对象的个数;
	 */
	public int Getsize() {
		return size;
	}

	/*
	 * （5）isEmpty：判断链表是否为空；
	 */
	public boolean isEmpty() {
		if (size == 0)
			return true;
		else
			return false;
	}

	/*
	 * （6）traverse：遍历链表，打印出所有的元素；
	 */
	public void traverse() {
		Node q = head;
		for (int i = 0; i < size; i++) {
			q = q.next;
			if (i == 0)
				System.out.print(q.data);
			else
				System.out.print(" " + q.data);
		}
		System.out.print("\n");
	}

	/*
	 * （7）getData：取得某个位置的对象。
	 */
	public Object getData(int index) {
		Node p = head;
		for (int i = 0; i < index; i++) {
			p = p.next;
		}
		return p.data;
	}

}

②测试类：

package Main;
import LinkList.DLinkList;;
public class Main {

	public static void main(String[] args) {
		int x = 0;
		DLinkList list=new DLinkList();
		System.out.println("获取初始链表长度：\n"+list.Getsize());
		System.out.println("在链表依次添加元素1,3,4,5,3，并打印链表：");
		for(int i=1;i<=5;i++) {
			if(i!=2)
				list.insert(i);
		}list.insert(3);
		list.traverse();
		System.out.println("在链表第2个位置添加元素2，并打印链表：");
		list.insert(2,2);
		list.traverse();
		System.out.println("获取链表中第5个元素：\n"+list.getData(5));
		System.out.println("删除链表中第4个元素，并打印链表：");
		list.delete(4,x);
		list.traverse();
		System.out.println("删除链表中第一个值为3的元素，并打印链表：");
		list.delete(3);
		list.traverse();
		System.out.println("判断链表是否为空：\n"+list.isEmpty());
		System.out.println("获取链表长度：\n"+list.Getsize());
		
	}

}

 

 

 

3.设计一个教师类Teacher（属于cn.net.sdkd包），要求：

1）属性有编号（int no）、姓名（String name）、年龄（int age）、所属学院（String seminary），为这些属性设置相应2）的get和set方法。

3）为Teacher类重写equals方法，要求：当两个教师对象的no相同时返回true。

4）重写Teacher类的toString方法，通过该方法可以返回“编号为**、姓名为**、年龄为**的**学院老师”形式的字符串。

5）由多个Teacher对象所形成的数组可以以两种方法排序（编号由低到高排序）：1）使用Arrays.sort(Object[] a)方法；2）6）使用Arrays.sort(Object[] a, Comparator c)方法。

7）再定义一个类TeacherManagement（属于cn.sd包），提供方法search，方法可以在一组给定的教师中，根据姓名（或年龄）返回等于指定姓名（或年龄）的教师的字符串信息，信息格式为：“编号为**、姓名为**、年龄为**的**学院老师”。如果没有满足条件的教师，则返回“没有符合条件的教师”。

8）构造main方法进行测试。
①Teacher类

package cn.net.sdkd;
import java.util.Arrays;
import java.util.Comparator;
public class Teacher implements Comparable{
	private int no;
	private int age;
	private String name;
	private String seminary;
	public Teacher() {
		
	}
	public Teacher(int no,int age,String name,String seminary) {
		this.no=no;
		this.age=age;
		this.name=name;
		this.seminary=seminary;
	}
	public int getNo() {
		return no;
	}
	public int getAge() {
		return age;
	}
	public String getName() {
		return name;
	}
	public String getSeminary() {
		return seminary;
	}
	public void setTeacher(int no,int age,String name,String seminary) {
		this.no=no;
		this.age=age;
		this.name=name;
		this.seminary=seminary;
	}
	public boolean equals(Teacher tea){
		if(this.no==tea.no)
			return true;
		else
			return false;
	}
	public String toString() {
		String s;
		s = "编号为" + no + "、姓名为" + name + "、年龄为" + age + "的" + seminary + "学院老师";
		return s;
	}
	public int compareTo(Object o) {
		int no2=((Teacher)o).no;
		if(no<no2) {
			return -1;
		} else {
			return 1;
		}
	}
}

②TeacherManagement类
 

package cn.sd;
import cn.net.sdkd.Teacher;
public class TeacherManagement {
	/*
	 * 按年龄查找
	 */
	public static void search(Teacher[] teachers,int age) {
		int len=teachers.length;
		for(int i=0;i<len;i++) {
			if(age==teachers[i].getAge()) {
				System.out.println(teachers[i].toString());
				break;
			}
			else if(i==len-1) {
				System.out.println("没有符合条件的老师");
			}
		}
	}
	/*
	 * 按姓名查找
	 */
	public static void search(Teacher[] teachers,String name) {
		int len=teachers.length;
		for(int i=0;i<len;i++) {
			if(name==teachers[i].getName()) {
				System.out.println(teachers[i].toString());
				break;
			}
			else if(i==len-1) {
				System.out.println("没有符合条件的老师");
			}
		}
	}
}

 ③测试类：
 

package Main;
import cn.sd.TeacherManagement;
import java.util.Arrays;
import java.util.Comparator;

import cn.net.sdkd.*;

public class Main {

	public static void main(String[] args) {
		Teacher[] teachers = new Teacher[3];
		teachers[0] = new Teacher(3, 30, "Tom", "外国语");
		teachers[1] = new Teacher(1, 28, "张三", "化工");
		teachers[2] = new Teacher(2, 59, "小明", "计算机");
		System.out.println("未排序：");
		for (int i = 0; i < 3; i++) {
			System.out.println(teachers[i].toString());
		}
		System.out.println("按编号排序：");
		Arrays.sort(teachers);
		Arrays.sort(teachers, new SortByNo());
		for (int i = 0; i < 3; i++) {
			System.out.println(teachers[i].toString());
		}
		System.out.println("查找姓名为小明的老师：");
		TeacherManagement.search(teachers, "小明");
		System.out.println("查找年龄为18岁的老师：");
		TeacherManagement.search(teachers, 18);
	}

}
class SortByNo implements Comparator<Teacher>{
    public int compare(Teacher o1, Teacher o2) {
    	if(o1.getNo()<o2.getNo()){
			return -1;
		} else {
			return 1;
		}
         
    }
     
}

 

4.编码实现一个类：（1）提供一个静态方法，可以将输入的一个int[]数组按照从小到大的顺序排列；（2）提供静态方法，对排好序的数组使用折半（二分）查找（使用递归和非递归两种形式分别实现）查找某一个整数。

①FTest类

package Find;

public class FTest {
	private static int []arr;
	public FTest(int []a,int n) {
		arr=new int[n];
		for(int i=0;i<a.length;i++) {
			arr[i]=a[i];
		}
	}
	/*
	 * 1）提供一个静态方法，可以将输入的一个int[]数组按照从小到大的顺序排列；
	 */
	public static void sort() {
		for(int i=0;i<arr.length-1;i++) {
			for(int j=0;j<arr.length-1;j++) {
				if(arr[j]>arr[j+1]) {
					int temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
	}
	/*
	 * （2）提供静态方法，对排好序的数组使用折半（二分）查找
	 * （使用递归和非递归两种形式分别实现）查找某一个整数。
	 */
	//非递归
	public static int search(int x) {
		int left=0;
		int right=arr.length-1;
		while(left <= right) {
			int middle = (left + right)/2;
			if(x==arr[middle]) {
				return middle;
			}else if (x < arr[middle]) {
				right = middle - 1;
			}else {
				left = middle + 1;
			}
		}
		return -1;
	}

	// 递归
	public static int search(int x, int left, int right) {
		int middle = (left + right) / 2;
		if (x < arr[left] || x > arr[right]) {
			return -1;
		}
		if (x == arr[middle]) {
			return middle;
		} else if (x < arr[middle]) {
			search(x, left, middle - 1);
		} else {
			search(x, middle + 1, right);
		}
		return -1;
	}
	public static void Print() {
		for(int i=0;i<arr.length;i++) {
			if(i==0) {
				System.out.print(arr[i]);
			}
			else {
				System.out.print(" "+arr[i]);
			}
		}
		System.out.print("\n");
	}
}

②测试类

package Main;
import Find.FTest;
import java.math.*;
public class Main {

	public static void main(String[] args) {
		int []arr=new int[5];
		for(int i=0;i<5;i++) {
			arr[i]=5-i;
		}
		FTest A=new FTest(arr,arr.length);
		System.out.println("排序前：");
		A.Print();
		A.sort();
		System.out.println("排序后: ");
		A.Print();
		int ans=A.search(5);
		System.out.println("循环查找数值为5的元素：");
		if(ans==-1) {
			System.out.println("该元素不在数组中。");
		}
		else {
			System.out.println("该元素在第"+ans+"个位置。");
		}
		ans=A.search(10, 0, arr.length-1);
		System.out.println("递归查找数值为10的元素：");
		if(ans==-1) {
			System.out.println("该元素不在数组中。");
		}
		else {
			System.out.println("该元素在第"+ans+"个位置。");
		}
	}

}

 

5.使用一维数组编码实现一个栈（Stack）类，要求提供以下操作：（1）boolean isEmpty()：判断栈当前是否为空；（2）入栈操作void push(obj)：把数据元素obj插入堆栈；（3）出栈操作Object pop()：出栈，并返回删除的数据元素；（4）Object getTop()：取堆栈当前栈顶的数据元素并返回；（5）利用Stack类实现一个方法：输入一个正整数，输出该整数所对应的二进制数。

①Stack类

package Test;
/*
 * 一维数组编码实现一个栈（Stack）类
 */
public class Stack {
	private static Object []arr;
	private static int length;
	private int size=4;
	public static int getLength() {
		return length;
	}
	public Object getArr(int index) {
		return arr[index];
	}
	private int addsize=10;

	public Stack() {
		arr = new Object[size];
		length = 0;
	}
	/*
	 * （1）boolean isEmpty()：判断栈当前是否为空；
	 */
	public boolean isEmpty() {
		return length==0;
	}
	/*
	 * 数组扩容
	 */
	public void addLengthArray() {
		Object []brr=new Object[size+addsize];
		System.arraycopy(arr, 0, brr, 0, arr.length);
		size=size+addsize;
		arr=brr;
	}
	/*
	 * （2）入栈操作void push(obj)：把数据元素obj插入堆栈；
	 */
	public void push(Object obj) {
		//数组内存不足时，进行扩容操作
		if(length+1>size) {
			addLengthArray();
		}
		arr[length]=obj;
		length++;
	}
	/*
	 * （3）出栈操作Object pop()：出栈，并返回删除的数据元素；
	 */
	public Object pop() {
		Object data=arr[length-1];
		arr[length-1]=0;
		length--;
		return data;
	}
	/*
	 * （4）Object getTop()：取堆栈当前栈顶的数据元素并返回；
	 */
	public Object getTop() {
		return arr[length-1];
	}
	/*
	 * 打印栈内元素
	 */
	public void print() {
		for(int i=0;i<length;i++) {
			System.out.print(arr[i]);

		}
		System.out.print("\n");
	}
}

②测试类

package Main;
import Test.Stack;
public class Main {

	public static void change(int data) {
		Stack s=new Stack();
		while(data!=0) {
			int x=data%2;
			s.push(x);
			data/=2;
		}
		for(int i=s.getLength()-1;i>=0;i--) {
			System.out.print(s.getArr(i));

		}
		System.out.print("\n");
	}
	public static void main(String[] args) {
		Stack s=new Stack();
		for(int i=1;i<6;i++) {
			s.push(i);
		}
		s.push("sss");
		System.out.println("元素插入栈中后：");
		s.print();
		s.pop();
		System.out.println("一次出栈操作后：");
		s.print();
		System.out.println("取堆栈当前栈顶的数据元素：");
		System.out.println(s.getTop());
		System.out.println("判断栈当前是否为空：");
		System.out.println(s.isEmpty());
		System.out.println("将十进制26转为二进制：");
		change(26);
		
	}

}

 

 

6.按照要求使用Java编码。
1）以类型int[][]声明一个叫matrix的二维数组变量，将矩阵初始化为一个5个元素的数组。
2）以下列方式为matrix的内部元素赋值：matrix从零开始循环到其长度值；例如索引为i，在每次迭代中，将matrix[i]指向一个新的整数数组，其长度为i。然后用索引变量j，对数组中的每一个元素进行循环。在每次内部循环中，将matrix[i][j]赋值为（i*j）。
3）通过循环打印matrix中的所有元素，结果为：

<>

<0>

<0 2>

<0 3 6>

<0 4 8 12>

package Test;

public class Matrix {

	public static void main(String[] args) {
		int [][]matrix=new int[5][];
		for(int i=0;i<5;i++) {
			matrix[i]=new int[i];
			for(int j=0;j<i;j++) {
				matrix[i][j]=i*j;
			}
		}
		for(int i=0;i<5;i++) {
			System.out.print("<");
			for(int j=0;j<i;j++) {
				if(j==0)
					System.out.print(matrix[i][j]);
				else
					System.out.print(" "+matrix[i][j]);
			}
			System.out.println(">");
		}

	}

}

 

 7.利用二维数组（double[]）实现一个矩阵类：Matrix。要求提供以下方法：（1）set（int row, int col, double value）：将第row行第col列的元素赋值为value；（2）get（int row，int col）：取第row行第col列的元素；（3）width()：返回矩阵的列数；（4）height()：返回矩阵的行数；（5）Matrix add（Matrix b）：返回当前矩阵与矩阵b相加后的矩阵；（6）Matrix multiply（Matrix b）：返回当前矩阵与矩阵b相乘后的矩阵。（7）Matrix transpose()：返回当前矩阵的转置矩阵；（8）getMax()：返回矩阵中的最大值及其所在行和列；（9）print()：以行和列的形式打印出当前矩阵。

①Matrix类

package Matrix;
import java.awt.Point;
import java.util.Vector;
public class Matrix {
	private double[][] matrix;
	private int n,m;
	public Matrix(int n,int m) {
		this.n=n;
		this.m=m;
		matrix=new double [n][m];
	}
	public Matrix(double arr[][],int n,int m) {
		this.n=n;
		this.m=m;
		matrix=new double [n][m];
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				matrix[i][j]=arr[i][j];
			}
		}
	}
	/*
	 * （1）将第row行第col列的元素赋值为value；
	 */
	public void set(int row, int col, double value){
		matrix[row-1][col-1]=value;
	}
	/*
	 * （2）取第row行第col列的元素；
	 */
	public double get(int row,int col){
		return matrix[row-1][col-1];
	}
	/*
	 * （3）返回矩阵的列数；
	 */
	public int width() {
		return m;
	}
	/*
	 * （4）返回矩阵的行数；
	 */
	public int  height() {
		return n;
	}
	/*
	 * （5）返回当前矩阵与矩阵b相加后的矩阵；
	 */
	public Matrix add(Matrix b) {
		Matrix c=new Matrix(this.matrix,n,m);
		if(n!=b.n||m!=b.m) {
			throw new IndexOutOfBoundsException();
		}
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				c.matrix[i][j]+=b.matrix[i][j];
			}
		}
		return c;
	}

	/*
	 * （6）返回当前矩阵与矩阵b相乘后的矩阵。
	 */
	public Matrix multiply(Matrix b) {
		if (m != b.n) {
			throw new IndexOutOfBoundsException();
		}
		Matrix c = new Matrix(n, b.m);
		for (int i = 0; i < c.n; i++) {
			for (int j = 0; j < c.m; j++) {
				for (int k = 0; k < m; k++) {
					c.matrix[i][j] += matrix[i][k] * b.matrix[k][j];
				}
			}
		}
		return c;
	}
	/*
	 * （7）返回当前矩阵的转置矩阵；
	 */
	public Matrix transpose() {
		Matrix c=new Matrix(m,n);
		for(int i=0;i<c.n;i++) {
			for(int j=0;j<c.m;j++) {
				c.matrix[i][j]=matrix[j][i];
			}
		}
		return c;
	}
	/*
	 * （8）返回矩阵中的最大值及其所在行和列；
	 */
	public Vector<Point> getMax(){
		Vector<Point> points = new Vector<Point>(100);
		double max=Double.MIN_EXPONENT;
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				if(matrix[i][j]>max) {
					max=matrix[i][j];
				}
			}
		}
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				if(matrix[i][j]==max) {
					Point p = new Point(i, j);
					points.add(p);
				}
			}
		}
		return points;
	}
	/*
	 * （9）以行和列的形式打印出当前矩阵。
	 */
	public void print(){
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				if(j==0) {
					System.out.print(matrix[i][j]);
				}else {
					System.out.print(" "+matrix[i][j]);
				}
			}
			System.out.print("\n");
		}
	}
}

②测试类

package Main;
import java.awt.Point;
import java.util.Vector;

import Matrix.Matrix;
public class Main {

	public static void main(String[] args) {
		int n=2,m=3;
		double [][]arr=new double[10][10];
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				arr[i][j]=(i*i+j*j)%9+1;//随便取的值
			}
		}
		Matrix matrix = new Matrix(arr, n, m);
		System.out.println("打印原始矩阵：");
		matrix.print();
		System.out.println("将第1行第2列元素更改为6，并打印矩阵：");
		matrix.set(1, 2, 6);
		matrix.print();
		System.out.println("获取矩阵第1行第2列元素：");
		System.out.println(matrix.get(1, 2));
		System.out.println("获取矩阵的行数与列数： ");
		System.out.println(matrix.height()+" , "+matrix.width());
		double [][]brr=new double[10][10];
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				brr[i][j]=1;
			}
		}
		Matrix matrix2 = new Matrix(brr, n, m);
		System.out.println("矩阵matrix与matrix2相加，并打印所得矩阵：");
		matrix.add(matrix2).print();
		double [][]crr=new double[10][10];
		for(int i=0;i<m;i++) {
			for(int j=0;j<2*n;j++) {
				crr[i][j]=0;
			}
		}
		Matrix matrix3 = new Matrix(crr, m, 2*n);
		System.out.println("矩阵matrix与matrix3相乘，并打印所得矩阵：");
		matrix.multiply(matrix3).print();
		System.out.println("打印matrix的转置矩阵：");
		matrix.transpose().print();
		System.out.println("获取matrix矩阵的最大值及所在行和列：");
		Vector<Point> points = matrix.getMax();
		System.out.print(matrix.get((int)points.get(0).getX()+1, (int)points.get(0).getY()+1));
		for(Point p:points) {
			System.out.print("\t( "+(int)(p.getX()+1)+", "+(int)(p.getY()+1)+" )");
		}
	}

}