superclass

I have this simple interface/class: public abstract class Message {} public class Message1 extends Message {} public class Message2 extends Message {} And an utility class: public class Utility { public void handler(Message m) { System.out.println("Interface: Message"); } public void handler(Message1 m) { System.out.println("Class: Message1"); } public void handler(Message2 m) { System.out.println("Class: Message2"); } } Now, the main class: public static void main(String[] args) { Utility p = new Utility(); Message1 m1 = new Message1(); p.handler(m1); Message m = (Message) m1; p.handler(m); }

There are numerous questions on the usage of super() but none of them appears to answer my question. When calling super().__init__() from a subclass, all method calls in the super-constructor are actually taken from the subclass . Consider the following class structure: class A(object): def __init__(self): print("initializing A") self.a() def a(self): print("A.a()") class B(A): def __init__(self): super().__init__() # add stuff for B self.bnum=3 # required by B.a() def a(self): print("B.a(), bnum=%i"%self.bnum) b=B() which fails with initializing A Traceback (most recent call last): File

Is it possible using Mockito and optionally Powermock to mock a superclass S such that any calls to the superclass to S (including calls to the S() constructor) are mocked? So using the below example, if I replace S with MockS using Mockito, will the call to super() use the constructor in MockS ? class S { S() { // Format user's hard drive, call 911, and initiate self-destruct } } class T extends S { T() { super(); } } class Test { @Mock private S mockS; new T(); // T's call to super() should call the mock, not the destructive S. } I've seen questions about mocking individual methods in S or

I've found that I can do it this way in the child class: ParentClass.variable = value; But I've been told that it's better practice to use get/set methods and not give direct access to variables outside a class. Though this was for when I had an instance of the class in another class, not for subclasses and superclasses. So is there a better way of doing this, and which way is generally considered best practice? You have a lot of options. super.field = x You have to have access to the field to do this field = x You have to have access to the field to do this. You also can't have another field

I would like to map the elements of a Scala tuple (or triple, ...) using a single function returning type R. The result should be a tuple (or triple, ...) with elements of type R. OK, if the elements of the tuple are from the same type, the mapping is not a problem: scala> implicit def t2mapper[A](t: (A,A)) = new { def map[R](f: A => R) = (f(t._1),f(t._2)) } t2mapper: [A](t: (A, A))java.lang.Object{def map[R](f: (A) => R): (R, R)} scala> (1,2) map (_ + 1) res0: (Int, Int) = (2,3) But is it also possible to make this solution generic, i.e. to map tuples that contain elements of different types