原型链与经典面向对象比较

1/1原型链与经典面向对象比较第一部分经典面向对象基本概念：封装、继承、多态。 2第二部分原型链基本概念：原型对象、原型链、委托。 3第三部分经典面向对象实现方式：类和对象。 6第四部分原型链实现方式：对象和原型对象。 7第五部分经典面向对象继承方式：基于类。 11第六部分原型链继承方式：基于委托。 14第七部分经典面向对象多态方式：函数重载和函数覆盖。 17第八部分原型链多态方式：函数重写和原型继承。 20

第一部分经典面向对象基本概念：封装、继承、多态。关键词关键要点【封装】：

1.封装是一种隐藏对象内部实现的机制，它允许对象将自身的数据和行为隐藏在内部，只暴露必要的接口，从而实现数据的保密性和对象的独立性。

2.封装有助于提高代码的可读性、可维护性和可重用性。通过封装，我们可以将复杂的数据结构和算法隐藏在对象内部，使得代码更加易于理解和维护。同时，封装还可以提高代码的可重用性，因为我们可以将常用的数据结构和算法封装成对象，然后在不同的程序中重复使用。

3.封装是面向对象编程的基本原则之一，它与继承和多态一起构成了面向对象编程的三大支柱。

【继承】：

封装

封装是将数据和操作数据的方法绑定在一起，形成一个独立的实体，对数据的访问只能通过该实体提供的接口进行。封装可以提高代码的安全性、可维护性、可重用性和可扩展性。

面向对象中的类就是封装的实现方式，类中包含的数据成员是对象的属性，类中定义的方法是对象的成员函数。

继承

继承是一种派生新类（子类）的方法，子类继承自父类，子类具有父类的数据成员和方法。子类可以扩展或修改父类的方法来适应自己的需要。继承可以使代码更易于维护、可重用和可扩展。

多态

多态性是指一个对象可以有多种形式，并且可以在不同的上下文中被使用。多态性可以提高代码的灵活性、可维护性和可重用性。

面向对象中的多态性主要通过方法重写和接口来实现。方法重写是指子类可以重新定义父类的方法，以便在子类中使用不同的实现。接口是一种定义方法签名的抽象类型，它允许不同的类实现相同的接口，从而可以实现多态性。

经典面向对象与原型链的比较

|特性|经典面向对象|原型链|

||||

|封装|通过类和对象实现|通过对象和原型对象实现|

|继承|通过子类和父类实现|通过原型对象和克隆实现|

|多态|通过方法重写和接口实现|通过委托和原型继承实现|

|优点|代码更易于维护、可重用和可扩展|代码更灵活、更易于扩展|

|缺点|代码可能更复杂、更难理解|代码可能更难调试|第二部分原型链基本概念：原型对象、原型链、委托。关键词关键要点主题名称：原型对象

1.原型对象是JavaScript中一个特殊的对象，它包含了其他对象可以继承的属性和方法。

2.每个JavaScript对象都有一个原型对象，可以通过Object.getPrototypeOf()方法获取。

3.原型对象可以被修改，这将影响该原型链上的所有对象。

主题名称：原型链

#原型链基本概念

一、原型对象

原型对象是JavaScript中一个特殊的对象，它拥有一个名为`[[Prototype]]`的属性，指向另一个对象。这个另一个对象也被称为原型对象，如此递归下去，形成一个对象之间的链条，称为原型链。

原型对象是创建其他对象的基础。当创建一个新对象时，JavaScript会自动创建一个原型对象并将其链接到新对象。原型对象包含了新对象的所有属性和方法，新对象可以继承原型对象中的属性和方法。

二、原型链

原型链是指从一个对象一直向上查找其原型对象直至`[[Prototype]]`为`null`的对象所构成的对象链。它允许对象访问其原型对象中的属性和方法，从而实现继承。

三、委托

委托是指对象委托其原型对象来处理它没有实现的方法或属性。当一个对象需要访问一个它没有实现的方法或属性时，它会沿着原型链向上查找，并调用原型对象中实现的方法或属性。

原型链与经典面向对象比较

1.继承机制

*原型链：原型链通过委托实现继承，子对象可以直接访问父对象中的属性和方法，而无需显式地声明继承关系。

*经典面向对象：经典面向对象语言通过继承关键字实现继承，子类显式地继承父类的属性和方法。

