Don't understand the reference thing.

Yep, that was a really bad place to put that video. But let me try to help.

==

When comparing to "primitives" (only two you have seen are char and int I think but there are more) == compares the values. example int x = 2; int y = 2; x == y is true;

now String is not a primitive(the dead giveaway is the S is capitalized) it is a object

Objects: When you define a class you are defining a blueprint for an object. You can think of this as if I was an architect and I came up with the blueprints for a house. Now I could ask a builder to make two identical houses Smiths House and Jones House. In Java this would look like this:

House smithsHouse = new House(); House jonesHouse = new House();

now if I use the == like this:

smithsHouse == jonesHouse the answer is false (answer to your second question).

Even if the Smith's and Jones both have the same number of people in their family. These are still two different houses(objects) now if I said that the Hilens lived with the Jones in the same house this would look like this in code:

jonesHouse = hilensHouse (thus hilensHouse could be said to be referencing joneHouse. question 1 );

Then we are talking about the same house with different names so:

jonesHouse == hilensHouse is true(third question).

If you are still with me great! Now that we have objects out of the way notice how I told Java to make a house(object) from my blueprint(class). Standard format for this is

Object someName = new object();

Notice the object() is actually the constructor which is named the same thing as the class. Keeping with the analogy of a house, you can think of this as the options field. In this case I am saying give me a standard house with no options denoted by the empty (). I could have given the customer the option to change things like maybe door color. If the Jones and the Smiths both wanted the same color doors would they still live in separate houses?

House smithsHouse = new House(redDoor) and house jonesHouse = new House(redDoor)

and so smithsHouse == jonesHouse.

Now taking it back to Strings when

String stringOne = new String("abc");
String stringTwo = new String("abc");

are defined in the standard object protocol like this, they are two different object just like smithsHouse and jonesHouse where above. So when you compare them:

stringOne == stringTwo the answer is false. (question 5)

Now that we are done with the other questions we come back to question land mind of question 4. Notice if I want to define string normally. This is done by typing

String someName = "some string"; String someOtherString = "some string";

Notice the lack of a constructor. There is no new String(). In this case the "some string" is not in a new object and because Java is looking to save on space it stores identical strings in the same place in memory. So now someName == someOtherString is true because Java has made it true to save space in memory and both fields are referencing the same thing. (question 1 again)

Hope this helped