Correctly understand object-oriented in JavaScript

Understanding Object-oriented:

To illustrate that JavaScript is a thoroughly object-oriented language, it is necessary to start with object-oriented concepts and explore some of the concepts in object-oriented:

1. Everything is empty;　

2. object has encapsulation and inheritance characteristics

3. Use message communication between objects and objects, each with information hiding

Object-oriented is just a concept or a programming idea, and it should not depend on the existence of a language. For example, Java uses object-oriented thinking to construct its language, which implements such mechanisms as class, inheritance, derivation, polymorphism, and interface. But these mechanisms are just a means of implementing object-oriented programming, not a necessity. In other words, a language can choose the right way to implement object-oriented according to its own characteristics. So, because most programmers first learn or use a similar Java, C + + and other advanced compiler language (Java Although semi-compiled semi-interpretation, but generally as a compilation to explain), so the preconceived acceptance of the "class" this object-oriented implementation, in learning the scripting language, It is customary to use the concept of a class-oriented object language to determine whether the language is an object-oriented language or whether it has object-oriented characteristics. This is one of the important reasons that hinder programmers from learning and mastering JavaScript.

In fact, the JavaScript language implements object-oriented programming in a way called prototypes (prototype) . The following is a discussion of class-based (class-based) object -oriented and prototype-based (prototype-based) object-oriented The difference between the two approaches in constructing an objective world.

Class-based object-oriented and prototype-based object-oriented approach comparison

In class-based object-oriented mode, objects (object) are generated by classes (class) . In the prototype-based object-oriented approach, the object is dependent on the constructor (constructor) to exploit The prototype (prototype) is constructed. Give an example of an objective world to illustrate the differences in cognition in two ways. For example, a factory build a car, on the one hand, workers must refer to a drawing, design rules how the car should be manufactured. The engineering drawing here is like the classin the language, and the car is in accordance with this class (class) Manufactured, on the other hand, workers and machines (equivalent to constructor) use various components such as engines, tires, and steering wheels (the equivalent of prototype's various properties) to construct the car.

First of all, the object in the objective world is the result of other physical object constructs, and the abstract "drawing" cannot produce "automobile", that is to say, the class is an abstract concept rather than an entity, and the object is produced by an entity;

Second, according to the most basic object-oriented law of all things, the class itself is not an object, but the constructors (constructor) and prototypes (prototype) in the prototype form are themselves objects that other objects have been constructed by way of prototype.

Again, in a class-oriented object language, the state of an object is held by an object instance (instance), and the object's behavior method is held by the class that declares the object, and only the structure and methods of the object can be inherited, whereas in the prototype object-oriented language, the object's behavior, States belong to the object itself, and can be inherited together (reference resources), which is also closer to the objective reality.

Finally, the class-oriented object language, such as Java, allows for the declaration of static and static methods in a class in order to compensate for the inconvenience of using global functions and variables in a procedural language. In fact, the objective world does not exist the so-called static concept, because all things are objects! In the prototype object-oriented language, the existence of global objects, methods or properties is not allowed, and there is no static concept except for the built-in objects (Build-in object). All language elements (primitive) must depend on the existence of an object. However, due to the characteristic of functional language, the object that the language element relies on is changed with the runtime (runtime) context, which is reflected in the change of this pointer. It is this characteristic that is closer to the natural view of "All things belong, the universe is the root of all things".

Object-oriented has inheritance. , it is divided into pseudo-inheritance and true inheritance. As an example:

function people (Name,age,lover) {//constructor is used to construct a class named people; we can construct many subclasses from this class. But how does a subclass inherit the properties of this class? Take a look at the following example

This.name=name;

This.age=age;

This.lover=lover;

This.run=function () {

Alert (this.name+ "speak to the sky and say Love Me")

}；

Construct a subclass man

Function Man () {

this.figt= "PK"//This sub-class is a single attribute

This.constructor (name,age,lover);//This step is very important, constructor is like a constructor,

Object posing as Law one

This.inherit=people;

This.inherit (Name,age,lover);

Delete.this.inherit

}

Object Impersonation Method 2, is the call () method, this method is quite simple

People.call (This,name,age,lover)

Object Impersonation Method 3, is

People.apply (This,[name,age,lover])

It's easy!! These objects impersonate the law just as you disguise yourself to inherit the property of others,

Now I'm talking about true inheritance.

Man.prototype=new people ();//This sentence is to explain the man's prototype point to the people; so he will inherit

var man=new man ("Chubby", 18, "jerk Off");

Console.log (man)

　　

Correctly understand object-oriented in JavaScript