Why wait(), notify() and notifyAll)() had to be on Object class than Thread

Reason: Reduce code-complexity and to avoid lot of additional lines of code.

Here is why:
Here is the producer-consumer problem that uses wait notify and notifyAll on Object Class:


Queue:
public class Queue {

private List numberQueue;
private final int MAX_SIZE = 5;
private int top = 0;
public void produce(Integer number) throws InterruptedException{
synchronized(numberQueue){
if(numberQueue.size() == MAX_SIZE)
numberQueue.wait();

numberQueue.add(number);
top =  top+1;
numberQueue.notifyAll();

}

}

public void consume() throws InterruptedException{
synchronized(numberQueue) {
if(numberQueue.size() == 0)
numberQueue.wait();

numberQueue.remove(top);
top = top-1;
numberQueue.notifyAll();

}
}


}



Producer:
public class Producer extends Thread{

Queue queue;

Producer(Queue queue){
this.queue = queue;
}

public void run(){

while(true){
Integer i = new java.util.Random().nextInt(50)+1;
try {
queue.produce(i);
} catch (InterruptedException e) {

e.printStackTrace();
}
}

}
}


Consumer:

public class Consumer extends Thread{

Queue queue;

Consumer(Queue queue){
this.queue = queue;

}

public void run(){

while(true){
try {
queue.consume();
} catch (InterruptedException e) {

e.printStackTrace();
}
}
}


}


ProdConsDemo:
public class ProdConsDemo {

public static void main(String[] args) {
Queue queue = new Queue();
Producer producer = new Producer(queue);
Consumer consumer = new Consumer(queue);

producer.start();
consumer.start();

}

}


I am not going to explain whats the program is all about since its pretty popular but what I am going to do is...Re-write the program considering wait, notify and notifyAll on Thread class.

Producer, Consumer and ProdConsDemo wont have to change since they dont have the wait/notifyAll methods. But below is the Queue class that gets changed with the highlighted lines of code.

Queue:

import java.util.List;
public class Queue {

private List numberQueue;
private final int MAX_SIZE = 5;
private int top = 0;
public void produce(Integer number) throws InterruptedException{
synchronized(numberQueue){

if(Thread.currentThread().getName() == "Producer" && numberQueue.size() == MAX_SIZE)
Thread.currentThread().wait();


numberQueue.add(number);
top =  top+1;
numberQueue.notifyAll();

}

}

public void consume() throws InterruptedException{
synchronized(numberQueue) {

if(Thread.currentThread().getName() == "Consumer" && numberQueue.size() == 0)
Thread.currentThread().wait();


numberQueue.remove(top);
top = top-1;
numberQueue.notifyAll();

}
}


}

The statement - Thread.currentThread().getName() is repetitive.


How to define the Shareable-Class:
Normally, the code inside the shared object is independent of the threads sharing it. And also, any critical section of the Shareable-class normally has a same/generalized business-logic across multiple threads. The logic won't vary from thread to thread.

Hence, in any critical section(a synchronized block or method), JVM needs the following 2 things to put the threads in wait or active state based on the locks.
1) Which is the currently running thread.
2) Which is the object on which the currently running thread acquired the monitor.

It is evident from the critical section that both the information can clearly be inferred by JVM. Then JVM will act as soon as it encounters the wait() irrespective of which class(Object or Thread) callling wait() or notify/notifyAll() methods.

Programming Language features(Under the hood) - Reuse, Scope, Code maintenance and Maintenance

I would like to discuss on how the ideas - Reuse, Scope, Code optimization and maintenance - drive one aspect of programming language design and ultimately its compiler or interpreter implementation.

To begin with, all or many existing programming languages up to some extent follow one or more of the fundamental paradigms such as - Functional, Declarative, Imperative/Procedural and Object Oriented.

A language is considered single paradigm type if it implements one of the paradigms and multi-paradigm language is the one which incorporates constructs from multiple paradigms.

    Hence, we can derive the fact that all existing programming languages have many characteristics in common. Below are some of the most important to list:

