Vergelijk Functioneel Programmeren, Imperatief Programmeren en Objectgeoriënteerd Programmeren

Als Oracle Corporation enkele Functionele constructies heeft geïntroduceerd in Java SE 8, zijn tegenwoordig de meeste interviewers geïnteresseerd in het stellen van vragen over Functioneel Programmeren. Als Java/Groovy/Scala-ontwikkelaar of een ontwikkelaar in Functioneel Programmeren, zouden we de volgende vragen en antwoorden moeten leren om succesvolle interviews af te leggen:

1. Wat is Functioneel Programmeren?
2. Wat zijn de “Voor- en Nadelen” van Functioneel Programmeren?
3. Wat zijn de verschillen tussen Functioneel Programmeren en Imperatief Programmeren?
4. Wat zijn de verschillen tussen Functioneel Programmeren en Objectgeoriënteerd Programmeren?
5. Wat zijn de verschillen tussen Functioneel Programmeren, Imperatief Programmeren (IP) en Objectgeoriënteerd Programmeren?
6. Wat zijn de belangrijkste voordelen van Functioneel Programmeren ten opzichte van Imperatief Programmeren of Objectgeoriënteerd Programmeren?
7. Wanneer moet je Functioneel Programmeren gebruiken?
8. Wanneer moet je Objectgeoriënteerd Programmeren gebruiken?
9. Wat zijn de nadelen van OOP?
10. Wat zijn de nadelen van OOP-Erfenis?
    … En meer

In dit bericht gaan we elk van de volgende drie populaire programmeerparadigma’s één voor één bespreken en ook de bovenstaande vragen beantwoorden:

1. Functioneel Programmeren (FP)
2. Imperatief Programmeren (IP)
3. Objectgeoriënteerd Programmeren (OOP)

Wat is Functioneel Programmeren?

In eenvoudige bewoordingen is Functioneel Programmeren (FP) een van de populaire programmeerparadigma’s, die berekeningen uitvoert zoals wiskundige functies zonder de toestand te wijzigen en gegevens te muteren. In Functioneel Programmeren zijn functies kandidaten van de eerste klasse. We schrijven programma’s door een reeks functies en onveranderlijke gegevens te definiëren. Voorbeelden van FP-talen:- Scala, Haskell, Earlang etc. zijn populaire FP-talen. Java SE 8 heeft ook enkele functionele constructies (raadpleeg alstublieft Java 8-posts voor meer details)

Wat zijn de kenmerken van FP?

Functionele programmeertalen zoals Scala hebben de volgende kenmerken.

1. Staat bestaat niet.
   FP-programma’s bevatten geen staat. Dat betekent dat alle gegevens onveranderlijk zijn en functies de staat niet kunnen wijzigen.
   Lage belangrijkheid van uitvoeringsvolgorde
   In FP-talen schrijven we programma’s met een reeks onafhankelijke functies. Functies bevatten een reeks instructies. In FP heeft de uitvoeringsvolgorde van die functies niet veel belang omdat ze geen staat hebben en alle functies onafhankelijk werken. Zelfs als we de uitvoeringsvolgorde veranderen, produceren ze nog steeds dezelfde resultaten.
   Stateless-programmeermodel
   Alle FP-programma’s gebruiken onveranderlijke gegevens en functies die die gegevens niet kunnen wijzigen. Dat betekent dat FP-talen het Stateless-programmeermodel ondersteunen.
   Functies zijn eersteklasburgers
   In FP-talen zijn functies eersteklas objecten. Functies zijn onafhankelijke eenheden, we kunnen ze in elke volgorde uitvoeren.
   Primaire manipulatie-eenheden
   In FP-talen zijn de primaire manipulatie-eenheden functies en datastructuren omdat alle programma’s worden gemaakt met behulp van deze eenheden.
   Modulaire programmering
   In FP-talen moeten we kleinere en onafhankelijke eenheden schrijven, genaamd Zuivere Functies, om het Stateless-programmeermodel te ondersteunen. Dat betekent dat FP betere modulariteit ondersteunt dan OOP.
   Higher-order-functies en Lazy Evaluation
   Functionele programmeertalen moeten functies van hogere orde en Lazy Evaluation-functionaliteiten ondersteunen.
   Primaire Flow Controls
   FP-talen gebruiken geen flow controls zoals For…Loop, Do…While Loop, While…Loop, en gebruiken ook geen conditionele verklaringen zoals If…Else of Switch-statements. Alle FP-talen schrijven programma’s met behulp van de volgende zaken:

• Functies
• Functieaanroepen
• Functieaanroepen met Recursie

