Please help me clear this confusion its bugging me alot. When I write the following code what happens in the memory and how is the object Jhon stored?(If I am correct that Jhon is an object and not merely a reference to an object)
class Human{
String Name;
float height;
}
class Student extends Human{
int Student_ID;
Student Jhon = new Student();
}
My question is, is Jhon an object or is it a reference to an object created? what is the reference variable here? What is an object variable here?
I'd say this is well-explained by the following line from JLS:
The value of a class instance creation expression is a reference to the newly created object of the specified class.
So, in the following code:
Student Jhon = new Student();
^-----------^ Class instance creation expression
^----------^ Variable declaration
To reiterate: the value of the class instance creation expression is the reference to a newly created object. That object is created somewhere in memory; but the key point is that the value isn't that object, but a reference to it.
And then you assign that reference to a variable, Jhon. So Jhon is not an object, nor a reference, but a variable whose value is a reference to a variable.
Just to add to #Andy Turner's response. Jhon is a variable that points to the reference to an instance of the class student that is held in the Java Virtual Machine (JVM) memory heap. The programmer has no way of directly accessing the object in the heap, that is all done by the JVM. The heap is managed by the JVM, when an object in the heap no longer has a variable that points to the reference to it, it will be cleaned up by the JVM garbage collection. The programmer does not have to concern themselves with this process.
See more detailed explanantion in official Oracle docs
Also see helpful disccusion in opening chapter of David Eck's book
I am teaching myself Java, and one of the review exercises in my book asks for the difference between an "object" and an "object variable."
I know what an object is (a specific instance of a class), but I can't seem to find the term "object variable" anywhere in the book (no answers section) or on the internet.
Does anyone know the meaning of this term?
I'll bite.
The Object is the instance itself, whereas the Object Variable is the reference to the Object.
Here's a contrived example:
Object o = new Object();
Object ref1 = o;
In his case, there is a single instance of the Object, but it is referenced by two Object Variables: o and ref1.
When an Object is no longer referenced by an Object Variable, the Object is garbage collected.
It's a synonym of "instance variable":
class A {
static int m; // <-- class variable
int n; // <-- instance variable
...
}
Evidently, this term is not so commonly used, and it would better to avoid any potential ambiguities by just sticking with "instance variable".
tl;dr;fmoe
I came across the same question in a review exercise found within Cay Horstmann, Big Java, Early Objects (John Wiley & Sons, 2013), 73.
Cay defines an object variable as a variable (whose type is a class) which stores a reference to the memory location of an object.
Rectangle box = new Rectangle();
box is the object variable which stores a reference to the newly instantiated Rectangle object's memory location.
Multiple object variables can exist which store the same reference to an object's memory location.
Rectangle box = new Rectangle(5,10,20,30);
Rectangle box2 = box;
Calling a mutator/mutagenic method (modifies the object on which the method is invoked) on either object variable mutates (modifies) the object since the object variables reference the same object's memory location
box2.translate(15, 25);
System.out.println(box.getY()); // 35.0
System.out.println(box2.getY()); // 35.0
This gets a bit confusing if you compare Cay's definition with the information from The Java Tutorials, and numerous other sources, but I believe this is the answer to your question when placed within the context of Cay's book(s).
I prefer this perspective => An object's memory location is stored in the object reference (object variable per Cay). When I invoke a method on an object, I specify the object reference followed by the dot (.) operator, followed by the method name.
objectReference.method();
If the public interface of a class allows access to one or more of it's instantiated object's fields (AKA instance variables, object variables, class member variables, properties, or attributes... depending on programming language and documentation) then I can access it by specifying the object reference, followed by the dot (.) operator, followed by the field name
objectReference.fieldName;
Why do I prefer this? I'm not a fan of using variable as a noun too many times; overloaded semantics boggle my simple mind.
#Faaris Cervon : Object variables are the variables which does not create any object but refer to some object ..
exmp : Date d1= new Date();
d1 is a object.
date d2;
d2 is not an object and neither it refers any object But it can hold any object of type date.
d2=d1; // valid.
hence d2 is a object variable.
It is important to remember that object variables does not contains objects actually but it refers to some object.
I found something that help you too.
There are few words like object, object variable and object reference.
Object variable and object reference are similar in the way that object variable stores the reference of an object where as object reference describes the location of an object. (You might be confused here so just consider them as same)
consider an example::
Class Car{
....
....
}
Car AudiQ7; //S1
Car AudiQ8 = new Car(); //S2
Here in S1 we created only object. Means it does not refer to memory.
In S2 we created an object variable/reference means it refers to memory location.
At university its tought, that an Object Variable is: "a variable whose type is a class, and which holds a reference to an object that is an instance of that class"
Object thing = new Object();
I am preparing for a certification exam and I don't understand this code:
Main:
public class TestStudent {
public static void main(String[] args) {
Student bob = new Student();
Student jian = new Student();
bob.name = "Bob";
bob.age = 19;
jian = bob;
jian.name = "Jian";
System.out.println("Bob's Name: " + bob.name);
}
}
Class:
public class Student {
public String name = "";
public int age = 0;
public String major = "Undeclared";
}
Why does this output "Bob's Name: Jian"?
Bob.name was never set to Jian. Obviously it must be because "jian = bob;" but i thought that would only set jian variables to the same as bob. What is this concept called and where is it explained in java tutorials?
Assignments in Java do not copy objects, they copy references. After this assignment
jian = bob;
your jian is no longer pointing to the Student object that you have allocated and assigned to jian, it's the same as bob, creating an alias to the same object. The original jian is now irretrievably lost, becoming eligible for garbage collection.
The following assingment
jian.name = "Jian";
overwrites the name in the bob variable through its jian alias, leading to the result that you see.
Look at the code `"jian = bob;"
You changed the reference of the bob object and set it to jian.
Then setting jian.name = "Jian" Also changes the bob object
now your jian object reference points on the same memory part as object reference bob, so if you change one of them - it will affect both of them, cause now they are the same object.
That's because bob and jian (like all non-primitive variables in java) are references (pointers to objects) rather than objects. So when you say jian = bob;, that makes jian point at the same object as bob.
This is a fundamental concept in Java: all object variables - that is, objects such as bob and jian which represent instances of Java Classes - are references. This concept is also referred to as pointers in languages such as C.
This means that your variable bob does not, conceptually, hold the values of the name, age and major fields, instead it points to a location in memory which holds the data. Accordingly, when you use an assignment operator (that's the = symbol) with object reference variables, you are simply changing which part of memory that variable points to. So the line:
bob = jian
means that the variable bob now refers to the same area of memory as jian, and anything you do in one will be reflected in the other.
This leaves an interested question of what has happened to the area of memory which holds Bob's data. Since we no longer have a reference to it, it is no longer possible for us to get hold of it, even though it still exists somewhere in memory (although Java will soon notice and clear it up - known as garbage collection).
Anyway, this sort of concept is better expressed diagrammatically, so I suggest looking at the official Java documentation or this tutorial.
The variables bob and jian are object references. See http://docs.oracle.com/javase/tutorial/java/javaOO/objectcreation.html
This article contains an example similar to yours: http://www.informit.com/articles/article.aspx?p=174371&seqNum=4
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.
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.
In line 2, you give this address to another method, callBar. Let's jump to that method next.
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.
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:
Ask JVM to build a house. It does, and gives us the address. We copy this address to a card named myFoo.
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.
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.
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.