When the Java compiler turns a class into bytecode, it must first look to a parent class. That is because the underlying implementation of classes is to point to the bytecode of the parent class - which holds the relevant methods and fields. Then it adds in pointers to the code of the child class functions - some of which are mandated by the &#39;implements&#39; keyword.

Because the parent class must be compilable, it is easier if the compiler knows up front what that class is. Further, you can extend only one class but implement any number of interfaces. The compilation time climbs if the extends keyword can be intermingled amongst any number of implements instructions. Compilers want to fail as fast as possible to decrease dev time, so this choice is logical. Further, it helps you think clearly about the class for the same reason.

Probably to make the compiler&#39;s job easier. It&#39;s just a convention. There isn&#39;t any advantage to being able to rearrange these things.

It&#39;s like asking why Java functions aren&#39;t written in pre-order notation like `public int (int a, int b)add{ return a+b; }`.

Im using the npm `mongodb` driver with node.

I have

    collection.findOne({query}, function(err, result) {
        //do something
    }

The problem is say I dont have any results, `err` is still `null` whether I find a result or don&#39;t. How would I know that there were no results found with the query?

I&#39;ve also tried

    info = collection.findOne(....

But the `info` is just `undefined` (it looked asynchronous so I didn&#39;t think it was the way to go anyway..)

MongoDB Node findone how to handle no results?

I went looking through `Raphael.js`&#39;s source code to find out how he converted RGB values to HSB. I found out the function he did it in and I was in the process of converting it to Python when I bumped into this nice triple-nested ternary operator:

    H = (C == 0 ? null :
        V == r ? (g - b) / C :
        V == g ? (b - r) / C + 2 :
                 (r - g) / C + 4
        );

It threw me for a loop because Python doesn&#39;t have the same kind of ternary operator that Javascript does. I spent a while looking over it and eventually hashed this somewhat saner code (using only if/else) out of it:

    if (C == 0) {
    	H = null;
    } else {
    	if(V == r) {
    		H = (g - b) / C;
    	} else {
    		if(V == g) {
    			H = (b - r) / C + 2;
    		} else {
    			H = (r - g) / C + 4;
    		}
    	}
    }

Was my interpretation correct? I&#39;m only asking this because if it isn&#39;t correct, I&#39;m faced with a *lot* of debugging. So. Did I &quot;get it&quot;?

A somewhat painful triple-nested ternary operator

Why must `implement` always be written after `extend` in a class declaration? For example: 

    public class Register extends ActionSupport implements ModelDriven

Why can it not be:

    public class Register implements ModelDriven extends ActionSupport 

The latter produces a compile-time error.

Why &quot;extends&quot; precedes &quot;implements&quot; in class declaration

Why must <code>implement</code> always be written after <code>extend</code> in a class declaration? For example:
<pre><code class="hljs language-java">public class Register extends ActionSupport implements ModelDriven
</code></pre>
Why can it not be:
<pre><code class="hljs language-java">public class Register implements ModelDriven extends ActionSupport 
</code></pre>
The latter produces a compile-time error.

I have to print the EST time in my Java application. I had set the time zone to EST using:

    Calendar cal = Calendar.getInstance(TimeZone.getTimeZone(&quot;EST&quot;));

But when the daylight savings is being followed in this timezone, my code does not print the correct time (it prints 1 hour less).

How to make the code work to read the correct time always, irrespective of whether the daylight savings are being observed or not?

PS: I tried setting the timezone to EDT, but it doesn&#39;t solve the problem.


How to tackle daylight savings using TimeZone in Java

I just started using Maven and I read that plugins are additional components that can be used.   
A typical structure of `pom.xml` file is

&lt;!-- language: xml-lang --&gt;

    &lt;project&gt;
      &lt;groupId&gt;org.koshik.javabrains&lt;/groupId&gt;
      &lt;artifactId&gt;JarName&lt;/artifactId&gt; (A fldernamed JarName was created) 
      &lt;version&gt;1.0-SNAPSHOT&lt;/version&gt;
      &lt;packaging&gt;jar&lt;/packaging&gt;
    
      &lt;name&gt;JarName&lt;/name&gt;
      &lt;url&gt;http://maven.apache.org&lt;/url&gt;
    
      &lt;properties&gt;
        &lt;project.build.sourceEncoding&gt;UTF-8&lt;/project.build.sourceEncoding&gt;
      &lt;/properties&gt;
    
      &lt;dependencies&gt;
        &lt;dependency&gt;
          &lt;groupId&gt;junit&lt;/groupId&gt;
          &lt;artifactId&gt;junit&lt;/artifactId&gt;
          &lt;version&gt;3.8.1&lt;/version&gt;
          &lt;scope&gt;test&lt;/scope&gt;
        &lt;/dependency&gt;
      &lt;/dependencies&gt;
    &lt;/project&gt;

**Question**: Where should I insert a `plugin` tag? such as the following:

    &lt;plugin&gt;
      &lt;groupId&gt;org.jibx&lt;/groupId&gt;
      &lt;artifactId&gt;jibx-maven-plugin&lt;/artifactId&gt;
      &lt;version&gt;1.2.4&lt;/version&gt;
      &lt;executions&gt;
        &lt;execution&gt;
          &lt;goals&gt;
            &lt;goal&gt;bind&lt;/goal&gt;
          &lt;/goals&gt;
        &lt;/execution&gt;
      &lt;/executions&gt;
    &lt;/plugin&gt;

Before the dependency or after the `dependency` tag? Does it matter?

Plugins in Maven and POM.xml

I&#39;m Working on document classification tasks in java.

 Both algorithms came highly recommended, what are the benefits and disadvantages of each and which is more commonly used in the literature for Natural Language Processing tasks? 



What are the major differences and benefits of Porter and Lancaster Stemming algorithms?

Recently, I decided to start learning about java web services and when I started to search a tutorial for java web-services in google, I found out that there are many types of webservices XML based, SOAP based, also RESTful webservices. 

Also, I found that there is a JAX-WS specification for xml based web-services, and JAX-RS specification for creating RESTful webservices. 

Q1) I got confused, it would be great if anybody can help me understanding the difference between these different type of webservices, so that I can decide which one to learn first.

Q2) Also, I want to learn in-depth about creating different types of web-services in java. Is there any tutorial or resources which can give an insight to each kind of webservice and a comparison between them.  

Q3) based on what scenarios and conditions should I decide that I want to create an XML based web-service rather than a SOAP service or I should go with RESTful service.

I need to learn Web Services in Java. What are the different types in it?

I have a webservice which is accepting a POST method with XML. It is working fine then at some random occasion, it fails to communicate to the server throwing IOException with message `The target server failed to respond`. The subsequent calls work fine. 

It happens mostly, when i make some calls and then leave my application idle for like 10-15 min. the first call which I make after that returns this error. 

I tried couple of things ... 

I setup the retry handler like
			

    HttpRequestRetryHandler retryHandler = new HttpRequestRetryHandler() {
				
				public boolean retryRequest(IOException e, int retryCount, HttpContext httpCtx) {
					if (retryCount &gt;= 3){
						Logger.warn(CALLER, &quot;Maximum tries reached, exception would be thrown to outer block&quot;);
						return false;
					}
					if (e instanceof org.apache.http.NoHttpResponseException){
						Logger.warn(CALLER, &quot;No response from server on &quot;+retryCount+&quot; call&quot;);
						return true;
					}
					return false;
				}
			};
			
			httpPost.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, retryHandler);

but this retry never got called. (yes I am using right instanceof clause). While debugging this class never being called. 

I even tried setting up `HttpProtocolParams.setUseExpectContinue(httpClient.getParams(), false);` but no use. Can someone suggest what I can do now? 


**IMPORTANT**
Besides figuring out why I am getting the exception, one of the important concerns I have is why isn&#39;t the retryhandler working here? 

Apache HttpClient Interim Error: NoHttpResponseException