2.多重继承

*原型链：原型链可以实现多重继承，一个对象可以拥有多个原型对象，并继承这些原型对象中的属性和方法。

*经典面向对象：经典面向对象语言通常只支持单继承，一个类只能继承一个父类。

3.代码复用

*原型链：原型链可以方便地实现代码复用，将公共的属性和方法定义在原型对象中，子对象可以直接继承这些属性和方法，无需重复定义。

*经典面向对象：经典面向对象语言中的代码复用通常通过继承来实现，子类可以继承父类的属性和方法，但需要显式地声明继承关系。

4.灵活性和扩展性

*原型链：原型链的灵活性更强，可以动态地添加或删除原型对象，从而改变对象的继承关系。

*经典面向对象：经典面向对象语言的继承关系通常是静态的，一旦类被定义，其继承关系就无法改变。

5.性能

*原型链：原型链的性能通常优于经典面向对象语言的继承机制，因为原型链可以避免创建不必要的对象。

*经典面向对象：经典面向对象语言的继承机制通常需要创建更多的对象，从而可能导致性能下降。

总结

原型链是一种在JavaScript中实现继承和代码复用的强大机制。它与经典面向对象语言的继承机制相比具有许多优势，例如灵活性更强、性能更好等。原型链广泛应用于JavaScript开发中，是理解JavaScript语言的重要概念之一。第三部分经典面向对象实现方式：类和对象。关键词关键要点【类和对象的概念】：

-类是对象的蓝图或模板，它描述了对象的属性和行为。类可以用类名、变量和方法来定义。

-对象是类的实例，它具有类的所有属性和行为。对象可以通过使用类名和new关键字来创建。

-类和对象是面向对象编程的基本概念，它们是构建面向对象程序的基础。

【类的成员】：

#经典面向对象实现方式：类和对象

在经典的面向对象编程中，类和对象是两个基本概念。类是描述一类事物的模板，而对象是类的一个实例。类和对象之间的关系是继承关系，即子类继承父类的属性和方法。

类

类是描述一类事物的模板，它定义了该类事物的属性和方法。类的属性是指该类事物拥有的特质，例如，人的属性包括姓名、年龄、性别等。类的对象则是该类事物的具体实例，例如，张三是人的一个对象，他具有姓名、年龄、性别等属性。

类可以被细分为不同的层次，称为类层次结构。类层次结构的顶层是根类，根类是所有其他类的父类。根类通常只定义一些基本属性和方法，而其他类则继承根类的属性和方法，并添加自己的属性和方法。

对象

对象是类的一个实例，它具有该类定义的所有属性和方法。对象可以相互通信，以实现各种功能。例如，一个学生对象可以向老师对象发送消息，请求老师对象帮助他解决问题。

对象可以被分为不同的类型，称为对象类型。对象类型是指对象拥有的属性和方法的集合。例如，学生对象类型具有姓名、年龄、性别等属性，以及学习、考试等方法。

类和对象之间的关系

类和对象之间的关系是继承关系，即子类继承父类的属性和方法。子类可以继承父类的所有属性和方法，也可以添加自己的属性和方法。

继承关系可以形成类层次结构，类层次结构的顶层是根类，根类是所有其他类的父类。根类通常只定义一些基本属性和方法，而其他类则继承根类的属性和方法，并添加自己的属性和方法。

类层次结构可以帮助我们组织和管理代码，使代码更加易读和易维护。第四部分原型链实现方式：对象和原型对象。关键词关键要点对象和原型对象

1.原型对象是一个特殊的对象，它包含了该类型的所有属性和方法。

2.每个对象都有一个原型对象，它可以访问原型对象中的所有属性和方法。

3.对象可以修改原型对象中的属性和方法，但不能修改原型对象本身。

原型链

1.原型链是一个对象的属性和方法的查找路径。

2.当对象访问一个属性或方法时，它首先会在自己的属性和方法中查找。

3.如果在自己的属性和方法中没有找到，它就会沿着原型链向上查找。

4.一直沿着原型链向上查找，直到找到该属性或方法，或者到达最顶层的原型对象。

原型继承

1.原型继承是JavaScript中的一种继承方式。

2.原型继承是通过修改原型对象来实现的。

3.当一个对象继承另一个对象时，它会复制另一个对象的原型对象。

