Object Oriented Programming
Object
Object is an instance of a class. All objects have a state and behavior.
Class
Class is the blueprint from which individual objects are created
Inheritance
Object-oriented programming allows classes to inherit commonly used state and behavior from other classes. In Java programming language, each class is allowed to have one direct superclass, and each superclass has the potential for an unlimited number of subclasses.
Interface
Methods form the object’s interface with the outside world. An interface is a group of related methods with empty bodies. Interface separates implementation and defines the structure. It is useful when the implementation changes frequently. Interface forms a contract between the class and the outside world.
Abstract Class
Abstract classes cannot be instantiated. It can only be used as a super class for other classes that extend the abstract class. Abstract classes are declared with keyword abstract. Abstract class methods can have implementations. Abstract class’s methods can’t have implementation only when declared abstract.
Encapsulation
Encapsulation is inclusion within a program object of all the resources needed for the object to function. It allows class to change its internal implementation without hurting the overall functioning of the system.
Polymorphism
Polymorphism is the ability to request that the same operations be performed by a wide range of different types of things.
Method overloading
Ability to define several methods all with the same name
Method overridding
Subclass overrides a specific implementation of a method that is already provided by one of its super classes.
References
JavaScript Arguments, Prototype, Constructor, Inheritance
Arguments
In every JavaScript function a private variable argument is automatically created, holding array of the arguments passed to the function.
Prototype
Every object has a special property, prototype. This property allows you to add properties/methods to all objects created from that object constructor. The prototype object loads before the object constructor does anything. Therefore by using prototype we can add properties, methods to both native objects and user-defined objects.
Constructor
Every instance of an object has a constructor property. It returns the Function object that created that instance of the object.
Inheritance
The prototype property is an object with no initial properties/methods. When we add properties/methods to this object, we automatically add them to all instances of the object. However, instead of adding properties/methods to the prototype object, we could replace the prototype object with an object that already has the properties/methods we want.
References
Java Collections
A collection is a object that groups multiple elements into a single unit.
List of core collection Java interfaces.*Collection - This interface is the least common denominator that all collections implement and is used to pass collections around and manipulate them where maximum generality is desired.
*Set - A collection that cannot contain duplicate elements
*List - A ordered collection that can contain duplicate elements. Elements can be accessed by their integer index.
*Queue - A collection which orders elements in first-in, first-out manner.
*Map - An object which maps keys to values. There cannot be duplicate keys.
*SortedSet - A set that maintains its elements in ascending order.
*SortedMap - A map that maintains its mappings in ascending order. Ways to traverse a collection.
*for-each
for (Object o : collection) System.out.println(o);
*Iterators - It enables to traverse a collection and to remove elements selectively. Iterator.remove is the only safe way to modify a collection during iteration
static void filter(Collection<?> c) { for (Iterator<?> it = c.iterator(); it.hasNext(); ) if (!cond(it.next())) it.remove(); } toArray method - translates collection to array.
Object[] a = c.toArray(); String[] a = c.toArray(new String[0]); Set Implementations.
*HashSet - Stores elements in hash table. Good performance, but makes no guarantee about order.
*TreeSet - Stores elements in red-black tree, orders elements by values, slower than HashSet. SortedSet implementation.
*LinkedHashSet - Implements a hash table with a linked list running through it, orders elements based on the order in which they were inserted. List Implementations.
*ArrayList - provides constant time positional access and is fast
*LinkedList - offers better performance under certain circumstances. If you add elements to beginning of list or iterate over the list to delete elements. Map Implementations.
*HashMap - Provides maximum speed, but not ordered.
*TreeMap - Ordered by the keys. SortedMap implementation.
*LinkedHashMap - Provides intermediate performance of the above two implementation. Ordered by insertion. References
http://docs.oracle.com/javase/tutorial/collections/interfaces/index.html
REST Principles
REST stands for Representational State Transfer
5 key principles of REST are -*Give everything a ID Examples http://example.com/orders/2007/11 http://example.com/products?color=green
-
Link things together Links help to refer to identifiable things
-
Use standard methods GET- To retrieve a representation. Its idempotent, meaning that has no additional effect if it is called more than once with the same input parameters PUT - update this resource with this data, or create it at this URI if it’s not there already. Its idempotent. DELETE - delete a resource. Its idempotent. POST - create a new resource. Its not idempotent.
-
Resources with multiple representations Provide multiple representations of resources for different needs.
-
Communicate statelessly A server should not have to retain some sort of communication state for any of the clients it communicates with beyond a single request. The most obvious reason for this is scalability — the number of clients interacting would seriously impact the server’s footprint if it had to keep client state.
References:
- https://www.ibm.com/developerworks/webservices/library/ws-restful/
- http://tomayko.com/writings/rest-to-my-wife
- http://www.infoq.com/articles/rest-introduction
Javascript Object oriented programming
*JavaScript is a prototype-based language which contains no class statement. Instead JavaScript uses functions as classes. Defining a class is as easy as defining a function.
*An object constructor/object constructor function is a function that’s used to define a new object. In this function, we declare the initial properties/methods of the new object, and usually assign them a pre-defined value.
*To create an instance of an object, we use the keyword “new”, followed by an object constructor. We can either use JavaScript’s built-in constructors to create a native object, or we can build our own constructors to create a user-defined object.
*Every object method has a variable – this – which refers to the current instance of that object from which the method is called. Example
function Computer(name) {
this.name=name;
this.getName=function() {
return this.name;
}
}
var computer1 = new Computer("Desktop-1");
alert(computer1.getName());//alerts Desktop-1
var computer2 = new Computer("Desktop-2");
alert(computer2.getName());//alerts Desktop-2