What are classes, references, and objects?

I've been programming Java for 2 years now, and I have encountered a problem where I couldn't understand and differentiate class, reference, and an object.

I am not sure if a class or reference are the same, though I have an idea of what an object is.

Can someone differentiate in a complete manner what classes, references, and objects are?

All I know is that a class is more like a template for an object (blueprint to a house where the class is the blueprint and the house is an object).

If you like housing metaphors:

• a class is like the blueprint for a house. Using this blueprint, you can build as many houses as you like.
• each house you build (or instantiate, in OO lingo) is an object, also known as an instance.
• each house also has an address, of course. If you want to tell someone where the house is, you give them a card with the address written on it. That card is the object's reference.
• If you want to visit the house, you look at the address written on the card. This is called dereferencing.

You can copy that reference as much as you like, but there's just one house -- you're just copying the card that has the address on it, not the house itself.

In Java, you can not access objects directly, you can only use references. Java does not copy or assign objects to each other. But you can copy and assign references to variables so they refer to the same object. Java methods are always pass-by-value, but the value could be an object's reference. So, if I have:

Foo myFoo = new Foo();     // 1
callBar(myFoo);            // 2
myFoo.doSomething()        // 4

void callBar(Foo foo) {
    foo = new Foo();       // 3
}

Then let's see what's happening.

1. Several things are happening in line 1. new Foo() tells the JVM to build a new house using the Foo blueprint. The JVM does so, and returns a reference to the house. You then copy this reference to myFoo. This is basically like asking a contractor to build you a house. He does, then tells you the house's address; you write this address down.
2. In line 2, you give this address to another method, callBar. Let's jump to that method next.
3. Here, we have a reference Foo foo. Java is pass-by-value, so the foo in callBar is a copy of the myFoo reference. Think of it like giving callBar its very own card with the house's address on it. What does callBar do with this card? It asks for a new house to be built, and then uses the card you gave it to write that new house's address. Note that callBar now can't get to the first house (the one we built in line 1), but that house is unchanged by the fact that a card that used to have its address on it, now has some other house's address on it.
4. Back in the first method, we dereference myFoo to call a method on it (doSomething()). This is like looking at the card, going to the house whose address is on the card, and then doing something in that house. Note that our card with myFoo's address is unchanged by the callBar method -- remember, we gave callBar a copy of our reference.

The whole sequence would be something like:

1. Ask JVM to build a house. It does, and gives us the address. We copy this address to a card named myFoo.
2. We invoke callBar. Before we do, we copy the address written on myfoo to a new card, which we give to callBar. It calls that card foo.
3. callBar asks the JVM for another house. It creates it, and returns the new house's address. callBar copies this address to the card we gave it.
4. Back in the first method, we look at our original, unchanged card; go to the house whose address is on our card; and do something there.

When you code, you build an

> Instance (occurrence, copy)

of an

> Object

of a said

> Class

and keep a

>reference

to it, so you can call its methods.

Also, some OOP basics: Classes, Object, Instance, and Reference.

In the book "Thinking in Java" from Bruce Eckel it has been described perfectly:

"You might imagine a television (the object) and a remote control (the reference). As long as you’re holding this reference, you have a connection to the television, but when someone says, “Change the channel” or “Lower the volume,” what you’re manipulating is the reference, which in turn modifies the object. If you want to move around the room and still control the television, you take the remote/reference with you, not the television.

Also, the remote control can stand on its own, with no television. That is, just because you have a reference doesn't mean there’s necessarily an object connected to it. So if you want to hold a word or sentence, you create a String reference:

String s;

But here you’ve created only the reference, not an object. If you decided to send a message to s at this point, you’ll get an error because s isn’t actually attached to anything (there’s no television). A safer practice, then, is always to initialize a reference when you create it:

String s = "asdf";

However, this uses a special Java feature: Strings can be initialized with quoted text. Normally, you must use a more general type of initialization for objects.

When you create a reference, you want to connect it with a new object. You do so, in general, with the new operator. The keyword new says, “Make me a new one of these objects.” So in the preceding example, you can say:

String s = new String("asdf");

Not only does this mean “Make me a new String,” but it also gives information about how to make the String by supplying an initial character string. Of course, Java comes with a plethora of ready-made types in addition to String. What’s more important is that you can create your own types. In fact, creating new types is the fundamental activity in Java programming."

Suppose you write there two lines of code:

Engine app1 = new Engine(); //LINE 1

Engine app2  = app1; //LINE 2

In line 1, Engine is a class, its a blue-print basically.

new Engine() is the instance that is made on the heap.

You are refering that instance by using app1 and app2 in your code.

So app1 and app2 are the references.

When you create an object, what happens behind the scene is that a piece of memory is reserved for containing that object. This could be anywhere in the great big memory landscape; it's up to the operating system and the compiler, and you don't really have any control or knowledge of where it ends up.

Ask yourself, then, how do you use that object if you don't know where in memory it is? How can you read a value from it if you don't know where that value is stored? This is what references do for you. They are a way of keeping in touch with the object. It's a little string attached to the balloon that is a reference.

You use the reference to say that "I want to touch this object now!", or "I want to read a value from this object!".

========= Class and Object ===========

Class => ex: Person (More like imagination)

Object => ex: John, Mike (Real person)

=========== Reference ============

ex:

Television tv1; - (Television is a class, tv1 is a remote controller without Television)

Television tv2 = new Television(); - (Now tv2 remote controller has a Television)

tv1 = tv2; - (Now tv1 and tv2 can control same Television)

Television tv3 = new Television(); - (tv3 is a new remote controller with new Television)

Class: Structure or BluePrint

Object: Physical Manifestation

Reference: Address of Object

Class is a template, you are right. It is some knowledge about data structure. Object is that structure instance in memory. Reference is a memory address of that instance.

If by Object you meant the java identifier, then Object is the basic class for all complex Java classes.

Object is the run time representation of the Classdefinition. And the name with which you use the object is called the reference (as it references the actual object location in memory )

example

MyClass ref = new MyClass();

Here, MyClass is (contains) the class definition.

new MyClass() creates an object for this class (done only during execution, hence runtime representsion)

ref is the name you use to work on the class object, is the reference.

> Class : Used to define a real life entity into a programming environment.

Any real life entity having at least one property and a corresponding behaviour can be considered as a class. Lets take an example of a Car, it is having a property accelerator which helps the car to move and to control its speed. The corresponding behaviour is acceleration, which is directly proportional to the push applied to the accelerator.

class Car {
    private String tier;
    private String tierFriction;
    private double weight;
    private double gasFedToEngine;
}

The above class shows some properties of a Car, on which its acceleration depends. Behaviour (method in the class) always depends on the property(s) (global attribute(s) of the class). Now if you want more details you can define Tier as another entity, then the definition will look like

class Tier {
    private String tierMaterial;
    private String tierFriction;
    private double weight;
    private double tierDiameter;
}

class Car {
    private Tier tier;  // getting all properties of Tier here itself
    private double weight;
    private double gasFedToEngine;
}

> Object : Used to define various flavours of an Entity and to perform data manipulations on them separately.

Now we have defined an entity to our program, say we are having a showroom of used cars, having cars of different companies. So each car becomes an object of our entity. Objects can be Audi, Nissan, Ferrari etc. So after opening the showroom we add cars to it like this

static List<Car> showroomCars = new ArrayList<Car>();
public boolean addCarToShowroom() {
    Car carNissan = new Car();  // always creates a new objects and allocates some memory in heap
    carNissan.setName("Nissan");
    carNissan.setColor(RED);
    carNissan.setWeight(300);
    showroomCars.add(carNissan);

    Car carAudi = new Car();
    carAudi.setName("Audi");
    carAudi.setColor(BLACK);
    carAudi.setWeight(270);
    showroomCars.add(carAudi);
}

So now two new cars are added to the Showroom, one of Nissan and another one of Audi, each having their own specific attribute values.

