2个不同的Java类，使用相同的方法，但一个实现一个接口

Question

Suppose, there are two java classes.

BaseA

public class BaseA extends ModuleBase{
   public void doSomething{
    //does something
   }

}

BaseB

public class BaseB extends ModuleBase implements
    SomeInterface {
   public void doSomething{
    //does something
   }

}

SomeInterface

public interface SomeInterface {
  public void doSomething();
}

so as you can see the only difference between BaseA & BaseB is that BaseB implements an interface. As far my understanding an interface is a reference type, similar to a class, that can contain only constants, method signatures, default methods, static methods, and nested types. It cannot be instantiated.

Questions:

1. it seems BaseA & BaseA would be same as the methods & code in them is same. correct?
2. Interface seems like a contract that spells out how software APIs interact with each other & have no effect on class functions. only purpose of interface is to enforce that BaseB has mandatorily implement doSomething , where as with BaseA , its optional & won't generate compile errors. if not, then why?
3. What difference implementing an interface make? I know you have to implement all methods of that particular interface but if can also you do that without the keyword implements InterfaceName as seen in BaseB Vs BaseA where we implemented exact same doSomething() . what difference having the keyword implements InterfaceName in class declaration make?

Answer 1

1. No. Classes in Java are the same when they have the same fully qualified name and when they were loaded from the same classloader. Java makes no attempt to look into methods and it doesn't compare method signatures.

   Or to put it differently: Java doesn't support duck typing .

2. Usually, interfaces are used to make a bunch of classes easily interchangeable. So you have something that needs a certain functionality. Instead of typing this to a single class, you can use an interface. People using that service can then feed it with different classes, according to their needs, making the service much more flexible (and somewhat harder to understand).

3. It means you can use BaseB in any place where InterfaceName is expected. That makes BaseB (and everything derived from it) much more useful/powerful.

Example:

If you want to check passwords, you can write a PasswordService class. But that means everyone has to use this class and live with the limitations.

If you offer a PasswordService interface, then users of your code can have different implementations: They can get passwords from a file, a database, LDAP, ... or for unit tests, they can write a service that says yes or no to every password.

Answer 2

what difference having the keyword implements InterfaceName in class declaration make?

You can then cast to that interface.

Java is not duck-typed.

Even if your class has a method void run() like a Runnable , you still won't be able to give it to places that want a Runnable without implementing the interface.

 new Thread(instanceOfMyNotRunnableClass);  // won't compile

Answer 3

1. Two classes are not same by their code. The code may be same but classes are still different. Two classes with same code may behave similar but will not be same.

2. To understand purpose of Interface, you should understand concepts of Abstraction and Encapsulation. Interface not only provides a contract, also provides an abstraction over underlying classes. You may write an API that takes object of type Interface without bothering about actual class implementing the Interface.

3. You can use BaseB in place where InterfaceName but you should not. This makes your code rigid for using only BaseB, whereas you may write an utility that takes any class that has implemented the interface.

Answer 4

Well, I assume that SomeInterface declares "doSomething", right?

If that's the case, the benefit for you is that you can treat BaseB as SomeInterface. Let's say you have another class BaseC, which also implements SomeInterface, then this code is valid:

SomeInterface inter = new BaseB();
inter = new BaseC();

while this is not valid:

SomeInterface interr = new BaseA();

Your advantage is, that you do not have to know, if inter is BaseB() or BaseC(), because you simple work on the interface declared methods, no matter how the implementation excatly looks like.

Answer 5

Interface is used to make skeleton of your API. Like java.util.ArrayList and java.util.LinkedList both are classes which implement interface java.util.List.

So if you have method like below

void doSomething(java.util.List list){

}

You can pass java.util.ArrayList or java.util.LinkedList as per your requirment with no harm.You don't have to create two diff. methods where one accept java.util.ArrayList and another accept java.util.LinkedList