SCAU 正n多边形类的定义与使用

冷不防 2023-10-05 15:03 11阅读 0赞

### 随堂实验5 正n多边形类的定义与使用 ###

题目类别: C实验

关键字: 类的定义 封装 可见性修饰符 对象创建与使用 对象数组

内容要求:

一、实验目的

(1)理解对象和类，掌握用类创建对象模型。

(2)理解和掌握数据域封装，可见性修饰符的使用

(3)学习如何定义类和创建对象，理解对象引用变量的概念。

(4)理解构造方法的作用，并使用构造方法创建类的对象。

二、实验内容

按照如下步骤完成实验：

步骤1：

创建一个Java Project，命名为：exp05

步骤2：

一个所有边长度都相同且所有角的度数都相同的多边形称为“正n边形”。

按下面要求定义一个类表示正n边形：

(1) 类名：RegularPolygon，放置在包exp05.shape中；

(2) 一个名为numberOfSides的int型私有数据域，表示多边形的边数，默认值为3；

(3) 一个名为lengthOfSide的double型私有数据域，表示多边形的边长，默认值为1.0；

(4) 一个名为x的double型私有数据域，表示多边形中心点的横坐标，默认值是0.0；

(5) 一个名为y的double型私有数据域，表示多边形中心点的纵坐标，默认值是0.0；

(6) 一个创建带默认值的正多边形对象的无参构造方法，，使用恰当的可见性修饰符修饰；

(7) 一个能创建指定边数和边长度、中心在(0,0)的正多边形对象的构造方法，，使用恰当的可见性修饰符修饰；

(8) 一个能创建指定边数和边长度、中心在(x,y)的正多边形对象的构造方法，，使用恰当的可见性修饰符修饰；

(9) 所有数据域的访问器和修改器；

(10)一个返回正多边形面积的方法：double getArea()，使用恰当的可见性修饰符修饰，面积公式如下：

其中，n是多边形的边数；s是多边形的边长。

(11)一个返回正多边形中心点到坐标原点距离的方法：double getDistance()，使用恰当的可见性修饰符修饰；

(12)覆盖toString方法，返回 “\[边数, 边长\]@(x,y)”形式的字符串；

(13)覆盖equals方法，当多边形对象的中心坐标、边数、边长均相同时，返回true，其他情况返回false；

(14)覆盖hashcode方法，要求：r1.equals(r2)返回为true时，r1.hashcode()与r2.hashcode()的返回值相同。

步骤3：

定义一个主类Main，放置在包exp05.main中，在主类中完成以下工作：

(1) 从键盘输入需要创建的多边形对象的个数n；

(2) 依次输入每个多边形的：边数、边长度、中心坐标，并创建多边形对象；

(3) 输出所有的多边形对象，以 “\[边数, 边长\]@(x,y)”形式；

(4)以 “\[边数, 边长\]@(x,y)”形式输出面积最大的多边形及其面积；

(5)以 “\[边数, 边长\]@(x,y)”形式输出距离坐标原点最近的多边形及其距离。

**Main类**

package exp03.main;
    
    import exp03.shape.RegularPolygon;
    
    import java.util.Scanner;
    
    public class Main {
        
    
        public static void main(String[] args) {
        
            Scanner cin = new Scanner(System.in);
            System.out.println("输入需要创建的多边形对象的个数n:");
            int n = cin.nextInt();
            System.out.println("依次输入每个多边形的：边数、边长度、中心坐标，并创建多边形对象:");
            RegularPolygon[] Re = new RegularPolygon[n];
            for(int i=0;i<n;i++){
        
                int NumberOfSides = cin.nextInt();
                double LengthOfSide = cin.nextDouble();
                double x = cin.nextDouble();
                double y = cin.nextDouble();
                Re[i] = new RegularPolygon(NumberOfSides,LengthOfSide,x,y);
                System.out.println(Re[i].toString());
            }
    
            double maxArea = Re[0].getArea();
            int result = 0;
            for(int i=1;i<n;i++){
        
                if(Re[i].getArea()>maxArea){
        
                    result = i;
                    maxArea = Re[i].getArea();
                }
            }
            System.out.println(Re[result].toString()+"  并且最大面积为："+Re[result].getArea());
    
            double miniDistance = Re[0].getDistance();
            result = 0;
            for(int i=1;i<n;i++){
        
                if(Re[i].getDistance()<miniDistance){
        
                    result = i;
                    miniDistance = Re[i].getDistance();
                }
            }
            System.out.println(Re[result].toString()+"  并最小距离为："+Re[result].getDistance());
    
        }
    }

**RegularPolygon类**

package exp03.shape;
    
    public class RegularPolygon {
        
        private int numberOfSides = 3;
        private double lengthOfSide = 1.0;
        private double x = 0.0;
        private double y = 0.0;
    
        public int getNumberOfSides() {
        
            return numberOfSides;
        }
    
        public void setNumberOfSides(int numberOfSides) {
        
            this.numberOfSides = numberOfSides;
        }
    
        public double getLengthOfSide() {
        
            return lengthOfSide;
        }
    
        public void setLengthOfSide(double lengthOfSide) {
        
            this.lengthOfSide = lengthOfSide;
        }
    
        public double getX() {
        
            return x;
        }
    
        public void setX(double x) {
        
            this.x = x;
        }
    
        public double getY() {
        
            return y;
        }
    
        public void setY(double y) {
        
            this.y = y;
        }
    
        public RegularPolygon(){
        
        }
    
        public RegularPolygon(int numberOfSides, int lengthOfSide){
        
            this.lengthOfSide = lengthOfSide;
            this.numberOfSides = numberOfSides;
        }
    
        public RegularPolygon(int numberOfSides,double lengthOfSide, double x, double y){
        
            this.numberOfSides = numberOfSides;
            this.lengthOfSide = lengthOfSide;
            this.x = x;
            this.y = y;
        }
    
        public double getArea(){
        
            return (numberOfSides*lengthOfSide*lengthOfSide)/4.0*Math.tan(Math.PI/numberOfSides);
        }
    
        public double getDistance(){
        
            return Math.sqrt(x*x+y*y);
        }
    
        @Override
        public String toString(){
        
            return "["+numberOfSides+","+lengthOfSide+"]@("+x+","+y+")";
        }
    
        @Override
        public boolean equals(Object O){
        
            if(O == null) return false;
            if(this.getClass()!= O.getClass()) return false;
            RegularPolygon r = (RegularPolygon) O;
            if(this.x!=r.x || this.y!=r.y||this.lengthOfSide!=r.lengthOfSide||this.numberOfSides!=r.numberOfSides)
                return false;
            return true;
        }
    
        @Override
        public int hashCode(){
        
            int result = hashCode();
            if(result == 0){
        
                result = 17;
                result = 31*result + (int)this.x;
                result = 31*result + (int)this.y;
                result = 31*result + (int)this.lengthOfSide;
                result = 31*result + this.numberOfSides;
            }
            return result;
        }
    }