1) Variable and Constants

2) Control Structures

3) Inheritance

4) Encapsulation

5) Abstraction

6) Functions or Subroutines or Procedures

7) Arithmetic and logic operations

8) Type

etc.,

Lets analyze the above mentioned constructs/features and see where we get lead to...

1) Variables, Constants and their assignment: These are required by any programming language since they fairly constitute the fundamentals of computation.

2) Control Structures: 

   -> Decision making features - if else, switch case - describe the direction of flow of program. This can again be categorized to be in the lines of computation.

   -> Iterative structures - for, while, for each and do while -  though describe the typical behavior of performing computation (Executing set of instructions) but highlight the point of Repetition. This is actually refers to a kind of modularity which is nothing but code reuse.

3) Inheritance: This is one of the best examples of code-reuse. Be it Class based inheritance from Java & C# or Prototype based inheritance in Javascript, both eventually indicate the fair usage of Code-Reuse concept. A subclass inheriting the superclass's properties plainly mean reusing existing methods and data. The whole purpose is to code-reduction and promote reuse.

4) Encapsulation: There are two thoughts to encapsulation

a) Bundling data and code to get a new data type: This though indicates that in creating a new datatype but under the hood it conceptualizes Reuse of existing code in the form of creating object which refers to data and methods(nothing but lines of code acting on the data bundled to it). 

b) Access restriction on code: Imposing access restrictions such as public/private/protected mean nothing but deciding which blocks of code to be available to other developers to reuse to prevent misuse.

5)Abstraction: Concept of hiding the implementation details is called Abstraction. In case of Functional / Procedural languages, the functional/procedure is modeled as element of abstraction. Whereas in OOP, a class represents the unit of abstraction. So basically fundamental building block of a programming paradigm represents the level of abstraction. Lot has been said. Lot has been told about abstraction but finally what it means in terms of programming...Well this is also ultimately represents Code Reuse.

A function is defined as a block of code that can be called any number of times during computation of a problem. This facilitates developer to reuse same lines of code(if he wants to use) by calling the function/procedure/subroutine instead of re-writing the whole again.

Similar reasoning applies to Class in Java or C#. Where the lines of code along with data on which the methods apply are bundled into an element called Class and that can be reused if need be.

Based on the above scenarios, we can conclude that characteristic of abstraction is nothing but how efficiently it allows for code-reuse.

6)Functions or Subroutines or Procedures: They are introduced from the mathematical principles of set theory and functions.

Functions at last also are means of achieving re-usability of code.

7) Arithmetic and logic operations: Operations are nothing but the computations to be performed based on the instructions later resulting the desired output. Hence more or less they belong to category of Computation rather than language characteristic.

8) Data Type: Categorizing the data such as Text, Integers, float Binary etc - to manage memory efficiently and perform faster calculations is more of computational characteristic than something to do with code writing technique.

barring the computation features such as Variables, Constants, Control Structures, Arithmetic &  logic operations, Data Types etc...rest of the characteristics - - one way or the other way have the following principles under the hood.

1)Reuse

2)Scope

3)Code maintenance

4)Maintenance

Introduction to Java's Inheritance and Interfaces - Part 3

So far dynamic polymorphism is permitted within a Class hierarchy(thanks to Inheritance) but not across multiple hierarchies. What it means is...

Consider the following hierarchies of classes:
Parent: Car, Child1: BMWCar extends Car, Child2: BenzCar extends Car
Parent: Aeroplane, Child1: Boeing extends Aeroplane, Child2: AirBus extends Aeroplane

Now I want to create a program which uses the above class hierarchies where the requirement is to dynamically call cruise() based on a user input.
Requirement: If user enters 
     Benz   --> cruise() from BenzCar class should be executed
  BMW    --> cruise() from BMWCar class should be executed
  Boeing --> cruise() from Boeing class should be executed
  AirBus --> cruise() from AirBus class should be executed
  
