Object-Oriented Programming: Difference between revisions

From NovaOrdis Knowledge Base
Jump to navigation Jump to search
 
(23 intermediate revisions by the same user not shown)
Line 33: Line 33:


An object is a specific instance of a [[#Class|class]].
An object is a specific instance of a [[#Class|class]].
=Associating Behavior with Types=


=Inheritance=
=Inheritance=
In its most generic form, inheritance in programming languages is the capability of declaring class hierarchies.
A hierarchy includes generic classes, called parent classes, or <span id='Superclass'></span>'''superclasses''', that are generic. The superclasses can be inherited by more specific and specialized classes, called <span id='Subclass'></span>'''subclasses'''. It is said that the subclass extends the superclass.
The superclasses declare attributes (state) and behavior that are shared with all their descendants. If something that is generally applicable to a set of classes, that belongs into the superclass, which can be then inherited. This is a great capability when it comes to code reusability. The generic state and behavior is declared only once, in superclass, and it does not have to be repeated in subclasses.
The subclasses also have the capability to declare state and behavior that is particular to them only, and no-one else, and differentiate them from siblings in the hierarchy.
Also, inheritance, together with [[#Overriding|overriding]] helps implement [[#Polymorphism|polymorphism]].
Different languages implement inheritance in different ways.


The inheritance implies that there are classes that are very generic, and other classes that are specific. The specific classes can inherit specific attributes and behavior from generic classes, and they can also have specific attributes and behaviors that are particular to them, and to no one else. Thus, classes form hierarchies.
In Java, the inheritance is formally declared with the <code>extends</code> keyword:
<syntaxhighlight lang='java'>
class SomeSubclass extends SomeSuperclass {
  ...
}
</syntaxhighlight>
In Python, we formally declare that a class extends other class with this syntax:
<syntaxhighlight lang='python'>
class SomeSubclass(SomeSuperclass):
  ...
</syntaxhighlight>


Parent types are called superclasses. Subtypes are called subclasses.
In Go, there is no formal support for inheritance in the language, there isn't even a <code>class</code> keyword, but inheritance can be implemented with a combination of struct field embedding and interfaces, as described here: {{Internal|Go_Inheritance_and_Polymorphism#Inheritance|Inheritance in Go}}


The motivation behind inheritance is code reusability. If something that is generally applicable to a set of classes, that belongs into the superclass, which can be then inherited.
=Overriding=
=Overriding=
A [[#Subclass|subclass]] overrides a method inherited from the [[#Superclass|superclass]] when re-defines a methods, while preserving the signature.


=Polymorphism=
=Polymorphism=
Line 48: Line 71:
At a programming language level, polymorphism is a feature of a programming language allowing a method to behave differently depending on the runtime state at a specific moment in time, specifically the particular object instance the method is being invoked on. The contract of the behavior is defined by an '''interface''', while the implementation of the interface may vary. In Java, different classes may implement an interface, and instances of those classes can be used interchangeably "as" that interface. In Go, different concrete types may implement an [[Go_Interfaces#Overview|interface]].
At a programming language level, polymorphism is a feature of a programming language allowing a method to behave differently depending on the runtime state at a specific moment in time, specifically the particular object instance the method is being invoked on. The contract of the behavior is defined by an '''interface''', while the implementation of the interface may vary. In Java, different classes may implement an interface, and instances of those classes can be used interchangeably "as" that interface. In Go, different concrete types may implement an [[Go_Interfaces#Overview|interface]].


In standard object-oriented languages like Java or Python, inheritance is part of the mechanism that allows polymorphism.
In standard object-oriented languages like Java or Python, polymorphism is implemented by combining [[Object-Oriented_Programming#Inheritance|inheritance]] and [[#Overriding|overriding]].


In Go, <font color=darkkhaki>...</font> [[Go_Language_Object_Oriented_Programming#Polymorphism|Object Oriented Programming in Go &#124; Polymorphism]].
Go implements polymorphism by allowing overriding of methods associated with embedded files in the struct that embeds the field: {{Internal|Go_Inheritance_and_Polymorphism#Polymorphism|Go Polymorphism}}

Latest revision as of 00:18, 31 August 2024

Internal

Overview

Object-oriented programming is first and foremost about message passing between class instances.

Object-Oriented Analysis and Design

In software development, design is often assumed to happen before programming. In reality, analysis, programming and design ten to overlay, combine and interweave. Object-oriented analysis is the process of looking at a problem, system or task, with the intention of creating an application that addresses it, and identifying the objects and interactions between objects. The analysis stage is about what needs to be done.

The output of the analysis stage is a set of requirements.

Object-oriented design (OOD) is the process of converting the requirements into an implementation specification. The designer names the objects, defines their behaviors and formally specifies which objects can activate specific behaviors on other objects. This stage is about how things should be done.

The output of the design stage is the implementation specification.

In most cases, all these stages overlap and the development happens in an iterative model, in which a small part of the project is modeled, designed and programmed, and then the program is iteratively reviewed and expanded.

Object-Oriented Programming vs Functional Programming

Object-Oriented Programming vs Functional Programming

Encapsulation

Encapsulation is grouping together data and functions that are related to each other. The formal definition of such a bundle of data and functions is a type or a class.

Class

A class represents a type, or a kind, of thing and concept. Classes encapsulate state - what kind of information, or attributes they can store. Classes also define behavior, or methods. Classes are blueprints for objects.

Objects

An object is a specific instance of a class.

Associating Behavior with Types

Inheritance

In its most generic form, inheritance in programming languages is the capability of declaring class hierarchies.

A hierarchy includes generic classes, called parent classes, or superclasses, that are generic. The superclasses can be inherited by more specific and specialized classes, called subclasses. It is said that the subclass extends the superclass.

The superclasses declare attributes (state) and behavior that are shared with all their descendants. If something that is generally applicable to a set of classes, that belongs into the superclass, which can be then inherited. This is a great capability when it comes to code reusability. The generic state and behavior is declared only once, in superclass, and it does not have to be repeated in subclasses.

The subclasses also have the capability to declare state and behavior that is particular to them only, and no-one else, and differentiate them from siblings in the hierarchy.

Also, inheritance, together with overriding helps implement polymorphism.

Different languages implement inheritance in different ways.

In Java, the inheritance is formally declared with the extends keyword: 

class SomeSubclass extends SomeSuperclass {
  ...
}

In Python, we formally declare that a class extends other class with this syntax: 

class SomeSubclass(SomeSuperclass):
  ...

In Go, there is no formal support for inheritance in the language, there isn't even a class keyword, but inheritance can be implemented with a combination of struct field embedding and interfaces, as described here:

Inheritance in Go

Overriding

A subclass overrides a method inherited from the superclass when re-defines a methods, while preserving the signature.

Polymorphism

Polymorphism implies behavior that is identical across implementations at a higher level of abstraction and at the same time different at a lower level of abstraction. For example, computing the area of a geometrical shape means the same thing across different geometrical shapes like circle, triangle, rectangle - the user wants to know the area - while it is meaning is very different at the lower level that actually computes the area for a particular shape. In other words, polymorphism is a way of establishing an abstraction.

At a programming language level, polymorphism is a feature of a programming language allowing a method to behave differently depending on the runtime state at a specific moment in time, specifically the particular object instance the method is being invoked on. The contract of the behavior is defined by an interface, while the implementation of the interface may vary. In Java, different classes may implement an interface, and instances of those classes can be used interchangeably "as" that interface. In Go, different concrete types may implement an interface.

In standard object-oriented languages like Java or Python, polymorphism is implemented by combining inheritance and overriding.

Go implements polymorphism by allowing overriding of methods associated with embedded files in the struct that embeds the field:

Go Polymorphism
Retrieved from "https://kb.novaordis.com/index.php?title=Object-Oriented_Programming&oldid=112613"