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: 
```
public class Scratch
{
   public static void main(String[] args)
    {
        Integer a = 1000, b = 1000;  //1
        System.out.println(a == b);

        Integer c = 100, d = 100;  //2
        System.out.println(c == d);
   }
}

```

**Output:**

```
false
true

```

Yep the first output is produced for comparing reference; 'a' and 'b' - these are two different reference. In point 1, actually two references are created which is similar as - 

```
Integer a = new Integer(1000);
Integer b = new Integer(1000);

```

The second output is produced because the `JVM` tries to save memory, when the `Integer` falls in a range (from -128 to 127). At point 2 no new reference of type Integer is created for 'd'. Instead of creating a new object for the Integer type reference variable 'd', it only assigned with previously created object referenced by 'c'. All of these are done by `JVM`. 

These memory saving rules are not only for Integer. for memory saving purpose, two instances of the following wrapper objects (while created through boxing), will always be == where their primitive values are the same - 

* Boolean
* Byte
* Character from **\u0000** to `\u007f` (7f is 127 in decimal)
* Short and Integer from **-128** to **127**
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() {}
}

```