10. Abstractie, Encapsulatie, Overerving en Polymorfisme
    Net als OOP, ondersteunen FP-talen alle 4 concepten: Abstractie, Encapsulatie, Overerving en Polymorfisme. FP-talen ondersteunen Overerving met Typeklassen of Implicits. Ze ondersteunen Polymorfisme met behulp van Generieken. Dit staat ook bekend als Parametrisch Polymorfisme.

Wat is de hoofdfocus van FP?

In tegenstelling tot OOP-talen, richten alle FP-taalprogramma’s zich voornamelijk op “Wat je doet” of “Wat er gedaan moet worden”. Ze richten zich voornamelijk op de volgende zaken:

• Welke informatie gewenst is, dat zijn Inputs.
• Welke transformaties vereist zijn, dat is de Eigenlijke Logica.

Dat betekent dat FP zich voornamelijk richt op “Wat er gedaan moet worden”. Het richt zich niet zozeer op “Hoe het gedaan moet worden”. Daarom kunnen we Functioneel Programmeren schrijven zoals een probleemdomeinbeschrijving. Daarom kunnen niet alleen Ontwikkelaars, maar ook andere mensen FP-code heel gemakkelijk begrijpen. Nu zullen we de “Voor- en Nadelen” (Voordelen en Nadelen) van Functioneel Programmeren bespreken.

Voordelen van Functioneel Programmeren?

Functionele Programmeertalen hebben de volgende Voordelen of Voordelen:

• Bugsvrij Code
  Aangezien FP-talen geen toestand ondersteunen, veroorzaken ze geen neveneffecten, wat betekent dat we Foutvrije code, Bugs-vrije code of Minder Foutgevoelige Code kunnen schrijven. – Efficiënte Parallelle Programmering
  Omdat FP-talen GEEN Mutable state hebben, veroorzaken ze geen problemen met toestandsverandering. Dit betekent dat ze alleen Immutable Data gebruiken. Ze gebruiken Onafhankelijke Eenheidseenheden om programma’s te schrijven, dat wil zeggen “Functies”. We kunnen zeer efficiënte Parallelle of Gelijktijdige Programmering schrijven omdat ze onafhankelijk draaien zonder de toestand te veranderen. – Betere Prestaties
  Omdat FP-programma’s bestaan uit alle onafhankelijke eenheden, kunnen ze Parallel of Gelijktijdig worden uitgevoerd. Om deze reden behalen FP-toepassingen betere prestaties. – Betere Insluiting
  In tegenstelling tot OOP ondersteunt FP betere insluiting met Pure Functions. Pure functies betekenen zonder neveneffecten. – Ondersteuning voor Geneste Functies
  Geneste functies betekenen het samenstellen van functies binnen andere functies om problemen op te lossen. FP ondersteunt geneste functies. – Verhoogde Herbruikbaarheid
  Omdat FP-programma’s bestaan uit Onafhankelijke Eenheden, dat wil zeggen “Functies”, kunnen we ze zeer eenvoudig hergebruiken. – Betere Modulariteit
  In FP-talen moeten we kleinere en onafhankelijke eenheden schrijven, genaamd Pure Functions, om het Stateless-programmeermodel te ondersteunen. Dat betekent dat FP betere modulariteit ondersteunt dan OOP. – Eenvoudige Lazy Evaluation
  In FP-talen is het zeer eenvoudig om Lazy Evaluation te schrijven. Ze ondersteunen Lazy Functionele Constructies zoals Lazy Lists, Lazy Maps, enz. – Verbeterde Leesbaarheid en Onderhoudbaarheid
  Functioneel programmeren (FP) verbetert ook de leesbaarheid en onderhoudbaarheid omdat ze onafhankelijk werken en de toestand niet veranderen. – Verhoogde Testbaarheid
  Omdat we onze FP-programma’s schrijven met Onafhankelijke Eenheden, dat wil zeggen “Functies”, kunnen we ze zeer eenvoudig unit testen. – Ondersteuning voor Abstractie over Gedrag
  In tegenstelling tot OOP ondersteunt FP zowel “Abstractie over Gegevens” als “Abstractie over Gedrag”. Omdat de echte wereld beide bevat. – Ondersteuning voor BigData
  Omdat FP Parallel programmeren en betere prestaties ondersteunt, is FP zeer geschikt voor het ontwikkelen van BigData-toepassingen. – Robuuste en Betrouwbare Code
  Omdat FP Immutable Data gebruikt, kunnen we gemakkelijk Robuuste en Betrouwbare Code ontwikkelen met FP.

Nadelen van Functioneel Programmeren?

Naast de geweldige voordelen hebben Functionele Programmeertalen ook zeer weinig of verwaarloosbare nadelen. Ze hebben alleen de volgende nadelen:

• Vereist veel geheugen
  FP heeft geen toestand. Ze creëren altijd nieuwe objecten om acties uit te voeren in plaats van bestaande objecten te wijzigen. Hierdoor gebruiken FP-toepassingen veel geheugen. – Richt zich NIET op Liskov Substitutie

