In real life, a car is an object.

A car has properties like weight and color, and methods like start and stop:

All cars have the same properties, but the property values differ from car to car.

All cars have the same methods, but the methods are performed at different times.

JavaScript Objects

You have already learned that JavaScript variables are containers for data values.

This code assigns a simple value (Fiat) to a variable named car:

var car = "Fiat";

The values are written as name:value pairs (name and value separated by a colon).

JavaScript objects are containers for named values.

Object Properties

The name:values pairs (in JavaScript objects) are called properties.

var person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};

Object Methods

Methods are actions that can be performed on objects.

Methods are stored in properties as function definitions.

var person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};

name = person.fullName();

<script>
var person = {
    firstName: "John",
    lastName : "Doe",
    id       : 5566,
    fullName : function() {
       return this.firstName + " " + this.lastName;
    }
};

document.getElementById("demo").innerHTML = person.fullName();
</script>

var x = new String();        // Declares x as a String object
    var y = new Number();        // Declares y as a Number object
    var z = new Boolean();       //	Declares z as a Boolean object

const object1 = {
  a: 'somestring',
  b: 42,
  c: false
};

console.log(Object.keys(object1));
// expected output: Array ["a", "b", "c"]
console.log(Object.keys(object1).length)  // output 3

Class: This is a programmer-defined datatype, which includes local functions as well as local data. You can think of a class as a template for making many instances of the same kind (or class) of object.

Defining a class

In class-based languages, you define a class in a separate class definition. In that definition you can specify special methods, called constructors, to create instances of the class. A constructor method can specify initial values for the instance's properties and perform other processing appropriate at creation time. You use the new operator in association with the constructor method to create class instances.

JavaScript follows a similar model, but does not have a class definition separate from the constructor. Instead, you define a constructor function to create objects with a particular initial set of properties and values. Any JavaScript function can be used as a constructor. You use the new operator with a constructor function to create a new object.

function myClass(){  // in javascript functions are class

}
// Adding properties and methods to the class

function myClass(){ 
	this.property1  //  private property without default value
	this.property2 = 5;  // declared with numeric value
	this.property3 = "World";  // declared with string value
    
	this.method1 = function method1(arg1){ // private method of myClass
		return arg1+"  "+this.property3;
    }
    
}

// instantiating of myClass
var instance1 = new myClass();

// Acessing method
var result = instance1.method1("Hello");
alert ( result);

The result will be :
Hello World

-----------------------------------------
Now if we create another instance of that class 

var instance2 = new myClass();
var result = instance2.method1("It is a beautiful");
alert(result);

The result will be :
It is a beautiful World
---------------------------------------------
// Acessing property of myClass
var result = instance1.property2;  
alert(result);  // restult will be 5

// We can change property value here
instance1.property2 =10;
var result = instance1.property2;
alert(result); // result will be 10 now

// Now we are accessing property2 through instanc2
var result = instance2.property2;
alert(result); // the value still 5 here,  becoz we didnt change the value here

Note: similarly we can chage propert3 value also

// now we can add method to our class using prototype

	myClass.prototype.method2 = function myMethod1(arg1){
	    this.property1 = arg1;
		return this.property1+"  "+this.property3;
    }

var instance2 = new myClass();
var result = instance2.method2("It is a beautiful");
alert(result);

// now we can add property to our class from outside using prototype
 myClass.prototype.property4 = "Garden";
 
 var result = instance1.property4;
 
 alert(result); // result will be garden now

Comparison of class-based (Java) and prototype-based (JavaScript) object systems:

• Class-based (Java)
• Prototype-based (JavaScript)


• Class and instance are distinct entities.
• All objects are instances.


• Define a class with a class definition; instantiate a class with constructor methods.
• Define and create a set of objects with constructor functions.


• Create a single object with the new operator.
• Same.


• Construct an object hierarchy by using class definitions to define subclasses of existing classes.
• Construct an object hierarchy by assigning an object as the prototype associated with a constructor function.
• Inherit properties by following the class chain.
• Inherit properties by following the prototype chain.
• Class definition specifies all properties of all instances of a class. Cannot add properties dynamically at run time.
• Constructor function or prototype specifies an initial set of properties. Can add or remove properties dynamically to individual objects or to the entire set of objects.

-----------------------------------------------------------

Constructor Function And Creating Object

function People (name, profession) {

}

//People () is the constructor function, because we use the new keyword below to invoke it.

var richard = new People (“Richard”, “Developer”) 

// richard is a new object we create from the People () constructor function.

The simplest way to build objects in Javascript is by declaring a new variable of type object and assigning the properties or methods that the object needs:

var rufus = new Object();
rufus.name = "rufus";
rufus.species = "cat";
rufus.hello = function() { alert("miaow"); }

-----------------------------------------------------------

Class properties and Method :

-----------------------------------------------------------

Member Variable: These are the variables defined inside a class. This data will be invisible to the outside of the class and can be accessed via member functions. These variables are called attribute of the object once an object is created.

Private & Public

Private members are made by the constructor. Ordinary vars and parameters of the constructor becomes the private members.

function Container(param) {
    this.member = param; // public
    var secret = 3;		// private
    var that = this;   // private
}

Member function: These are the function defined inside a class and are used to access object data.

This constructor makes three private instance variables: param, secret, and that. They are attached to the object, but they are not accessible to the outside, nor are they accessible to the object's own public methods. They are accessible to private methods. Private methods are inner functions of the constructor.

function Container(param) {

    function dec() {
        if (secret > 0) {
            secret -= 1;
            return true;
        } else {
            return false;
        }
    }

    this.member = param;
    var secret = 3;
    var that = this;
}

-----------------------------------------------------------

functions and methods

function Human(fullName) {
  this.fullName = fullName;
}

// Add a couple of methods to Human.prototype
Human.prototype.speak = function(){
  alert("I speak English!");
};
Human.prototype.introduction = function(){
  alert("Hi, I am " + this.fullName);
};

var test = new Human("Mizan");
test.introduction();

-----------------------------------------------------------

Object: An individual instance of the data structure defined by a class. You define a class once and then make many objects that belong to it. Objects are also known as instance.

-----------------------------------------------------------

Child class/Subclasses/derived class/ Inheritance: A class that inherits from another class. This is also called a subclass or derived class. When a class is defined by inheriting existing function of a parent class then it is called inheritance. Here child class will inherit all or few member functions and variables of a parent class.

In a class-based language, you create a hierarchy of classes through the class definitions. In a class definition, you can specify that the new class is a subclass of an already existing class. The subclass inherits all the properties of the superclass and additionally can add new properties or modify the inherited ones. For example, assume the Employee class includes only the name and dept properties, and Manager is a subclass of Employee that adds the reports property. In this case, an instance of the Manager class would have all three properties: name, dept, and reports.

JavaScript implements inheritance by allowing you to associate a prototypical object with any constructor function. So, you can create exactly the Employee — Manager example, but you use slightly different terminology. First you define the Employee constructor function, specifying the name and dept properties. Next, you define the Manager constructor function, specifying the reports property. Finally, you assign a new Employee object as the prototype for the Manager constructor function. Then, when you create a new Manager, it inherits the name and dept properties from the Employee object.

Any constructor may serve as a parent. For example:

	function Parent( p1, p2 ) {
		var prop1 = p1;		// private property
		this.prop2 = p2;	// public property
					// private method
		function meth1() { return prop1; }
					// public methods
		this.meth2 = function(){ return this.prop2; };
		this.meth3 = function(){ return meth1(); };
	}

	var pc = new Parent( "one", "two" );	// create new Parent object

----------------------------------------------------------

inheritance by prototype

There are two non-obvious constructs required to achieve inheritance: 
setting up the inheritance relation, and initializing the members of the 
parent class inherited by the child class. There is more than one way to 
do it, but this is the best I’ve found.

	function Child( p1, p2, p3, p4 ) {
		Parent.apply( this, arguments ); // initialize Parent's members
		this.prop3 = p3;
		this.meth3 = function(){ return this.prop3; }	// override
		var prop4 = p4;
		this.meth4 = function(){ return prop4; }
	}
	Child.prototype = new Parent();	// set up inheritance relation

	var cc = new Child( "one", "two", "three", "four" );

	var result1 = cc.prop2;		// parent property via child
	var result2 = cc.meth2();	// parent method via child
	var result3 = cc.meth3();	// child method overrides parent method
	var result4 = cc.meth4();	// child method

	var cc2 = new Child( "one", "two", "three", "four"); // another child
	cc2.prop2 = "something else";	// change other child’s parent’s member

-----------------------------------------------------------

Parent/Superclass/ Baseclass: A class that is inherited from by another class. This is also called a base class or super class.

-----------------------------------------------------------

Mixed/Composite classes: A mixed class is another way to combine the functionality from other classes into a new class. A mixed class manages the properties of other classes and may only use a subset of the functionality of a class, whereas a derived class uses the complete set of functionality of its superclasses and usually extends this functionality.

-----------------------------------------------------------

