super

In Java type arguments, does mean strictly subtypes only? or would E also suffice? Yes, super and extends gives inclusive lower and upper bounds respectively. Here's a quote from Angelika Langer's Generics FAQ : What is a bounded wildcard? A wildcard with an upper bound looks like ? extends Type and stands for the family of all types that are subtypes of Type , type Type being included . Type is called the upper bound . A wildcard with a lower bound looks like ? super Type and stands for the family of all types that are supertypes of Type , type Type being included . Type is called the lower

I know that super() and multi-inheritance have already been discussed here. But I did not find a solution, regarding my specific problem in python3. Let's assume we have: #! /usr/bin/env python3 class A(object): def __init__(self): super().__init__() def foo(self): print("The") class B(object): def __init__(self): super().__init__() def foo(self): print("world") class C(B): def __init__(self): super().__init__() def foo(self): super().foo() print("is") class D(A,C): def __init__(self): super().__init__() def foo(self): super().foo() print("nice") d = D() d.foo() This will get me: The nice On

In Ruby, super is a keyword rather than a method. Why was it designed this way? Ruby's design tends toward implementing as much as possible as methods; keywords are usually reserved for language features that have their own grammar rules. super , however, looks and acts like a method call. (I know it would be cumbersome to implement super in pure Ruby, since it would have to parse the method name out of caller , or use a trace_func . This alone wouldn't prevent it from being a method, because plenty of Kernel 's methods are not implemented in pure Ruby.) It behaves a little differently, in

Consider the following set of expressions: class T {{ /*1*/ super.toString(); // direct /*2*/ T.super.toString(); // synthetic Supplier<?> s; /*3*/ s = super::toString; // synthetic /*4*/ s = T.super::toString; // synthetic }} Which gives the following result: class T { T(); 0 aload_0 [this] 1 invokespecial java.lang.Object() [8] 4 aload_0 [this] 5 invokespecial java.lang.Object.toString() : java.lang.String [10] 8 pop // ^-- direct 9 aload_0 [this] 10 invokestatic T.access$0(T) : java.lang.String [14] 13 pop // ^-- synthetic 14 aload_0 [this] 15 invokedynamic 0 get(T) : java.util.function

when dealing with wildcards such as setting/adding a generic item to a certain container is it suggested to use something like this? void add(List<? super T> someList,someitem){ someList.add(someItem); } and when retrieving an item it is suggested to use something like this <T> void f1(List<? extends T> obj, T item) { obj.add(item); } What is the principle behind this? and when will I know if I should use this ? user1676688 you should have a look at the explanation of PECS principle What is PECS (Producer Extends Consumer Super)? In short, when you want to get information from an object, make

I have seen some Apple examples that do call [super viewDidUnload]; and some that don't. I read an article (a few months ago so I dont recall the url) that said calling [super viewDidUnload]; was unnecessary but it didn't explain beyond that. Is there a definitive reason why or why not to tell super that the viewDidUnload ? And, (if it should be done) do I call super before setting all my properties to nil , after, or does it matter? - (void)viewDidUnload { // Is this necessary? // [super viewDidUnload]; self.tableDataSource = nil; self.titleLabel = nil; // Is it better to call super before or