Swapan Kumar Nandi

Yes, it can. Technically, there is nothing called object oriented programming. Object oriented programming mechanism is built over procedural language using 'this' pointer. Therefore, you can do OO programming using C itself as following - 1. Simply put the functions and data structure in a single file 2. Make the data structure static (equivalent to private in OO) 3. Mark all internal methods as static (equivalent to private in OO) 4. Those methods which will be accessed by the program outside of this file should not be static (equivalent to public OO) 5. Methods can take data structure instance as one of the arguments. (Not necessarily, functions should be invoked by any function pointer defined within the data structure)

1. C is a high level language mostly used for writing - - system software : operating system, compilers - tools : word processors, excel, paint brush etc - native (platform dependent) API for VM languages like, Java, .NET (C#, VB) - Interpreters of other languages e.g. PHP are written in C/C++ - writing communication software, switch, router, gateways 2. Many other languages e.g. Java, C#, PHP internally depend on interpreter/native API's that are written in C. 3. Without C other languages will not have any existence 4. C has to remain for other languages to exists

why can't we create an object for abstract class? why wait,notify,notifyall methods were in object class but not in thread class?

1. 'Why can't we create an object for abstract class?' Abstract class do not have any physical existence: Animal - Abstract super class Cat, Dog, Cow - Subclass of 'Animal' You can see Cat, Dog, Cow are roaming around physically but not Animal that way. 2. Why wait, notify, notifyall methods were in object class but not in thread class? If they would be there in the Thread class then in cases where you would create thread using Runnable instance (using object having 'Runnable' implementation) those wait, notify, notifyall methods would not be available - you had to write your own. Since they are defined in the Object class, we could use them in the above scenario today.

There are many answers that 'this' is a self reference can be used to invoke constructor, instance variable etc. etc. Now where from do we get this 'this' inside the methods or constructors of a class?. To use a variable like 'this' or any other, say 'length' inside a class methods or constructor it should either be an instance variable or a variable declared locally or local variable passed to the method or constructor as argument. In case of 'this' we do not do so but still we use it. Where from do we get this 'this' then? To understand this 'this' you need to know that object oriented constructs is build upon the procedural construct with some degree of illusion. Example: public class RectangleTest { public static void main(String[] args) { Rectangle rect = new Rectangle(); int x = rect.var; // Makes sense as 'var' is different for different objects int area = rect.getArea(); // Technically non-sense as the method 'getArea' is the same for all objects then why //rect.getArea(). It should rather be like int area = getArea(rect); // Java compiler converts the 'getArea' as follows //int area = getArea(rect); // CONVERSION 1 - at the point of usage // THIS ARGUMENT 'rect' BECOMES 'this' } } class Rectangle { private int length; private int breadth; public int var; // declared just for demo public Rectangle() { length = 30; breadth = 20; var = 1; } private boolean validateParameters() { if(length <= 0) return false; if(length <= 0) return false; return true; } public int getArea() { boolean isValid = validateParameters(); if(isValid == false) { // To raise exception } int area = length * breadth; return area; } // Java compiler converts the method getArea() and others as follows: //CONVERSION 2 - at the point of declaration /* public Rectangle(Rectangle this) { this.length = 30; this.breadth = 20; var = 1; } public int getArea(Rectangle this) { boolean isValid = validateParameters(this); if(isValid == false) { // To raise exception } int area = this.length * this.breadth; return area; } private boolean (Rectangle this) { if(this.length <= 0) return false; if(this.length <= 0) return false; return true; } */ } We know that memories are allocated for each object to accommodate instances of data members but methods and constructors are loaded into memory once irrespective of no of objects you create. Therefore, instances of data members are object specific but the methods are not. Then the following code inside main : int x = rect.var is meaningful whereas the following code inside main: int area = rect.getArea(); is technically non-sense as the method 'getArea' is the same for all objects then why to invoke on a object reference. It should rather be like int area = getArea(rect); to operate on an object. Actually, the java compiler does these required necessary transformations as marked above with the tags 'CONVERSION 1' and 'CONVERSION 2' both at the point of declaration of a method or constructor and at the point of usage. The java compiler adds an extra parameter of type self i.e. (here Rectangle this) as first parameter to every method and constructor. Thus we get this 'this'; This is actually a mechanism used by OOP language to implement object construct seating at the top of procedural language using or creating (whichever word you like better) a bit of illusion.

There are many answers that 'this' is a self reference can be used to invoke constructor, instance variable etc. etc. Now where from do we get this 'this' inside the methods or constructors of a class?. To use a variable like 'this' or any other, say 'length' inside a class methods or constructor it should either be an instance variable or a variable declared locally or local variable passed to the method or constructor as argument. In case of 'this' we do not do so but still we use it. Where from do we get this 'this' then? To understand this 'this' you need to know that object oriented constructs is build upon the procedural construct with some degree of illusion. Example: public class RectangleTest { Rectangle rect = new Rectangle(); int area = rect.getArea(); /* Technically non-sense as the method 'getArea' is the same for all objects then why rect.getArea(). It should rather be like int area = getArea(rect);*/ // Java compiler converts the 'getArea' as follows // int area = getArea(rect); CONVERSION 1 - at the point of usage // THIS ARGUMENT 'rect' BECOMES 'this' int x = rect.var; // Makes sense as 'var' is different for different objects } public class Rectangle { private int length; private int breadth; public int var; // declared just for demo public Rectangle() { length = 30; breadth = 20; var = 1; } public int getArea() { int area = length * breadth; return area; } // Gets converted to: /* CONVERSION 2 - at the point of declaration public int getArea(Rectangle this) { int area = this.length * this.breadth; return area; } */ } We know that memories are allocated for each object to accommodate instances of data members but methods and constructors are loaded into memory once irrespective of no of objects you create. Therefore, instances of data members are object specific but the methods are not. Then the following code inside main : int x = rect.var is meaningful whereas the following code inside main: int area = rect.getArea(); is technically non-sense as the method 'getArea' is the same for all objects then why to invoke on a object reference. It should rather be like int area = getArea(rect); to operate on an object. Actually, the java compiler does these required necessary transformations as marked above with the tags 'CONVERSION 1' and 'CONVERSION 2' both at the point of declaration of a method or constructor and at the point of usage. The java compiler adds an extra parameter of type self i.e. (here Rectangle this) as first parameter to every method and constructor. Thus we get this 'this'; This is actually a mechanism used by OOP language to implement object construct seating at the top of procedural language using or creating (whichever word you like better) a bit of illusion.