inheritance.md

Inheritance in JavaScript

1. What is inheritance in JavaScript, and how does it differ from inheritance in other programming languages?
2. What is a Prototypal inheritance model?
3. What is the difference between classical and prototypal inheritance?
4. What is a constructor function in JavaScript, and how does it differ from a regular function?
5. How does the .prototype property work in JavaScript, and what is its relationship to constructor functions?

Younes Nourzehi, Muhammed Hasan, Muhammed Mustafa Alnaddaf, Jimaa Maya, Radman Lotfiazar

1. Inheritance in JavaScript allows Classes to inherit properties and methods from other Classes, in the old version of JS it used to use prototypes for inheritance instead of classes.

2. Prototypal inheritance is a model of inheritance in JavaScript where objects (classes) inherit properties and methods directly from other objects (classes).

3. In classical, objects are created from classes, which act as blueprints for creating objects. In prototypal inheritance, there are no classes, and objects inherit directly from other objects.

4. A constructor function in JavaScript is a special type of function that is used to create new objects. It differs from a regular function in that it is called with the new keyword and sets up the newly created object.

5. The. prototype property in JavaScript is an object that specifies the properties and methods that should be inherited by objects created using a constructor function.

Team: @AsliSema @EdipNaser @aydinfz @Silvor23

1. Inheritance in JavaScript is achieved through prototypes and differs from classical inheritance in other programming languages. JavaScript allows for multiple inheritance and requires a solid understanding of prototypes to use effectively.
2. A prototypal inheritance model is a way of achieving inheritance in object-oriented programming where objects inherit properties and methods directly from other objects, rather than through the use of classes or hierarchies. In JavaScript, this is achieved through the use of object prototypes.
3. Classical inheritance has objects that inherit from other classes while prototypes act as more of a chain.
4. A constructor function in JavaScript is a special type of function that is used to create objects with a specific type or class. It differs from a regular function in that it uses the this keyword to refer to the object being created, and it does not return a value.
5. We access the prototype of a constructor function by typing the constructor function's name, and adding the attribute .prototype
   The prototype is just a JavaScript Object.

Ahmad Alashtar, Afra Kucukaydin, Ozlem Keles, Abdulrahman Albakkar, Nour Eddin Hamouda.
1- Inheritance in JavaScript is prototypal. In JavaScript, there are no classes, and objects can inherit properties and methods from other objects directly.
2- Prototypal inheritance model is where objects can inherit properties and methods from other objects. Prototypal inheritance model allows for dynamic object hierarchies, you can add new properties and methods to an object's prototype object at any time.
3- The difference between classical inheritance and prototypal inheritance is how they each handle generalisations. Classical inheritance has objects that inherit from other classes while prototypes act as more of a chain. The key difference between classical and prototypal inheritance is that classical inheritance is based on classes, while prototypal inheritance is based on objects and their prototypes.
4- Constructor function is designed to be called using the new keyword. A constructor function typically returns undefined, regular function can return any value. A constructor is a special function that creates and initializes an object instance of a class.
function animals(name){
this.name=name;
}
const animal1= new animal("some name")
5- .prototype property works as the prototype for all instances created with the constructor function.
class Plant {
hasEair(" you can breath here ")
}

Team members: @OmarQaqish @noorin99 @MOHAMMAD-ALMOHAMMAD @zeynepdumlupinar, Talal Bakkour

1. Inheritance in javascript is used to inherit attributes and methods of a class. In JavaScript, objects are created directly from other objects, which are seen as prototypes, and every object has a prototype chain. This is different from classical inheritance in other languages, which involves creating objects from classes that define their properties and methods.
2. The linking of prototypes of a parent object to a child object to share and utilize the properties of a parent class using a child class. It is a model of inheritance in which an object can inherit properties and methods directly from another object, known as its prototype.
3. The main difference between classical and prototypal inheritance in JavaScript is that in classical inheritance, objects are created from classes, while in prototypal inheritance, objects are created directly from other objects (prototypes). Additionally, classical inheritance follows a strict hierarchy, whereas prototypal inheritance allows for more flexibility in object creation and inheritance. In the prototype model, each new instance of an object will have a parent due to the prototype chain, in the classical model, this isn't always the case
4. Constructor functions creates a new instance of the context its in, regular functions don't and they would point to the same reference in memory and they are of type object.
5. In JavaScript, every function has a property called .prototype, which is an object that serves as the prototype for any objects created with that function as a constructor. When a constructor function is called with the new keyword, a new object is created and linked to the constructor's .prototype object, which allows the new object to inherit properties and methods from it.