Please explain in an easy to understand language or a link to some article.

Implements vs extends: When to use? What&#39;s the difference?

How do I call a super constructor in Dart? Is it possible to call named super constructors?

How do I call a super constructor in Dart?

Can an interface extend multiple interfaces in Java? This code appears valid in my IDE and it does compile:

    interface Foo extends Runnable, Set, Comparator&lt;String&gt; { }

but I had heard that multiple inheritance was not allowed in Java. Why does there appear to be an exception for interfaces?

Can an interface extend multiple interfaces in Java?

I want to save my time and reuse common code across classes that extend PIXI classes (a 2d webGl renderer library).

**Object Interfaces:**

    module Game.Core {
        export interface IObject {}
    
        export interface IManagedObject extends IObject{
            getKeyInManager(key: string): string;
            setKeyInManager(key: string): IObject;
        }
    }

My issue is that the code inside `getKeyInManager` and `setKeyInManager` will not change and I want to reuse it, not to duplicate it, here is the implementation:

    export class ObjectThatShouldAlsoBeExtended{
        private _keyInManager: string;
    
        public getKeyInManager(key: string): string{
            return this._keyInManager;
        }
    
        public setKeyInManager(key: string): DisplayObject{
            this._keyInManager = key;
            return this;
        }
    }

What I want to do is to automatically add, through a `Manager.add()`, the key used in the manager to reference the object *inside* the object itself in its property `_keyInManager`.

So, let&#39;s take an example with a Texture. Here goes the `TextureManager`

    module Game.Managers {
        export class TextureManager extends Game.Managers.Manager {
    
            public createFromLocalImage(name: string, relativePath: string): Game.Core.Texture{
                return this.add(name, Game.Core.Texture.fromImage(&quot;/&quot; + relativePath)).get(name);
            }
        }
    }

When I do `this.add()`, I want the `Game.Managers.Manager` `add()` method to call a method which would exist on the object returned by `Game.Core.Texture.fromImage(&quot;/&quot; + relativePath)`. This object, in this case would be a `Texture`:

    module Game.Core {
        // I must extend PIXI.Texture, but I need to inject the methods in IManagedObject.
        export class Texture extends PIXI.Texture {
    
        }
    }

I know that `IManagedObject` is an interface and cannot contain implementation, but I don&#39;t know what to write to inject the class `ObjectThatShouldAlsoBeExtended` inside my `Texture` class. Knowing that the same process would be required for `Sprite`, `TilingSprite`, `Layer` and more.

I need experienced TypeScript feedback/advice here, it must be possible to do it, but not by multiple extends since only one is possible at the time, I didn&#39;t find any other solution.

Typescript: How to extend two classes?

Suppose I have a pure abstract class (that is, an abstract class without any implementation):

    abstract class A {
        abstract m(): void;
    }

Like in C# and Java, I can **extend** the abstract class:

    class B extends A {
        m(): void { }
    }

But *unlike* in C# and Java, I can also **implement** the abstract class:

    class C implements A {
        m(): void { }
    }

How do classes `B` and `C` behave differently? Why would I choose one versus the other?

(Currently, the TypeScript [handbook](http://www.typescriptlang.org/Handbook) and [language specification](https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md) don&#39;t cover abstract classes.)

Extending vs. implementing a pure abstract class in TypeScript

I would like to know what ***Man*** and ***Child*** have in common and how they differ.

&lt;!-- language: lang-ts --&gt;

    class Person {
      name: string;
      age: number;
    }
    class Child extends Person {}
    class Man implements Person {}

Content Type	Original Author	Original Content on Stackoverflow
Question	lzjun	View Question on Stackoverflow
Solution 1 - Java	Nathaniel Ford	View Answer on Stackoverflow
Solution 2 - Java	trutheality	View Answer on Stackoverflow

Why "extends" precedes "implements" in class declaration

Java Problem Overview

Java Solutions

Solution 1 - Java

Solution 2 - Java

A somewhat painful triple-nested ternary operator

MongoDB Node findone how to handle no results?

Attributions