Wat zijn de belangrijkste concepten van Functioneel Programmeren?

De volgende concepten zijn belangrijk in Functioneel Programmeren.

• Functions van de Eerste Klasse.
• Lui Evaluatie.
• Functions van Hogere Orde.
• Onveranderlijkheid (Niet-muteerbare Data).
• Modulariteit.
• Geen Bijwerkingen.
• Lui Evaluatie.
• Recursieve Functie-Aanroepen.

Wat is Imperative Programming?

Imperative Programming (IP) is een van de populaire Programmeerparadigma’s die een reeks stappen/instructies/statements in een bepaalde volgorde uitvoert. Voorbeelden van IP-talen: Java, C, C++ etc

Belangrijkste kenmerken van Imperative Programming?

Elke Imperative Programming (IP) taal kan de volgende kenmerken bevatten:

• Reeks van statements.
• Volgorde van uitvoering van statements is zeer belangrijk.
• Ze bevatten een toestand.
• Ze gebruiken zowel onveranderlijke als veranderlijke gegevens.
• Ze kunnen de toestand wijzigen.
• Ze kunnen bijwerkingen hebben.
• Stateful Programming Model.
• Ze veranderen rechtstreeks de toestand van het programma.
• Ze stellen de toestand voor met gegevensvelden.

Wat is Objectgeoriënteerd Programmeren?

Object georiënteerd programmeren is een ander soort programmeerparadigma. Het vertegenwoordigt alles als een Object. Elk Object bevat enkele gegevensvelden en methoden. Alle OOP-programma’s bevatten een toestand. Ze gebruiken wijzigbare gegevens en gegevensstructuren. Net als bij FP kunnen we complete programma’s schrijven door immutable gegevens te gebruiken, maar het dwingt deze regel niet af. Objectgeoriënteerd programmeren (OOP) is een superset van imperatief programmeren. Het volgt alle kenmerken van IP met enkele extra functies. Die extra functies zijn:

• Alles is een Object.
• Elk Object bevat enkele gegevensvelden en methoden.
• OOP-concepten: abstractie, encapsulatie, overerving en polymorfisme

In tegenstelling tot functionele programmeertalen, zijn OOP-talen voornamelijk gericht op “Hoe moet het worden gedaan”. Dat betekent dat we ons als ontwikkelaar richten op “Hoe doe je het”. Bovendien combineert OOP zowel “Wat je doet” als “Hoe je het doet”. Daarom kunnen we geen beknopte en meer leesbare code schrijven. Alleen ontwikkelaars kunnen de code begrijpen, andere mensen kunnen meer verward raken om de toepassingscode te begrijpen, ze kunnen het niet begrijpen.

Nadelen van objectgeoriënteerd programmeren (OOP)?

Hoewel OOP veel real-time problemen oplost, heeft het nog steeds de volgende nadelen (vergeleken met FP):

• Het ondersteunt geen volledige herbruikbaarheid.
• Het is niet volledig modulair.
• Het doorbreekt het concept van encapsulatie.
• Overerving heeft veel nadelen.

Belangrijkste nadelen van overerving:

• Doorbreekt het principe van encapsulatie
• Wanneer het niveau van overerving toeneemt, is het zeer moeilijk en lastig te onderhouden en objecten te maken.

Wanneer Functioneel Programmeren gebruiken?

We moeten voor Functioneel Programmeren (FP) kiezen in de volgende scenario’s:

• Wanneer we veel verschillende bewerkingen op gegevens gaan uitvoeren die vaststaan.
• Met andere woorden, wanneer we weinig dingen hebben met meer bewerkingen.

Wanneer Objectgeoriënteerd Programmeren gebruiken?

We moeten voor Objectgeoriënteerd Programmeren (OOP) kiezen in de volgende scenario’s:

• Wanneer we weinig bewerkingen gaan uitvoeren op veel verschillende varianten die gemeenschappelijk gedrag vertonen.
• Met andere woorden, wanneer we meer dingen hebben met weinig operaties.

OPMERKING:- Hier zijn Dingen echte objecten en operaties zijn echte handelingen. Bijvoorbeeld, in Java vertegenwoordigen we deze echte dingen als “Klassen” en echte acties als Methoden (Operaties).

Verschillen tussen FP en OOP (IP)?

Dat is alles over drie populaire programmeerparadigma’s. OPMERKING:- Ik kom eigenlijk uit OOP, maar ben een jaar geleden begonnen met werken aan FP. Dus als deskundigen in functioneel programmeren fouten vinden in deze post, geef me dan alstublieft uw waardevolle input. Laat alstublieft een reactie achter als u mijn bericht leuk vindt of als u twijfels of suggesties heeft.