Team members: Tasneem Akkad, Atakan Serbes, Rayan Alrouh, Cansu Aysagdic.

1. A class can inherit all the methods and properties of another class. When it comes to inheritance, JavaScript only has one construct: objects. Each object has a private property which holds a link to another object called its prototype. That prototype object has a prototype of its own, and so on until an object is reached with null as its prototype.
2. Prototypes are hidden objects that are used to share the properties and methods of a parent class to child classes.
3. Classical Inheritance is a mechanism in which one class can extend the methods of another class. Key Ideas: Classes may inherit from other classes. Objects are created from classes. Classes are immutable they can not be modified at runtime. But objects can be modified at runtime. The main difference between classical and prototypal inheritance is the way objects inherit properties and methods from their parent objects.
4. Constructor function in js is a function that is used with a new keyword to create objects. the purpose of constructor to define properties and methods for an object that is created. The main difference is constructor only works with new key. and does not have any return. but regular function does have a return.

Motaz Ali, Joud Khanji, Abdulsalam Hamandoush, Ismail Dincer, Sara nafisa:

1. inheritance in JS is when you create a subclass from a parent class, and this subclass or child class will inherit the methods and properties from the parent class, the difference between JS inheritance is that JS use prototype-based inheritance, but the others like Java or C++ use a real OOP classes

Omid Kayhani | Khaled Naes | Yasir Irzooqi | Hande Nur Demirbay

1. In JavaScript, inheritance is implemented using prototypes, which are objects that serve as templates for other objects. It differs from inheritance in other programming languages in that JavaScript uses prototypal inheritance rather than class-based inheritance.
2. Prototypal inheritance is a way of implementing inheritance in JavaScript, where objects can inherit properties and methods from other objects, which are used as prototypes.
3. Classical inheritance is static and doesn't allow for dynamic changes to an object's inheritance hierarchy as prototypal does.
4. A constructor function in JavaScript is a special function that is used to create objects, and it differs from a regular function in that it is typically called with the new keyword and sets the this keyword to refer to the new object it creates.

@saidbaradai @sheidanouri @Mustapha909 @9hello6 @tomiece317

1- Inheritance in JavaScript allows objects to inherit properties and methods from other objects using a prototypal inheritance model. This differs from classical inheritance used in many other programming languages, where objects are created from classes and inherit properties and methods from those classes.
2- Simply put, prototypical inheritance refers to the ability to access object properties from another object. We use a JavaScript prototype to add new properties and methods to an existing object constructor. We can then essentially tell our JS code to inherit properties from a prototype. Prototypical inheritance allows us to reuse the properties or methods from one JavaScript object to another through a reference pointer function.
3- The main difference between classical and prototypal inheritance is the way that objects inherit properties and method. Classical inheritance involves objects being created from classes in a strict class hierarchy, while prototypal inheritance involves objects being created directly from other objects in a prototype chain.Classical inheritance is a more rigid and static inheritance model, while prototypal inheritance is more flexible and dynamic.
4- A constructor function in JavaScript is used to create and initialize objects with specific state and behavior. It differs from a regular function in that it uses the this keyword to refer to the object being created and is typically called with the new keyword. A regular function performs computation or returns a value and can be called with or without new.
5- The .prototype property in JavaScript is used to add properties and methods to constructor functions. When a new object is created using a constructor function with the new keyword, it inherits properties and methods from the constructor function's .prototype object. This allows shared properties and methods to be added to constructor functions and shared among all instances created from that function.