3、按要求编程：（1）定义一个圆类Circle，该圆类的数据成员包括：圆心点位置及圆的半径；方法成员有：设置圆心位置和半径的方法，获取圆心位置和半径的方法，无参的构造方法初始化圆心位置为(0,0)，半径为1。另外定义一个构造方法可以接收圆心位置与半径的参数。编写测试类创建Circle类的对象，并且分别调用各种方法，对比这些方法的执行结果。（2）定义一个矩形类MyRectangle，类中有4个私有的整型变量，分别是矩形的左上角坐标(xUp,yUp)和右下角坐标(xDown,yDown)；类中定义没有参数的构造方法和有4个int参数的构造方法，用来初始化类对象。类中还有以下方法：getw()—一计算矩形的宽度;getH()——计算矩形的高度；area()—计算矩形的面积；toString()—把矩形的宽、高和面积等信息作为为宇符串返回。编写代码创建MyRectangle类的对象并输出矩形对象的信息。（3）设计一个长方体类MyCube，该类包含第2题中的MyRectangle类对象作为类的成员变量，表示长方体的底面；此外还包含一个整型变量d，表示长方体的高。类中定义构造方法初始化类对象、定义求体积和表面积的方法。编写代码测试MyCube类。（4）对于第2、3题的类分别用类的访问修饰符public与无修饰符定义，同时把它们声明在同一个包中、不同的包中，分析程序的编译情况，理解类及其成员的访问控制符的作用。

(1) Circle类的代码实现：

public class Circle {
    private double x; // 圆心x坐标
    private double y; // 圆心y坐标
    private double radius; // 圆的半径

    public Circle() {
        x = 0;
        y = 0;
        radius = 1;
    }

    public Circle(double x, double y, double radius) {
        this.x = x;
        this.y = y;
        this.radius = radius;
    }

    public void setX(double x) {
        this.x = x;
    }

    public void setY(double y) {
        this.y = y;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }

    public double getRadius() {
        return radius;
    }

    public static void main(String[] args) {
        Circle c1 = new Circle();
        System.out.println("圆心坐标为：" + c1.getX() + "," + c1.getY());
        System.out.println("圆的半径为：" + c1.getRadius());

        Circle c2 = new Circle(2, 3, 4);
        System.out.println("圆心坐标为：" + c2.getX() + "," + c2.getY());
        System.out.println("圆的半径为：" + c2.getRadius());
    }
}

(2) MyRectangle类的代码实现：

public class MyRectangle {
    private int xUp; // 左上角x坐标
    private int yUp; // 左上角y坐标
    private int xDown; // 右下角x坐标
    private int yDown; // 右下角y坐标

    public MyRectangle() {
    }

    public MyRectangle(int xUp, int yUp, int xDown, int yDown) {
        this.xUp = xUp;
        this.yUp = yUp;
        this.xDown = xDown;
        this.yDown = yDown;
    }

    public int getxUp() {
        return xUp;
    }

    public void setxUp(int xUp) {
        this.xUp = xUp;
    }

    public int getyUp() {
        return yUp;
    }

    public void setyUp(int yUp) {
        this.yUp = yUp;
    }

    public int getxDown() {
        return xDown;
    }

    public void setxDown(int xDown) {
        this.xDown = xDown;
    }

    public int getyDown() {
        return yDown;
    }

    public void setyDown(int yDown) {
        this.yDown = yDown;
    }

    public int getW() {
        return Math.abs(xDown - xUp);
    }

    public int getH() {
        return Math.abs(yDown - yUp);
    }

    public int area() {
        return getW() * getH();
    }

    public String toString() {
        return "宽度：" + getW() + "，高度：" + getH() + "，面积：" + area();
    }

    public static void main(String[] args) {
        MyRectangle rect = new MyRectangle(1, 2, 3, 4);
        System.out.println(rect.toString());
    }
}

(3) MyCube类的代码实现：

public class MyCube {
    private MyRectangle bottom; // 底面矩形
    private int height; // 高

    public MyCube() {
    }

    public MyCube(MyRectangle bottom, int height) {
        this.bottom = bottom;
        this.height = height;
    }

    public void setBottom(MyRectangle bottom) {
        this.bottom = bottom;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public MyRectangle getBottom() {
        return bottom;
    }

    public int getHeight() {
        return height;
    }

    public int getVolume() {
        return bottom.area() * height;
    }

    public int getSurfaceArea() {
        return 2 * bottom.area() + 2 * bottom.getW() * height + 2 * bottom.getH() * height;
    }

    public static void main(String[] args) {
        MyRectangle bottom = new MyRectangle(1, 2, 3, 4);
        MyCube cube = new MyCube(bottom, 5);
        System.out.println("长方体的底面为：" + cube.getBottom().toString());
        System.out.println("长方体的高为：" + cube.getHeight());
        System.out.println("长方体的体积为：" + cube.getVolume());
        System.out.println("长方体的表面积为：" + cube.getSurfaceArea());
    }
}

(4) 对于第2、3题的类分别用类的访问修饰符public与无修饰符定义，同时把它们声明在同一个包中、不同的包中的代码实现：

Circle类：

// 不同包中，访问权限为public
package com.example.shape;

public class Circle {
    // 省略代码
}

// 同一个包中，访问权限为默认
package com.example.shape;

class Circle {
    // 省略代码
}

MyRectangle类：

// 不同包中，访问权限为public
package com.example.shape;

public class MyRectangle {
    // 省略代码
}

// 同一个包中，访问权限为默认
package com.example.shape;

class MyRectangle {
    // 省略代码
}

MyCube类：

// 不同包中，访问权限为public
package com.example.shape;

public class MyCube {
    // 省略代码
}

// 同一个包中，访问权限为默认
package com.example.shape;

class MyCube {
    // 省略代码
}

在同一个包中，类的访问权限为默认时，类可以被同一个包中的其他类访问；在不同的包中，类的访问权限为public时，类可以被其他包中的类访问。如果类的访问权限为默认，则只能在同一个包中访问。如果将类的访问权限改为private，则只能在该类中访问，其他类均无法访问。因此，类及其成员的访问控制符的作用是控制类及其成员的访问范围。