SCAU java实验7 类与类之间的关系

实验7 类与类之间的关系
题目类别: 实验

关键字: 类、对象、封装、聚合、组合

内容要求:

一、实验目的

（1）在理解和掌握类的定义和封装的基础上了解类之间的关系。

（2）理解和掌握this关键字的使用。

二、实验内容

步骤1：按照以下要求编写一个名为Point的类，代表二维坐标系中的一个点。

(1) 放在包ex03中；

(2) 两个int类型的数据域x和y，分别代表点的横、纵坐标；

(3) 对数据域进行封装；

(4) 无参构造方法，初始化的坐标是(0,0)；

(5) 有参构造方法，两个参数x,y分别初始化数据域x和y；

(6) 一个计算两个点之间距离的方法distance(Point other)，返回值类型double，表示当前对象与参数对象之间的距离。

步骤2：按照以下要求编写一个名为Circle的类，代表二维坐标系中的一个圆。

(1) 放在包ex03中；

(2) 一个Point类型的数据域center，代表圆的圆心；

(3) 一个double类型的数据域radius，代表圆的半径；

(4) 对数据域进行封装；

(5) 无参构造方法将圆心坐标设为坐标圆点(0,0)，半径设为1.0；

(6) 有参构造方法需要根据参数值设置圆心坐标和半径值；

(7) 一个计算圆面积的方法double getArea()；

(8) 一个判断当前圆对象与参数圆对象是否相交的方法(相交方式见下图):

boolean isIntersected(Circle other)

(9) 一个判断当前圆对象是否包含参数圆对象的方法(包含方式见下图)：

boolean contains(Circle other)

(10)提供返回当前圆的字符串的方法，返回的字符串格式为：[Circle(x,y)-raduis]

String getCircle()

步骤3：按照以下要求编写一个名为Circles的类，其中包含一个对圆操作的功能。

(1) 放在包ex03中；

(2) 编写静态方法createCircles，

参数：int n，表示生成圆的个数；

返回值：Circle[]，存放生成圆对象的数组；

功能：生成位置和大小均随机的n个圆对象。

(3) 编写静态方法outputCircles，

参数：Circle[]，存放圆对象的数组；

返回值：void

功能：输出数组中所有的圆，每行一个；

(4) 编写静态方法getIsolatedCircles

参数：Circle[] circles

返回值：Circle[]，由符合条件的圆组成的数组

功能：找到参数circles数组中所有孤立的圆，孤立圆是指该圆与数组中其他的圆都不存在相交或包含的关系。

步骤4：按照以下要求编写主类Main, 放在包main中，主方法main实现以下步骤：

(1) 从键盘输入生成圆的个数n；

(2) 生成n个圆对象并存放在数组中；

(3) 输出这n个圆对象；

(4) 找出这n个圆中的孤立圆，存储在数组中；

(5) 输出所有的孤立圆，如果没有输出“无孤立圆”。

提交：打包为可以执行的JAR文档，其中要包含源程序文件。

Point

package ex03;

public class Point {
    private int x;
    private int y;
    Point(){
        x=0;
        y=0;
    }
    Point(int x,int y){
        this.x=x;
        this.y=y;
    }
    double distance(Point other){
        double d=(this.x-other.x)*(this.x-other.x)+(this.y-other.y)*(this.y-other.y);
        d=Math.sqrt(d);
        return d;
    }
    int getX(){
        return this.x;
    }
    int getY(){
        return this.y;
    }
}

Circle

package ex03;

public class Circle {
    private Point center;
    private double radius;
    Circle (){
        center=new Point();
        radius=1.0;
    }
    Circle(int x,int y,double radius){
        center=new Point(x,y);
        this.radius=radius;
    }
    double getArea(){
        return 2*Math.PI*radius*radius;
    }
    boolean isIntersected(Circle other){
        double d=this.center.distance(other.center);
        if(d>(this.radius+ other.radius)||d+other.radius<this.radius){
            return false;
        }else {
            return true;
        }
    }
    boolean contains(Circle other){
        double d=this.center.distance(other.center);
        if(d+other.radius<this.radius&&this.radius>other.radius){
            return true;
        }else {
            return false;
        }
    }
    String getCircle(){
        int x=this.center.getX();
        int y=this.center.getY();
        String reBack="[Circle("+x+","+y+")-"+radius+"]";
        return reBack;
    }
}

Circles

package ex03;

import java.util.Random;

public class Circles {
    static Circle[] createCircles(int n){
        Circle[] reCircle=new Circle[n];
        Random r=new Random();
        for(int i=0;i<n;i++){
            int x=r.nextInt();
            int y=r.nextInt();
            double radius=r.nextDouble();
            reCircle[i]=new Circle(x,y,radius);
        }
        return reCircle;
    }
    static void outputCircles(Circle[] circles){
        for(int i=0;i<circles.length;i++){
            System.out.println(circles[i].getCircle());
        }
    }
    static Circle[] getIsolatedCircles(Circle[] circles){
        Circle[] rightCircles=new Circle[circles.length];
        int num=-1;
        for (int i=0;i<circles.length;i++){
            Circle test=circles[i];
            boolean flag=true;
            for(int j=0;j<circles.length;j++){
                if(i==j){
                    continue;
                }else{
                    flag=test.isIntersected(circles[j])||test.contains(circles[j]);
                }
            }
            if(flag==false){
                num++;
                rightCircles[num]=test;
            }
        }
        return rightCircles;
    }
}

Main

package ex03;
import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner reader=new Scanner(System.in);
        int n;
        System.out.print("请输入生成圆的个数：");
        n=reader.nextInt();
        Circle[] circles;
        circles=Circles.createCircles(n);
        Circles.outputCircles(circles);
        Circle[] alongCircles;
        alongCircles=Circles.getIsolatedCircles(circles);
        System.out.println("-----------------------------------------");
        if(alongCircles[0]==null){
            System.out.println("无孤立圆");
            return;
        }
        for(int i=0;i< alongCircles.length&&alongCircles[i]!=null;i++){
            System.out.println(alongCircles[i].getCircle());
        }

    }
}