Java Programming

Object & Class

Unified Modeling Language (UML) notation

Reference Variables and Reference Types and Instant Variables

Variables: Primitive Type and Reference Type

Static & Nonstatic

Visibility Modifier & Data field Encapsulation(private)

Immutable & mutable

String pool helps in saving a lot of space for Java Runtime although it takes more time to create the String.

• All data fields must be private.
• There can’t be any mutator methods for data fields.
• No accessor methods can return a reference to a data field that is mutable.

Class Abstraction & Encapsulation

Four Class Relationship

1. Association: general binary relationship that describes an activity between two classes. eg. (Student <--> Course <--> Faculty)

2. Aggregation: an ownership relationship between two objects. eg. (Student <-- Aggregation --> Address)

3. Composition: exclusively owned by an aggregating object. eg.(Student<-- Composition --> Name)

4. Inheritance

Wrapper Class(Method Requires) & Primitive Type(Performance)

Boxing & Unboxing:

Integer intObject = newInteger (2);        // boxing
Integer intObject = 2;                     // auto boxing

Double.MIN_VALUE = 1.4E–45;
Double.MAX_VALUE = 1.79769313486231570e+308d

Inheritance

Superclass & Subclass

• subclass extends superclass
• private data fields is superclass is accessible by outside class protected
• Java not allowed Multiple inheritance
• More information is subclass

Constructor Chaining

• super() invokes the no-arg constructor of its superclass
• In any case, constructing an instance of a class invokes the constructors of all the superclasses along the inheritance chain

Overriding vs Overloading

• Overloading

  1. occurs when two or more methods in one class have the same method name but different parameters.
  2. An be either in the same class or different classes related by inheritance.
  3. the same name but a different parameter list.

• Overriding: (Polymorphism)@override

  1. having two methods with the same method name and parameters. one in parent class, one in subclass. child class has specific implements.
  2. are in different classes related by inheritance
  3. have the same signature and return type

Object & toString()

1. Every class in Java is extended from the java.lang.Objectclass.
2. we should @override public String toString() otherwise output address of Object
3. System.out.print(Object) == System.out.print(Object.toString())
4. Output Array by one line System.out.print(Arrays.asList(array).toString());

Polymorphism

Polymorphism means that a variable of a supertype can refer to a subtype object

Declared Type & Actual Type

List<Integer> list = new ArrayList<>();

Method Matching & Dynamic Binding

Declared type decide matching by parameter type, number, order in Compile time

The JVM dynamically binds the implementation of the method at Runtime, decided by the actual type of the variable

Implicit casting & Explicit casting

Student b = (Student)o;      // explicit
Object o = new Student();    // implicit

Upcasting & instanceof

Upcasting : It is always possible to cast an instance of a subclass to a variable of a superclass

Instance of: The declared type decides which method to match at compile time

Object myObject = new Circle();
... 
// Some lines of code
/** Perform casting if myObject is an instance of Circle */ 
if (myObject instanceof Circle) {
  System.out.println("The circle diameter is " + ((Circle)myObject).getDiameter());
... 
}

Abstract and Interface