4.这样，该对象就可以访问另一个对象的所有属性和方法。

经典面向对象继承

1.经典面向对象继承是通过派生类来实现的。

2.派生类继承了基类的所有属性和方法。

3.派生类可以覆盖基类的方法，也可以添加新的方法。

4.派生类和基类是独立的，它们之间没有直接的引用关系。

原型链实现方式的优点

1.原型链实现方式简单，易于理解。

2.原型链实现方式可以节省内存，因为多个对象可以共享同一个原型对象。

3.原型链实现方式可以提高性能，因为对象可以快速地访问原型对象中的属性和方法。

原型链实现方式的缺点

1.原型链实现方式难以跟踪，因为对象可以修改原型对象中的属性和方法。

2.原型链实现方式可能导致意外的错误，因为对象可以访问原型对象中的所有属性和方法，即使这些属性和方法不是为该对象设计的。原型链实现方式：对象和原型对象

原型链是一种实现继承的机制，它允许对象访问和继承另一个对象的行为和属性。在原型链中，每个对象都有一个原型对象，原型对象是另一个对象的副本，它包含了该对象的行为和属性。当一个对象调用一个方法或访问一个属性时，它首先会在自己的属性中查找，如果没有找到，它会继续在原型对象中查找，依此类推，直到找到该方法或属性。

在原型链中，对象和原型对象之间存在着一种父子关系，对象是原型对象的子对象，原型对象是对象的父对象。每个对象都可以有多个原型对象，它的原型对象可以是另一个对象，也可以是另一个对象的原型对象，如此循环，直到遇到根对象（原型链的顶端对象）。

对象

对象是原型链中的基本组成单位，它包含了该对象的行为和属性。对象的行为和属性可以通过原型对象来继承，也可以通过直接分配来添加。

原型对象

原型对象是另一个对象的副本，它包含了该对象的行为和属性。原型对象可以被多个对象共享，从而实现代码的重用。

原型链的构建过程

原型链的构建过程如下：

1.创建一个根对象。

2.为根对象添加行为和属性。

3.创建一个子对象，并将其原型对象设置为根对象。

4.为子对象添加行为和属性。

5.创建另一个子对象，并将其原型对象设置为子对象。

6.为另一个子对象添加行为和属性。

如此循环，直到创建出所有需要的对象。

原型链的优点

原型链具有以下优点：

*代码的复用：原型链允许多个对象共享相同的原型对象，从而实现代码的复用。

*继承的灵活性：原型链可以实现多重继承，这使得对象可以继承多个原型对象的行为和属性。

*性能优化：原型链可以减少对象的创建和销毁时间，从而优化性能。

原型链的缺点

原型链也存在以下缺点：

*难以理解：原型链的实现方式比较复杂，这使得它难以理解和维护。

*容易出现循环引用：如果原型链中存在循环引用，这可能会导致内存泄漏。

*不支持信息隐藏：原型链不具备信息隐藏的特性，这使得子对象可以访问和修改父对象的行为和属性。

原型链与经典面向对象编程的比较

原型链和经典面向对象编程（OOP）都是实现继承的机制，但它们之间存在着一些区别。

*原型链是一种基于对象的继承机制，而OOP是一种基于类的继承机制。

*原型链中的对象可以有多个原型对象，而OOP中的对象只能有一个父类。

*原型链的继承是动态的，这意味着可以在运行时修改对象的原型对象，而OOP的继承是静态的，这意味着只能在编译时修改对象的父类。

*原型链不具备信息隐藏的特性，而OOP具有信息隐藏的特性。

总的来说，原型链和OOP各有优缺点，在不同的场景下，可以使用不同的继承机制来实现代码的重用。第五部分经典面向对象继承方式：基于类。关键词关键要点基于类的继承

1.概念：基于类的继承是一种经典的面向对象继承方式，它允许一个类（子类）从另一个类（父类）继承属性和方法。

2.优点：

-代码重用：子类可以继承父类的方法和属性，减少重复编写代码量。

-代码的可读性：通过继承可以将相关的代码组织在一起，使代码更加易于阅读和理解。

-代码的可维护性：如果父类发生变化，子类无需改动，使代码更加易于维护。

3.局限性：

-类间关系复杂：随着继承层次的加深，类之间的关系变得复杂，可能导致难以维护和理解。

