JavaScript 객체지향의 세 가지 기본 특성 소개

객체지향을 배운 학생들은 객체지향의 세 가지 기본 특성인 캡슐화, 상속, 다형성을 모두 알아야 하지만 이 세 가지 단어에 대해서는 잘 알지 못할 수도 있습니다. 프런트 엔드의 경우 가장 많이 노출되는 것은 캡슐화 및 상속일 수 있지만 다형성은 그렇게 이해되지 않을 수 있습니다. 封装与继承，对于多态来说可能就不是那么了解了。

封装

在说封装之先了解一下封装到底是什么？

什么是封装

封装：将对象运行所需的资源封装在程序对象中——基本上，是方法和数据。对象是“公布其接口”。其他附加到这些接口上的对象不需要关心对象实现的方法即可使用这个对象。这个概念就是“不要告诉我你是怎么做的，只要做就可以了。”对象可以看作是一个自我包含的原子。对象接口包括了公共的方法和初始化数据。（节选自百度百科）

我对于封装的理解，可能还有一个步骤就是抽离，首先你要清楚在一个对代码中你应该抽离那些属性方法，有了这些为基础才能更好的做好封装。

封装无非就是其属性和方法封装。

1. 类：封装对象的属性和行为

2. 方法：封装具体逻辑功能

3. 访问封装：访问修饰封装无非就是对其访问权限进行封装

class Employees {
    constructor(name,age){
        this.name = name;
        this.age = age;
    }
    getInfo(){
        let {name,age} = this;
        return {name,age};
    }
    static seyHi(){
        console.log("Hi");   
    }
}

let lisi = new Employees("Aaron",18);
lisi.seyHi();   // lisi.seyHi is not a function
lisi.getInfo();  // {name: "Aaron", age: 18}
Employees.seyHi();  // Hi

在Employees中抽出的公共属性有name,age,公共方法有getInfo,seyHi，然而getInfo与seyHi所不同的是seyHi使用了static修饰符，改变其为静态方法，seyHi只属于Employees这个类。然而getInfo方法则是属于实例的。

这里使用了static对seyHi方法对其进行了访问权限的封装。

再举一个例子。

Promise.then()  //  Promise.then is not a function
let p1 = new Promise(() => {})
p1.then();  //  Promise {<pending>}
Promise.all([1]);   //  Promise {<resolved>: Array(1)}

从上面的代码中可以看出Promise也使用了static对其方法的访问权限进行了封装。

继承

继承：说到继承并不太陌生，继承可以使得子类具有父类的各种的公有属性和公有方法。而不需要再次编写相同的代码。在令子类别继承父类别的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类别的原有属性和方法，使其获得与父类别不同的功能。（节选自百度百科）

子类继承父类后，子类具有父类属性和方法，然而也同样具备自己所独有的属性和方法，也就是说，子类的功能要比父类多或相同，不会比父类少。

class Employees {
    constructor(name){
        this.name = name;
    }
    getName(){
        console.log(this.name)
    }
    static seyHi(){
        console.log("Hi");   
    }
}
class Java extends Employees{
    constructor(name){
        super(name);
    }
    work(){
        console.log("做后台工作");
    }
}
let java = new Java("Aaron");
java.getName();
java.work();
// java.seyHi();    //  java.seyHi is not a function

从上面的例子可以看出继承不会继承父类的静态方法，只会继承父类的公有属性与方法。这一点需要注意。

子类继承之后既拥有了getName方法，同样也拥有自己的worker方法。

多态

多态：按字面的意思就是“多种状态”，允许将子类类型的指针赋值给父类类型的指针。（节选自百度百科）

说白了多态就是相同的事物，调用其相同的方法，参数也相同时，但表现的行为却不同。多态分为两种，一种是行为多态与对象的多态。

多态的表现形式重写与重载。

什么是重写

重写：子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。（节选自百度百科）

class Employees {
    constructor(name){
        this.name = name;
    }
    seyHello(){
        console.log("Hello")
    }
    getName(){
        console.log(this.name);
    }
}
class Java extends Employees{
    constructor(name){
        super(name);
    }
    seyHello(){
        console.log(`Hello,我的名字是${this.name},我是做Java工作的。`)
    }
}
const employees = new Employees("Aaron");
const java = new Java("Leo");
employees.seyHello();   //  Hello
java.seyHello();    //  Hello,我的名字是Leo,我是做Java工作的。
employees.getName();    //  Aaron
java.getName(); //  Leo

