I have a question about polymorphism in Java. I have a abstract base class Shape and two derived classes Rectangle and Circle. I know that I can call overridden methods in Circle and Rectangle class with a Shape class reference but what if I have a method that Shape class doesn't have but Circle class has. How can I use polymorphism in this situation?
You cannot use polymorphism in this situation. The very idea of polymorphism is that you can use an object in a specified way irrespective of its actual shape (specific object type). By requiring access to a method that is unique to (literally) a specific shape, you must forego polymorphism.
(The above argument would not apply if Circle actually had subclasses, in which case you could polymorphically call these methods, but this is just moving the argument somewhere else.)
This happens all the time. The answer is that you need to cast your Shape to a Circle to access the method
Shape s = ...;
if (s instanceof Circle) {
((Circle)s).foo(); //method only on Circle
}
If you store a Circle in a Shape instance, you can invoke Circle methods on s by casting s to Circle:
Shape s = new Circle();
...
if ( s.instanceof(Circle) ) {
((Circle)s).circleMethod();
}
Apart from the casting solution suggested by other answers, if you think all subclasses of Shape should provide that method but you can't/don't want to implement it on Shape, you can declare the method as abstract and implement the method in Circle and Rectangle.
public abstract class Shape {
public abstract void foo();
}
public class Circle extends Shape {
public void foo() {
// Implementation
}
}
then you can do:
Shape s = new Circle();
s.foo();
I'm using a Processing library to build my project in Java. I use a function that returns me an object of type PShape (which I don't have access to source).
I need to make this object of type Shape (a class I designed that extends PShape).
How can I make that?
Basically I have:
PShape pShape = loadShape(filename);
Where loadShape is a function I don't have access to source code.
I want to somehow do:
class Shape extends PShape {...}
and then
Shape shape = (Shape) loadShape(filename);
But it won't work, once loadShape() will give me a PShape, not a Shape
How can I make loadShape returns a Shape?
Thank you
If loadShape() returns a PShape, then it returns a PShape. You can't make it return a subclass of PShape.
Easiest approach would be Shape either copies the PShape into a new instance:
e.g.
Shape myLoadShape(String filename)
{
return new Shape(loadShape(filename));
// Assumes you have a `Shape(PShape)` constructor.
}
or perhaps Shape isn't a subclass, but it contains a PShape data member.
class Shape
{
// No one picked up my C++ syntax goof ;-)
protected PShape pshape;
// Using a constructor is just one way to do it.
// A factory pattern may work or even just empty constructor and a
// load() method.
public Shape(String filename)
{
pshape = loadShape(filename);
// Add any Shape specific setup
}
}
I'm writing a simple Asteroids-clone game, using Swing to display the graphics. I'm kind of following Derek Banas' tutorials, but decided to expand on my own.
The original idea is that every graphic element in the game (i.e. the Asteroids, the Spaceship and the Bullets) extends the Polygon class. Their constructor would look something like this:
public class SpaceShip extends Polygon {
//x and y coordinates
public static int[] polyXArray = {...};
public static int[] polyYArray = {...};
//other class variables
{...}
public SpaceShip() {
super(polyXArray, polyYArray, polyXArray.length);
}
}
And it will be similar for the other graphic elements.
EDIT: The key element here is that the two arrays don't store the actual coordinates of the objects, but their position relative to their centre, whose coordinates are double-type class-variable. Thus, the arrays describe just the shape of the object, while the subclass move() method will affect the centre's coordinates. The class responsible for the actual drawing will call the move() method and then apply an affine transform to move and rotate the shape (according to a properly defined angle parameter). I'm doing this to avoid precision problems related to dealing with double arithmetic.
Now, since the elements share a lot of "equal" variables (their centre coordinates, which I need in order to translate them with an affine transform, their speed components etc...) and methods (getters and setters, move() methods, etc...) I thought about making them be the extension of an abstract class - say, GameShape - which holds all these common methods and variables. GameShape would now be the one extending Polygon directly:
public abstract class GameShape extends Polygon {
//x and y coordinates, still unassigned
public static int[] polyXArray, polyYArray;
//other class variables
{...}
public GameShape() {
super(polyXArray, polyYArray, polyXArray.length);
}
}
Then, I'd want to assign the desired value to polyXArray and polyYArray when I define the different subclasses in order to draw the different shapes I need, but I haven't been able to find a way to do it.
I do want those variable to be static because they are specific properties of the single classes, and I wouldn't want to pass them as a parameter every time I instantiate a new object.
My situation is very similar to the one described in this question, but the proposed solution doesn't seem to work, since I need those very variables in the constructor. Is there a way to get over - or around - this problem? Regardless of the procedure, my main aim is to have a superclass common to all the graphic elements, in order to avoid tens of lines of copy-pasted code.
You have pairs of arrays that describe the shapes of specific kinds of game objects. If different game objects can have different shapes, then they cannot all share a single pair of arrays, as would be the case if they were static properties of a common superclass of all the game object classes. Different objects of the same kind can share the same pair of arrays (supposing that those don't need to be modified on a per-object basis), which could correspond to those arrays being static fields of the concrete game object classes. In that case, however, if you want a superclass of those classes to be able to access the correct shape data for a given game object, then it has to be told what those shape data are.
There are two main ways you could do that:
You could pass the appropriate shape arrays to the superclass's constructor. You say you don't want to do this, but I don't understand why.
You could define accessor methods on the superclass that the subclasses are supposed to override to provide the correct shape data (this is called the Template Method pattern).
The solution from this question will work if your classes will NOT extend shape, but provide shapes via accessor + private static field.
public abstract class GameObject {
...
public abstract Polygon getShape();
This also helps to escape shapes duplication.
If you really do want to initialize things in your constructor, just call the empty super(); and then loop against abstract getPolyXArray() and getPolyYArray() to feed addPoint.
public abstract class GameShape extends Polygon {
public GameShape() {
super();
final int length = getPolyXArray().length;
for (int i = 0; i < length; i++) {
addPoint(getPolyXArray()[i], getPolyYArray()[i]);
}
}
public abstract int[] getPolyXArray();
public abstract int[] getPolyYArray();
//common stuff...
}
public class Asteroids extends Polygon {
public int[] getPolyXArray() { return new int[]{1, 2, 3}; }
public int[] getPolyYArray() { return new int[]{1, 2, 3}; }
}
The array fields cannot be static because different shapes have different coordinates. Also you don't need these arrays in the specific subclasses because they are already in Polygon or GameShape.
Here is more-or-less how I would write GameShape (although I agree with #Michael that you don't need to pass both polyXArray and polyXArray.length to the constructor).
public abstract class GameShape extends Polygon {
// I got rid of the array fields as I think they are in Polygon anyway.
//other class variables
{...}
// I added arguments to your constructor.
public GameShape(int[] polyXArray, int[] polyYArray) {
super(polyXArray, polyYArray, polyXArray.length);
}
}
The trouble is that super must be the first line of a constructor, but you can do it using private methods to build the arrays:
public final class BoringRectangle extends GameShape {
public BoringRectangle(int left, int right, int top, int bottom) {
super(xArray(left, right), yArray(top, bottom));
}
private static int[] xArray(int left, int right) {
return new int[] {left, right, right, left};
}
private static int[] yArray(int top, int bottom) {
return new int[] {bottom, bottom, top, top};
}
}
I would think that polyXArray and polyYArray reside in the Polygon class; that's where they belong. Therefore it's not a good idea to have duplicate fields. Also, get rid of the ned to call the super constructor. I would design the class structure like this:
public class SquareShape extends Polygon {
private int size;
public SquareShape(int x, int y, int size) {
this.size = size;
int[] xpoints = new int[4]{
x - size / 2,
x - size / 2,
x + size / 2,
x + size / 2
};
int[] ypoints = new int[4]{
y - size / 2,
y + size / 2,
y + size / 2,
y - size / 2
};
setXArray(xpoints);
setYArray(ypoints);
}
}
This way, you can ensure that all SquareShape objects do indeed have a square shape, but you can customize things you should be able to customize. Like position and size, which should not be static shared fields. setXArray and setYArray should be protected methods residing in Polygon. You don't want the outside world messing with the individual points. You can add public getters, although.
NOTE
You may want to consider using a single array of a complex Point type, rather then two tightly coupled and dependent arrays. I feel like this will greatly simplify a lot of tasks in your project.
EDIT:
As VGR stated in the comments, this will not compile. So, we will have to change the implementation a little, namely, we will use the HAVE relationship instead of IS relationship :-)
First of all, do not make the poly array fields static. If you do, they will be the same for all of the subclasses as well, so what is the point?
Secondly, use a template method design pattern here. Your class will look something like this:
public abstract class GameShape {
//x and y coordinates, still unassigned
public int[] polyXArray, polyYArray;
private Polygon polygon;
//other class variables
{...}
public GameShape() {
instantiatePolyArrays();
this.polygon = new Polygon(polyXArray, polyYArray, polyXArray.length);
}
protected abstract void instantiatePolyArrays();
public final Polygon getPolygon(){
return this.polygon;
}
}
Every extending class will have to override this method and you can instantiate the arrays for each of the classes in each of the method overrides.
Also, a word about the IS-HAVE relationship problem - what you presented in your example is a IS relationship, in which the GameShape object IS a Polygon, hence the need to call the super constructor and the problem with that. In my solution this is replaces by a HAVE relationship, in which the GameShape object HAS a Polygon object inside, accessed with a getPolygon() method. This allows you to have lots of additional flexibility :-)
I have a Point object that holds coordinates, I then use that Point in the creation of two other objects, a Triangle and a Circle, then inside circle object I translate that point. It also translates the point in the triangle class. Why is this? Have I just set up two variables to access the same object rather than have a 'copy' of that object in both shapes? How can I amend this?
I create the point in the main class then pass that point onto the constructors of both the Circle and Triangle classes which then assign it to a property of that class.
So it's like this:
//main class
Point p = new Point(50,50);
Circle c = new Circle(p);
Triangle t = new Triangle(p);
c.translate(20,30); //also translates the triangles point
//Circle class
public Circle(Point p) {
this.p = p;
}
//Triangle class
public Triangle(Point p) {
this.p = p;
}
Yes, you passed two references to the same Point object to Circle and Triangle.
To avoid this, there are basically two solutions:
create a copy of the Point object (either before passing it to Triangle and Circle, or in the constructor of those two classes, to make sure they use a different instances)
make the Point class immutable (all fields final, no setter), to make sure nobody can ever modify a Point. To translate a point, you would then be forced to create a new Point, with new coordinates. This is much safer, because you can't forget to make a copy. The immutability guarantees that the point can be shared between shapes without any way for them to modify each other by modifying their points.
The constructors for both your Circle and Triangle classes just assign the Point they are given to a data member. In this way, you're storing a reference to the same object, and every time it's manipulated, it will effect all references to it.
A safer way of handling such situations is, as you suggested, to copy the object passed to the constructor. E.g.:
//Circle class
public Circle(Point p) {
this.p = new Point(p.getX(), p.getY());
}
Alternatively, if you defined Point as clonable:
//Circle class
public Circle(Point p) {
this.p = p.clone();
}
Your making one instance of the Point object and making references to that one Point object in the Circle and Triangle object instances. The translate method modifies that Point object.
I have a class called Shape that is abstract, and a class named Circle that extends Shape
Shape shapeCircle = new Circle();
I can set and get colors of shapeCircle fine because the color getters and setters are in Shape , but the dimensions of Circle is only for the Circle class (radius).
If Circle class has an instance variable private int radius and a method called getRadius(), how can I get/set the radius of shapeCircle? I tried shapeCircle.getRadius();, but no luck.
Only methods of Shape are accessible with object shapeCircle.
shapeCircle is type Shape, methods in Circle are not visible.
By using this,
Circle shapeCircle = new Circle();
you can call both method of Circle and Shape. The above case is take advantage of only Inheritance.
Edit
But if you add public abstract int getDimension(); in Shape class and Circle class implements getDimension() method
#Override
public int getDimension() {
return radius;
}
All classes that extends Shape needs to implements getDimension() method. But each subclass has its own dimension.
You can use
Shape shapeCircle = new Circle();
shapeCircle.getDimension();
This takes advantage of both polymorphism and abstract class.
Shape shapeCircle = new Circle();
Here the reference is of Shape and shape class doesn't defines radius variable.So you cannot use shapeCircle.getRadius();
To invoke get/set radious method type cast the shapecircle variable like this
Circle shapeCircle = (Circle)shapeCircle;
Now you can invoke the get/set radious methods. Please note that typecasting code should be in some different method to benefit using polymorphism.
EDIT:
You should design your abstract classes or interfaces to be having all important/common operations/methods which will help you in writing polymorphic code. For example: Radius field is specific to a Circle class.But consider you eventually want to calculate the area. So you should define CalculateArea() method in your abstract class and let every shape implement this method.This way, you achieve polymorphism.
Shape ShapeCicle = new Circle(Radius);
Float area = ShapeCircle.area();
Point is don't confine yourself with the radius example.Try to define classes in a way so that you can benefit from polymorphism.
You have to use instanceof keyword to check for the original type here . If the type is Circle, then you can type cast and call the getRadius method. Something like
if (shapeCircle instanceof Circle) {
Circle circle = (Circle)shapeCircle;
int radius = circle.getRadius();
}
That should do.
'Shape is not Circle' = Circle methods not available for Shape.