Polymorphism: This is an object oriented concept where same function can be used for different purposes. For example function name will remain same but it make take different number of arguments and can do different task.

<script type="text/javascript">
  function Person(age, weight) {
    this.age=age;
    this.weight=weight;
    this.getInfo=function() {
      return "I am " + this.age + " years old " +
        "and weighs " + this.weight +" kilo.";
    }
  }
  function Employee(age, weight, salary){
    this.salary=salary;
    this.age=age;
    this.weight=weight;
    this.getInfo=function() {
      return "I am " + this.age + " years old " +
        "and weighs " + this.weight +" kilo " +
        "and earns " + this.salary + " dollar.";
    }
  }
  Employee.prototype= new Person();
  Employee.prototype.constructor=Employee;
// The argument, 'obj', can be of any kind
// which method, getInfo(), to be executed depend on the object
// that 'obj' refer to.
  function showInfo(obj) {
    document.write(obj.getInfo()+"<br>");
  }

  var person = new Person(50,90);
  var employee = new Employee(43,80,50000);
  showInfo(person);
  showInfo(employee);
</script>

The result will be:
I am 50 years old and weighs 90 kilo.
I am 43 years old and weighs 80 kilo and earns 50000 dollar.

//Define human class
function Human(fullName) {
  this.fullName = fullName;
}

// Add a couple of methods to Human.prototype
Human.prototype.speak = function(){
  alert("I speak English!");
};
Human.prototype.introduction = function(){
  alert("Hi, I am " + this.fullName);
};

//Define Student class
function Student(fullName, school, courses) {

  Human.call(this, fullName);

  // Initialize our Student properties
   this.school = school;
   this.courses = courses;
};
Student.prototype = Object.create(Human.prototype); // See note below

// Set the "constructor" property to refer to Student
Student.prototype.constructor = Student;


// override the "introduction" method
Student.prototype.introduction= function(){
  alert("Hi, I am " + this.fullName + ". I am a student of " + this.school + ", I study "+ this.courses +".");
};

// Add a "exams" method
Student.prototype.takeExams = function(){
  alert("This is my exams time!");
};


var student = new Student("Ahmed","NED University", "Computer Science");
student.introduction();   // "Hi, I am Ahmed. I am a student of NED University, I study Computer Science."
student.speak();       // "I speak English!"
student.takeExams(); // "This is my exams time!"

// Check that instanceof works correctly
alert(student instanceof Human);  // true 
alert(student instanceof Student); // true

-----------------------------------------------------------

Overloading: a type of polymorphism in which some or all of operators have different implementations depending on the types of their arguments. Similarly functions can also be overloaded with different implementation.

Data Abstraction: Any representation of data in which the implementation details are hidden (abstracted).

-----------------------------------------------------------

Encapsulation: refers to a concept where we encapsulate all the data and member functions together to form an object.

All properties or let us say member variables defined with the "this" keyword inside a function object is of public type, which mean that they can be accessed from outside of a created object.

function Person(n) {
// name and getName ar both public
    this.name = n;
    this.getName = function() { return this.name; }
}

All variables, which are defined with the "var" keyword and all the methods that a constructor function contains is private and therefore NOT accessible from outside of a created object. The same applies to all function arguments.

One of the most important things in object-oriented programming (OOP) is data encapsulation, which means to make private properties and then define public access methods to change these. All public methods, which are defined inside a function object, have access to all defined private member variables and private methods in a created object.

Public methods defined on the outside of a function object can not access private member variables as they are not defined in the same scope as those.

Private methods have no directly access to properties that are defined to be public with "this" keyword in a function object. To achieve this, one can define a variable that has the same reference as "this" refers to.

Example:

<script type="text/javascript">
  function Person(n, y) {
    var name=n;
    var year=y;
    // Set a variable to the same as this
    var thisObj=this;
    this.setName= function(n){ name=n;}
    this.getName= function(){ return name;}
    this.setYear= function(y){ year=y;}
    this.getYear= function(){ return year;}
    var born = function() {
      var nYear=new Date().getFullYear();
      // Use the thisObj variable which is the same as this refer to.
      return nYear-thisObj.getYear();
      // The "this" keyword inside this function refers to an object
      // created by the constructor function of this function object.
    }
    this.getBornYear= function() {
      return born();
    }
  }
  var person = new Person("Nikita",60);
  document.write(person.getName()+" was born in "+person.getBornYear()+"
");
</script>

-----------------------------------------------------------

Constructor: refers to a special type of function which will be called automatically whenever there is an object formation from a class.

Destructors: refers to a special type of function which will be called automatically whenever an object is deleted or goes out of scope.

Closures