Solution: 
This situation is quite common in OOPs programming. Here is the code below:

public class DemoInterface{

public static void main(String[] args){
Car car;
Airplane plane;
if(args[0].equals("Benz")){
car = new BenzCar();
}else if(args[0].equals("BMW")){
car = new BMWCar();
}else if(args[0].equals("Boeing")){
plane = new Boeing();
}else if(args[0].equals("AirBus")){
plane = new AirBus();
}else{
System.out.println("Invalid entry. Pls try again.");
}


//Calling the method
if(car != null)
car.cruise();
if(plane !=null)
plane.cruise();

}

}

Solution is okay...but observe the repetition:
car.cruise(); 
plane.cruise();

The method is called twice. Though it is necessary but can be avoided and has to be. Since this program contains just 2 different class hierarchies and we created two super-class obj-refs able to refer all other sub-class objects. But, What if it has many more.It might lead to more number of references. To optimize this situation, Java has provided Interface.

Interface(Def from Oracle):In the Java programming language, an interface is a reference type, similar to a class, that can contain only constants, method signatures, default methods, static methods, and nested types. Method bodies exist only for default methods and static methods. Interfaces cannot be instantiated—they can only be implemented by classes or extended by other interfaces.

I would say... Interfaces similar to SuperClass obj-ref referencing SubClass'Object for the benefits of code-optimization can do the same but accross multiple Class-Hierarchies. Its a level beyond the polymorphism achieved with Inheritance.

Notation: As in Class level inheritance, where super-class variable can refer any of its child class objects, An interface's variable too can refer any of its implementing classes. Lets use Interface in the above situation.

Figure followed by updated solution below shows how the hierarchy looks like if interface is used.

We can see, the super classes - Car & Airplane - implement CarOPlane interface containing the methods - cruise() and selfDrive(). Then, the child classes override those methods again.

Note: What methods that are qualified to be in Interface?
All those identical methods(methods with same signatures) which belong to multiple class-hierarchies can be part of Interface's definition.


Interface: 
public interface CarOPlane{
public void selfDrive();
public void cruise();
}

Updated solution:

public class DemoInterface{

public static void main(String[] args){
CarOPlane cop;                        //Creating an interface obj-ref
if(args[0].equals("Benz")){          
cop = new BenzCar();  //Assigning implementing class's object
}else if(args[0].equals("BMW")){
cop = new BMWCar();               //Assigning implementing class's object
}else if(args[0].equals("Boeing")){
cop = new Boeing();      //Assigning implementing class's object
}else if(args[0].equals("AirBus")){
cop = new AirBus();               //Assigning implementing class's object
}else{
System.out.println("Invalid entry. Pls try again.");
}


//Calling the method
if(cop != null)
cop.cruise();     //Calling the cruise() method. This is where the code is optimized

}

}

Summary of Interface benefits:
1) Code optimization: Repetition is reduced as a result code maintenance reduced too. Means..if some part of the repeated code need to be changed, it has to change at every repeated line of code.
2) Interface reference can refer objects span across multiple class hierarchies(A limitation in inheritance based). A level beyond polymorphism achieved with Inheritance.


Deadly Diamond of Death: Many Java professionals have an opinion that multiple-inheritance creates the problem of Deadly Diamond of Death(DDD) and Interface is the solution. But I wont agree. Here is my take...

In case of child-class inheriting a parent-class, the child basically inherits the code and does not require it to write the new code unless it really needs its own implementation. Hence, if a child tries to inherit from multiple parents containing identical methods(bodies may differ but do exit), the problem arises as to which parent's method need to inherit(DDD). Java does not allow this. 

But, same is not the case with Interfaces. They don't have implementation. Therefore, if a class implements several interfaces that have identical method-signatures only(but no bodies), it only imports method signatures and implements them. No confusion as to which code to implement since there is no code exist in interface's methods.

