-->

What are classes, references and objects?

2019-01-02 20:18发布

问题:

I've been programming java for 2 years now, and apparently I have encountered a problem where I couldn't understand and differentiate class, reference, and an object again (I do not get why I forget these concepts).

Lets get to down to the problem, which is that I am not sure if a class or reference are the same, though I have already an idea what is object.

Can someone differentiate in a nice and understandable and complete manner what are classes, references and object?

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

回答1:

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.


回答2:

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.



回答3:

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."



回答4:

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.



回答5:

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!".



回答6:

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.



回答7:

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.



回答8:

========= 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)



回答9:

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).
        **/
    }
}


标签: