Java代码实现创建一个Circle类 ，要求有2个实例变量和2个实例函数。

下面是一个简单的Java代码示例，实现了创建一个Circle类，包含2个实例变量和2个实例函数：

public class Circle {
    private double radius;
    private String color;

    public Circle(double r, String c) {
        radius = r;
        color = c;
    }

    public double getRadius() {
        return radius;
    }

    public String getColor() {
        return color;
    }

    public double getArea() {
        return Math.PI * radius * radius;
    }

    public double getCircumference() {
        return 2 * Math.PI * radius;
    }
}

这个Circle类包含了一个构造函数，用于初始化实例变量radius和color。另外，它还包含了两个实例函数getArea和getCircumference，用于计算圆的面积和周长。在这个类中，我们使用了Math.PI常量和radius实例变量来计算这些值。

相关问题

用java创建一个circle类，添加r作为成员变量，计算出元的面积

好的，我可以帮你写一个 Java 的 Circle 类，并添加计算面积的方法。以下是代码示例：

public class Circle {
    private double r;
    
    public Circle(double r) {
        this.r = r;
    }
    
    public double getArea() {
        return Math.PI * r * r;
    }
}

在这个类中，我们定义了一个私有的 double 类型成员变量 `r`，并在构造方法中初始化它。我们还添加了一个公共的方法 `getArea()`，用于计算圆的面积，返回结果为 double 类型。

要使用这个类，你可以创建一个 Circle 对象，并调用它的 `getArea()` 方法来计算面积，如下所示：

Circle c = new Circle(5.0); // 创建一个半径为 5 的圆
double area = c.getArea();  // 计算圆的面积
System.out.println("圆的面积为：" + area);

输出结果为：

圆的面积为：78.53981633974483

列举一个原型模式的java代码实例，所有类写在一个类当中1

好的，以下是一个将所有类都写在一个类中的原型模式的 Java 代码实例：

public class PrototypePatternExample {
    public static void main(String[] args) {
        Circle circle = new Circle(10, 20, 30);
        Circle clonedCircle = circle.clone();
        System.out.println("Original Circle: " + circle.toString());
        System.out.println("Cloned Circle: " + clonedCircle.toString());

        Square square = new Square(5);
        Square clonedSquare = square.clone();
        System.out.println("Original Square: " + square.toString());
        System.out.println("Cloned Square: " + clonedSquare.toString());
    }

    public static abstract class Shape implements Cloneable {
        private int x;
        private int y;

        public Shape(int x, int y) {
            this.x = x;
            this.y = y;
        }

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

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

        public int getX() {
            return x;
        }

        public int getY() {
            return y;
        }

        @Override
        public abstract Shape clone();

        @Override
        public String toString() {
            return "x: " + x + ", y: " + y;
        }
    }

    public static class Circle extends Shape {
        private int radius;

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

        public Circle(Circle circle) {
            super(circle.getX(), circle.getY());
            this.radius = circle.radius;
        }

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

        public int getRadius() {
            return radius;
        }

        @Override
        public Circle clone() {
            return new Circle(this);
        }

        @Override
        public String toString() {
            return super.toString() + ", radius: " + radius;
        }
    }

    public static class Square extends Shape {
        private int side;

        public Square(int x, int y, int side) {
            super(x, y);
            this.side = side;
        }

        public Square(int side) {
            this(0, 0, side);
        }

        public Square(Square square) {
            this(square.getX(), square.getY(), square.side);
        }

        public void setSide(int side) {
            this.side = side;
        }

        public int getSide() {
            return side;
        }

        @Override
        public Square clone() {
            return new Square(this);
        }

        @Override
        public String toString() {
            return super.toString() + ", side: " + side;
        }
    }
}

这里定义了一个 `Shape` 抽象类和两个具体子类 `Circle` 和 `Square`，它们都实现了 `Cloneable` 接口，表示它们支持克隆。`Shape` 类有两个属性：x 和 y，以及一个构造函数和一个抽象的 `clone()` 方法。具体子类 `Circle` 和 `Square` 分别有自己的属性和构造函数，以及重写了 `clone()` 和 `toString()` 方法。在 `Circle` 和 `Square` 的 `clone()` 方法中，调用了它们的复制构造函数来实现克隆。在 `main()` 方法中，我们创建了一个 `Circle` 对象和一个 `Square` 对象，并调用它们的 `clone()` 方法来获取它们的副本，最后输出它们的信息。