精华内容
下载资源
问答
  • 主要介绍了JS实现面向对象继承的5种方式,结合实例形式分析了JavaScript面向对象继承功能的5种常见实现方法原理与操作技巧,需要的朋友可以参考下
  • 主要介绍了JavaScript面向对象继承原理与实现方法,结合实例形式分析就面向对象程序设计中原形、对象、继承的相关概念、原理、实现方法及操作注意事项,需要的朋友可以参考下
  • JavaScript面向对象继承详解,js进阶高手必读,内含六部分
  • 所有面向对象的语言都应该有继承的特性,JavaScript 也不例外。
  • java 面向对象 继承 PDF格式java 面向对象 继承 PDF格式java 面向对象 继承 PDF格式
  • 主要介绍了PHP面向对象继承用法,结合实例形式分析了php面向对象程序设计中继承的使用方法及代码优化处理与减少代码重复的相关操作技巧,需要的朋友可以参考下
  • 一面相对象继承机制  今天算是什么都没干,尽在了解面向对象三大特性之一的继承了,过去的学习的C++和C#都是正统的面向对象语 言,学习的时候也没有怎么深入了解过,只是简单的学习最基础的继承。下午在看继承...
           一面相对象继承机制

          今天算是什么都没干,尽在了解面向对象三大特性之一的继承了,过去的学习的C++和C#都是正统的面向对象语

    言,学习的时候也没有怎么深入了解过,只是简单的学习最基础的继承。下午在看继承机制的时候,看到一个很经典

    的继承机制实例。这个实例使用UML很好的解释了继承机制。

          说明继承机制最简单的方式是,利用一个经典的例子就是几何形状。实际上,几何形状只有两种,即椭圆形(是圆

    形的)和多边形(具有一定数量的边)。圆是椭圆的一种,它只有一个焦点。三角形、矩形和五边形都是多边形的一种,

    具有不同数量的边。正方形是矩形的一种,所有的边等长。这就构成了一种完美的继承关系,很好的解释了面向对象

    的继承机制。

           在这个例子中,形状是椭圆形和多边形的基类(通常我们也可以叫它父类,所有类都由它继承而来)。椭圆具有一

    个属性(foci),说明椭圆具有的焦点的个数。圆形继承了椭圆形,因此圆形是椭圆形的子类,椭圆形是圆形的超类。同

    样,三角形、矩形和五边形都是多边形的子类,多边形是它们的超类。最后,正方形继承了矩形。

          最好用图来解释这种继承关系,这是 UML(统一建模语言)的用武之地。UML的主要用途之一是,可视化地表示像

    继承这样的复杂对象关系。下面的图示是解释形状和它的子类之间关系的UML图示:


          在UML中,每个方框表示一个类,由类名说明。三角形 、矩形和五边形顶部的线段汇集在一起,指向形状,说明

    这些类都由形状继承而来。同样,从正方形指向矩形的箭头说明了它们之间的继承关系。

          二ECMAScript继承机制的实现

          要用ECMAScript实现继承机制,您可以从要继承的基类入手。所有开发者定义的类都可作为基类。出于安全原

    因,本地类和宿主类不能作为基类,这样可以防止公用访问编译过的浏览器级的代码,因为这些代码可以被用于恶意

    攻击。

           选定基类后,就可以创建它的子类了。是否使用基类完全由你决定。有时,你可能想创建一个不能直接使用的基

    类,它只是用于给子类提供通用的函数。在这种情况下,基类被看作抽象类。尽管ECMAScript并没有像其他语言那样

    严格地定义抽象类,但有时它的确会创建一些不允许使用的类。通常,我们称这种类为抽象类。

          创建的子类将继承超类的所有属性和方法,包括构造函数及方法的实现。记住,所有属性和方法都是公用的,因

    此子类可直接访问这些方法。子类还可添加超类中没有的新属性和方法,也可以覆盖超类的属性和方法。由于JS并不

    是正统的面向对象语言,一些名词也需要做出改变。

          三ECMAScript继承的方式

          ECMAScript语言中将被继承的类(基类)称为超类型,子类(或派生类)称为子类型。和其他功能一样,ECMAScript

    实现继承的方式不止一种。这是因为JavaScript中的继承机制并不是明确规定的,而是通过模仿实现的。这意味着所

    有的继承细节并非完全由解释程序处理。作为开发者,你有权决定最适用的继承方式。下面为您介绍几种具体的继承

    方式。
           (1)原型链方式

          继承这种形式在ECMAScript中原本是用于原型链的。上一篇博文已经介绍了创建对象的原型方式。原型链扩展了

    这种方式,以一种有趣的方式实现继承机制。prototype 对象是个模板,要实例化的对象都以这个模板为基础。总而

    言之,prototype 对象的任何属性和方法都被传递给那个类的所有实例。原型链利用这种功能来实现继承机制。我们

    来看一个例子:

    function A() {//超类型A中必须没有参数
        this.color = "red";
        this.showColor = function () {
           return this.color;
        };
    };
    function B() {//子类型B
        this.name = "John";
        this.showName = function () {
           return this.name;
        };
    };
    B.prototype = new A();//子类型B继承了超类型A,通过原型,形成链条
    var a = new A();
    var b = new B();
    document.write(a.showColor());//输出:blue
    document.write(b.showColor());//输出:red
    document.write(b.showName());//输出:John
          在原型链中,instanceof运算符的运行方式也很独特。对B的所有实例,instanceof为A和B都返回true

    ECMAScript的弱类型世界中,这是极其有用的工具,不过使用对象冒充时不能使用它。例如:

    var b = new B();
    document.write(b instanceof A);//输出:true
    document.write(b instanceof B);//输出:true
           使用原型链方式实现了继承,但是这种方式无法共享和子类型给超类型传递参数。我们可以借用构造函数方式(也

    就是对像冒充)的方式来解决这两个问题。

           (2)对象冒充方式

          对象冒充方式的其原理如下:构造函数使用this关键字给所有属性和方法赋值(即采用对象声明的构造函数方式)。

    因为构造函数只是一个函数,所以可使A构造函数成为B的方法,然后调用它。B就会收到A的构造函数中定义的属性

    和方法。例如,用下面的方式改写上面的例子创建对象A和B:
           1call()方法

    function A(Color) {//创建超类型A
        this.color = Color;
        this.showColor = function () {
              return this.color;
        };
    };
    function B(Color,Name) {//创建子类型B
        A.call(this, Color);//对象冒充,给超类型传参
        this.name = Name;//新添加的属性
        this.showName = 
    };
    var a = new A("blue");
    var b = new B("red", "John");
    document.write(a.showColor());//输出:blue
    document.write(b.showColor());//输出:red
    document.write(b.showName());//输出:John
           2apply()方法

          和上面call()方法唯一的区别就是在子类型B中的代码:

    A.call(this,arguments);//对象冒充,给超类型传参

          当然,只有超类型中的参数顺序与子类型中的参数顺序完全一致时才可以传递参数对象。如果不是,就必须创建

    一个单独的数组,按照正确的顺序放置参数。

          使用对象冒充方式虽然解决了共享和传参的问题,但是没有原型,复用就更不可能了,所以我们组合上述的两种

    方式,即原型链方式和对象冒充的方式实现JS的继承。

          (3)混合方式

          这种继承方式使用构造函数定义类,并非使用任何原型。对象冒充的主要问题是必须使用构造函数方式,这不是

    最好的选择。不过如果使用原型链,就无法使用带参数的构造函数了。开发者如何选择呢?答案很简单,两者都用。

    由于这种混合方式使用了原型链,所以instanceof运算符仍能正确运行。

           在上一篇博文,创建对象的最好方式是用构造函数定义属性,用原型定义方法。这种方式同样适用于继承机制,

    用对象冒充继承构造函数的属性,用原型链继承prototype对象的方法。用这两种方式重写前面的例子,代码如下:

    function A(Color) {
        this.color = Color;
    };
    A.prototype.showColor = function () {
        return this.color;
    };
    function B(Color, Name) {
        A.call(this, Color);//对象冒充
        this.name = Name;
    };
    B.prototype = new A();//使用原型链继承
    B.prototype.showName = function () {
        return this.name;
    };
    var a = new A("blue");
    var b = new B("red", "John");
    document.write(a.showColor());//输出:blue
    document.write(b.showColor());//输出:red
    document.write(b.showName());//输出:John
           继承的方式和创建对象的方式有一定的联系,推荐使用的继承方式还时原型链和对象冒充的混合方式。使用这种

    混合方式可以避免一些不必要的问题。

           看这篇博文的时候,必须看一下前面的创建对象的方式:轻松学习JavaScript十二:JavaScript基于面向对象之创

    建对象(一)轻松学习JavaScript十二:JavaScript基于面向对象之创建对象(二)。那么理解起来应该没有那么难了,

    JS面向对象的一些概念时需要我们回过头来再理解的。

      

    展开全文
  • 需求: ...利用面向对象继承法来做,代码如下: 公共父类 这一类是,他们都有颜色有腿,而且在吃饭 public class Pet { private String name; private String color; private int leggs; pub...

    需求:
    已知猫类和狗类:
    属性:毛的颜色,腿的个数
    行为:吃饭
    猫特有行为:抓老鼠catchMouse
    狗特有行为:看家lookHome
    利用面向对象继承法来做,代码如下:

    公共父类
    这一类是,他们都有颜色有腿,而且在吃饭

    public class Pet {
    	private String name;
    	private String color;
    	private int leggs;
    	public Pet(String name,String color,int leggs) {
    		this.color=color;
    		this.leggs=leggs;
    		this.name=name;
    	}
    	public String getColor() {
    		return color;
    	}
    	public void eat() {
    		System.out.println(leggs+"条腿的"+color+"的"+name+"在吃饭");
    	}
    	public void setColor(String color) {
    		this.color = color;
    	}
    	public int getLeggs() {
    		return leggs;
    	}
    	public void setLeggs(int leggs) {
    		this.leggs = leggs;
    	}
    	
    }
    

    猫类

    public class Cat extends Pet{
    	public Cat(String name,String color,int leggs) {
    		super(name,color,leggs);
    	}
    	public void work() {
    		System.out.println(" "+"吃完饭后抓老鼠");
    	}
    }
    

    狗类

    public class Dog extends Pet {
    	public Dog(String name,String color,int leggs) {
    		super(name,color,leggs);
    	}
    	public void work() {
    		System.out.println(" "+"吃完饭后看家");
    	}
    }
    

    测试类

    public class Test {
    	 public static void main(String[] args) {
    		 Cat s=new Cat("小媚猫","花白色",4);
    		 s.eat();
    		 s.work();
    		 Dog t=new Dog("阿黄狗","黄白色",4);
    		 t.eat();
    		 t.work();
    	 }
    }
    

    输出结果
    在这里插入图片描述
    欢迎大家留言讨论!

    展开全文
  • 基于Java面向对象的理解,根据面向对象继承与封装,帮助理解面向对象相关知识
  • 面向对象继承实例(a如何继承b)

    千次阅读 2013-07-01 11:16:13
    面向对象继承实例 window.onload = function(){ function parent(age,name){ this.age = age; this.name = name; } parent.prototype.show = function(){ alert('父级方法'); } function child...
    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="utf-8">
    <title>面向对象继承实例</title>
    <script type="text/javascript">
    	window.onload = function(){
    		function parent(age,name){
    			this.age = age;
    			this.name = name;
    		}
    		parent.prototype.show = function(){
    			alert('父级方法');
    		}
    		function child(age,name,job){
    			parent.apply(this,arguments);
    			this.job = job;
    		}
    		(function(){
    			for(var i in parent.prototype){
    			child.prototype[i]=parent.prototype[i]
    			}
    		})();
    
    		var b = new parent(14,'侠客行');
    		var a = new child(15,'狼侠','侠客');
    		a.show();
    
    	}
    </script>
    </head>
    <body>
       <h1>面向对象继承实例</h1>
       <p>经常看到面试题有关继承问题 a如何继承b 决定写一下,其实继承就是继承父级的属性和方法</p>
    </body>
    </html>


    展开全文
  • 面向对象,动物练习 综合练习,抽象方法,继承,多态,多种动物的叫声。但是这是面向对象
  • Java面向对象继承与组合的问题

    千次阅读 2007-03-17 15:18:00
    Java面向对象继承与组合的问题
    Java面向对象继承与组合的问题
    1.继承和组合的概念
    在新类里简单地创建原有类的对象。我们把这种方法叫作“组合”,因为新类由现有类的对象合并而成。我们只是简单地重复利用代码的功能,而不是采用它的形式。
    第二种方法是创建一个新类,将其作为现有类的一个“类型”。我们可以原样采取现有类的形式,并在其中加入新代码,同时不会对现有的类产生影响。这种魔术般的行为叫作“继承”(Inheritance),涉及的大多数工作都是由编译器完成的。对于面向对象的程序设计,“继承”是最重要的基础概念之一。对于组合和继承这两种方法,大多数语法和行为都是类似的(因为它们都要根据现有的类型生成新类型)。
    2.组合也就是一个类的对象是另外一个类的成员,一般的程序都有组合的意味,只不过是基本数据类型是成员变量,下面请看具体的例子
    class Head
    {
           Head(){
          System.out.println(" head ");
          }
    }
    class Body
    {
          Body(){
          System.out.println(" body ");
          }
    }
    class Person()
    {
          Head h=null;
          Body b=null;
         Person()                                //人是由头和身体组成的,Head和Body的对象是Person的一部分
        {
          h=new Head();
          b =new Body();
        }
     
    }
     
    3.继承作为面向对象的三个重要特性的一个方面,在面向对象的领域有着及其重要的作用,好像没听说哪个面向对象的语言不支持继承
     class Person
    {
     private String name=null;
     private int age=0;
     public Person(String n,int a)
     {
      name=n;
      age=a;
     }
     int getAge()
     {
      return age;
     }
     String getName()
     {
      return name;
     }
     void getDescription()
     {
      System.out.println("name: "+name+"/t"+"age: "+age);
     }
    }
    class Student extends Person
    {
     private String studno=null;
     public Student(String n,String no,int a)
     {
      super(n,a);
      studno=no;
     }
    }
    说明:Student类中有三个成员变量name,age,studno和一个方法getDescription();
    注意:子类继承了父类的所有变量和函数,只是子类不能访问父类的private类型的变量和函数,其实privae类型的变量还是继承到子类中的
     
    4.
    无论还是继承,都允许我们将子对象置于自己的新类中。大家或许会奇怪两者间的差异,以及到底该如何选择。
    如果想利用新类内部一个现有类的特性,而不想使用它的接口,通常应选择组合。也就是说,我们可嵌入一个对象,使自己能用它实现新类的特性。但新类的用户会看到我们已定义的接口,而不是来自嵌入对象的接口。考虑到这种效果,我们需在新类里嵌入现有类的private对象。
    有些时候,我们想让类用户直接访问新类的组合。也就是说,需要将成员对象的属性变为public。成员对象会将自身隐藏起来,所以这是一种安全的做法。而且在用户知道我们准备合成一系列组件时,接口就更容易理解。car(汽车)对象便是一个很好的例子:

    class Engine {  public void start() {}  public void rev() {}  public void stop() {}}class Wheel {  public void inflate(int psi) {}}class Window {  public void rollup() {}  public void rolldown() {}}class Door {  public Window window = new Window();  public void open() {}  public void close() {}}public class Car {  public Engine engine = new Engine();  public Wheel[] wheel = new Wheel[4];  public Door left = new Door(),       right = new Door(); // 2-door  Car() {    for(int i = 0; i < 4; i++)      wheel[i] = new Wheel();  }  public static void main(String[] args) {    Car car = new Car();    car.left.window.rollup();    car.wheel[0].inflate(72);  }} ///:~

    由于汽车的装配是故障分析时需要考虑的一项因素(并非只是基础设计简单的一部分),所以有助于客户程序员理解如何使用类,而且类创建者的编程复杂程度也会大幅度降低。
    如选择继承,就需要取得一个现成的类,并制作它的一个特殊版本。通常,这意味着我们准备使用一个常规用途的类,并根据特定的需求对其进行定制。只需稍加想象,就知道自己不能用一个车辆对象来组合一辆汽车——汽车并不“包含”车辆;相反,它“属于”车辆的一种类别。“属于”关系是用继承来表达的,而“包含”关系是用组合来表达的。

    5. protected
    现在我们已理解了继承的概念,protected这个关键字最后终于有了意义。在理想情况下,private成员随时都是“私有”的,任何人不得访问。但在实际应用中,经常想把某些东西深深地藏起来,但同时允许访问衍生类的成员。protected关键字可帮助我们做到这一点。它的意思是“它本身是私有的,但可由从这个类继承的任何东西或者同一个包内的其他任何东西访问”。也就是说,Java中的protected会成为进入“友好”状态。
    我们采取的最好的做法是保持成员的private状态——无论如何都应保留对基 础的实施细节进行修改的权利。在这一前提下,可通过protected方法允许类的继承者进行受到控制的访问:

    import java.util.*;class Villain {  private int i;  protected int read() { return i; }  protected void set(int ii) { i = ii; }  public Villain(int ii) { i = ii; }  public int value(int m) { return m*i; }}public class Orc extends Villain {  private int j;  public Orc(int jj) { super(jj); j = jj; }  public void change(int x) { set(x); }} ///:~

    可以看到,change()拥有对set()的访问权限,因为它的属性是protected(受到保护的)。
     
    6. 再论合成与继承
    在面向对象的程序设计中,创建和使用代码最可能采取的一种做法是:将数据和方法统一封装到一个类里,并且使用那个类的对象。有些时候,需通过“组合”技术用现成的类来构造新类。而继承是最少见的一种做法。因此,尽管继承在学习OOP的过程中得到了大量的强调,但并不意味着应该尽可能地到处使用它。相反,使用它时要特别慎重。只有在清楚知道继承在所有方法中最有效的前提下,才可考虑它。为判断自己到底应该选用组合还是继承,一个最简单的办法就是考虑是否需要从新类上溯造型回基础类。若必须上溯,就需要继承。但如果不需要上溯造型,就应提醒自己防止继承的滥用。但只要记住经常问自己“我真的需要上溯造型吗”,对于组合还是继承的选择就不应该是个太大的问题
     
    展开全文
  • 传统的JavaSCript继承是这个样子的://相当于构造函数 var myClass = function(name) { this._name = name; }; //通过原型方法继承 ...或者使用Node.JS的util对象继承util.inherits(myClass, require('event
  • javascript面向对象继承的简单实例: 作为一门面向对象的语言,继承自然是它的一大特性,尽管javascript的面向对象的实现机制和和c#和java这样典型的面向对象不同,但是继承的基本特点还是具有的,简单的说就是获得...
  • 主要介绍了Python面向对象类继承和组合,结合实例形式分析了Python3面向对象继承的原理、用法以及继承与组合相关使用技巧,需要的朋友可以参考下
  • 面向对象的概念 掌握类的继承、方法重写、super关键字的使用、final关键字 熟悉面向对象继承和多态的概念
  • 第4讲 面向对象继承第4讲 面向对象继承第4讲 面向对象继承第4讲 面向对象继承第4讲 面向对象继承第4讲 面向对象继承第4讲 面向对象继承第4讲 面向对象继承第4讲 面向对象继承第4讲 面向对象继承...
  • 主要介绍了JS面向对象编程继承操作,结合实例形式详细分析了JS面向对象继承的具体概念、原理、实现方法及操作注意事项,需要的朋友可以参考下
  • 主要介绍了Python面向对象继承代码详解,分享了相关代码示例,小编觉得还是挺不错的,具有一定借鉴价值,需要的朋友可以参考下
  • 主要介绍了Python3.5面向对象继承,结合图文与实例形式详细分析了Python3.5面向对象继承的相关概念、原理、实现方法及操作注意事项,需要的朋友可以参考下
  • 主要介绍了Python面向对象继承和多态用法,结合实例形式分析了Python面向对象程序设计中继承与多态的原理及相关操作技巧,需要的朋友可以参考下
  • 主要介绍了Javascript简单实现面向对象编程继承实例代码,简单分析了面向对象程序设计的特征与继承的具体实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • 下面小编就为大家带来一篇JS 面向对象继承---多种组合继承详解。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 是一篇关于JavaScript的面向对象继承的文章,对想学习JavaScript中面向对象的同学来说是很有帮助,虽然一些Javascript用户可能永远也不需要知道原型或面向对象语言的性质,但是那些来自传统面向对象的语言的开发者...
  • 主要介绍了Python面向对象继承原理与用法,结合具体案例形式分析了Python面向对象程序设计中继承的原理、使用方法及相关操作注意事项,需要的朋友可以参考下
  • 主要介绍了Python面向对象继承和组合用法,结合实例形式分析了Python面向对象程序设计中组合与继承的相关原理、使用方法及操作注意事项,需要的朋友可以参考下
  • OC面向对象继承

    千次阅读 2014-09-27 15:16:14
    OC面向对象继承     OC面向对象继承 一、基本概念 程序的世界和人类的“对象”世界在思想上是没有设么区别的,富二代继承了父母,自然就拥有了父母拥有的所有资源,子类继承了父类同样就拥有了父类所有的...
  • 主要介绍了Python面向对象类的继承,结合实例形式详细分析了Python面向对象程序设计中类的继承原理、定义、使用方法及相关操作注意事项,需要的朋友可以参考下
  • 这是关于面向对象继承与接口的课件!这是关于面向对象继承与接口的课件!这是关于面向对象继承与接口的课件!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 457,170
精华内容 182,868
关键字:

面向对象继承