excuse me for asking such a generic question, but I can't phrase it better. I have seen code of this style fairly often, but have not yet used it.    variable= someClass.someMethod(new someOtherClass(){       methodDeclaration(){       } });   If you don't know what I mean, the top answer could serve as an example:   When is this used? Are there any examples of problems that can only be solved by such code?
1841
What is the use of anonymous classes in Java? Can we say that usage of anonymous class is one of the advantages of Java?
1947
What's the best way to call a generic method when the type parameter isn't known at compile time, but instead is obtained dynamically at runtime?  Consider the following sample code - inside the Example() method, what's the most concise way to invoke GenericMethod&lt;T&gt;() using the Type stored in the myType variable?  public class Sample {     public void Example(string typeName)     {         Type myType = FindType(typeName);          // What goes here to call GenericMethod&lt;T&gt;()?         GenericMethod&lt;myType&gt;(); // This doesn't work          // What changes to call StaticMethod&lt;T&gt;()?         Sample.StaticMethod&lt;myType&gt;(); // This also doesn't work     }      public void GenericMethod&lt;T&gt;()     {         // ...     }      public static void StaticMethod&lt;T&gt;()     {         //...     } }
110522
Possible Duplicate:          I've been seeing that expression for over 10 years now. I've been trying to think what it's good for. Since I see it mostly in #defines, I assume it's good for inner scope variable declaration and for using breaks (instead of gotos.)  Is it good for anything else? Do you use it?
119696
In Java you can define a new class inline using anonymous inner classes. This is useful when you need to rewrite only a single method of the class.  Suppose that you want create a subclass of OptionParser that overrides only a single method (for example exit()). In Java you can write something like this:  new OptionParser () {      public void exit() {         // body of the method     } };   This piece of code creates a anonymous class that extends OptionParser and override only the exit() method.  There is a similar idiom in Python? Which idiom is used in these circumstances?
29419
There are a group of private methods in my class, and I need to call one dynamically based on an input value. Both the invoking code and the target methods are in the same instance. The code looks like this:  MethodInfo dynMethod = this.GetType().GetMethod("Draw_" + itemType); dynMethod.Invoke(this, new object[] { methodParams });   In this case, GetMethod() will not return private methods. What BindingFlags do I need to supply to GetMethod() so that it can locate private methods?
14396
For years, I've been using named blocks to limit the scope of temporary variables.  I've never seen this done anywhere else, which makes me wonder if this is a bad idea.  Especially since the Eclipse IDE flags these as warnings by default.  I've used this to good effect, I think, in my own code.  But since it is un-idiomatic to the point where good programmers will distrust it when they see it, I really have two ways to go from here:     avoid doing it, or  promote it, with the hope that it will become an idiom.   Example (within a larger method):  final Date nextTuesday; initNextTuesday: {     GregorianCalendar cal = new GregorianCalendar();     ... // About 5-10 lines of setting the calendar fields     nextTuesday = cal.getTime(); }   Here I'm using a GregorianCalendar just to initialize a date, and I want to make sure that I don't accidentally reuse it.  Some people have commented that you don't actually need to name the block.  While that's true, a raw block looks even more like a bug, as the intent is unclear.  Furthermore, naming something encourages you to think about the intention of the block.  The goal here is to identify distinct sections of code, not to give every temporary variable its own scope.  Many people have commented that it's best to go straight to small methods.  I agree that this should be your first instinct.  However, there may be several mitigating factors:   To even consider a named block, the code should be short, one-off code that will never be called elsewhere. A named block is a quick way to organize an oversized method without creating a one-off method with a dozen parameters.  This is especially true when a class is in flux, and the inputs are likely to change from version to version. Creating a new method encourages its reuse, which may be ill-advised if the use cases aren't well-established.  A named block is easier (psychologically, at least) to throw away. Especially for unit tests, you may need to define a dozen different objects for one-off assertions, and they are just different enough that you can't (yet) find a way to consolidate them into a small number of methods, nor can you think of a way to distinguish them with names that aren't a mile long.   Advantages of using the named scope:   Can't accidentally reuse temporary variables Limited scope gives garbage collector and JIT compiler more information about programmer intent Block name provides a comment on a block of code, which I find more readable than open-ended comments Makes it easier to refactor code out of a big method into little methods, or vice versa, since the named block is easier to separate than unstructured code.   Disadvantages:  Not idiomatic: programmers who haven't seen this use of named blocks (i.e. everyone but me) assume it's buggy, since they can't find references to the block name.  (Just like Eclipse does.)  And getting something to become idiomatic is an uphill battle.  It can be used as an excuse for bad programming habits, such as:   Making huge, monolithic methods where several small methods would be more legible. Layers of indentation too deep to read easily.   Note:  I've edited this question extensively, based on some thoughtful responses.  Thanks!
110717
In Java, you can qualify local variables and method parameters with the final keyword.  public static void foo(final int x) {   final String qwerty = "bar";  }   Doing so results in not being able to reassign x and qwerty in the body of the method.  This practice nudges your code in the direction of immutability which is generally considered a plus. But, it also tends to clutter up code with "final" showing up everywhere. What is your opinion of the final keyword for local variables and method parameters in Java?
28147
What is reflection, and why is it useful?  I'm particularly interested in Java, but I assume the principles are the same in any language.
59881
When I ran  on my code, for example:      if (some condition)     {         Some code...                 }   ReSharper gave me the above warning (Invert "if" statement to reduce nesting), and suggested the following correction:     if (!some condition) return;    Some code...   I would like to understand why that's better. I always thought that using "return" in the middle of a method problematic, somewhat like "goto".
22508
I've found a couple of references () that suggest using final as much as possible and I'm wondering how important that is. This is mainly in the the context of method parameters and local variables, not final methods or classes. For constants, it makes obvious sense.  On one hand, the compiler can make some optimizations and it makes the programmer's intent clearer. On the other hand, it adds verbosity and the optimizations may be trivial.  Is it something I should make an effort to remember?
32487
As far as I understand, whatever can be done using DeclareMathOperator can also be achieved using newcommand, but not the other way around. If this is the case, what are the circumstances where DeclareMathOperator is the better choice? When should I take solely newcommand?  I found a question regarding , and I wonder what other aspects should be taken into consideration when it comes to choosing which method to use when defining math operators.
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.
7441
Was there any reason why the designers of Java felt that local variables should not be given a default value? Seriously, if instance variables can be given a default value, then why can't we do the same for local variables?  And it also leads to problems as explained in :     Well this rule is most frustrating when trying to close a resource in a finally block. If I instantiate the resource inside a try, but try to close it within the finally, I get this error. If I move the instantiation outside the try, I get another error stating that a it must be within a try.      Very frustrating.
1624
The very common beginner mistake is when you try to use a class property "statically" without making an instance of that class. It leaves you with the mentioned error message:     You can either make the non static method static or make an instance of that class to use its properties.   Why? I am not asking for solutions. I would be grateful to know what is the reason behind it. The very core reason!  private java.util.List&lt;String&gt; someMethod(){     /* Some Code */     return someList;             }  public static void main(String[] strArgs){                // The following statement causes the error. You know why..     java.util.List&lt;String&gt; someList = someMethod();          }
107998
Is it like...  var obj = new Object();  obj.function1 = function(){     //code }   or something like that?
119794
I need to use a couple of variables in my lightning components. Hence, I declared them with @AuraEnabled annotation. There are a couple of methods which also being used in a lightning controller(i.e. they are also with @AuraEnabled annotation).   The variables which are annotated with @AuraEnabled, will be updating in different conditions of methods. Hence I need to these variables in that @AuraEnabled methods. However, I am getting compile time error, with following approaches:   If I declare @AuraEnabled variables, and directly using them in @AuraEnabled methods; I am getting variable not declared error.   e.g.  @AuraEnabled public Integer someCount;  @AuraEnabled public static List&lt;custom_object&gt; processData(){    if(this){         someCount += someValue;    }else{        someCount -= someValue;    } }    If I use this.comeCount += someValue; , I am getting Variable does not exist: this.sum1 error.    Please let me know if there is any way to achieve this or am I doing something wrong.
62239
Coming from a C# background the naming convention for variables and method names are usually either camelCase or PascalCase:  // C# example string thisIsMyVariable = "a" public void ThisIsMyMethod()   In Python, I have seen the above but I have also seen underscores being used:  # python example this_is_my_variable = 'a' def this_is_my_function():   Is there a more preferable, definitive coding style for Python?