通过上面的代码可以看出Java继承了Employees,然而子类与父类中都存在seyHello方法，为了满足不同的需求子类继承父类之后重写了seyHello方法。所以在调用的时候会得到不同的结果。既然子类继承了父类，子类也同样拥有父类的getName

캡슐화

캡슐화에 대해 이야기하기 전에 먼저 캡슐화가 무엇인지부터 알아볼까요? 캡슐화란 무엇입니까

🎜🎜🎜캡슐화: 프로그램 개체에서 개체를 실행하는 데 필요한 리소스(기본적으로 메서드 및 데이터)를 캡슐화합니다. 객체는 "인터페이스를 노출합니다". 이러한 인터페이스에 연결된 다른 개체는 개체에 의해 구현된 메서드에 상관없이 이 개체를 사용할 수 있습니다. 개념은 "어떻게 하는지 알려주지 말고 그냥 하세요"입니다. 객체는 자체 포함된 원자로 생각할 수 있습니다. 객체 인터페이스에는 공용 메서드와 초기화 데이터가 포함됩니다. (바이두 백과사전 발췌) 🎜🎜제가 이해한 캡슐화에는 분리라는 또 다른 단계가 있을 수 있습니다. 먼저 한 쌍의 코드에서 어떤 속성과 메서드를 분리해야 하는지 알아야 합니다. . 이러한 방법으로만 기본 사항을 더 잘 요약할 수 있습니다. 🎜🎜캡슐화는 속성과 방법을 캡슐화하는 것에 지나지 않습니다. 🎜

1. 🎜클래스: 객체의 속성과 동작을 캡슐화합니다🎜
2. 🎜메소드: 특정 논리 함수를 캡슐화합니다🎜
3. 🎜액세스 캡슐화: 액세스 수정 캡슐화는 액세스 권한을 캡슐화하는 것에 지나지 않습니다🎜

class Employees {
    constructor(arg){
        let obj = null;
        switch(typeof arg)
        {
            case "string":
                  obj = new StringEmployees(arg);
                  break;
            case "object":
                  obj = new ObjEmployees(ObjEmployees);
                  break;
            case "number":
                obj = new NumberEmployees(ObjEmployees);
                break;
        }
        return obj;
    }
}
class ObjEmployees {
    constructor(arg){
        console.log("ObjEmployees")
    }
}
class StringEmployees {
    constructor(arg){
        console.log("StringEmployees")
    }
}
class NumberEmployees {
    constructor(arg){
        console.log("NumberEmployees")
    }
}
new Employees({})   // ObjEmployees
new Employees("123456") //  StringEmployees
new Employees(987654)   //  NumberEmployees

🎜 Employees에서 추출된 공개 속성은 name입니다. > ,age, 공용 메소드에는 getInfo, seyHi가 포함되지만, getInfo 및 seyHi code> 차이점은 <code>seyHi가 static 수정자를 사용하여 이를 정적 메서드로 변경한다는 것입니다. seyHi는 Employees 클래스에만 속합니다. . 그러나 getInfo 메소드는 인스턴스에 속합니다. 🎜🎜여기에서는 static을 사용하여 seyHi 메서드의 액세스 권한을 캡슐화합니다. 🎜🎜또 다른 예를 들어주세요. 🎜rrreee🎜위 코드에서 볼 수 있듯이 Promise는 static을 사용하여 메서드의 액세스 권한을 캡슐화합니다. 🎜

상속 🎜

