[NB: These are actually a set of posts which are points I noted down while learning Java from Core Java Volume I by Cay Horstmann and Gay Cornell. This is in no way an attempt to copy their material  or serve as a substitute; but serves only as a quick cheat sheet for me to look into important topics quickly]

The first part of this post can be read here.  In this part we will be mostly discussing inheritance.

- super keyword is used to access the methods of the super class.
- super can be used to call the constructor of the super class also.

- protected fields can only be accessed by sub classes.

Polymorphism – an object variable can actually refer to multiple actual types.
Dynamic binding – Actually selecting the appropriate method at run time.

Substitution principle - You can use  a subclass object whenever the program expects a super class object.
A variable of Employee can refer to an object of Employee or any subclass of employee (for eg Manager).

Manager boss = new Manager(...);
Employee[] staff = new Employee[3];
staff[0] = b0ss;

Here staff[0] and boss refer to the same object. However staff[0] is an Employee object and thus we cannot call the methods of Manager on it. So staff[0].setBonus() is wrong while boss.setBonus() is correct.

You cannot assign a super class object to a sub class variable. so Manager m = staff[i]; is wrong.

Arrays of sub class references can be converted to arrays of super class references without cast.

Manager[] managers = new Managers[4];
Employee[] staff = managers;

The above code is correct. Now both staff and managers refers to the same array. So though even when it is legal to say staff[0] = new Employee(…); it is incorrect to do staff[0].setBonus(); cause  it is an Employee variable which doesn’t have access to that method. All arrays remember the element type with which they are created , and they monitor only compatible references are stored into them.

- final classes aren’t extensible.
- a final method cannot be overridden in sub class.
- fields can also be final. A final field cannot be changed after the object has been constructed. However if a class is declared as final, only the methods , not the fields are automatically final.

Abstract Classes
- If a class has even one abstract method the class should be marked abstract.
- Abstract classes can have concrete methods and fields.
- If a class extending an abstract class hasn’t implemented all the abstract methods in the super class then it should also be termed as abstract class.
- A class can be declared as abstract even though it doesn’t have any abstract methods.
- An abstract class cannot be instantiated. But we can have object variables of abstract class, but such a variable must refer to an object of non abstract subclass. Also though we cannot call new on an abstract class they still have constructors.

Interface
- is a way of describing  what classes should do without specifying how they should do it.
- all methods in an interface is abstract.
- a class can implement more than one interface.
- Once we implement an interface in a class we should supply definitions to all the methods.
- Interfaces are not classes. Thus we cannot construct interface objects. But we can have interface variables. These variables should however refer to an object of a class that implements the interface.

[NB: These are actually a set of posts which are points I noted down while learning Java from Core Java Volume I by Cay Horstmann and Gay Cornell. This is in no way an attempt to copy their material  or serve as a substitute; but is serves only as a quick cheat sheet for me to look into important topics quickly]

Class – A template or blueprint from which objects are made.
Encapsulation – combining data and behavior in one package and hiding the implementation details from the user of the object.
Instance fields – data in an object.
Methods – procedures that work on data.
State – A specific object will have specific values for it’s instance fields. The set of those values are the current state of the object.

Constructors

• A constructor has the same name as the class.
• A class can have more than one constructor
• A class can take zero, one, or more parameters.
• Two constructors are different if the type and order are different. So ConsName(int size, String name) and ConsName(String name, int size) are different
• A constructor can have no return value. There can be a method with the same name as the class, but the difference of this class to that of constructor is the return type.
• A constructor is always called with the new operator.
• If no constructor was explicitly created a default constructor is generated automatically.
• The instance values will be initialized with default values in the default constructor.
• A constructor can call another constructor through the this() keyword.

- You can have only one public class in a source file but you can have any number of non public classes.
- Never write accessor methods that return references to mutable objects. Always clone those mutable references.
- A method can access the private data of all of the objects of its class.
- Final methods (mostly used as helper methods).
- Final instance fields must be initialized when the object is constructed and after which it will not be  modified again.
- Static fields: only one field per class.
- Static final fields: constants
- Static methods: You don’t need an object to call these methods. You cannot access instance fields from a static method.

- Java uses pass by value. Even in case of references it is pass by value. We get a copy of the reference which refers to the original object. That is why instance fields changes in case of references inside a method. But a swap of objects inside a method will not cause the original references to be swapped.

- Initialization blocks : These are executed whenever an object  of that class is constructed. No matter which constructor is called, first the initialization block is run then only the body of the constructor is run.
- Static initialization blocks:  to initialize static instance fields.

- The instance fields in a class will automatically get initialized but the local variables inside a method needs to be explicitly initialized.

- finalize() method is used to reclaim important resources, but it is not the safest method.

Packages
- for organizing your work
- to get unique class names and separate the classes from others provided by others.
- a class can use all classes from it’s own package and all public classes from other packages.
- if there is name clashes between two classes from different packages you can use specific imports or use full package names.
- you can use static imports to import static fields and methods.