下次自动登录
现在的位置:
& 综合 & 正文
c# 中基类变量指向派生类对象的实例化
c# 中基类变量指向派生类对象的实例化
1.层次结构（针对构造函数）
要实例化的类的构造函数本身不能初始化类，还必须调用基类中的构造函数。所以引入层次结构进行构造。
层次结构的构造是：先找到要实例化的类的构造函数，再找到并默认他父类的构造函数，再往上找到system.object基类的构造函数，当上面再也没有类时。从这个顶层的类开始下发构造函数的执行。
2.对象初始化顺序
子类的属性或字段-----&基类的属性或字段-----&基类的构造函数-----&子类的构造函数
a)先变量后构造函数。变量先被初始化,然后构造函数被执行
b)先静态化后实例化。当一个类被访问时,静态变量和构造函数最先被初始化.接着是对象的实例化变量和构造函数被初始化
c)先派生类后基类。对于变量和静态构造函数,派生对象在基对象之前被初始化.比如C类派生自B类,B类派生自A类,那么变量和静态构造函数被初始化次序是C-B-A.
d)除了实例构造函数。对于实例构造函数,基类构造函数在派生类构造函数之前执行,实例构造函数被执行次序是A-B-C.
e)不要假定变量的次序。Fields依据它们在源文件中的声明的顺序依次初始化.然而,自从程序员和工具可以随意安排变量的声明后,你不应该在依靠变量任何特别的次序初始化
f)对虚方法用两个阶段的构建。避免从一个构造器调用虚方法. 如果在初始化一个对象时需要调用一些虚方法,应在完整构造该对象的地方使用两阶段的构建，并随后调用已构造对象的初始化方法。
3.root = new Child();
这个方法其实是面向对象方面的知识。
基类的对象当然不能访问派生类的成员了，虽然实际上是个child对象，但其类型是parent，向上转换后，已经屏蔽了对派生类成员的访问
root这个对象，会忽略child类的其他派生方法，只有重写方法受到影响。
【上篇】【下篇】面向对象（Object-oriented,OO）的语言有一个标志，那就是它们都有类的概念，而通过类可以创建任意多个具有相同属性和方法的对象。ECMAScript中没有类的概念，因此它的对象也与基于类的语言中的对象有所不同。
ECMA-262把对象定义为：&无序属性的集合，其属性可以包含基本值、对象或者函数。& 严格来讲，这就相当于说对象是一组没有特定顺序的值。 对象的每个属性或方法都有一个名字，而每个名字都映射到一个值。 正因为这样，我们可以把ECMAScript的对象想象成散列表：无非就是一组名值对，其中值可以是数据或函数。
每个对象都是基于一个引用类型创建的，这个引用类型可以是原生类型，也可以是开发人员定义的类型。
创建对象最简单的方式就是创建一个Object的实例，然后再为它添加属性和方法。例：
var person = new Object();
person.name = 'nico';
person.sayName = function(){
alert(this.name);
person.sayName();
这种方式有明显的缺点：使用同一个接口创建很多对象，会产生大量重复代码。 为解决这个问题，人们开始使用工厂模式的一种变体。
function createPerson (name,age) {
var o = new Object();
o.sayName = function() {
alert(this.name);
var person1 = createPerson('nico',22);
var person2 = createPerson('nana',23);
person1.sayName();
person2.sayName();
工厂模式虽然解决了创建多个相似对象的问题，但却没解决对象识别的问题（即怎样知道一个对象的类型）。
构造函数模型
ECMAScript中的构造函数可用来创建特点类型的对象。像Object和Array这样的原生构造函数，在运行时会自动出现在执行环境中。此外，也可以创建自定义的构造函数，从而定义自定义对象类型的属性和方法。例：
function Person(name,age) {
this.name =
this.age =
this.sayName = function() {
alert(this.name);
var person1 = new Person('nico',22);
var person2 = new Person('nana',23);
person1.sayName(); //'nico'
person2.sayName(); //'nana'
函数名Person的首字母为大写P。按照惯例，构造函数始终都应该以一个大写字母开头。 要创建Person对象实例，必须使用new操作符。以这种方式调用构造函数实际上会经历以下4个步骤：
创建一个新对象
将构造函数的作用域赋给新对象（因此this就指向了这个新对象）
执行构造函数中的代码（为这个新对象添加属性）
返回新对象
在前面的例子中，person1和person2分别保存着Person的一个不同实例。 这两个对象都有一个constructor（构造函数）属性。 该属性指向Person
alert(person1.constructor == Person);
alert(person2.constructor == Person);
对象的constructor属性最初是用来标识对象类型的。 &但是检测对象类型，还是 instanceof操作符更可靠一些。 我们在这个例子中创建的所有对象既是Object的实例，同时也是Person对象的实例。
alert(person1 instanceof Object);
alert(person1 instanceof Person);
alert(person2 instanceof Object);
alert(person2 instanceof Person);
创建自定义的构造函数意味着将来可以将它的实例标识为一种特定的类型； 而这正是构造函数模式胜过工厂模式的地方。 在这个例子中，person1和person2之所以同是Object的实例，是因为所有对象均继承自Object。
1、将构造函数当作函数
构造函数与其他函数唯一的区别，就在于调用它们的方式不同。 不过构造函数也是函数，不存在定义构造函数的特殊语法。 任何函数，只要通过new操作符来调用，那它就可以作为构造函数； 而任何函数，如果不通过new操作符来调用，那它跟普通函数也不会有什么两样。 例如：前面的例子中定义的Person() 函数可以通过下列任何一种方式来调用：
//当作构造函数
var person = new Person('nico',22);
person.sayName();
//作为普通函数来调用，在全局对象中调用一个函数时，this对象总是指向Global对象(在浏览器中就是window对象)。
Person('nana',22);
//方法属性会添加到window
window.sayName(); //'nana'
//在另一个对象的作用域中调用
var o = new Object();
Person.call(o,'jhon',30);
o.sayName(); //'Jhon'
2、构造函数的问题
使用构造函数的主要问题，就是每个方法都要在每个实例上重新创建一遍。 在前面的例子中，person1和person2都有一个名为sayName()的方法，但那两个方法不是同一个Function实例。 ECMAScript中的函数是对象，因此每定义一个函数，也就是实例化了一个对象。 从逻辑角度来讲，此时的构造函数也可以这样定义：
function Person(name,age) {
this.name =
this.age =
this.sayName = new Function ("alert(this.name)");
//与声明函数在逻辑上是等价的
从这个角度看构造函数，更容易明白每个Person实例都包含一个不同的Function实例。 这个两个函数是不等的，下面代码可以证明：
alert(person1.sayName == person2.sayName);
我们创建的每一个函数都有一个prototype（原型）属性，这个属性是一个对象，它的用途是包含可以由特定类型的所有实例共享的属性和方法。 如果按照字面意思理解，那么prototype就是通过调用构造函数而创建的那个对象的原型对象。 &使用原型的好处是可以让所有对象实例共享它所包含的属性和方法。 换句话说，不必在构造函数中定义对象信息，而是可以将这些信息直接添加到原型对象中，如下：
function Person(){};
Person.prototype.name = 'nico';
Person.prototype.age = 22;
Person.prototype.sayName = function () {
alert(this.name);
var person1 = new Person();
person1.sayName();
var person2 = new Person();
person2.sayName();
alert(person1.name == person2.name);
在此，我们将sayName()方法和所有属性直接添加到了prototype属性中，构造函数变成了空函数。 即使如此，也仍然可以通过调用构造函数来创建一个新对象，而新对象还会具有相同的属性和方法。 但与构造函数不同的是，新对象的这些属性和方法是所有实例共享的。换句话说，person1和person2访问的都是同一组属性和同一个sayName()函数。 要理解原型模式的工作原理，必须先理解ECMAScript中原型的性质
1、理解原型
无论什么时候，只要创建了一个新函数，就会根据一组特点的规则为该函数创建一个prototype属性。默认情况下 prototype属性会自动获取一个constructor(构造函数)属性 ，这个属性包含一个指向prototype属性所在函数的指针。 &就拿前面的例子来说，Person.prototype.constructor指向Person。而通过这个构造函数，我们还可以继续为原型添加其他属性和方法。
创建了自定义的构造函数后，其原型属性默认只会取得constructor属性，至于其他方法，则都是从Object继承而来的。 当调用构造函数创建一个新实例后，该实例的内部将包含一个指针（内部属性），指向构造函数的原型属性。在很多实现中，这个属性名字是__proto__，而且通过脚本可以访问到（在Firefox、Safari、Chrome和Flash的ActionScript中，都可以通过脚本访问__proto__）；而在其他实现中，这个属性对脚本则是完全不可见的。 不过，要明确的真正重要一点，就是这个连接存在于实例与构造函数的原型属性之间，而不是存在于实例与构造函数之间。
以前面的例子来说，Person.prototype指向了原型对象，而Person.prototype.constructor又指回了Person。 原型对象中除了包含constructor属性之外，还包括后来添加的其他属性。 Person的每个实例，（person1、person2）都包含一个内部属性(__proto__)，该属性仅仅指向了Person. 换句话说，它们与构造函数没有直接的关系。 此外，要注意的是，虽然这两个实例都不包含属性和方法，但我们却可以调用person1.sayName()。 这是通过查找对象属性的过程来实现的。
虽然某些实现中无法访问到内部的__proto__属性，但在所有的实现中都可以通过isPrototypeOf()方法来确定对象之间是否存在这种关系。从本质上讲，如果对象的__proto__指向调用isPrototypeOf()方法的对象，那么这个方法就返回true。例：
alert(Person.prototype.isPrototypeOf(person1));
alert(Person.prototype.isPrototypeOf(person2)); //true
每当代码读取某个对象的某个属性时，都会执行一次搜索，目标是具有给定名字的属性。搜索首先从对象实例本身开始。如果在实例中找到了具有给定名字的属性，则返回该属性的值；如果没有找到，则继续搜索指针指向的原型对象，在原型对象中查找具有给定名字的属性。如果在原型对象中找到了这个属性，则返回该属性值。 这正是多个对象实例共享原型所保存的属性和方法的基本原理。
前面提到过，原型最初只包含constructor属性，而该属性也是可以共享的，因此可以通过对象实例访问。
虽然可以通过对象实例访问保存在原型中的值，却不能通过实例重写原型中的值。 如果在实例中添加了一个与实例原型同名的属性，该属性将屏蔽原型中的那个属性， 当访问该属性的时候，先会在实例中搜索该属性是否存在，它确实存在所以返回它的值，不再搜索原型了。例：
function Person(){}
Person.prototype.name = 'nico';
Person.prototype.sayName = function () {
alert(this.name);
var person1 = new Person();
var person2 = new Person();
person1.name = 'nana';
alert(person1.name);
alert(person2.name);
这个例子中，person1的name被一个新值屏蔽了。 但无论访问person1.name还是person2.name都能正常返回值。即分别是&nana&(来自实例) "nico"(来自原型)。 当作alert()中访问person1.name时，需要读取它的值，因此就会在实例上搜索一个名为name的属性，这个属性确实存在，于是就返回它的值而不再搜索原型了。 &当以同样的方式访问person2.name时，并没有在实例上发现该属性，因此会继续搜索原型，结果在那里找到了name属性。
当为实例添加一个属性时，这个属性就会屏蔽原型对象保存的同名属性，换句话说，添加这个属性只会阻止我们访问原型中的那个属性，但不会修改那个属性。 即使将这个属性设置为null,也只会在实例中设置这个属性，而不会恢复其指向原型的连接。 不过，使用delete操作符可以完全删除实例属性，从而让我们能够重新访问原型中的属性。
使用hasOwnProperty()方法可以检测一个属性是存在于实例中，还是存在于原型中。这个方法（不要忘了它是从Object继承来的）只在给定属性存在于对象实例中时，才会返回ture。例：
function Person() {}
Person.prototype.name = 'nico';
var person1 = new Person();
alert(person1.hasOwnProperty("name"));
person1.name = 'john';
alert(person1.hasOwnProperty("name")); // true
2、原型与in操作符
有两种方法使用in操作符：单独使用和在for-in循环中使用。在单独使用时，in操作符会在通过对象能够访问给定属性时返回true，无论该属性存在实例还是原型。 例：
function Person() {}
Person.prototype.name = 'nico';
var person1 = new Person();
alert(person1.hasOwnProperty("name"));
alert("name" in person1);
3、更简单的原型语法
&为了从视觉上更好的封装原型的功能，更常见的做法是用一个包含所有属性和方法的对象字面量来重写整个原型对象。例：
function Person() {}
Person.prototype = {
name:'nico'
我们将Person.prototype设置为等于一个以对象字面量形式创建的对象。最终结果相同，但有一个例外：constructor属性不再指向Person了。 前面讲过，每创建一个函数，就会同时创建它的prototype对象，这个对象也会自动获得constructor属性。而我们再这里使用的语法，本质上完全重写了默认的prototype对象，因此constructor属性页变成了新对象的constructor属性（指向Object构造函数），不再指向Person函数。此时，尽管instanceof操作符还能返回正确的结果，但通过constructor已经无法确定对象的类型了。例：
var person = new Person();
alert(person instanceof Person);
alert(person.constructor == Person); //false
alert(person.constructor == Object);
如果constructor属性很重要，可以特意将它设置回适当的值。 例如：
function Person(){}
Person.prototype = {
constructor:Person,
name:'nico',
sayName:function(){
alert(this.name);
var person = new Person();
alert(person.constructor == Person) //true
4、原型的动态性
由于在原型中查找值的过程是一次搜索，因此我们对原型对象所做的任何修改都能够立刻从实例上反映出来&即使是先创建了实例再修改原型也是如此，例：
var person = new Person();
Person.prototype.name = 'nico';
alert(person.name);
其原因可以归结为实例与原型之间的松散连接关系。当我们调用person.name时，首先会在实例中搜索名为name的属性，在没找到的情况想，会继续搜索原型。因为实例与原型之间的连接只不过是一个指针，而不是副本，因此就可以在原型中找到新的name的属性并返回值。
尽管可以随时为原型添加属性和方法，并且修改能够立即在所有对象实例中反映出来，但是如果是重写整个原型对象，那么情况就不一样了。我们知道，调用构造函数时会为实例添加一个指向最初原型的__proto__指针，而把原型修改为另外一个对象就等于切断了构造函数与最初原型之间的联系（实例__proto__指针仍然指向最初的原型而不是现在的原型对象）。 请记住：实例中的指针仅指向原型，而不指向构造函数。例：
function Person(){}
var person = new Person();
Person.prototype = {
name:'nico'
alert(person.name); //error
在这个例子中，先创建了Person的一个实例，然后又重写了Person原型。 然后在调用person.name时发生了错误，因为person指向的原型中不包含以改名字（&name&）命名的属性。 重写原型对象切断了现有原型与任何之前已经存在的对象实例之间的联系； 它们引用的仍然是最初的原型。
5、原生对象的原型&
原型模式的重要性不仅体现在创建自定义类型方面，就连所有原生的引用类型，都是采用这种模式创建的。 所有原生引用类型（Object、Array、String，等等）都在其构造函数的原型上定义了方法。 例如，在Array.prototype中可以找到sort()方法，而在String.prototype中可以找到substring()方法，如下所示：
alert(typeof Array.prototype.sort); & &//"function"
alert(typeof String.prototype.substring); &//"function"
通过原生对象的原型，不仅可以取得所有默认方法的引用，而且也可以定义新方法。 可以像修改自定义对象的原型一样修改原生对象的原型，因此可以随时添加方法。 下面的代码就给基本包装类型String添加了一个名为startsWith()的方法：
String.prototype.startsWith = function (text) {
return this.indexOf(text) == 0
var msg = "Hello world";
alert(msg.startsWidth("Hello"));
由于msg是字符串，而且后台会调用String基本包装函数创建这个字符，因此通过msg就可以调用startsWidth()方法。
尽管可以这么做，但我们不推荐在产品化的程序中修改原生对象的原型。 如果因为某个实现中缺少某个方法，就在原生对象的原型中添加这个方法，那么当在另一个支持该方法的实现中运行代码时，就可能会导致命名冲突。而且，这样做也可能意外地重写原生方法。
6、原型对象的问题
原型模式也不是没有确定。 首先，它省略了为构造函数传递初始化参数这一环节，结果所有实例在默认情况下都将取得相同的属性值。 虽然这会在某种程度上带来一些不便，但还不是原型的最大问题。 原型模式的最大问题是由其共享的本性所导致的。
原型中所有属性是被很多实例共享的，这种共享对于函数非常合适。 对于那些包含基本值的属性倒也说得过去，毕竟通过在实例上添加一个同名属性，可以隐藏原型中的对应属性。 然而，对于包含引用类型值的属性来说，问题就比较突出了。例：
function Person() {}
Person.prototype = {
name:'nana',
friends:['nico'],
sayName:function(){
alert(this.name);
var person1 = new Person();
var person2 = new Person();
person1.friends.push('john');
alert(person1.friends);
// "nico,john");
alert(person2.friends);
//"nico,john");
alert(person1.friends== person2.friends);
在此，Person.prototype对象有一个名为friends的属性，该属性包含一个字符串数组。 然后，创建了Person的两个实例。 接着，修改了person1.friends引用的数组，向数组中添加了一个字符串。 由于数组存在于Person.prototype而非person1，所有刚刚提到的修改也会通过person2.name反映出来。 假如我们的初衷就是这样所有实例中共享一个数组，那么对这个结果没有话可说。 &可是，实例一般都是要有属于自己的全部属性的。 而这个问题正是我们很少看到有人单独使用原型模式的原因所在。
组合使用构造函数模式和原型模式
创建自定义类型的最常见方式，就是组合使用构造函数模式与原型模式。 构造函数模式用于定义实例属性，而原型模式用于定义方法和共享的属性。 结果，每个实例都会有自己的一份实例属性的副本，但同时又共享着对方法的引用，最大限定地节省了内存。 另外，这种混合模式还支持向构造函数传递参数；可谓集两种模式之长。 下面的代码重写了前面的例子：
function Person(name) {
this.name =
this.friends = ['nico'];
Person.prototype = {
sayName:function(){
alert(this.name);
var person1 = new Person('lee');
var person2 = new Person('lus');
person1.sayName();
person2.sayName();
person1.friends.push('nana');
alert(person1.friends); //'nico,nana'
alert(person2.friends); //'nico'
在这个例子中，实例属性都是在构造函数中定义的，而由所有实例共享的方法sayName()则是在原型中定义的。 而修改了person1.friends，并不会影响到person2.friends，因为它们分别引用了不同的数组。
这种构造函数与原型混合的模式，是目前在ECMAScript中使用最广泛、认同度最高的一种创建自定义类型的方法。可以说，这是来定义引用类型的一种默认模式。
阅读(...) 评论()对象(一)--对象的继承
时间： 21:57:35
&&&& 阅读：22
&&&& 评论：
&&&& 收藏：0
标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&聊一聊JavaScript中的对象的继承
时间过得是真的快，感觉才更新博客怎么就快一个礼拜了...这两天看了点python和flask框架了解了下，最后还是打算去系统地学习下node，又看了MongoDB，之后觉得Linux挺有意思的又去找资料学习(选发行版本，装虚拟机...), 感觉把时间都折腾在这儿了，有点不务正业(想了想还是日后抽时间学习吧，现在还是把前端知识巩固好，毕竟目前是个连实习都找不到的渣渣...
不过node还是要学的，计划之后手撸一个个人博客练练手...
在前一篇中，文中提到过原型模式，其实呢在JavaScript中对象的继承就是以原型模式作为基础的。
每个构造函数都有一个prototype属性指向的它的原型对象，而构造函数创建的实例对象可以顺势访问到原型对象中的属性
原型对象，它也可以是另外一个构造函数的实例对象，因此它就可以访问更高层次的原型对象的属性，这样原型对象与原型对象以某种形式相连就构成了一条原型链, 而继承其实就是依赖于原型链。
打个比方Person和Student两个类，根据常识Student肯定是Person的一个子集，即Person具有的属性和方法Student按道理都应该有，那么我们在已经有Person的基础上不应该再在Student中编写重复的代码，而是用Student去继承Person来实现代码的复用
function Person(name="name", age="20") {
this.name = name
this.age = age
this.hobbies = [‘readBooks‘, ‘swimming‘]
Person.prototype.sayHello = function() {
console.log(`Hello, my name is ${this.name}`)
function Student(homework) {
this.homework = homework
&!-- 将Student的原型对象去引用Person的实例化对象 --&
Student.prototype = new Person()
Student.prototype.doHomework = function() {
console.log(`i am doing ${this.homework} homework`)
let stu1 = new Student(‘math‘)
console.log(!!(stu1.name && stu1.age && stu1.sayHello)) // true
我们可以发现是在Student的实例化对象可以顺着原型链(绿色)找到这几个属性，name和age分布在Student.prototype中， sayHello分布在Person.prototype中，参照如下图
另外，构造函数的原型对象都继承自Object.prototype, 这就是为什么所有对象都具有toString 等方法
原型继承通过将原型对象赋值为一个父类的实例对象来实现继承，实质就是原型链的搭建
需要注意的地方是在将原型对象重新赋值后，它的constructor 需要手动指正
另外大家有没有注意到在上面这个例子中name, age 等属性都包含在同一个对象中，也就是说所有的子类对象在访问这些属性的时候实际上都是同一个值，如若它们是引用类型，任何实例对象对其的修改都会在其他对象访问时得到反映
let stu1 = new Student()
console.log(stu1.hobbies) // [‘readBooks‘, ‘swimming‘]
stu1.hobbies.push(‘running‘)
let stu2 = new Student()
console.log(stu2.hobbies) // [‘readBooks‘, ‘swimming‘, ‘runnning‘]
并且在创建子类型的实例时不能对父类型的构造函数传参，这也是一个问题
借用构造函数组合继承
为了解决以上两个问题：
所有子类型实例访问父类型属性时其实都是在访问原型属性
在创建子类型的实例时不能对父类型的构造函数进行传参
借用构造函数闪亮登场了
function Student(name, age, homework) {
// 使用call()(or apply())方法绑定this
Person.call(this, name, age)
this.homework = homework
// 相当于下面
function Student(name, age, homework) {
this.name = name
this.age = age
this.homework = homework
&!-- 将Student的原型对象去引用Person的实例化对象 --&
Student.prototype = new Person()
这样将属性重新定义在子类的实例上，方法还是放置在原型链上，很好地解决了以上两个问题, 自身的name和age遮蔽了原型链上的name和age
还要一个问题就是子类型已经可以创建父类属性了，原型对象还是会再次创建这些属性，在这里Student.prototype对象中name和age依旧会被创建，因为调用了一个Person的构造函数, 但是name和age在原型对象中已经是多余的了
直接继承prototype
之前将父级构造函数的实例赋值给子构造函数的原型对象Student.prototype = new Person(), 会造成属性在原型对象中的冗余
这次我们选择直接继承父构造函数的原型对象
Student.prototype = Person.prototype
避免了不必要的属性定义在原型对象中，并且少了一次构造函数的调用节省了内存
但是又有一个问题暴露出来了，就是此时子构造函数的原型对象和父构造函数的原型对象同时指向一个对象, 其中任何一个添加修改属性都会影响对方
比如上面，当我们想要指正Student.prototype的constructor时,Person.prototype的constructor也发生了改变
Student.prototype.constructor = Student
console.log(Perosn.prototype.constructor) // Student
寄生组合式继承
利用空对象作为中介
function object(o) {
function F() {}
F.prototype = o
return new F()
function Student(name, age, homework) {
Person.call(this, name, age)
this.homework = homework
Student.prototype = object(Person.prototype)
既避免的父级构造函数的多余调用，又将父子构造函数的原型对象区分开来，且空对象的占有的内存很少，因此寄生组合式继承棒棒的！
JavaScript主要通过原型链实现继承，原型链的构建是通过将一个类型的实例赋值给另一个构造函数的原型实现。这样，子类型就能够访问父类型的所有属性和方法。原型链的问题是对象实例共享所有继承的属性和方法，因此不适宜单独使用。解决这个问题的技术是借用构造函数，即在子类型构造函数的内部调用超类型的构造函数。这样就可以做到每个实例都有自己的属性。使用最多的继承模式是组合继承，即使用原型链继承共享的属性和方法，而通过借用构造函数继承实例属性
但是，寄生组合式继承是实现基于类型继承的最有效方式标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&原文地址：https://www.cnblogs.com/guanine/p/9311037.html
&&国之画&&&& &&&&chrome插件
版权所有 京ICP备号-2
迷上了代码！}