Are you looking for:

    Super.class.isAssignableFrom(Sub.class)

If you want to know whether or not a `Class` extends another, use [Class#isAssignableFrom(Class&lt;?&gt;)][1]. For your example, it would be:

    if(B.class.isAssignableFrom(A.class)) { ... }

If you&#39;re interested in whether or not an instance is of a particular type, use `instanceof`:

    A obj = new A();
    if(obj instanceof B) { ... }

Note that these will return `true` if the class/instance is a member of the type hierarchy and are not restrictive to direct superclass/subclass relationships. For example:

    // if A.class extends B.class, and B.class extends C.class
    C.class.isAssignableFrom(A.class); // evaluates to true
    // ...and...
    new A() instanceof C; // evaluates to true

If you want to check for direct superclass/subclass relationships, [Tim has provided an answer][2] as well.


  [1]: http://download.oracle.com/javase/6/docs/api/java/lang/Class.html#isAssignableFrom(java.lang.Class)
  [2]: https://stackoverflow.com/questions/3504870/how-to-test-if-one-java-class-extends-another-at-runtime/3504901#3504901

You want to know if `b` &lt;a href=&quot;http://download-llnw.oracle.com/javase/1.5.0/docs/api/java/lang/Class.html#isAssignableFrom%28java.lang.Class%29&quot;&gt;is assignable from&lt;/a&gt; `a`:

    b.isAssignableFrom(a);

Additionally, if you want to know that `a` is a direct subclass of `b`:

    a.getSuperclass().equals(b);

There are many legends about them. I want to know the truth. What are the differences between the two following examples?

  1. `&lt;input type=&#39;submit&#39; value=&#39;text&#39; /&gt;`

  2. `&lt;button type=&#39;submit&#39;&gt;text&lt;/button&gt;`

Difference between &lt;input type=&#39;submit&#39; /&gt; and &lt;button type=&#39;submit&#39;&gt;text&lt;/button&gt;

What do I have to do to have a function on a website where it says it will redirect you to the site in 3 seconds or so? 

Redirect website after specified amount of time

How to I test if `a` is a subclass of `b`?

    Class&lt;?&gt; a = A.class;
    Class&lt;?&gt; b = B.class;



How to test if one java class extends another at runtime?

How to I test if <code>a</code> is a subclass of <code>b</code>?
<pre><code class="hljs language-ini">Class&#x3C;?> a = A.class;
Class&#x3C;?> b = B.class;
</code></pre>

How can I format the `&quot;2010-07-14 09:00:02&quot;` date string to depict just `&quot;9:00&quot;`?

Extract time from date String

I have implemented a few Java applications now, only desktop applications so far. I prefer to use immutable objects for passing the data around in the application instead of using objects with mutators (setters *and getters*), also called JavaBeans.

But in the Java world, it seems to be much more common to use JavaBeans, and I can&#39;t understand why I should use them instead. Personally the code looks better if it only deals with immutable objects instead of mutate the state all the time. 

Immutable objects are also recommended in **Item 15: Minimize mutability**, *Effective Java 2ed*.

If I have an object `Person` implemented as a **JavaBean** it would look like:

    public class Person {
        private String name;
        private Place birthPlace;
    
        public Person() {}
    
        public setName(String name) {
            this.name = name;
        }
    
        public setBirthPlace(Place birthPlace) {
            this.birthPlace = birthPlace;
        }
    
        public String getName() {
            return name;
        }
    
        public Place getBirthPlace() {
            return birthPlace;
        }
    }

And the same `Person` implemented as an **immutable** object:

    public class Person {
        private final String name;
        private final Place birthPlace;
    
        public Person(String name, Place birthPlace) {
            this.name = name;
            this.birthPlace = birthPlace;
        }

        public String getName() {
            return name;
        }
     
        public Place getBirthPlace() {
            return birthPlace;
        }
    }

Or closer to an `struct` in C:

    public class Person {
        public final String name;
        public final Place birthPlace;
    
        public Person(String name, Place birthPlace) {
            this.name = name;
            this.birthPlace = birthPlace;
        }
    }

I could also have getters in the immutable object to hide the implementation details. But since I only use it as a `struct` I prefer to skip the &quot;getters&quot;, and keep it simple.

Simply, I don&#39;t understand why it&#39;s better to use JavaBeans, or if I can and should keep going with my immutable POJOs?

Many of the Java libraries seem to have better support for JavaBeans, but maybe more support for immutable POJOs gets more popular over time?


Why shouldn&#39;t I use immutable POJOs instead of JavaBeans?

I have an object which has many bufferedimages in it, I want to create a new object copying all the bufferedimages into the new object, but these new images may be altered and i don&#39;t want the original object images to be altered by altering the new objects images.

is that clear?

Is this possible to do and can anyone suggest a good way to do it please?
I have thought of getSubImage but read somewhere that any changes to the subimage are relected back to the parent image.

I just want to be able to get a fresh entirely separate copy or clone of a BufferedImage


How do you clone a BufferedImage

The compiler seems to be ok with this (single digit hex values only):
    
    byte[] rawbytes={0xa, 0x2, 0xf};

But not this:

    byte[] rawbytes={0xa, 0x2, 0xff};

I get a &quot;Possible Loss of Precision found : int required : byte&quot; error?

What am I doing wrong - or are single digit hex numbers a special case ?

Java 1.5.x.


Literal Syntax For byte[] arrays using Hex notation..?

I am wondering at the difference between declaring a variable as `volatile` and always accessing the variable in a `synchronized(this)` block in Java?

According to this article http://www.javamex.com/tutorials/synchronization_volatile.shtml there is a lot to be said and there are many differences but also some similarities.

I am particularly interested in this piece of info:

&gt; ...
&gt;
- access to a volatile variable never has the potential to block: we&#39;re only ever doing a simple read or write, so unlike a synchronized block we will never hold on to any lock;
- because accessing a volatile variable never holds a lock, it is not suitable for cases where we want to **read-update-write** as an atomic operation (unless we&#39;re prepared to &quot;miss an update&quot;);

What do they mean by **read-update-write**? Isn&#39;t a write also an update or do they simply mean that the **update** is a write that depends on the read?

Most of all, when is it more suitable to declare variables `volatile` rather than access them through a `synchronized` block? Is it a good idea to use `volatile` for variables that depend on input? For instance, there is a variable called `render` that is read through the rendering loop and set by a keypress event?

Difference between volatile and synchronized in Java

Why did the Python designers decide that subclasses&#39; `__init__()` methods don&#39;t automatically call the `__init__()` methods of their superclasses, as in some other languages? Is the Pythonic and recommended idiom really like the following?

    class Superclass(object):
        def __init__(self):
            print &#39;Do something&#39;

    class Subclass(Superclass):
        def __init__(self):
            super(Subclass, self).__init__()
            print &#39;Do something else&#39;

Why aren&#39;t superclass __init__ methods automatically invoked?

I need a working approach of getting all classes that are inherited from a base class in Python.

How to find all the subclasses of a class given its name?

I would like to test whether a class inherits from another class, but there doesn&#39;t seem to exist a method for that.

    class A
    end
    
    class B &lt; A
    end
    
    B.is_a? A 
    =&gt; false

    B.superclass == A
    =&gt; true

A trivial implementation of what I want would be:

    class Class
      def is_subclass_of?(clazz)
        return true if superclass == clazz
        return false if self == Object
        superclass.is_subclass_of?(clazz)
      end
    end

but I would expect this to exist already.

Test whether a Ruby class is a subclass of another class

Let&#39;s say that I have a class Suit and four subclasses of suit: Heart, Spade, Diamond, Club.

    class Suit:
       ...
    class Heart(Suit):
       ...
    class Spade(Suit):
       ...
    class Diamond(Suit):
       ...
    class Club(Suit):
       ...

I have a method which receives a suit as a parameter, which is a class object, not an instance. More precisely, it may receive only one of the four values: Heart, Spade, Diamond, Club. How can I make an assertion which ensures such a thing? Something like:

    def my_method(suit):
       assert(suit subclass of Suit)
       ...

I&#39;m using Python 3.


How do I check (at runtime) if one class is a subclass of another?

So say I have a subclass that extends a superclass. In what scenarios do I need to explicitly type `super()` to get the superclass constructor to run? 

I&#39;m looking at an example in a book about abstract classes and when they extend it with a non-abstract subclass, the subclass&#39;s default constructor is blank and there&#39;s a comment that says the superclass&#39;s default constructor will be called. At the same time I&#39;ve also seen instances on here where someone&#39;s problem was not explicitly calling `super()`. 

Is the distinction from calling the superclass&#39;s default/non-default constructor from the subclass&#39;s default/non-default constructor?

When do you need to explicitly call a superclass constructor?

I&#39;m trying to know if a class is an Enum, but I think I&#39;m missing something:

    if (test.MyEnum.class instanceof Enum&lt;?&gt;.class)
     obj = resultWrapper.getEnum(i, test.MyEnum.class);
    else 
     obj = resultWrapper.getObject(i);

It gives me an error saying that Enum&lt;?&gt;.class is not valid. So how I can check if a class is a Enum? I&#39;m pretty sure it is possible to determine that, I&#39;m just unable to get it.

Thanks


Checking if a class is java.lang.Enum

Is there anyway to detect if a JavaScript object is a regex?

For example, I would like to do something like this:

    var t = /^foo(bar)?$/i;
    alert(typeof t); //I want this to return &quot;regexp&quot;

Is this possible?

Thanks!

EDIT: Thanks for all the answers. It seems I have two very good choices:

    obj.constructor.name === &quot;RegExp&quot;

or

    obj instanceof RegExp

Any major pros/cons to either method?

Thanks again!

typeof for RegExp

I see gain in performance when using `getClass()` and `==` operator over `instanceOf` operator.
  
		
	Object  str = new Integer(&quot;2000&quot;);
	
	long starttime = System.nanoTime();

	if(str instanceof String) {
		System.out.println(&quot;its string&quot;);
	} else {
		if (str instanceof Integer) {
			System.out.println(&quot;its integer&quot;);
			
		}
	}

	System.out.println((System.nanoTime()-starttime));
	
	starttime = System.nanoTime();

	if(str.getClass() == String.class) {
		System.out.println(&quot;its string in equals&quot;);
	} else {
		if(str.getClass() == Integer.class) {
			System.out.println(&quot;its integer&quot;);
		}
	}

	System.out.println((System.nanoTime()-starttime));
	

Is there any guideline, which one to use `getClass()` or `instanceOf`?

Given a scenario: I know exact classes to be matched, that is `String`, `Integer` (these are final classes), etc.

Is using `instanceOf` operator bad practise ?


instanceof Vs getClass( )

I have a question of using switch case for `instanceof` object:

For example: my problem can be reproduced in Java:

    if(this instanceof A)
        doA();
    else if(this instanceof B)
        doB();
    else if(this instanceof C)
        doC():

How would it be implemented using `switch...case`?

Is it possible to use the instanceof operator in a switch statement?

Is there a way to determine if an object is an instance of a generic type?

    public &lt;T&gt; test(Object obj) {
        if (obj instanceof T) {
            ...
        }
    }

That clearly doesn&#39;t work. Is there an alternative? Like I want to use Java reflection to instantiate a class and then check to make sure it is of type generic `T`.


Content Type	Original Author	Original Content on Stackoverflow
Question	Armand	View Question on Stackoverflow
Solution 1 - Java	meriton	View Answer on Stackoverflow
Solution 2 - Java	Rob Hruska	View Answer on Stackoverflow
Solution 3 - Java	Tim Stone	View Answer on Stackoverflow

How to test if one java class extends another at runtime?

Java Problem Overview

Java Solutions

Solution 1 - Java

Solution 2 - Java

Solution 3 - Java

Redirect website after specified amount of time

Difference between <input type='submit' /> and <button type='submit'>text</button>

Attributions