Core Java - II:
A constructor is a block of code-like methods. It is called when an instance of a class is created. When the constructor is called, the memory for the object is allocated in heap memory.
2-types → No-arg constructor, Parameterized constructor.
Constructor overloading can also be done.
- The physical address where a particular object is stored in memory is called a reference.
A static variable acts as a common variable to all the instances of a class.
If the variable is changed in one instance of a class, the same will be reflected in all the other instances which are created before and after the change.
And a static variable can be directly accessed from a class ([i.e.], without being instantiated).
An instance variable is not common to all the instances of a class.
And an instance variable cannot be accessed directly from a class.
It should be accessed from the instance of the class ([i.e.], object of the class).
Instance variables are also called Member variables.
Static methods can be called directly from the class instead of an instance.
These methods are not dependent on the objects of a class and its variables.
Static methods cannot access instance methods and instance variables directly. It can only access static variables.
Instance methods need to be called from an instance of a class.
Instance methods can access both instance and static methods and variables directly.
Multiple methods that have the same name but a different number of parameters and, the same or different return types.
The method to be run will be calculated according to the method name, return type and the number of arguments given during compilation.
Method Overloading is called Compile Time Polymorphism, as the compiler is the one that decides which method is to be run.
Both static and instance methods can be overloaded.
Defining a method in a child class that already exists in the parent class with the same name, the same number of parameters, and same return type.
Method overriding is called Run Time Polymorphism, as the method to be run is decided during runtime.
Only instance methods can be overridden.
Only inherited methods can be overridden.
Constructors, Private methods, and final methods cannot be overridden.
Autoboxing & Unboxing:
Autoboxing means converting a primitive int value to an Integer class value.
Unboxing means converting an Integer class value to a primitive int value.
Composition describes a has-a relationship link.
Instead of extending a class and inheriting all the functionalities of a parent class, the class will be used as a datatype of an instance variable in another class. This way, the functionalities can also be inherited.
As Java doesn't support multiple inheritances, the same can be achieved by using composition.
We can create multiple instance variables with different datatypes, which in turn point to different classes in this case.
These parameters are called Type Parameters.
Enables types (classes and interfaces) to be parameters when defining classes, interfaces, and methods.
The benefit is to eliminate the need to create multiple versions of methods or classes for various data types.
We can use one version of the methods to handle all the reference data types.
There is also bounded types where you can create the objects of a generic class to have data of specific derived types [e.g.] Number. In case the Number class is extended, only the subclasses of Number can be passed through that generic class as data.
The part of the application where the variable is accessible is called the scope of that variable.
There are three types of scopes:
Class level → Accessed anywhere inside the class. The variables are called Class members.
Method level → Accessed only inside the method. The variables are called Local variables.
Block level → Accessed only inside blocks of code. [e.g.] Loops
Visibility tells us how the class, methods and variables can be accessed.
There are five types of access modifiers:
Public → Members can be reached from anywhere.
Protected → Members can only be reached from the same class, or from within the class.
Internal → Members can only be reached from the same project.
Protected Internal → Members can only be reached from the same project and those classes that inherit from the class, even from another project.
Private → Members can only be reached by other members of the same class.
If a variable is declared as final, the value of that variable cannot be changed.
If a method is declared as final, that method cannot be overridden.
If a class is declared as final, that class cannot be extended.
The package is a mechanism to encapsulate a group of classes, sub-packages and interfaces.
It helps in preventing naming conflicts.
Packages can be considered as data encapsulation or data hiding.
Mechanism to handle runtime errors so that the normal flow of the application can be maintained.
Some exceptions are,
Throwable class is the root class of the Java exception hierarchy inherited by two subclasses Exception and Error.
Types of Exception:
The classes that directly inherit the Throwable class except RuntimeException and Error are known as checked exceptions.
[e.g.] IOException, SQLException, etc.
Checked exceptions are checked at compile-time.
The classes that inherit the RuntimeException are known as unchecked exceptions.
[e.g.] ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException, etc.
Unchecked exceptions are checked at runtime.
Error is irrecoverable.
[e.g.] OutOfMemoryError, VirtualMachineError, AssertionError etc.
Keywords to handle exceptions:
Specifies a block where the exception code should be placed.
Always followed by either catch or finally.
Used to handle the exception.
This can be followed by finally block later.
- Used to execute the code of the program whether an exception is handled or not.
- Used to throw an exception.
Used to declare exceptions.
Specifies that there may occur an exception.
It doesn’t throw an exception.
It is always used with method signature.