If the return type must be the type of the class that implements the interface, then what you want is called an F-bounded type: public interface A<T extends A<T>>{ public T b(); } public class C implements A<C>{ public C b() { … } } public class D implements A<D>{ public D b() { … … Read more
While the type parameters of a generic method can be restricted by bounds, such as extends Foo & Bar, they are ultimately decided by the caller. When you call getFooBar(), the call site already knows what T is being resolved to. Often, these type parameters will be inferred by the compiler, which is why you … Read more
You can use an intersection of two interfaces: interface Api<T> { [key: string]: T[]; } type ApiType<T> = Api<T> & { meta: Meta; } declare let x: ApiType<string>; let a = x.meta // type of `a` is `Meta` let b = x[“meta”]; // type of `b` is `Meta` let p = x[“someotherindex”] // type of … Read more
A general rule of implementing and extending is you can make your new class or interface “less restrictive” but not “more restrictive”. If you think of the requirement to handle an exception as a restriction, an implementation that doesn’t declare the exception is less restrictive. Anybody who codes to the interface will not have trouble … Read more
When you cast o1 and o3 with (I2), you tell the compiler that the class of the object is actually a subclass of its declared type, and that this subclass implements I2. The Integer class is final, so o3 cannot be an instance of a subclass of Integer: the compiler knows that you’re lying. C1 … Read more
The point of an interface is to specify the public API. An interface has no state. Any variables that you create are really constants (so be careful about making mutable objects in interfaces). Basically an interface says here are all of the methods that a class that implements it must support. It probably would have … Read more
This is a very interesting issue! It seems like JLS section 12.4.1 ought to cover this definitively. However, the behavior of Oracle JDK and OpenJDK (javac and HotSpot) differs from what’s specified here. In particular, the Example 12.4.1-3 from this section covers interface initialization. The example as follows: interface I { int i = 1, … Read more
Taking some of the things you have described: “So you could be sure that some fields in a class are defined for every implementation of this interface.” “If a define a Interface for this class so that I can have more classes which implement the message interface, I can only define the send method and … Read more
In C#, a class that implements an interface is required to define all members of that interface. In the case of an abstract class, you simply define those members with the abstract keyword: interface IFoo { void Bar(); } abstract class Foo : IFoo { public abstract void Bar(); } Or to put it another … Read more
myInterface myinterface = new B(); The reference type of myinterface is myInterface. That means you can only access the methods defined in the interface. You can cast it to type B in order to make the method call. NOTE: From here on out I’ll be using the proper naming conventions. Example MyInterface myInterface = new … Read more