구조 함수 - 상속 상세 정보

먼저 부급 구조 함수를 하나 쓰다

        function Parent(name){
            this.name = name;
            this.money = 10000000;
            this.hobby = function(){
                console.log("Parent this.hobby");
            }
        }
        Parent.prototype.active = function(){
            console.log("Parent.prototype");
        }
        Parent.prototype.eat = function(){
            console.log("Parent.prototype.eat");
        }

이어서 서브집합의 구조 방법

        function Son(name){
        }

자집은 부급의 내용을 계승하려면 그 안에 넣어야 한다

        function Son(name){
            Parent.call(this,name);
        }

이렇게 하면 부급 안의 내용을 계승할 수 있다

        var newSon = new Son("rrrr");
        console.log(newSon.name);  // rrrr
        console.log(newSon.money); // 10000000
        newSon.hobby(); // Parent this.hobby

이렇게 쓰는 것은 아무런 문제가 없을 것 같지만, 우리가 자집에 부급과 같은 속성이나 방법을 쓰면?

        function Son(name){
            Parent.call(this,name);  // rrrr
            this.money = 10; 
            this.hobby = function(){
                console.log("Son this.hobby");
            }
        }
        var newSon = new Son("rrrr");
        console.log(newSon.name);  // rrrr
        console.log(newSon.money); // 10
        newSon.hobby(); // Son this.hobby

상술한 코드는 서브집합이 부급을 계승하고 자신이 이 방법을 다시 쓸 때 자신을 기준으로 상술한 계승 구조 계승으로 돌아간다는 것을 나타낸다

              function Parent(name){
            // 
            this.name = name;
            this.money = 10000000
            // 
            this.hobby = function(){
                console.log("Parent this.hobby");
            }
        }
        // 
        Parent.prototype.active = function(){
            console.log("Parent.prototype");
        }
        Parent.prototype.eat = function(){
            console.log("Parent.prototype.eat");
        }
        function Son(name){
            Parent.call(this,name);
        }
        var newSon = new Son("rrrr");
        console.log(newSon.name);  // rrrr
        console.log(newSon.money);  // 100000
        console.log(newSon instanceof Parent); // false
        console.log(newSon instanceof Son); // true
        newSon.hobby()  //  Parent this.hobby
        newSon.active();  //  
        newSon.eat();  //  

상기에서 알 수 있듯이 서브집합은 부급을 계승하고 부급 자체의 속성과 방법만 계승하며 부급 원형상의 방법을 계승하지 않는다. 왜냐하면 구조 계승의 핵심은 부류의 구조 함수를 사용하여 부류의 실례를 강화하는 것이다. 이는 부류의 실례 속성을 부류(원형에 사용하지 않음)의 특징을 복제하는 것과 같다.

하위 클래스 실례가 상위 클래스 인용 속성을 공유하는 문제를 해결한다

하위 클래스 실례를 만들 때 상위 클래스에 파라미터를 전달할 수 있습니다

다중 계승을 실현할 수 있으며, (call 여러 개의 부류 대상) 단점:

실례는 부류의 실례가 아니라 자류의 실례일 뿐이다

부류의 실례 속성과 방법만 계승할 수 있고 원형 속성과 방법은 계승할 수 없다

함수 복용을 실현할 수 없고 모든 하위 클래스는 부류 실력 함수의 사본이 있어 성능에 영향을 미친다

이것은 실례 계승을 이용할 수 있다

        function Son(name){
            var ins = new Parent(name);
            return ins;
        }
        var newSon = new Son("ggg");
        console.log(newSon.name);   // ggg
        console.log(newSon.money);   // 10000000
        console.log(newSon instanceof Parent);   // true
        console.log(newSon instanceof Son);   // false
        newSon.hobby()  //  Parent this.hobby
        newSon.active();  //  Parent.prototype
        newSon.eat(); //  Parent.prototype.eat

실례 계승의 핵심.상위 인스턴스에 새 특성을 추가하여 하위 인스턴스로 피쳐를 반환합니다.

호출 방식을 제한하지 않고 new 하위 클래스()든 하위 클래스()든 되돌아오는 대상은 같은 효과 단점을 가진다

실례는 부급의 실례이지 자류의 실례가 아니다

다중 계승을 지원하지 않습니다

재조합 계승

        function Son(name){
            Parent.call(this,name);
        }
        
        Son.prototype.eat = function(){
            console.log("Son.prototype.eat");
        }
        Son.prototype = new Parent();
        var newSon = new Son("ggg");
        console.log(newSon.name);   // ggg
        console.log(newSon.money);   // 10000000
        console.log(newSon instanceof Parent);   // true
        console.log(newSon instanceof Son);   // true
        newSon.hobby()  //  Parent this.hobby
        newSon.active();  //  Parent.prototype
        newSon.eat(); //  Parent.prototype.eat

조합 계승의 핵심은 부류 구조를 통해 부류의 속성을 계승하고 전참의 장점을 보존한 다음에 강폭과 실례 부류 원형을 통해 함수 복용 특징을 실현하는 것이다.

실례 속성, 방법을 계승할 수도 있고 원형 속성, 방법을 계승할 수도 있다

즉 자류의 실례이자 부류의 실례이다

인용 속성 공유 문제가 존재하지 않습니다

전삼 가능

함수 복용 가능 단점:

두 차례의 부류 구조 함수를 호출하여 두 개의 실례를 생성한다(부류 실례는 부류 원형의 그 부분을 차단한다)

마지막으로 기생 조합 계승을 통해 빈 구조 함수를 만듭니다.

        function Son(name){
            Parent.call(this,name);
        }
        
        Son.prototype.eat = function(){
            console.log("Son.prototype.eat");
        }
        // 
        function Link(){}
        // Person4       Link 
        Link.prototype = Parent.prototype;
        // Student 。    ， 
        //Student   Link     Person4
        Son.prototype = new Link();
        var newSon = new Son("tt")
        console.log(newSon.name);   // tt
        console.log(newSon.money);   // 10000000
        console.log(newSon instanceof Parent);   // true
        console.log(newSon instanceof Son);   // true
        newSon.hobby()  //  Parent this.hobby
        newSon.active();  //  Parent.prototype
        newSon.eat(); //  Parent.prototype.eat