Classes, Objects, and Methods
Classes in the Java platform API libraries define a set of objects that share a Inheritance defines relationships among classes in an object-oriented language. Association is relation between two separate classes which establishes In Object-Oriented programming, an Object communicates to other Object to use. What is the relationship between classes and objects? as its type rather than one of Java's primitive types), the value stored in the variable is not an object.
Similarly, an instance variable in a subclass can shadow an instance variable of the same name in its parent class, as shown in Figure 6. The scope of shadowed variables In Figure 6. The actual variable selected depends on the scope in which we are working. In the previous example, all variables were of the same type.
About the only reason for declaring a variable with the same type in a subclass is to provide an alternate initializer. A more important use of shadowed variables involves changing their types.
We could, for example, shadow an int variable with a double variable in a subclass that needs decimal values instead of integer values. Both variables still exist; methods of the superclass see the original variable, and methods of the subclass see the new version. The determination of what variables the various methods see occurs at compile time.
However, both variables actually exist for a given instance of DecimalCalculator, and they can have independent values.
Relation between class and object
In fact, any methods that DecimalCalculator inherits from IntegerCalculator actually see the integer variable sum. Since both variables exist in DecimalCalculator, we need to reference the variable inherited from IntegerCalculator. We do that using the super reference: Another important point about shadowed variables has to do with how they work when we refer to an object by way of a less derived type. For example, we can refer to a DecimalCalculator object as an IntegerCalculator. If we do so and then access the variable sum, we get the integer variable, not the decimal one: Overriding Methods In Chapter 5we saw we could declare overloaded methods i.
Overloaded method selection works in the way we described on all methods available to a class, including inherited ones. This means that a subclass can define some overloaded methods that augment the overloaded methods provided by a superclass. But a subclass does more than that; it can define a method that has exactly the same method signature arguments and return type as a method in its superclass.
In that case, the method in the subclass overrides the method in the superclass and effectively replaces its implementation, as shown in Figure 6.
Overriding methods to change the behavior of objects is called sub-type polymorphism. Method overriding In Figure 6.
- Classes, Objects, and Methods
- Stay ahead with the world's most comprehensive technology and business learning platform.
- Related Content
The Cat class also adds the more unique behaviors of purring and hunting mice. But overridden methods are actually more powerful than that. For example, if we have a Cat instance assigned to a variable of the more general type Animal and we call its sleep method, we get the sleep method implemented in the Cat class, not the one in Animal: For example, access to a shadowed variable would find the implementation in the Animal class, not the Cat class.
However, because methods are virtual, the appropriate method in the Cat class can be located, even though we are dealing with an Animal object. This means we can deal with specialized objects as if they were more general types of objects and still take advantage of their specialized implementations of behavior.
A common programming error in Java is to miss and accidentally overload a method when trying to override it. Any difference in the number or type of arguments produces two overloaded methods instead of a single, overridden method.
Make it a habit to look twice when overriding methods. Overridden methods and dynamic binding In a previous section, we mentioned that overloaded methods are selected by the compiler at compile time.
Overridden methods, on the other hand, are selected dynamically at runtime. Even if we create an instance of a subclass, our code has never seen before perhaps a new object type loaded from the networkany overriding methods that it contains will be located and invoked at runtime to replace those that existed when we last compiled our code.
In contrast, if we load a new class that implements an additional, more specific overloaded method, our code will continue to use the implementation it discovered at compile time. Another effect of this is that casting i. Static method binding static methods do not belong to any object instance; they are accessed directly through a class name, so they are not dynamically selected at runtime like instance methods.
A static method in a superclass can be shadowed by another static method in a subclass, as long as the original method was not declared final. In Java, instance methods are, by default, dynamic. We have seen final used with variables to effectively make them constants.
When applied to a method, final means that its implementation is constant; no overriding allowed. Compiler optimizations When javac, the Java compiler, is run with the -O switch, it performs certain optimizations.
It can inline final methods to improve performance while slightly increasing the size of the resulting class file. Another kind of optimization allows you to include debugging code in your Java source without penalty. So when we compile with DEBUG set to false, calls to the debug method generate no residual code at all.
In some recent versions of Java, the -O switch is documented not to work at all! We document it here mainly for completeness. Method selection revisited By now you should have a good, intuitive idea as to how methods are selected from the pool of potentially overloaded and overridden method names of a class. If you are satisfied with your understanding, you may wish to skip this little exercise in logic.
In a previous section, we offered an inductive rule for overloaded method resolution. It said that a method is considered more specific than another if its arguments are assignable to the arguments of the second method.
We can now expand this rule to include the resolution of overridden methods by adding the following condition: What does that mean?
Well, the only classes whose types are assignable are classes in the same inheritance hierarchy. Since subclass types are assignable to superclass types, but not vice versa, the resolution is pushed, in the way that we expect, down the chain, toward the subclasses. This effectively adds a second dimension to the search, in which resolution is pushed down the inheritance tree towards more refined classes and, simultaneously, toward the most specific overloaded method within a given class.
When you override a method, the new method the overriding method must adhere to the throws clause of the method it overrides. In other words, if an overridden method declares that it can throw an exception, the overriding method must also specify that it can throw the same kind of exception, or a subtype of that exception.
By allowing the exception to be a subtype of the one specified by the parent, the overriding method can refine the type of exception thrown, to go along with its new behavior.
Herbivore is a subclass of Animal, so its eat method must also be able to throw an InedibleException.
8.1 Java | Class & Object Relationship
It can then add to and modify what it inherits. The class that inherits is called a subclass, and the class that it inherits from is said to be its superclass.
Modify the following class so that the two instance variables are private and there is a getter method and a setter method for each instance variable: To make a variable private, just add the word "private" in front of each declaration. We need two methods for each variable. One of them returns the value of the variable. The other provides a new value for the variable.
The names for these methods should follow the usual naming convention for getter and setter methods. Note that my setter methods use the special variable this so that I can use the same name for the parameter of the method as is used for the instance variable. This is a very common pattern. Explain why the class Player that is defined in the previous question has an instance method named toStringeven though no definition of this method appears in the definition of the class.
If a class is not declared to extend any class, then it automatically extends the class Object, which is one of the built-in classes of Java. So in this case, Player is a direct subclass of Object. The Object class defines a toString method, and the Player class inherits this toString method from Object. The methods and member variables in a class include not just those defined in the class but also those inherited from its superclass. Explain the term polymorphism.
Polymorphism refers to the fact that different objects can respond to the same method in different ways, depending on the actual type of the object. This can occur because a method can be overridden in a subclass. In that case, objects belonging to the subclass will respond to the method differently from objects belonging to the superclass. If B is a subclass of A, then a variable of type A can refer to either an object of type A or an object of type B.
Let's say that var is such a variable and that action is a method in class A that is redefined in class B. Consider the statement "var. Does this execute the method from class A or the method from class B? The answer is that there is no way to tell! The answer depends on what type of object var refers to, a class A object or a class B object. The method executed by var. This is the real meaning of polymorphism.
Java uses "garbage collection" for memory management. Explain what is meant here by garbage collection. What is the alternative to garbage collection? The purpose of garbage collection is to identify objects that can no longer be used, and to dispose of such objects and reclaim the memory space that they occupy. If garbage collection is not used, then the programmer must be responsible for keeping track of which objects are still in use and disposing of objects when they are no longer needed.
If the programmer makes a mistake, then there is a "memory leak," which might gradually fill up memory with useless objects until the program crashes for lack of memory. What is an abstract class, and how can you recognize an abstract class in Java. An abstract class is one that cannot be used to create objects.
It exists only as a basis for making subclasses, and it expresses all the properties and behaviors that those subclasses have in common. In Java, a class can be marked with the modifier abstract to make it abstract.
It will then be a syntax error to try to call a "new Vehicle" constructor. Only a class that has been marked as abstract can contain abstract instance methods.
Lesson 8: Object-Oriented Programming
Java makes it available automatically in instance methods. It can be used in instance methods, and it holds a reference to the object that contains the method or, in terms of messages, the object that received the message that is being processed.
It provides a way to refer to "this object. If doSomething is an instance method, it can also be called as this. For this problem, you should write a very simple but complete class. The class represents a counter that counts 0, 1, 2, 3, 4, The name of the class should be Counter. It has one private instance variable representing the value of the counter. It has two instance methods: Write a complete definition for the class, Counter.