XMU JAVA第二次实验报告

XMU JAVA第二次实验报告

最大子方阵

题目：

给定一个由0,1组成的n*n方阵（n在运行时提醒用户输入），判断其中由全1组成的最大子方阵的左上角位置和阶数。例如用户输入n为5，随机产生的方阵如下：

程序的输出为：
最大子方阵位于(2,2)，阶数3。

要求编写方法实现上述功能，返回值是一个包含3个元素的数组，依次表示行下标，列下标，阶数。
方法原型：public static int[] findLargestBlock(int[][] m)

思路：

程序一共分为两个步骤，第一步为产生随机方阵，第二步为寻找最大子方阵。

产生随机方阵封装在 public static int[][] creatmatrix(int n) 方法里，给定一个n，产生一个n*n的矩阵。

产生随机数的方法为： m[i][j]=(int)(Math.random()*10)%2;

寻找最大子方阵封装在 public static int[] findLargestBlock(int[][] m) 方法里。

二维数组遍历出最大的那个方阵，我们假定有一个盒子，盒子的大小为最大子方阵的长度，因为需要返回盒子最大的数组，我们就由大到小进行遍历。区间为【1，二维数组的长度】，然后我们必须不断的移动盒子进行判断是否为最大子方阵，包括向右移动和向下移动二重循环。判断是最大子方阵的方法是将盒子中的数累加，最后等于盒子的面积，则返回。

代码：

package com.company;
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.println("请输入方阵维数n：");
        int n=input.nextInt();
        int[][] m = creatmatrix(n);
        int[] a=new int[3];
        a=findLargestBlock(m);
        System.out.print("\n");
        System.out.println("最大子方阵位于：("+a[0]+","+a[1]+")");
        System.out.println("阶数："+a[2]);
    }

    //产生一个n*n矩阵，元素为0或1,输出打印
    public static int[][] creatmatrix(int n){
        int[][] m = new int[n][n];
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                m[i][j]=(int)(Math.random()*10)%2;
                System.out.print(m[i][j]+"\t");
            }
            System.out.print("\n");
        }
        return m;
    }

    //找到最大的全为1的矩阵块
    public static int[] findLargestBlock(int[][] m){
        int n = m.length;
        int[] a = new int[3];
        for (int z=n;z>0;z--){  //第一重循环，盒子的长度
            for (int i=0;i<=n-z;i++){  //往右往下移动盒子
                for (int j=0;j<=n-z;j++){
                    int sum = 0;
                    for (int i2=i;i2-i<z;i2++){
                        for (int j2=j;j2-j<z;j2++){
                            sum += m[i2][j2];
                        }
                    }
                    if (z * z == sum) {
                        a[0] = i; a[1] = j; a[2] = z;
                        return a;
                    }
                }
            }
        }
        return a;
    }
}

效果：

二次方程类

题目要求：

设计一个二次方程类QuadraticEquation，用于处理形如ax2 + bx + x = 0 (a≠0)的二次方程，成员如下：
私有成员a, b, c用于存储系数；
含三个参数的构造方法，用于传入a, b, c；
三个方法getA(), getB(), getC()，用于传出系数；
一个方法getDiscriminant()用于传出b2 - 4ac的值；
两个方法getRoot1()和getRoot2()用来返回方程的两个根。注意方程可能没有实根，所以返回值定义为String。
请提供一个测试类，测试上述所有方法。

设计思路：

类的封装让求根更加遍历，同时保护了私有成员。通过接口给外界提供了访问他的路口。

代码：

package com.company;
import java.util.*;
class QuadraticEquation{
    private double a,b,c;
    QuadraticEquation(){this(1,0,0);}
    QuadraticEquation(double a,double b,double c){
        this.a = a; this.b = b; this.c = c;
    }
    public double getA(){ return a; }
    public double getB(){ return b; }
    public double getC(){ return c; }
    public double getDiscriminant(){ return b*b-4*a*c;}
    public String getRoot1(){
        String s=String.valueOf((-b+Math.sqrt(getDiscriminant()))/(2*a));
        return s;
    }
    public String getRoot2(){
        String s=String.valueOf((-b-Math.sqrt(getDiscriminant()))/(2*a));
        return s;
    }
    public void solveEq(){
        if(getDiscriminant()<0){
            System.out.println("方程无解");
        }
        else if(getDiscriminant()==0){ //只有一个解
            System.out.println("x1=x2="+getRoot1());
        }
        else{  //两个解
            System.out.println("x1="+getRoot1());
            System.out.println("x2="+getRoot2());
        }
    }
}
//测试类
public class Main {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.print("a=");
        double a=input.nextDouble();
        System.out.print("b=");
        double b=input.nextDouble();
        System.out.print("c=");
        double c=input.nextDouble();
        QuadraticEquation eq=new QuadraticEquation(a,b,c);
        System.out.println("a="+eq.getA());
        System.out.println("b="+eq.getB());
        System.out.println("c="+eq.getC());
        System.out.println("b^2-4*a*c="+eq.getDiscriminant());
        System.out.println("root1 ="+eq.getRoot1());
        System.out.println("root2 ="+eq.getRoot2());
        System.out.println("方程组的解为:");
        eq.solveEq();
    }
}

效果：

2*2线性方程组

题目要求：

设计一个类LinearEquation用于处理如下的2*2线性方程组，成员包含：
私有成员a,b,c,d,e,f；
一个6参数构造方法，用于传入a,b,c,d,e,f；
6个getter用于返回a,b,c,d,e,f，例如getA(), getB(),…；
一个方法isSolvable()用于判定方程是否有解，有则返回true，否则false；
方法getX()和getY()返回一组解。
请提供一个测试类，测试上述所有方法。

设计思路：

题目很容易，谈谈封装，封装就是将一类事物的属性和行为抽象成一个类，使其属性私有化，行为公开化，提高了数据的隐秘性的同时，使代码模块化。这样做使得代码的复用性更高。

代码：

package com.company;
import java.util.*;
class LinearEquation{
    private double a,b,c,d,e,f;
    LinearEquation(double a,double b,double c,double d,double e,double f){
        this.a = a;this.b = b;this.c = c;
        this.d = d;this.e = e;this.f = f;
    }
    public double getA(){ return a;}
    public double getB(){ return b;}
    public double getC(){ return c;}
    public double getD(){ return d;}
    public double getE(){ return e;}
    public double getF(){ return f;}
    public boolean isSolvable(){
        if((a*d - b*c)<=1e-6) {
            return false;
        }else{
            return true;
        }
    }
    public String getX(){
        if(isSolvable())  return String.valueOf((e*d-b*f)/(a*d-b*c));
        else return "无解";
    }
    public String getY(){
        if(isSolvable())  return String.valueOf((a*f-e*c)/(a*d-b*c));
        else return "无解";
    }
}
public class Main {

    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.print("a=");
        double a=input.nextDouble();
        System.out.print("b=");
        double b=input.nextDouble();
        System.out.print("c=");
        double c=input.nextDouble();
        System.out.print("d=");
        double d=input.nextDouble();
        System.out.print("e=");
        double e=input.nextDouble();
        System.out.print("f=");
        double f=input.nextDouble();
        LinearEquation ll=new LinearEquation(a,b,c,d,e,f);
        System.out.println("a="+ll.getA());
        System.out.println("b="+ll.getB());
        System.out.println("c="+ll.getC());
        System.out.println("d="+ll.getD());
        System.out.println("e="+ll.getE());
        System.out.println("f="+ll.getF());
        System.out.printf("%.2fx+%.2fy=%.2f\n", a,b,e);
        System.out.printf("%.2fx+%.2fy=%.2f\n", c,d,f);
        System.out.println("isSovable="+ll.isSolvable());
        System.out.println("X="+ll.getX());
        System.out.println("Y="+ll.getY());
    }
}

效果：

Location类

题目要求：

定义一个Location类，用于搜索二维数组的最大元素出现的位置和值。位置用公有的整型成员变量row, col表示，最大值用公有的浮点型成员变量maxValue表示。一个成员方法用来求解二维数组的最大元素及其位置，原型如下：
public static Location locateLargest(double[][] a)
例如数组为{{1,2,3},{8,9,9,5},{4,3,5,7,8}}，最大元素为9，位置是(1,1)。注意最大值不止一个的时候，只记录第一次出现的位置。
请提供一个测试类，测试上述方法。

设计思路：

面向对象练习

代码：

package com.company;
import java.util.*;
class Location{
    public int row,col;
    public double maxValue;
    Location(){}
    Location(int row,int col,double maxValue){this.row=row;this.col=col;this.maxValue=maxValue;}
    public static Location locateLargest(double[][] a){
        double maxValue=a[0][0];
        int row=0,col=0;
        for(int i=0;i<a.length;i++)
            for(int j=0;j<a[i].length;j++){
                if(a[i][j]>maxValue){
                    row = i; col = j; maxValue = a[i][j];
                }
            }
        Location l=new Location(row,col,maxValue);
        return l;
    }
}
public class Main {

    public static void main(String[] args) {
        Location l=new Location();
        l=l.locateLargest(creatArray());
        System.out.println("行:"+l.row);
        System.out.println("列:"+l.col);
        System.out.println("最大值:"+l.maxValue);
    }
    //创建一个数组
    public static double[][] creatArray(){
        Scanner in = new Scanner(System.in);
        System.out.println("请输入行数：");
        int r=in.nextInt();
        double [][]a = new double[r][];
        for(int i=0;i<r;i++){
            System.out.println("请输入第"+i+"行的列数：");
            int c=in.nextInt();
            a[i]=new double[c];
        }
        System.out.println("请输入数组");
        for(int i=0;i<r;i++){
            for(int j=0;j<a[i].length;j++){
                a[i][j]=in.nextDouble();
            }
        }
        return a;
    }
}

效果：