We Keep Coding

How to call both abstract methods AND interface methods in an array?

I created an array to hold different shapes. Circle and Square are abstract classes extended from Class Shape. Cube and Sphere are from the interface called ThreeDShape. I need to find the area for all shapes and the area and volume for the 3D shapes and call them using an array. I got the Test class to be able to use the abstract methods. How do I get the test class to use the interface methods? How do I print the abstract methods AND the interface methods in a single array?
I also need to call the details of each class from within the array using the getClass() method.
public class Test {
public static void main(String[] args) {
Shape [] shape = new Shape[4];
Circle circle = new Circle();
shape[0] = circle;
Shape sphere = new Sphere();
shape[1] = sphere;
Shape cube = new Cube();
shape[2] = cube;
Square square = new Square();
shape[3] = square;
for(Shape shape1 : shape) {
System.out.println("The area of " + shape1.getClass() +" is " + shape1.area());
System.out.println("The volume of " + shape1.getClass() +" is " + shape1.volume());
System.out.println("Found in " + shape1.getClass());
System.out.println(" ");
}
}
}
public interface ThreeDShape {
public abstract double volume();
}
public class Cube implements ThreeDShape{
double a = 5;
public double volume() {
return a*a*a;
}
public double area() {
return 6*a*a;
}
}
public class Square extends Shape {
double s = 5;
public double area() {
return s*s;
}
}
public class Circle extends Shape {
double r = 9;
public double area() {
return r*r*3.14;
}
}
public class Sphere implements ThreeDShape {
double r1 = 5;
public double volume() {
return ( 4.0 / 3.0 ) * Math.PI * Math.pow( r1, 3 );
}
public double area() {
return 4*3.14*r1*r1;
}
}
public abstract class Shape {
public abstract double area();
protected abstract double volume();
}
```

Your design is wrong.
Everything should be a subclass of Shape. If you want some specialization then Sphere and Cube should be subclasses of ThreeDShape that is subclass of Shape. So to do what you do you just call a super method of Shape that has different implementation (aka is overwritten) on every subclass.
The loops becomes just this:
for (Shape s: shapes){
s.myBeautifulMethod();
}
If you want to keep ThreeDShape as an interface then Sphere and Cube should be both Shape and ThreeDShape:
public class Sphere extends Shape implements ThreeDShape { [...] }
public class Cube extends Shape implements ThreeDShape { [...]}
but I would stick with a single hierarchy, since otherwiese you are moving forward to multiple inheritance, and this is not very Java.
You are asking for a reflective logic where is not needed at all.
Hope I helped.

If you want to do this, you need to check the type of each shape and cast as you loop through the array. Something like:
for(Shape shape1: shape) {
System.out.println("Area: " + shape1.area());
if(shape1 instanceof ThreeDShape) {
System.out.println("Volume: " + ((ThreeDShape) shape1).volume());
}
}
Generally, type checking and casting like this should be avoided - it probably indicates bad program design. Interfaces and abstract classes are designed for situations where you have multiple types that support the same API. Here, though, you have 2 different APIs: Shape and ThreeDShape.

What I prefer is to avoid instanceOf, getClass and so on
public interface OperationalShape {
double getVolume();
double getArea();
String getName();
boolean supportsVolume();
}
public class Circle implements OperationalShape {
public double getVolume() {
throw new CustomUnsupportedException();
{
public boolean getArea() {
return ...
}
public String getName() {
return "Circle";
}
public boolean supportsVolume() {
return false;
}
}
After that you can iterate on your collection of OperationalShapes, checking with an if(supportsVolume()) if you should call getVolume() or not. You can get the name via getName().

For this code to compile ,
1)You need to change the Shape class to Shape interface. because interface can only implement an interface and not class.
or
2)Change ThreeDShape to class and extends to Shape class
ThreeDShape sphere = new Sphere();
shape[1] = sphere;
1 type implementation
public class Test {
public static void main(String[] args) {
Shape [] shape = new Shape[4];
Circle circle = new Circle();
shape[0] = circle;
ThreeDShape sphere = new Sphere();
shape[1] = sphere;
ThreeDShape cube = new Cube();
cube.volume();
shape[2] = (Shape) cube;
Square square = new Square();
shape[3] = square;
int x = 3;
int z = 1;
for(Shape shape1 : shape) {
System.out.println("The area of the circle is " + shape1.area());
System.out.println("The volume of the circle is " + shape1.volume());
x++;
z++;
System.out.println("Found in " + shape1.getClass());
System.out.println(" ");
}
}
}
interface ThreeDShape extends Shape{
public abstract double volume();
}
class Cube implements ThreeDShape{
double a = 5;
public double volume() {
return a*a*a;
}
public double area() {
return 6*a*a;
}
}
class Square implements Shape {
double s = 5;
public double area() {
return s*s;
}
#Override
public double volume() {
// TODO Auto-generated method stub
return 0;
}
}
class Circle implements Shape {
double r = 9;
public double area() {
return r*r*3.14;
}
#Override
public double volume() {
// TODO Auto-generated method stub
return 0;
}
}
class Sphere implements ThreeDShape {
double r1 = 5;
public double volume() {
return ( 4.0 / 3.0 ) * Math.PI * Math.pow( r1, 3 );
}
public double area() {
return 4*3.14*r1*r1;
}
}
interface Shape{
double area();
double volume();
}

As the other answers mentioned, the design is wrong. This is how I would do it.
If you have to use interface and abstract class in one project, you need to think which of them is more generic. In this class, is Shape or ThreeDShape more generic? Ofcourse, ThreeDShape is a kind of Shape.
Hence, Shape should be an interface and ThreeDShape an abstract class that implements the Shape interface, and not the other way around. An abstract class can implement an interface without actually implementing its methods, but an interface cannot extend an abstract class.
public interface Shape {...}
public abstract class ThreeDShape implements Shape {...}
public class Circle implements Shape {...} // Same for Square
public class Cube extends ThreeDShape {...} // Same for Sphere

How I can implements method from one class in another class

I have class Shape2D, in that class I have method that calculate circle area circleArea, also I have class CircleArea where I store all atributes that I need for my method. Also, my class CircleArea extends class Shape2D. So, How I can implement my method from class Shape2D into class CircleArea.
This is my Shape2D class:
public class Shape2D {
public static void areaCircle(Circle c) {
double circleArea = Math.pow(c.getR(), 2) * Math.PI;
}
}
And this is my Circle class:
public class Circle extends Shape2D {
private double r;
public Circle() {
}
public double getR() {
return r;
}
public void setR(double r) {
this.r = r;
}
}

To implement one of the methods from the Shape2D class in the Circle class, you could do:
Shape2D.areaCircle(circleObject);
The above line can be called in the Circle class. Don't forget to pass in an actual circle object into the function.

You have a static method inside of 2D shape, meaning you can use it in any class without having 2DShape instantiated. This also means that you do not need the circle class to extend 2DShape to use this method, but I imagine you are going for that parent child relationship for the OO paradigm. If you don't want the method to be called from any class, remove static from the method. If you wish to call it statically inside of your Circle class constructor, first instantiate r to something, and then pass it into the static method call.
public class Circle extends Shape2D {
private double r;
public Circle() {
r=1;
Shape2D.areaCircle(this);
}
public double getR() {
return r;
}
public void setR(double r) {
this.r = r;
}
}
Note that your static function doesn't actually return anything, so it calculates the area and the value is lost. You can fix this inside of shape2D by changing the return type of circleArea to double in stead of void, and returning the result appropriately.
public static double areaCircle(Circle c) {
double circleArea = Math.pow(c.getR(), 2) * Math.PI;
return circleArea;
}
or non-statically, and protected in stead of public (either will work)
protected double areaCircle(Circle c) {
double circleArea = Math.pow(c.getR(), 2) * Math.PI;
return cricleArea;
}
If you wanted to do the same thing, but removed the static flag from the method, then you can use super to call parent methods.
public class Circle extends Shape2D {
private double r;
public Circle() {
r=1;
super.areaCircle(this);
}
public double getR() {
return r;
}
public void setR(double r) {
this.r = r;
}
}
Now if you wanted to actually store the area inside of this circleObject, I would create another attribute for the Circle class, and modify your constructor as such. Perhaps even adding a constructor that takes an int argument for radius (or in the future, an area with some way to differentiate the two that can get the radius value).
public class Circle extends Shape2D {
private double r;
private double area;
//Default Constructor
public Circle() {
r=1;
this.area = super.areaCircle(this);
}
//Radius constructor
public Circle(double rad) {
this.r = rad;
this.area = super.areaCircle(this);
}
public double getR() {
return r;
}
public void setR(double r) {
this.r = r;
}
}
It's also worth mentioning that you should look at the scope of these methods you create, and what you are trying to accomplish with them. For instance, you have your circleArea method defined as public, when it could be defined as protected and function similarly for this case. Protected means that the method can be used inside of the class, as well as all subclasses (children of the parent class, like circle). You can read information about these closures here. Also, when working with object inheritance, you should get into the habit of using the this keyword to reference which methods/attributes you actually wish to retrieve. Info on this keyword.
I realize this is a lot to take in, but if you have any questions feel free to comment!

Making a variable final and static in one subclass, while keeping it variable in others in Java

I have a superclass and two subclasses that extend it. I'd like to initialize a variable called radius which can be set freely in subclass A, but is always the same for subclass B. I could initialize the variable every time I create an object B, but I was wondering if it's possible to make the variable final and static in subclass B, while still being able to implement a getter in my superclass. I might implement more subclasses which have a radius that's either final or variable. If not I'm wondering what would be the most elegant solution for my problem. Here is some sample code which works, but isn't very great.
abstract class SuperClass {
public double getRadius() {
return this.radius;
}
protected double radius;
}
class A extends SuperClass{
public void setRadius(double radius) { // Would like to put this setter in SuperClass for future subclasses.
this.radius = radius;
}
}
class B extends SuperClass{
public B() {
radius = 0.2; //Want to make this static and final only for this subclass.
}
}

Making a variable final and static in one subclass, while keeping it
variable in others in Java
Technically, you cannot do it.
A field is either a static field or an instance field, not both.
As alternative, override getRadius() in the B class where you want to provide a different value :
#Override
public double getRadius() {
return 0.2;
}
And to make this constant respected, you should also override the setter in this B class:
#Override
public void setRadius(double radius) {
throw new UnsupportedOperationException();
}

Why dont you try this:
Make the Variable private in the superclass.
Have a getter and setter method in the superclass.
Override the setter method in the subclass so that is is not possible to change the variable.
Like that:
abstract class SuperClass {
private double radius;
public double getRadius() {
return this.radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
}
class A extends SuperClass{
}
class B extends SuperClass{
public B() {
super.setRadius(0.2d);
}
#Override
public void setRadius(double radius) {
throw new UnsupportedOperationException("My Info Text");
}
}

Another approach would be to have the base class in its own package, with a protected setter:
package sandbox.radius.base;
public class Radius {
private double radius;
public double getRadius() {
return radius;
}
protected void setRadius(double radius) {
this.radius = radius;
}
}
Then implementations in a different package, exposes the setter only where appropriate, delegating to super:
package sandbox.radius;
import sandbox.radius.base.Radius;
public class FixedRadius extends Radius {
public FixedRadius() {
setRadius(0.2);
}
}
and
package sandbox.radius;
import sandbox.radius.base.Radius;
public class MutableRadius extends Radius {
public void setRadius(double radius) {
super.setRadius(radius);
}
}
So the API is cleaner:
public class RadiusApp {
public static void main(String[] args) {
FixedRadius fr = new FixedRadius();
fr.getRadius();
// fr.setRadius(1.0); //compile error
MutableRadius mr = new MutableRadius();
mr.getRadius();
mr.setRadius(1.0);
}
}

can we just declare constructor in parent class and define it in another class in java?

class Rad{
public double p=10,a;
Rad();
}
class Area{
Rad(){
a=3.14*p*p;
System.out.println(a);
}
public static void main(String args[]){
Rad o=new Rad();
}
}
SOMETHING LIKE THIS BUT IT'S NOT WORKING;CAN I GET PROVIDED WITH SOLUTION||||

The only possible constructors in Area are Area constructors, but the empty Area constructor overrides the empty Rad constructor (if Area is a subclass of Rad). Something like,
class Rad {
public double p = 10, a;
protected Rad() { // <-- only visible to subclasses.
}
}
Also, I wouldn't print in the constructor; instead override toString and print the instance you have created. Something like,
class Area extends Rad { // <-- a subclass of Rad.
public Area() {
a = Math.PI * p * p;
}
#Override
public String toString() {
return String.valueOf(a);
}
public static void main(String args[]) {
Rad o = new Rad();
System.out.println(o);
}
}

No you cannot...Constructors must be defined in their own class...not their parent's and not their children's

How to use circle.java to calculate getVolume of a cylinder. [2 classes]

edit2
Sorry never mind I just added
public double cylinderSurfaceArea() {
return 2 * base.circleArea() + base.circleCirumference() * 2 * height;
}
}
With no error codes. This would be correct?
edit:
Thank you to all those who have answered. I have since changed my previous Cylinder class to read. Now I want to take it a step further and add
public double cylinderSurfaceArea() {
return 2 * Math.PI * radius * radius + 2 * Math.PI * radius * h;
}
However it now says that radius (or even r) returns an error "cannot find symbol - variable radius). Shouldn't the symbol be found/declared from the Circle class?
What I am trying to do is calculate the volume of a cylinder using a separate Circle.java class.
So for instance, I have the following so far for my circle.java
public class Circle {
public double radius;
public Circle(double r) {
radius = r;
}
public double circleArea() {
return Math.PI * radius * radius;
}
public double circleCirumference() {
return Math.PI * 2 * radius;
}
}
Now here are where the questions start. When making the Cylinder class do I start with:
public class Cylinder extends Circle {
If so, overall I have:
public class Cylinder extends Circle {
public Circle base;
public double height;
public Cylinder(double r, double h) {
height = h;
base = new Circle(r);
}
public double getVolume() {
return base.circleArea * height;
}
}
However, I keep getting an error after:
public Cylinder(double r, double h) {
Stating that:
constructor Circle in class Circle cannot be applied to given types; required:double; found: noarguments; reason:actual and formal arguments lists differ in length."
Can someone push me in the right direction? What am I doing wrong?

That happens because the first call of you constructor is implicit super()
Quote from the Java Tutorials:
If a constructor does not explicitly invoke a superclass constructor, the Java compiler automatically inserts a call to the no-argument constructor of the superclass. If the super class does not have a no-argument constructor, you will get a compile-time error.
You need to make a parameterless constructor in your Circle class or change your Cylinder constructor like this:
public Cylinder(double r, double h) {
super(r);
height = h;
}

You're implicitly calling the super constructor with no argument, but there's no such constructor.
But you have a design problem : You're trying to use both composition and inheritance. One would be enough.
Using inheritance :
public class Cylinder extends Circle {
public double height;
public Cylinder(double r, double h) {
super(r);
height = h;
}
public double getVolume() {
return circleArea() * height;
}
}
Using composition (almost always better) :
public class Cylinder {
public Circle base;
public double height;
public Cylinder(double r, double h) {
height = h;
base = new Circle(r);
}
public double getVolume() {
return base.circleArea * height;
}
}

You don't need an explicit base field in Java when using inheritance. To initialise the base class (or "superclass"), you need to use the super statement in your child class constructor:
class Circle {
public Circle(double radius) {
// …
}
}
class Cylinder extends Circle {
public Cylinder(double radius, double height) {
super(radius); // calls the parent class constructor
// …
}
}
Alternately, you could use composition instead of inheritance - probably a better design in this case:
class Circle {
public Circle(double radius) { /* … */ }
}
class Cylinder { // no `extends` here
public Cylinder(Circle base, double height) {
// …
}
public Cylinder(double radius, double height) {
this(new Circle(radius)); // calls the above constructor
// …
}
}
(I'm omitting trivial assignments and fields in the above code sample for brevity.)

Problem 1:
The problem in your program is no default constructor present in your Circle. While creating the Cylinder object its looking for the default constructor in Circle.
if you modify your Circle as below it will work
class Circle {
public Circle(){
}
}
problem 2
There is "base.circleArea" method only present in Circle, you have forgot "()"
base.circleArea need to change to base.circleArea().
public class Cylinder extends Circle {
public double getVolume() {
return base.circleArea() * height;
}
}
Problem 3
Your Cylinder should be like below. You are already extended circle so no need to create variable Circle base inside Cylinder.
class Cylinder extends Circle {
public double height;
public Cylinder(double r, double h) {
super(r);
height = h;
}
public double getVolume() {
return circleArea * height;
}
}