I am learning about method overriding in Java. Below is an example of method overriding.  class ABC{    public void myMethod(){     System.out.println("Overridden Method");    } } public class XYZ extends ABC{     public void myMethod(){     System.out.println("Overriding Method");    }    public static void main(String args[]){     ABC obj = new XYZ();     obj.myMethod();    } }   When an overridden method is called through a reference of parent class, then type of the object determines which method is to be executed. Now consider below :  ABC obj = new ABC(); obj.myMethod(); // This would call the myMethod() of parent class ABC (1)  XYZ obj = new XYZ(); obj.myMethod(); // This would call the myMethod() of child class XYZ (2)  ABC obj = new XYZ(); obj.myMethod(); // This would call the myMethod() of child class XYZ (3)   If (2) and (3) gives same output : Overriding Method, then why use (3)? We could just use (2) right?  I am new to Java, so I will tend to ask many doubts! Please help! Thank you!
685
I have seen this mentioned a few times and I am not clear on what it means. When and why would you do this?   I know what interfaces do, but the fact I am not clear on this makes me think I am missing out on using them correctly.   Is it just so if you were to do:  IInterface classRef = new ObjectWhatever()   You could use any class that implements IInterface? When would you need to do that? The only thing I can think of is if you have a method and you are unsure of what object will be passed except for it implementing IInterface. I cannot think how often you would need to do that.   Also, how could you write a method that takes in an object that implements an interface? Is that possible?
62286
I need to make some reflective method calls in Java. Those calls will include methods that have arguments that are primitive types (int, double, etc.). The way to specify such types when looking up the method reflectively is int.class, double.class, etc.  The challenge is that I am accepting input from an outside source that will specify the types dynamically. Therefore, I need to come up with these Class references dynamically as well. Imagine a delimited file a list of method names with lists of parameter types:  doSomething int double doSomethingElse java.lang.String boolean   If the input was something like java.lang.String, I know I could use Class.forName("java.lang.String") to that Class instance back. Is there any way to use that method, or another, to get the primitive type Classes back?  Edit: Thanks to all the respondents. It seems clear that there is no built-in way to cleanly do what I want, so I will settle for reusing the ClassUtils class from the Spring framework. It seems to contain a replacement for Class.forName() that will work with my requirements.
86715
I'm looking at some GXT code for GWT and I ran across this use of Generics that I can't find another example of in the Java tutorials. The class name is  if you want to look at all of the code.  Here are the important parts:  private RpcMap map;  public &lt;X&gt; X get(String property) {   if (allowNestedValues &amp;&amp; NestedModelUtil.isNestedProperty(property)) {     return (X)NestedModelUtil.getNestedValue(this, property);   }   return map == null ? null : (X) map.get(property); }   X is defined nowhere else in the class or anywhere in the hierarchy, and when I hit "go to declaration" in eclipse it just goes to the &lt;X&gt; in the public method signature.  I've tried to call this method with the following two examples to see what happens:  public Date getExpiredate() {     return  get("expiredate"); }  public String getSubject() {     return  get("subject"); }   They compile and show no errors or warnings.  I would think at the very least I would have to do a cast to get this to work.  Does this mean that Generics allow a magic return value that can be anything and will just blow up at runtime?  This seems counter to what generics are supposed to do.  Can anyone explain this to me and possibly give me a link to some documentation that explains this a little better?  I've went through Sun's 23 page pdf on generics and every example of a return value is defined either at the class level or is in one of the parameters passed in.
4013
If I have two variables:  Object obj; String methodName = "getName";   Without knowing the class of obj, how can I call the method identified by methodName on it?  The method being called has no parameters, and a String return value. It's a getter for a Java bean.
102058
When overriding the equals() function of java.lang.Object, the javadocs suggest that,      it is generally necessary to override the hashCode  method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.   The hashCode() method must return a unique integer for each object (this is easy to do when comparing objects based on memory location, simply return the unique integer address of the object)  How should a hashCode() method be overriden so that it returns a unique integer for each object based only on that object's properities?   public class People{    public String name;    public int age;     public int hashCode(){       // How to get a unique integer based on name and age?    } } /*******************************/ public class App{    public static void main( String args[] ){        People mike = new People();        People melissa = new People();        mike.name = "mike";        mike.age = 23;        melissa.name = "melissa";        melissa.age = 24;        System.out.println( mike.hasCode() );  // output?        System.out.println( melissa.hashCode(); // output?    } }
107586
Can a class overload methods that also exist in the publicly inherited interface? It seems like this is unambiguous and useful, but compilers (VC, Intel, GCC) all complain, at least by my construction. Below is a toy example. The inherited rebound() function has two clear overloads, yet this will not compile.  If you rename the rebound() method in either class, it works fine, but if they share the same member function name (even though they're overloaded with different argument types!) you get a fatal error of "too few arguments to function call."  The workaround is trivial (I'll just rename the methods) but I'm just trying to understand if this is a C++ restriction (and why it would be).   #include  class Bound { public:   Bound() : x0(0.0), x1(0.0) {};   Bound(double x) : x0(x), x1(x) {};   double width() const {return x1-x0;}   void rebound(const Bound *a, const Bound *b); private:   double x0, x1; };  void Bound::rebound(const Bound *a, const Bound *b) {   if (a && b) {     x0=std::min(a->x0, b->x0);     x1=std::max(a->x1, b->x1);   } }  class Node : public Bound { public:   Node(double x) : Bound(x), left(0), right(0) {};   Node(Node *a, Node *b) : left(a), right(b) {rebound();}   void rebound() { rebound(left, right); } private:   Node *left;   Node *right; };   int main() {   Node A(1.0);   Node B(2.0);   Node C(&A, &B); }
3008
What are differences between declaring a method in a base type "virtual" and then overriding it in a child type using the "override" keyword as opposed to simply using the "new" keyword when declaring the matching method in the child type?
37596
Say I have a class that's meant to perform a single function. After performing the function, it can be destroyed. Is there any reason to prefer one of these approaches?  // Initialize arguments in constructor MyClass myObject = new MyClass(arg1, arg2, arg3); myObject.myMethod();  // Pass arguments to method MyClass myObject = new MyClass(); myObject.myMethod(arg1, arg2, arg3);  // Pass arguments to static method MyClass.myMethod(arg1, arg2, arg3);   I was being intentionally vague about the details, to try to get guidelines for different situations. But I didn't really have in mind simple library functions like Math.random(). I'm thinking more of classes that perform some specific, complex task, but only require one (public) method to do it.
38779
I'm new to Apex and development in general... So, I'm playing around coding and doing some badges in Trailhead. I created a small piece of code, as below, and have no actual use: public class GenderIdentifier {     public void DetermineGender(String Gender){                 if (Gender == 'Man'){             Gender = 'Male';             } else {             Gender = 'Female';         }            } }  If I make the method 'non-static' it works, and I can see it working fine executing as a anonymous block. If I make it static, I can't execute the anonymous block, as I get an Error like:  Non static method cannot be referenced from a static context: void GenderIdentifier.DetermineGender(String)  What am I doing wrong? It would make sense to have a method like this as Static. I think I misunderstood the concept of static methods.
53471
Now that it's clear , there is an associated concept that I use all the time without knowing what it really means.   I suppose everybody made once a mistake with parenthesis, resulting  in an "object is not callable" exception. What's more, using __init__ and __new__ lead to wonder what this bloody __call__ can be used for.  Could you give me some explanations, including examples with the magic method ?
102136
Is there a way to Invoke an overloaded method using reflection in .NET (2.0).  I have an application that dynamically instantiates classes that have been derived from a common base class.  For compatibility purposes, this base class contains 2 methods of the same name, one with parameters, and one without.  I need to call the parameterless method via the Invoke method.  Right now, all I get is an error telling me that I'm trying to call an ambiguous method.  Yes, I could just cast the object as an instance of my base class and call the method I need.  Eventually that will happen, but right now, internal complications will not allow it.  Any help would be great!  Thanks.
92800
For a given class I would like to have tracing functionality i.e. I would like to log every method call (method signature and actual parameter values) and every method exit (just the method signature).      How do I accomplish this assuming that:     I don't want to use any 3rd party AOP libraries for C#, I don't want to add duplicate code to all the methods that I want to trace,   I don't want to change the public API of the class - users of the class should be able to call all the methods in exactly the same way.     To make the question more concrete let's assume there are 3 classes:     public class Caller   {      public static void Call()       {          Traced traced = new Traced();          traced.Method1();          traced.Method2();       }  }   public class Traced   {      public void Method1(String name, Int32 value) { }       public void Method2(Object object) { }  }   public class Logger  {      public static void LogStart(MethodInfo method, Object[] parameterValues);       public static void LogEnd(MethodInfo method);  }   How do I invoke Logger.LogStart and Logger.LogEnd for every call to Method1 and Method2 without modifying the Caller.Call method and without adding the calls explicitly to Traced.Method1 and Traced.Method2?  Edit:  What would be the solution if I'm allowed to slightly change the Call method?
50500
A curious thing happens in Java when you use an abstract class to implement an interface: some of the interface's methods can be completely missing (i.e. neither an abstract declaration or an actual implementation is present), but the compiler does not complain.  For example, given the interface:  public interface IAnything {   void m1();   void m2();   void m3(); }   the following abstract class gets merrily compiled without a warning or an error:  public abstract class AbstractThing implements IAnything {   public void m1() {}   public void m3() {} }   Can you explain why?
114445
So I understand what a static method or field is, I am just wondering when to use them. That is, when writing code what design lends itself to using static methods and fields.   One common pattern is to use static methods as a static factory, but this could just as easily be done by overloading a constructor. Correct? For example:  var bmp = System.Drawing.Bitmap.LoadFromFile("Image01.jpg");   As for static fields, is creating singelton-objects their best use?
81621
If I write the following class:  public class Example {        int j;       int k;        public Example(int j, int k) {            j = j;            k = k;       }        public static void main(String[] args) {            Example exm = new Example(1,2);            System.out.println(exm.j);            System.out.println(exm.k);       }  }   The program compiles, but when I run the program, the main method will print out two 0s. I know that in order to say that I want to initialize the instance variables in the constructor I have to write:  this.j = j; this.k = k;   But if I don't write it, then which variable is evaluated (or considered) in the constructor (on the left and on the write hand side of the expressions)? Is is the argument or the instance variable? Does it make a difference?  Are there other cases where the use of this is obligatory?
80088
When referencing class variables, why do people prepend it with this? I'm not talking about the case when this is used to disambiguate from method parameters, but rather when it seems unnecessary.  Example:  public class Person {             private String name;      public String toString() {         return this.name;     } }   In toString, why not just reference name as name?  return name;   What does this.name buy?   a stackoverflow question whose code has this pre-pending.
68648
Let's say that you have overridden an object's equals() and hashCode() methods, so that they use the object's fields.  How you do you check if two references are to the same object, ala the stock equals() method?