-类层次深度问题：当继承层次过深时，可能会导致方法调用或变量访问路径过长，导致性能问题。

-类间耦合度高：子类与父类之间耦合度高，如果父类发生变化，子类也需要做出相应改动。

重用性

1.概念：重用性是指在不同的程序或系统中повторно使用相同的功能或特性。

2.优点：

-提高生产力：通过重用已有代码，可以减少开发时间和成本。

-提高代码质量：重用的代码通常经过反复测试和优化，因此质量较高。

-提高代码一致性：重用代码可以确保在不同程序或系统中使用相同的功能或特性时保持一致性。

3.局限性：

-灵活性问题：重用代码可能无法满足特定需求，需要进行修改和定制才能符合要求。

-维护问题：如果重用的代码需要更新或修改，可能涉及多个程序或系统，导致维护难度增加。

-版权和许可：使用重用代码时需要考虑版权和许可问题，确保合法合规。一、概念厘清

1.类：类是具有相同特征、属性和方法的一组对象的集合。类是对象类型，对象是类的实例。

2.对象：对象是类的实例，具有类的属性和方法。对象可以彼此交互，以实现特定的功能。

3.继承：继承是一种将父类属性和方法传递给子类的方式。通过继承，子类可以复用父类的属性和方法，而无需重新编写。

4.封装：封装是一种将对象的属性和方法隐藏起来，使其只能通过特定的方法来访问的方式。封装可以保护对象的内部数据，防止被意外修改。

5.多态：多态是一种允许对象具有不同行为的能力。当父类有多个子类时，子类可以分别实现父类的方法，使子类具有不同的行为。

二、经典面向对象继承方式：基于类

1.定义和结构

经典面向对象继承方式是基于类的，由类和对象组成。类定义了对象的属性和方法，而对象是类的实例，具有类的属性和方法。类与对象之间存在继承关系，子类可以继承父类的属性和方法，而子类还可以添加自己的属性和方法。

2.优点和缺点

基于类的继承方式具有以下优点：

（1）代码复用：通过继承，子类可以复用父类的代码，从而实现代码复用，减少重复工作。

（2）可扩展性：通过继承，可以很容易地扩展类，只需要添加新的子类即可，从而实现类的可扩展性。

（3）多态性：通过继承，可以实现多态性，即子类可以根据自己的实现来重写父类的方法，从而实现不同的行为。

基于类的继承方式也存在以下缺点：

（1）复杂性：基于类的继承方式可能会导致代码复杂性增加，特别是当存在多重继承或深层继承时。

（2）耦合性：基于类的继承方式会导致类之间的耦合性增加，当父类发生变化时，子类也可能会受到影响。

三、典型应用场景

基于类的继承方式广泛应用于各种场景，包括：

（1）GUI编程：在GUI编程中，继承可以用于创建不同类型的窗口控件，例如，按钮、文本框、列表框等。

（2）数据结构：在数据结构中，继承可以用于创建不同类型的数据结构，例如，链表、栈、队列等。

（3）算法：在算法中，继承可以用于创建不同类型的算法，例如，排序算法、搜索算法等。

四、与原型链继承方式的比较

经典面向对象继承方式和原型链继承方式都是实现继承的两种方式，但两者之间存在一些差异。

（1）继承机制：经典面向对象继承方式是基于类的，通过类来实现继承。原型链继承方式是基于对象的，通过原型链来实现继承。

（2）继承关系：经典面向对象继承方式的继承关系是固定的，子类和父类之间的关系是静态的。原型链继承方式的继承关系是动态的，子对象和父对象之间的关系可以动态改变。

（3）代码复用：经典面向对象继承方式可以通过代码复用来实现继承，而原型链继承方式则无法实现代码复用。

（4）可扩展性：经典面向对象继承方式具有较好的可扩展性，可以通过添加新的子类来扩展类。原型链继承方式的扩展性较差，需要修改原型对象才能扩展对象。

（5）多态性：经典面向对象继承方式支持多态性，即子类可以根据自己的实现来重写父类的方法，从而实现不同的行为。原型链继承方式不支持多态性。

总体而言，经典面向对象继承方式和原型链继承方式各有优缺点，在不同的场景中，需要根据具体需求选择合适的继承方式。第六部分原型链继承方式：基于委托。关键词关键要点【原型链继承方式：基于委托。】：

