R4R ----> SCJP1.5 Chapter06

Benefits of Encapsulation

Two benefit are there for the Encapsulation : > flexibility > maintainability. These benefits are not become atomatically , we have to do smthing for the enable those things. We should create a classes and code in a way that supports flexibility and maintainability. public clas More --- >>

every class must be a constructor including abstract class.A constructor looks like this: class Foo { Foo() { } // The constructor for the Foo class } constructors are used to initialize instance variable state, as follows: class Foo { int size; String name; Foo(String name, int size) { thi More --- >>

Constructors are invoked at runtime when we say new on some class type as follows : Horse h = new Horse(); But what really happens when we say new Horse() : > Horse constructor is invoked. > Animal constructor is invoked (Animal is the superclass of Horse). > Object constructor i More --- >>

Horse class with two constructors : class Horse { Horse() { } Horse(String name) { } } Will the compiler put in a default constructor for the class above? No! class Horse { Horse(String name) { } } Now will the compiler insert a default constructor class Hors More --- >>

Illegal Override Code | Problem with the Code ------------------------------------------------- private void eat() { } |Access modifier is more restrictive. ------------------------------------------------- public void eat() |Declares a checked thro More --- >>

Method Invocation Code | Result ---------------------------------------------------- Animal a = new Animal(); |Generic Animal Eating a.eat(); Generically ---------------------------------------------------- Horse h = new Horse(); |Horse eating hay h.eat(); More --- >>

HAS-A relationships bassically dependent on the usage, rather than inheritance. We can also say class A HAS-A B if code in class A has a reference to an instance of class B. For example, We can say the following : > A Horse IS-A Animal. A Horse HAS-A Halter. and the code looks like this : publi More --- >>

We will want to take advantage of some of the code in the superclass version of a method, yet still override it to provide some additional specific behavior.“Run the superclass version of the method, then come back down here and finish with my subclass additional method code.”It’s easy to do in code More --- >>

When the method is invoked more than one method of the same name might exist for the object type we’re invoking a method on.Deciding which of the matching methods to invoke is based on the arguments. If we invoke the method with a String argument, the overloaded version that takes a String is call More --- >>

In Object Oriented the concept of IS-A is based on inheritance. IS-A is a way of saying, “this thing is a type of that thing.” Our express the IS-A relationship in Java through the keyword extends: public class Car { // Cool Car code goes here } public class Subaru extends Car { // More --- >>

When we want to overload that code is shown : public void changeSize(int size, String name, float pattern) { } The following methods are legal overloads of the changeSize() method : public void changeSize(int size, String name) { } public int changeSize(int size, float pattern) More --- >>

Page 1