I want to do this:
One principal abstract class that has two methods
abstract method 1
abstract method 2
two secoundary class
class A implements method 1
class B implements method 2
How can I do this?
Abstract force me to implemenst all the methods in a class?
> I want to do this:
>
> One principal abstract class that has two methods
> abstract method 1
> abstract method 2
>
> two secoundary class
> class A implements method 1
> class B implements method 2
>
> How can I do this?
> Abstract force me to implemenst all the methods in a
> class?
Abstract classes can declare non-abstract methods. Declare
method1() and method2() in the abstract class, and, neither
extending class will be required to implement it.
Also, ==puckstopper. Consider hard if this problem
is properly solved by inheritance.
> class A and class B do almost the same. That is why I
> need inheritance( I think)
Ok that's fine, what about method1() and method2() do they do the same thing.
As an example, I might have two or more different ways to calculate the sale price on an item depending on the circumstances. Is that the case you have or are the functions carried out by method1() and method2() entirely different?
PS.
I have a principal class that call 10 methods called:
method A
method B
method C
..
method J
I need to implement this methods in diferent classes because each one of this method have to be implemented by a different person.
So I think to create a abstract class with the ten methods to and after that, each person will extends the abstract class and implement one method?
Have I expained well?
Then you don't need ten different methods not at all you need one method, and now I think I understand your problem. Inheritance from an abstract class isn't the answer to your problem.
Consider the following:
public abstract class SuperClass
{
public void methodA()
{
// ... Method A functionality
}
public void methodB()
{
// ... Method A functionality
}
public void methodC()
{
// ... Method A functionality
}
}
class A extends SuperClass
{
public void doStuff()
{
methodA() ;
methodB() ;
methodC() ;
}
}
class B extends SuperClass
{
public void doStuff()
{
methodA() ;
methodB() ;
methodC() ;
}
}
You have two classes that inherit from SuperClass and they ALL have access to all of its member functions (methodA() ... methodC()). Since methodA() ... methodC() all do the same thing there's absolutely no point to this at all.
So, if methodA() ... methodX() all have the same functionality then you only need it in one place [SuperClass] and this is a case where inheritance is the answer that you want.
Or, if methodA() ... methodX() have different functionality but the same method signature and have NO default behavior then you want an interface which the other developers would implement.
Or, if methodA() ... methodX() have default behavior but MIGHT be changed by the developer implementing the functionality then a superclass which you would override in the subclass is the correct answer.
Making sense now?
PS.