Introduction to Java's Inheritance and Interfaces - Part 2

Contd...

Lets now use the above classes in main program:

Objective: Based on an input from a user, the program has to use code from either Car or BenzCar or BMWCar.

Requirment: If the entry from use is Car then use the code from Car class similary for Benz and BMW.

Solution:

public class InheritanceDemo{

public static void main(String[] args){

if(args[0].equals("Car")){

Car car = new Car();

car.drive();          //Prints This is default drive implementation

car.accelerate();     //Prints This is default accelerate implementation

car.applyBrakes();    //Prints This is default applyBrakes implementation

}

else if(args[0].equals("Benz"){

BenzCar benz = new BenzCar();

benz.drive();         //Prints This is default drive implementation

benz.accelerate();    //Prints Accelerate slowly and steadily.

benz.applyBrakes();  //Prints This is default applyBrakes implementation

}

else if(args[0).equals("BMW"){

BMWCar bmw = new BMWCar();

bmw.drive();          //Prints Drive or move at highest speed all the time

bmw.accelerate();     //Prints Accelerate at brisk speed but steadily.

bwm.applyBrakes();    //Prints This is default applyBrakes implementation

}

else

System.out.println("Invalid Entry");

}

}

Notation: Super-class referencing Sub class object: So far, the code looks simple but there is an issue with the code. It contains lot of repetition.

car.drive();
benz.drive();
bmw.drive();

Like-wise the other methods - accelerate() and applyBrakes().
This repetition has made the program lengthy with more number of lines of code than required. As a result the code's compilation time increases. But there is a facility provided by Java's inheritance to optimize this kind of situations.

Use of the notation: Super class referencing Sub class object

Yes. The Super-class's or Parent-class's object reference can refer to its sub-class's or child class's object.

Car car = new BenzCar();
Car car = new BMWCar();



Lets use this notation in the above program.

public class InheritanceDemo{

public static void main(String[] args){

Car car;                 //Creating a Super class's object reference.

if(args[0].equals("Car")){
car = new Car();     //Assign a Class's object to its reference.
}
else if(args[0].equals("Benz"){

car = new BenzCar(); //Assign Subclass's object to its SuperClass's reference.


}
else if(args[0).equals("BMW"){
car = new BMWCar();  //Assign Subclass's object to its SuperClass's reference.
}

else
System.out.println("Invalid Entry");

car.drive();          //Prints based on input
car.accelerate();     //Prints based on input
car.applyBrakes();    //Prints based on input


}

}

Now see, how the code has shaped up with fewer number of lines with the new notation.
A Super-Class's object can behave(or morph or act) like its sub-class's object based on the object that it refers. This is called Runtime polymorphism or Dynamic polymorphism. An important concept closely associated with efficient coding.

Introduction to Java's Inheritance and Interfaces - Part 1

Before beginning to learn Java as a programming language, it is equally important to learn the evolution of the Object Oriented Programming from the days of Machine language. Here, I am just providing a tiny history of how it evolved all along. Note that it is very very tiny. There are books written all over about these Programming Paradigms.

During the days of Machine Languages, the coding is very difficult as it forces developers/coders to type instructions in binary digits like below:

10110000 01100001

01100010 11100101

00100010 10101001

Hardly, readable isn't it?. That is when the Human-Readable-Mnemonics are invented to easily remember the binary instructions.

MOV AL, 61h

CPY CH, 21H

ADD CY, CB

SUB AB, NY

Mnemonics have somewhat reduced the difficulties involved in binary languages but not completely solved the problems. Lets study a case. Say we want the processor(CPU) to do the following:

1. Read 2 numbers

2. Add the numbers

3. Store the result in another variable

This can be coded straight away as follows:

READ A       //Read data from variable A

READ B       //Read data from variable B

ADD A,B      //Add contents of B to A

MOV A, AH    //Save the contents of A to memory location AH

This is sufficient for now. But, what if we want to perform the same operation multiple times in future? The code is going to be a long list of repeated instructions.

READ A

READ B

ADD A,B 

MOV A, AH

UPD A

UPD B

READ A

READ B

ADD A,B 

MOV A, AH

UPD A

UPD B

READ A

READ B

ADD A,B 

MOV A, AH

UPD A

UPD B

READ A

READ B

ADD A,B 

MOV A, AHA

And so on. This repetition of code is strictly unwanted and highly inefficient. So, in order to resolve this, what can be done is ..Group the repeated block of statements as Function. Then assign a name to it and call the function whenever that block of code is required(is to be repeated). This type of Code-Reuse is called Functional Abstraction also called Process Abstraction. A concept that changed the style of programming since then.

Now the above code can be re-written as:

function add(A,B){

UPD A

UPD B

READ A

READ B

ADD A,B 

MOV A, AH

}

add(10,20)

add(20,30)

add(30,40) ..And so on. 

Note: The repetition of above function call - add(10,20) - can be put in a loop. Loops and Conditional Statements etc are other programming language constructs.

Functional Abstraction: The concept of hiding implementation details from the user of the function. Means, a developer who wants to use add(A,B) function need not know about the actual code inside the function block. All he/she needs is how to use the function. What parameters are to be sent(Eg: A, B) and what it returns.

This paved the way for Functional Programming.

Well! Not stopping at this, then came along another type of abstraction called Data Abstraction - The central & dominant theme of Object oriented languages.

Data Abstraction: In its plain sense, hiding the data and only exposing the methods which operate on that data. So anyone who wants to perform any operation on the data, need to use those methods associated with it.

The binding of both data and its associated methods together in a single block is called Class and its instantiation is called Object - The building blocks of Object Oriented Programming.

Note: The newly created data structure - Class - is also termed as Abstract Data Type(ADT).

The abstraction in object oriented languages is implemented using 3 more concepts:

1. Inheritance

2. Polymorphism

3. Encapsulation

Strictly remember that Abstraction is not a feature of OOPs. This is as stated earlier the central theme.

Abstraction be it Process or Data is basically Code-Reuse if you observe carefully. How effectively the code can be re-used and maintained determines the efficiency of language. Hence, the 3 concepts revolve around achieving Data abstraction.

Inheritance(Def from Oracle): The idea of inheritance is simple but powerful: When you want to create a new class and there is already a class that includes some of the code that you want, you can derive your new class from the existing class. In doing this, you can reuse the fields and methods of the existing class without having to write (and debug!) them yourself.

Here is the example of code re-use in Inheritance:

Base Code:
public class Car{
String name;
String model;
String number;

public void getDetails(){

}

public void drive(){
system.out.println("This is default drive implementation");
}

public void accelerate(){
System.out.println("This is default accelerate implementation");
}

public void applyBraks(){
System.out.println("This is default applyBrakes implementation");
}
}


Re-use Sample 1:
public class BenzCar extends Car {

float price;
float company;


/*String name;
String model;
String number;*/    //Inherited from Parent Car. Code is re-used.

//Did not want the default code. Hence, code is written. Did not re-use.
public void accelerate(){
System.out.println("Accelerate slowly and steadily.");
}   


/*drive() & applyBraks()*/  //Inherited from Parent Car. Code is re-used

}


Re-use Sample 2:
public class BMWCar extends Car {

float price;
float company;
float brandName;


/*String name;
String model;
String number;*/    //Inherited from Parent Car. Code is re-used.

//Did not want the default code. Hence, code is written. Did not re-use.
public void accelerate(){
System.out.println("Accelerate at brisk speed but steadily.");
}

//Did not want the default code. Hence, code is written. Did not re-use.
public void drive(){
system.out.println("Drive or move at highest speed all the time");
}

/*applyBraks()*/  //Inherited from Parent Car. Code is re-used

}