I understand that it’s not allowed because there are rules against it. I am confused as to why it’s not allowed. The general rule is: a user defined conversion must not in any way replace a built-in conversion. There are subtle ways that this rule can be violated involving generic types, but you specifically say … Read more
You can embed interface types. See the Interface type specification type Student interface { People GetScore() int GetSchoolName() string }
OK, I’ve done some research. If you create the following hierarchy: public interface One { void DoIt(); } public interface Two : One { void DoItMore(); } public class Magic : Two { public void DoItMore() { throw new NotImplementedException(); } public void DoIt() { throw new NotImplementedException(); } } And compile it, then reference … Read more
Ad 1: The additional abstract base class allows you to evolve the interface without breaking the implementation. Supposed there was no abstract base class, and you’d extend the interface, let’s say by adding a new method. Then your implementation was broken, because your class does not implement the interface any longer. Using an additional abstract … Read more
Try an extension method instead: public interface IMyInterface { string GetClassName(); } public static class IMyInterfaceExtensions { public static void PrintClassName<T>( this T input ) where T : IMyInterface { Console.WriteLine(input.GetClassName()); } } This allows you to add static extension/utility method, but you still need an instance of your IMyInterface implementation. You can’t have interfaces … Read more
I find that there are valid reasons for using an interface instead of a concrete class as a property. For example, if your Field class was in a seperate project to the Address class, and you didn’t have a dependency on the Address class’s project from the Field class’s project. There are other ways of … Read more
This is a good question and a real problem. The easiest way to deal with it in Java likely involves the use of generics, as mentioned in Jochen’s answer. There’s a good discussion of the issue and a reasonable solution in this blog entry on Using Inheritance with Fluent Interfaces, which combines generics with the … Read more
You can’t simply convert []interface{} to []string even if all the values are of concrete type string, because those 2 types have different memory layout / representation. For details see Cannot convert []string to []interface {}. You have to define how you want values of different types to be represented by string values. The easiest … Read more
The second interface can be implemented with the with keyword class ImplementingClass extends EventRecorder with TransactionCapable { def record(event: Event) {} def commit() {} } Further on each subsequent interface is separated with the keyword with. class Clazz extends InterfaceA with InterfaceB with InterfaceC { //… }