I don't understand why we can't do the following:
interface MyInterface extends Cloneable {}
class myClazz implements MyInterface {
public Object clone() { return null; }
}
class test{
public static void main(String[]a){
MyInterface o = new myClazz();
o.clone(); // IMPOSSIBLE
}
}
But this will work fine
interface Misc{
public void testM();
}
interface MyInterface extends Misc{}
class myClazz implements MyInterface {
public void testM() {}
}
class test{
public static void main(String[]a){
MyInterface o = new myClazz();
o.testM(); // OK
}
}
What's happen with Cloneable?
Thanks,
The Cloneable interfaces doesn't have any methods.
It's just a marker interface which the base Object.clone method (which is protected) checks for.
If you want a clone method, you need to declare it yourself.
This beacause the Cloneable interface is not a normal interface but more or less a tagging interface which ensures to the JVM that the clone method of the class that implements it is legal and actually working.
As the documentation states the Cloneable interface does not declare the signature of the clone method. That method is inherently inherited in any class you declare from the Object class but it is protected by default. This is why you should weaken this constraint by making it public in the middle interface MyInterface that you declare.
Take a look at this hint given in Java doc:
Note that this interface does not contain the clone method. Therefore, it is not possible to clone an object merely by virtue of the fact that it implements this interface. Even if the clone method is invoked reflectively, there is no guarantee that it will succeed.
It's just because clone() isn't public in Object. If you declare public Object clone() in your interface -- in other words, if you make your first example like your second -- then your first example will work.
Related
I'm newbie to Java. I would like to ask different between the following interface examples?
public interface MyInterface {
public void doSomething();
}
like this
public class MyClass implements MyInterface {
public void doSomething {....}
}
and this
public class MyClass implements MyInterface {
protected MyInterface myInterface;
public MyClass (MyInterface myInterface) {
this.myInterface = myInterface;
}
public void doSomething () {
myInterface.doSomething();
}
}
In first case you implement an interface using a class and you implement the function doSomething in that class. you can call the doSomething function by creating an instance of the class MyClass
MyInterface obj = new MyClass();
obj.doSomething();
In second case, you wont be even able to instantiate an instance of the MyClass because it needs another instance of it-self or another class which implements that interface.
public class MyClass implements MyInterface {
public void doSomething {....}
}
MyClass implements the interface MyInterface. It means your class holds a concrete behavior that your interface promise. By implementing the interface your class guaranteed the MyClass has the concrete feature your interface abstracted in its declaration.
But I doubt you may not have a real scenario to implement an interface as well as create an instance of interface in a class. Second part of your question is one of the most famous design topic of inheritance vs composition. Chances of using both inheritance and composition together of an interface is barely rare.
The first two code are one interface and another class which implements the interface.
The third code is MyClass that implements MyInterface and creates a object reference to MyInterface named myInterface. The next part
public MyClass (MyInterface myInterface) {
this.myInterface = myInterface;
}
is a simple constructor and the next part
public void doSomething () {
myInterface.doSomething();
}
is calling of a method.
The first one is inheritance and the second one is composition. Inheritance is an "is-a" relationship, while composition is a "has-a".
For example, if there is a Pressable interface which represents everything that can be pressed, Button, Checkbox should implement it. If there is a Color class, the Button should have a composition relationship between the Color, since a Button should have a color, but a Button is not a type of Color.
A commonly known mistake is the java.util.Stack. Since a Stack is not a java.util.Vector, Stack should not inherit Vector.
An interface is an abstract type in Java and it specify a set of abstract methods that classes must implement. A class usually implement the interface as shown in your first example.
In your second example, even though MyClass is implementing the interface, the behaviour of doSomething method will depend on the instance of MyInterface implementation that it will get when instantiate MyClass object.
It is not possible to instantiate an interface. You will have to do something like below. Here MySecondClass implements the MyInterface.
MyClass m = new MyClass(new MyInterface()
{
#Override
public void doSomething()
{
// TODO Auto-generated method stub
}
});
MyClass m2 = new MyClass(new MySecondClass());
}
Let's say that I have an interface, and all classes that implement that interface also extend a certain super class.
public class SuperClass {
public void someMethod() {...}
}
public interface MyInterface {
void someOtherMethod();
}
//many (but not all) sub classes do this
public class SubClass extends SuperClass implements MyInterface {
#Override
public void someOtherMethod() {...}
}
Then if I'm dealing with an object of type MyInterface and I don't know the specific sub class, I have to hold two references to the same object:
MyInterface someObject = ...;
SuperClass someObjectCopy = (SuperClass) someObject; //will never throw ClassCastException
someObjectCopy.someMethod();
someObject.someOtherMethod();
I tried making the interface extend the super class, but it's a compiler error:
public interface MyInterface extends SuperClass {} //compiler error
I also thought of combining the interface and the super class into an abstract class like so:
public abstract class NewSuperClass {
public void someMethod();
public abstract void someOtherMethod();
}
But then i can't have a sub class that doesn't want to implement someOtherMethod().
So is there a way to signify that every class that implements an interface also extends a certain class, or do I have no choice but to carry around two references to the same object?
I think that the only solution you have would be to have a reference to both, but this indicates that you have a design flaw somewhere. The reason I say is because you should think of an interface as something that your implementing classes will always need. For example, a Car and Airplane both need a Drive() interface. A design reconsideration is probably worth your time. However, if you still want to follow that path, you can do the following:
public class ClassA {
public void methodA(){};
}
public abstract class ClassB extends Class A{
public void methodB();
}
After you have the above setup, you can now reference an object that has the two methods by doing the following:
ClassB classB = new ClassB();
classB.methodA();
classB.methodB();
Now you don't actually have to actually use two pointers to the same object.
My question is that can one interface extend another interface or it implements another interface.
interface A {
}
interface B extends A {
}
OR
interface B implements A {
}
Barring Java 8 extensions, an interface doesn't implement anything.
So therefore extends is the correct term.
An interface can only extend another interface, since an interface cannot contain any implementation.
interface ParentInterface{
void myMethod();
}
interface SubInterface extends ParentInterface{
void anotherMethod();
}
Yes, they can via the extends keyword, as interfaces can't implement any methods, only declare their signatures.
interface A {
public void foo();
}
interface B extends A {
// You don't implement the methods from A here
public void bar();
}
class C implements B {
public void foo(){
}
public void bar(){
}
}
Any class that then implements B must then implement the methods from A as well.
Yes, an interface can extend another interface in Java.
// this interface extends from the Body interface:
public interface FourLegs extends Body
{
public void walkWithFourLegs( );
}
Well but we must think,
When would we want an interface to extend another interface
We know that any class that implements an interface must implement the method headings that are declared in that interface. And, if that interface extends from other interfaces, then the implementing class must also implement the methods in the interfaces that are being extended or derived from.
So, in the example above, if we have a class that implements the FourLegs interface, then that class must have definitions for any method headings in both the FourLegs interface and the Body interface.
Question part 2:Interface do not Implement another interface,Because
Implements denotes defining an implementation for the methods of an interface. However interfaces have no implementation so that's not possible.
In terms of Inheritance in case of "INTERFACE" they always extends they never implement anything.
Suppose I have an interface called Interface, and a concrete class called Base, which, to make thing a bit more complicated, has a ctor that requires some arguments.
I'd like to create an anonymous class that would extend Base and implement Interface.
Something like
Interface get()
{
return new Base (1, "one") implements Interace() {};
}
That looks reasonable to me, but it doesn't work!
(P.S: Actually, the Interface and Base are also generic classes :D. But I'll ignore that for now)
No, you can't do that with an anonymous class. You can create a named class within a method if you really want to though:
class Base {
}
interface Interface {
}
public class Test {
public static void main(String[] args) {
class Foo extends Base implements Interface {
};
Foo x = new Foo();
}
}
Personally I'd usually pull this out into a static nested class myself, but it's your choice...
This scenario makes little sense to me. Here's why: assume class Base is this:
class Base {
public void foo();
}
and Interface is this:
interface Interface {
public void bar();
}
Now you want to create an anonymous class that would be like this:
class MyClass extends Base implements Interface {
}
this would mean that MyClass inherits (or possibly overrides) method bar from Base and must implement method foo from Interface. So far so good, your class has these two methods either way.
Now, think what happens when you are returning an object of type Interface from your method: you only get the functionality that Interface offers, namely method foo. bar is lost (inaccessible). This brings us down to two cases:
Extending Base is useless because you do not get to use its methods, since the new object is seen as an Interface.
Interface also has a method foo, but that would mean that Base itself should implement Interface, so you can just extend Base directly:
class Base implements Interface {
public void foo();
public void bar();
}
class MyClass extends Base {
}
I was wondering if the next thing is possible for implementation:
Lets say I've got 2 interfaces while each one of them has 1 function header.
For example, iterface1 has function g(...) and interface2 has function f(...)
Now, I make a class and declaring that this class is implementing these 2 interfaces.
In the class I try doing the next thing:
I start implementing function g(...) and in it's implementation I make a local class that implements interface2 and I add to this class the implementation of f(...).
I'm not quite sure what you mean. I am picturing something like this:
interface Interface1
{
public void g();
}
interface Interface2
{
public void f();
}
class MyClass implements Interface1, Interface2
{
#Override
public void g()
{
class InnerClass implements Interface2
{
#Override
public void f()
{
}
}
}
}
Is that what you meant?
In this case, the answer is no. The inner class (InnerClass) works fine, but it doesn't count as an implementation of f for the outer class. You would still need to implement f in MyClass:
MyClass.java:11: MyClass is not abstract and does not override abstract method
f() in Interface2
Yes it is legal. However a class does not implement an interface because an inner class implements it. The class must implement the interface explicitly or declare itself as abstract.
Yes, it's legal. In the example you've given, your class should implement all methods of both interfaces, and your local class should implement all methods of interface2.