Class only gives definition, manipulation is done on Object, for doing manipulation on any Class, object should be created. Every time an object is created to a class all its non-satic(instance) variables will load into memory with their respective default values.

> Reference : Used to address an object

When we say Car carAudi = new Car(); we define a new object to Car and a memory location is assigned for that object. The reference variable carAudi holds the memory address of that object. Object is never accessed directly by user, neither its memory location. That's where reference variable has significance, its stores the hexadecimal format of memory location. If we want to do modifications on an object do with the help of reference not directly.

An object can have any number of reference, but a reference can point only to one object at a time.

class Car {
    void test() {
        Car car1 = new Car();  // (1)
        Car car2 = new Car();  // (2)
        car2 = car1;
        /** 
         Says that car2 should point to where car1 points, so now both points to first object of Car
         But for this car2 has to loose its current object-(2), making it an Abandoned object (An object with no active reference from the stack).
        **/
    }
}

• In Real world, Object is a material thing that can be seen and touched in this universe.
• In Programming, Objects are same but those are stored or trapped inside a memory like when any object is being created. it will create in the RAM(Memory). So, As a human we will not be able to see it or touch it but it do exist in the memory somewhere.
• So, we don't care about how system is creating or destroying objects, rather we will see how to handle it using programming.
• In order to create an object, Programming language provide's us syntax format's which we can use handle these objects.
• Now, How you will define what object you want to create like if you want to create a customize new car then you have to provide your requirements to the manufacturer right?.
• Same way in programming, class is used. The class is a blueprint which will define how object should look like/what all data it will store and what all operation it will do. It doesn't exist in the memory and just used to define the requirements for creating an object.

Let's take an example of student:

//We have a Student class. Below are some attributes which we will use:
    class Student
    {
        string Name;
        int Age;
        string Address;
    }

Now, Above Student doesn't really exist. This is only a blue print of how student will be. If we need to create a student then we call it creating a object and below is the format to create one student.

Student student=new Student();

Now, 1 student object has been created in the memory which can be used to set any name/age/address and get the same information as shown below:

        static void Main(string[] args)
        {
            Student student = new Student();
            student.Name = "Vivek";
            student.Age = 24;
            student.Address = "Address";
            Console.Write("Student Name is " + student.Name + " whose age is " + student.Age + " and he/she stays at " + student.Address);
        }

Now, Assume you want to provide some work to Student, How will you do it?

//By writing a function/method and write the code which student should handle as below:
    class Student
    {
        public string Name;
        public int Age;
        public string Address;

        public void Run()
        {
            //Write some code
        }

        public void Walk()
        {
            //Write some code
        }
    }

Above one is just an example as student will not run in the memory, So, Code which you have to write is C# code only or whatever programming language which you are using to write code. Like do some operation with C#.

Now, I would like to highlight that:

• if you see in the real world. Student does not only contain Name/Address/Age but student also have other attributes like Mother Name/Father Name/Passport etc. In addition to normal attributes, We can also add body parts like Brain/Heart/Legs etc.
• So, Class Student can be more complex if you add all attributes to it.

Example: Your customize car will not customize all parts of your car. You have to use exisiting parts like wheels/tier/Air conditioner etc. So, Classes can use exisiting classes/struct/methods/fields etc. in order to achieve the requirement. As you can see below that class is using other classes/struct/methods/fields etc. in order to achieve the requirements:

        //String is also class which represents text as a sequence of UTF-16 code units
        public string Name;

        //Integer is a struct which represents a 32-bit signed integer
        public int Age;

        //String is also class which represents text as a sequence of UTF-16 code units
        public string Address;

Everything in Java is associated with class objects and classes, including attributes and methods. Ex: a car is an object in real life. The car has attributes, such as weight and color, and methods, such as drive and brake. A Class is like an object constructor or a "blueprint" for creating objects.

A reference is an address that indicates where an object's variables and methods are stored. You aren't actually using objects when you assign an object to a variable or pass an object to a method as an argument.