Question: I got introduced to OWL [here](http://www.w3schools.com/rdf/rdf_owl.asp) and [here](http://www.w3.org/TR/owl-guide/). And also seen few examples like...
<http://www.co-ode.org/ontologies/pizza/pizza.owl>

How should I run this example? Are there any tools to run these OWL files?

Is there any blog/site to see a working example of Ontology? An example to say..."This is the difference that Ontology makes..." kind of.

Answer: 
Direct assignment of an int literal to an Integer reference is an example of auto-boxing, where the literal value to object conversion code is handled by the compiler.

So during compilation phase compiler converts `Integer a = 1000, b = 1000;` to `Integer a = Integer.valueOf(1000), b = Integer.valueOf(1000);`.

So it is `Integer.valueOf()` method which actually gives us the integer objects, and if we look at the source code of [`Integer.valueOf()`](https://docs.oracle.com/javase/7/docs/api/java/lang/Integer.html#valueOf(int)) method we can clearly see the method caches integer objects in the range -128 to 127 (inclusive).

```
/**
 * Returns an {@code Integer} instance representing the specified
 * {@code int} value.  If a new {@code Integer} instance is not
 * required, this method should generally be used in preference to
 * the constructor {@link #Integer(int)}, as this method is likely
 * to yield significantly better space and time performance by
 * caching frequently requested values.
 *
 * This method will always cache values in the range -128 to 127,
 * inclusive, and may cache other values outside of this range.
 *
 * @param  i an {@code int} value.
 * @return an {@code Integer} instance representing {@code i}.
 * @since  1.5
 */
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

```

So instead of creating and returning new integer objects, `Integer.valueOf()` the method returns Integer objects from the internal `IntegerCache` if the passed int literal is greater than -128 and less than 127.

Java caches these integer objects because this range of integers gets used a lot in day to day programming which indirectly saves some memory.

The cache is initialized on the first usage when the class gets loaded into memory because of the static block. The max range of the cache can be controlled by the `-XX:AutoBoxCacheMax` JVM option.

This caching behaviour is not applicable for Integer objects only, similar to Integer.IntegerCache we also have `ByteCache, ShortCache, LongCache, CharacterCache` for `Byte, Short, Long, Character` respectively.

You can read more on my article [Java Integer Cache - Why Integer.valueOf(127) == Integer.valueOf(127) Is True](https://programmingmitra.com/2018/11/java-integer-cache.html).
Class `Integer` contains cache of values between -128 and 127, as it required by JLS [5.1.7. Boxing Conversion](https://docs.oracle.com/javase/specs/jls/se8/html/jls-5.html#jls-5.1.7 "Chapter 5. Conversions and Contexts"). So when you use the `==` to check the equality of two `Integer`s in this range, you get the same cached value, and if you compare two `Integer`s out of this range, you get two diferent values.

You can increase the cache upper bound by changing the JVM parameters:

```none
-XX:AutoBoxCacheMax=<cache_max_value>

```

or

```none
-Djava.lang.Integer.IntegerCache.high=<cache_max_value>

```

---

See inner [`IntegerCache`](https://hg.openjdk.java.net/jdk8/jdk8/jdk/file/687fd7c7986d/src/share/classes/java/lang/Integer.java#l769 "private static class IntegerCache, java 1.8") class:

```java
/**
 * Cache to support the object identity semantics of autoboxing for values
 * between -128 and 127 (inclusive) as required by JLS.
 *
 * The cache is initialized on first usage.  The size of the cache
 * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
 * During VM initialization, java.lang.Integer.IntegerCache.high property
 * may be set and saved in the private system properties in the
 * sun.misc.VM class.
 */

```

```java
private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        // high value may be configured by property
        int h = 127;
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

```