🎜상속: 상속에 대해 말하는 것이 낯설지 않습니다. 상속을 통해 하위 클래스는 상위 클래스의 다양한 공개 속성을 갖게 될 수 있습니다 속성 및 공개 메서드. 동일한 코드를 다시 작성할 필요가 없습니다. 하위 범주가 상위 범주를 상속하도록 하는 동안 일부 속성을 재정의하고 일부 메서드를 재정의할 수 있습니다. 즉, 상위 범주에서 다른 기능을 얻을 수 있도록 상위 범주의 원래 속성과 메서드를 덮어쓸 수 있습니다. (바이두 백과사전에서 발췌) 🎜🎜하위 클래스가 상위 클래스를 상속받은 후 하위 클래스는 상위 클래스의 속성과 메서드를 가지면서도 고유한 속성과 메서드도 갖게 됩니다. 즉, 하위 클래스는 상위 클래스보다 더 많은 기능을 갖습니다. 또는 상위 클래스와 동일합니다. 🎜rrreee🎜 위의 예에서 상속은 상위 클래스의 정적 메서드를 상속하지 않고 상위 클래스의 공용 속성과 메서드만 상속한다는 것을 알 수 있습니다. 주의가 필요합니다. 🎜🎜상속 후 하위 클래스에는 getName 메서드뿐만 아니라 자체 worker 메서드도 있습니다. 🎜

다형성 🎜

🎜다형성: 문자 그대로 "다중 상태"를 의미하며, 하위 클래스 유형의 포인터를 클래스 유형의 상위 포인터에 할당할 수 있습니다. (바이두 백과사전에서 발췌) 🎜🎜직접 말하면 다형성은 같은 것이고, 같은 메소드를 호출하고 매개변수가 같을 때 동작이 다릅니다. 다형성은 두 가지 유형으로 나뉘는데, 하나는 행동 다형성과 객체 다형성입니다. 🎜🎜다형성 표현식 재작성 및 오버로드. 🎜🎜🎜🎜다시 쓰기란 무엇입니까🎜🎜🎜🎜다시 쓰기: 하위 클래스는 동일한 메서드를 다시 작성하지 않고도 상위 클래스에서 메서드를 상속할 수 있습니다. 그러나 때로는 하위 클래스가 상위 클래스의 메서드를 변경 없이 상속하기를 원하지 않지만 특정 수정을 하려고 하므로 메서드를 다시 작성해야 합니다. 메서드 재정의는 메서드 덮어쓰기라고도 합니다. (바이두 백과사전 발췌) 🎜rrreee🎜위 코드에서 Java는 Employees를 상속하지만 seyHello는 두 하위 클래스 모두에 존재함을 알 수 있습니다. 및 상위 클래스.code> 메소드는 다양한 요구 사항을 충족하기 위해 하위 클래스가 상위 클래스를 상속하고 seyHello 메소드를 다시 작성합니다. 따라서 전화를 걸면 다른 결과를 얻게 됩니다. 하위 클래스는 상위 클래스를 상속하므로 하위 클래스에는 상위 클래스의 getName 메서드도 있습니다. 🎜🎜🎜🎜새로고침이란 무엇인가요🎜🎜🎜

重载就是函数或者方法有相同的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。（节选自百度百科）

class Employees {
    constructor(arg){
        let obj = null;
        switch(typeof arg)
        {
            case "string":
                  obj = new StringEmployees(arg);
                  break;
            case "object":
                  obj = new ObjEmployees(ObjEmployees);
                  break;
            case "number":
                obj = new NumberEmployees(ObjEmployees);
                break;
        }
        return obj;
    }
}
class ObjEmployees {
    constructor(arg){
        console.log("ObjEmployees")
    }
}
class StringEmployees {
    constructor(arg){
        console.log("StringEmployees")
    }
}
class NumberEmployees {
    constructor(arg){
        console.log("NumberEmployees")
    }
}
new Employees({})   // ObjEmployees
new Employees("123456") //  StringEmployees
new Employees(987654)   //  NumberEmployees

因为JavaScript是没有重载的概念的所以要自己编写逻辑完成重载。

在上面的代码中定义了Employees,ObjEmployees,StringEmployees,NumberEmployees类,在实例化Employees的时候在constructor里面进行了判断，根据参数的不同返回不同的对应的类。

这样完成了一个简单的类重载。

总结

1. 封装可以隐藏实现细节，使得代码模块化；

2. 继承可以扩展已存在的代码模块（类），它们的目的都是为了——代码重用。

3. 多态就是相同的事物，调用其相同的方法，参数也相同时，但表现的行为却不同。多态分为两种，一种是行为多态与对象的多态。

在编程的是多多运用这个写思想对其编程时很有用的，能够使你的代码达到高复用以及可维护。

相关免费学习推荐：js视频教程

위 내용은 JavaScript 객체지향의 세 가지 기본 특성 소개의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!