Abstract class - access to parent

Question

Hi:
I would like to do the following, but I don´t know how (neither if its possible):
Access from an abstract class a method of its implementer class.
public class ContainerClass () implements AbstractClass{
public void AbstractMethod(){
super().Method1();
public abstract class AbstractClass(){
public void Method1(){
parent.AbstractMethod();
parent.getClassName(); // I am expecting ContainerClass
public void AbstractMethod();
The method Method1 will be the same for every class implementing AbstractClass, but dependent of the implementation of the AbstractMethod in the container class.
Theoretically, the ContainerClass object should have all the methods implemented in runtime, therefore, all of them accessible in the same object.
Does anybody know how to do this?
Cheers!

Answer 1

You'll probably want to look a bit into the differences between an interface and an abstract class. Here, you're defining AbstractClass which provides a 'default' set of behaviors for another object that will extend it, but you are trying to use it as an interface, which defines what methods must be available.
For example, if you were defining a few shapes and wanted common behavior to be available, you might define it as an interface:
public interface Shape {
  public int area();
public class Square implements Shape {
  private int length;
  public Square(int length) {
    this.length = length;
  public int area() {
    return length * length;
}By defining Shape as an interface, you guarantee that every class implementing it will have 'public int area()'.
An abstract class is a little different. It would let you do things like this:
public abstract class AbstractShape {
  public abstract int area();
  public String toString() {
    return "The area of this shape is " + area();
public class Square extends AbstractShape {
  // Same code as before
}It would define default code (which you can also override) as well as certain methods which you must override (or be abstract). These two approaches could also be combined, making AbstractShape and/or Square also implement Shape, which is what a lot of Java API classes do. For example, the List interface defines methods that must be available (like add(), remove(), etc). It also has AbstractList, which implements many of the required List methods, but not all. A class that extends AbstractList only needs to implement a few more methods to be fully usable.