1.原型链继承是一种基于对象委托的继承方式，它允许一个对象访问另一个对象的属性和方法。

2.在原型链继承中，每个对象都拥有一个原型对象，该原型对象包含该对象的所有属性和方法。

3.当一个对象尝试访问一个它不拥有的属性或方法时，它会将其委托给其原型对象。此过程一直持续到委托链顶部的对象为止。

【原型链的优点】：

原型链继承方式：基于委托

原型链继承方式是一种基于委托的继承方式。在原型链继承中，子对象会继承父对象的原型对象，并通过原型对象来访问父对象的方法和属性。这意味着，子对象可以访问父对象的所有方法和属性，但不能直接访问父对象本身。

原型链继承方式的一个优点是，它可以实现多重继承。在经典面向对象继承中，一个子类只能继承一个父类，但在原型链继承中，一个子对象可以继承多个父对象。这使得原型链继承方式非常适合用于实现具有多重继承需求的系统。

原型链继承方式的另一个优点是，它可以提高代码的重用性。在原型链继承中，父对象的方法和属性可以被子对象直接使用，而不需要重新实现。这使得代码的重用性大大提高，从而减少了开发人员的工作量。

原型链继承方式的主要缺点是，它可能会导致代码的执行效率降低。在原型链继承中，子对象访问父对象的方法和属性时，需要通过原型对象来进行委托。这可能会导致代码的执行效率降低，特别是当父对象的方法和属性被子对象频繁调用时。

总体而言，原型链继承方式是一种非常灵活的继承方式，它可以实现多重继承和提高代码的重用性。但是，原型链继承方式也可能会导致代码的执行效率降低。因此，在使用原型链继承方式时，需要仔细权衡其优缺点。

原型链继承方式与经典面向对象继承方式的比较

原型链继承方式与经典面向对象继承方式的主要区别在于，原型链继承方式是基于委托的，而经典面向对象继承方式是基于类的。在原型链继承中，子对象直接继承父对象的原型对象，并通过原型对象来访问父对象的方法和属性。而在经典面向对象继承中，子类直接继承父类的所有方法和属性。

原型链继承方式与经典面向对象继承方式的另一个区别在于，原型链继承方式可以实现多重继承，而经典面向对象继承方式只能实现单一继承。在原型链继承中，一个子对象可以继承多个父对象，而经典面向对象继承中，一个子类只能继承一个父类。

原型链继承方式与经典面向对象继承方式的第三个区别在于，原型链继承方式的代码重用性更高。在原型链继承中，父对象的方法和属性可以被子对象直接使用，而不需要重新实现。而在经典面向对象继承中，子类需要重新实现父类的方法和属性，这可能会导致代码的重复。

原型链继承方式与经典面向对象继承方式的第四个区别在于，原型链继承方式的代码执行效率可能会更低。在原型链继承中，子对象访问父对象的方法和属性时，需要通过原型对象来进行委托。这可能会导致代码的执行效率降低，特别是当父对象的方法和属性被子对象频繁调用时。而在经典面向对象继承中，子类直接继承父类的所有方法和属性，因此子类访问父类的方法和属性时不需要进行委托，这使得代码的执行效率更高。

原型链继承方式的应用场景

原型链继承方式非常适合用于实现具有多重继承需求的系统。例如，在JavaScript中，对象可以通过原型链继承方式来实现多重继承。此外，原型链继承方式还非常适合用于实现代码的重用。例如，在React中，组件可以通过原型链继承方式来实现代码的重用。

总而言之，原型链继承方式是一种非常灵活的继承方式，它可以实现多重继承和提高代码的重用性。但是，原型链继承方式也可能会导致代码的执行效率降低。因此，在使用原型链继承方式时，需要仔细权衡其优缺点。第七部分经典面向对象多态方式：函数重载和函数覆盖。关键词关键要点函数重载

1.函数重载是指在同一个类中定义多个具有相同名称但参数不同的函数，以便在不同的情况下可以使用不同的函数。

2.函数重载可以提高代码的可读性和可维护性，因为它可以使代码更加简洁，并减少重复代码的数量。

3.函数重载还可以在一定程度上提高代码的运行效率，因为它可以避免在运行时进行类型转换。

函数覆盖

1.函数覆盖是指在子类中重新定义父类中已经存在的方法，以便在子类中使用不同的方法来实现相同的操作。

2.函数覆盖可以实现多态性，即子类对象可以被父类对象引用，并可以在父类对象上调用子类的方法。

3.函数覆盖还可以在一定程度上提高代码的可读性和可维护性，因为它可以使代码更加清晰，并减少重复代码的数量。经典面向对象的多态方式：函数重载和函数覆盖

经典面向对象的多态性主要体现在函数重载和函数覆盖两个方面。

1.函数重载（FunctionOverloading）

函数重载是指在同一个类中定义多个具有相同函数名但参数列表不同的函数。当调用函数时，编译器会根据实际参数的类型和数量选择要调用的函数。函数重载可以提高代码的可读性和可维护性，因为它允许使用相同的函数名来表示具有不同功能的多个操作。

例如，在以下代码中，`add()`函数被重载了三次，一次接受两个整数参数，一次接受两个浮点数参数，一次接受一个整数参数和一个浮点数参数。

```

public:

returna+b;

}

returna+b;

}

returna+b;

}

};

```

在调用`add()`函数时，编译器会根据实际参数的类型和数量来选择要调用的函数。例如，以下代码调用`add()`函数来计算两个整数的和：

```

Calculatorcalculator;

intresult=calculator.add(1,2);

```

编译器会选择第一个`add()`函数，并将两个整数参数传递给函数。

2.函数覆盖（FunctionOverriding）

函数覆盖是指在子类中重新定义父类中的函数。当子类对象调用被覆盖的函数时，将会调用子类中的函数，而不是父类中的函数。函数覆盖允许子类定制父类中的行为，从而实现多态性。

例如，在以下代码中，`Animal`类定义了一个`speak()`函数，`Dog`类继承了`Animal`类并覆盖了`speak()`函数。

```

public:

cout<<"Animalspeaks"<<endl;

}

};

public:

cout<<"Dogbarks"<<endl;

}

};

```

当创建一个`Dog`对象并调用`speak()`函数时，将会调用`Dog`类中的`speak()`函数，而不是`Animal`类中的`speak()`函数。

函数重载和函数覆盖是经典面向对象的多态性实现方式。函数重载允许在同一个类中定义具有相同函数名但参数列表不同的函数，函数覆盖允许子类定制父类中的行为。这两种方式都可以提高代码的可读性和可维护性，并实现多态性。第八部分原型链多态方式：函数重写和原型继承。关键词关键要点【原型链多态方式：函数重写和原型继承】：

1.函数重写：函数重写是指在子类型中重新定义父类型中已经存在的方法。在原型链中，当子类型对象调用某个方法时，会首先在子类型中查找该方法。如果子类型中存在该方法，则直接调用子类型中的方法。如果子类型中不存在该方法，则会沿着原型链向上查找，直到找到该方法为止。

2.原型继承：原型继承是指子类型继承父类型的原型对象。在原型链中，当子类型创建新对象时，会将父类型的原型对象作为子类型新对象的原型对象。这样，子类型新对象就可以访问父类型原型对象中的属性和方法。

3.多态性：多态性是指在不同的对象上调用相同的方法，可以得到不同的结果。在原型链中，由于子类型对象可以访问父类型原型对象中的属性和方法，因此子类型对象可以调用父类型中定义的方法。当在不同的子类型对象上调用相同的方法时，会得到不同的结果，这就体现了多态性。

【原型链与经典面向对象比较】：

原型链多态方式：函数重写和原型继承

概述

在原型链中，多态性是通过函数重写和原型继承来实现的。函数重写是指在子对象中重新定义父对象中的同名函数，从而实现对父对象函数的覆盖。原型继承是指子对象继承父对象的原型对象，从而获得父对象原型对象中的所有属性和方法。

函数重写

在原型链中，函数重写是指在子对象中重新定义父对象中的同名函数，从而实现对父对象函数的覆盖。函数重写是一种常见的多态性实现方式，它允许子对象根据自己的需要来重新定义父对象中的函数，从而实现更加灵活和定制化的行为。

```javascript

='Parent';

}

console.log('HellofromParent');

};

='Child';

}

Ctotype=newParent();

console.log('HellofromChild');

};

constparent=newParent();

constchild=newChild();

parent.sayHello();//HellofromPare