Programação Orientada a objetos

Finalmente entenda Programação Orientada a Objetos com facilidade usando apenas Javascript e o seu navegador

O objetivo desse guia é trazer para você de forma muita didática e prática, os principais conceitos de orientação a objetos. Usar a linguagem de programação Javascript vai permitir que você escreva código enquanto aprende os principais conceitos, sem precisar instalar nada no seu computador. Tudo que vai precisar é o seu navegador.

Esse é um artigo prático, portanto você vai tirar melhor proveito e aprender de verdade, se estiver em frente ao seu computador, escrevendo código, ao invés de estar deitado no sofá com o smartphone na mão 😉

Bora aprender!

Programação Estruturada

Antes de explicar o paradigma (estilo) de programação orientação a objetos, é importante falar rapidamente sobre o paradigma anterior a ela, ainda muito usado atualmente, principalmente por iniciantes de programação.

A programação estruturada é um conjunto de instruções, definidos de cima para baixo no seu editor de código, que definem o passo a ser executado para resolver determinado problema. Fazendo uma analogia, seria uma receita de bolo, onde os principais ingredientes são os dados, comandos condicionais e interativos e as subrotinas (mais conhecidas como funções).

Iniciantes em programação normalmente usam esse paradgima estruturado, por ser a forma mais simples de criar os primeiros programas. Porém, usar programação estruturada para desenvolver programas profissionais, com milhares de linhas de código pode rapidamente deixar o seu código bagunçado e de difícil manutenção.

Veja abaixo o exemplo de um programa criado usando programação estruturada com a linguagem de programação Pascal.

{*****************************************************************************
 * A Pascal quicksort.
 *****************************************************************************}
PROGRAM Sort(input, output);
    CONST
        { Max array size. }
        MaxElts = 50;
    TYPE 
        { Type of the element array. }
        IntArrType = ARRAY [1..MaxElts] OF Integer;

    VAR
        { Indexes, exchange temp, array size. }
        i, j, tmp, size: integer;

        { Array of ints }
        arr: IntArrType;

    { Read in the integers. }
    PROCEDURE ReadArr(VAR size: Integer; VAR a: IntArrType);
        BEGIN
            size := 1;
            WHILE NOT eof DO BEGIN
                readln(a[size]);
                IF NOT eof THEN 
                    size := size + 1
            END
        END;

    { Use quicksort to sort the array of integers. }
    PROCEDURE Quicksort(size: Integer; VAR arr: IntArrType);
        { This does the actual work of the quicksort.  It takes the
          parameters which define the range of the array to work on,
          and references the array as a global. }
        PROCEDURE QuicksortRecur(start, stop: integer);
            VAR
                m: integer;

                { The location separating the high and low parts. }
                splitpt: integer;

            { The quicksort split algorithm.  Takes the range, and
              returns the split point. }
            FUNCTION Split(start, stop: integer): integer;
                VAR
                    left, right: integer;       { Scan pointers. }
                    pivot: integer;             { Pivot value. }

                { Interchange the parameters. }
                PROCEDURE swap(VAR a, b: integer);
                    VAR
                        t: integer;
                    BEGIN
                        t := a;
                        a := b;
                        b := t
                    END;

                BEGIN { Split }
                    { Set up the pointers for the hight and low sections, and
                      get the pivot value. }
                    pivot := arr[start];
                    left := start + 1;
                    right := stop;

                    { Look for pairs out of place and swap 'em. }
                    WHILE left <= right DO BEGIN
                        WHILE (left <= stop) AND (arr[left] < pivot) DO
                            left := left + 1;
                        WHILE (right > start) AND (arr[right] >= pivot) DO
                            right := right - 1;
                        IF left < right THEN 
                            swap(arr[left], arr[right]);
                    END;

                    { Put the pivot between the halves. }
                    swap(arr[start], arr[right]);

                    { This is how you return function values in pascal.
                      Yeccch. }
                    Split := right
                END;

            BEGIN { QuicksortRecur }
                { If there's anything to do... }
                IF start < stop THEN BEGIN
                    splitpt := Split(start, stop);
                    QuicksortRecur(start, splitpt-1);
                    QuicksortRecur(splitpt+1, stop);
                END
            END;
                    
        BEGIN { Quicksort }
            QuicksortRecur(1, size)
        END;

    BEGIN
        { Read }
        ReadArr(size, arr);

        { Sort the contents. }
        Quicksort(size, arr);

        { Print. }
        FOR i := 1 TO size DO
            writeln(arr[i])
    END.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

O que é um objeto?

lorem Qui Lorem sunt qui non minim tempor exercitation labore ullamco nisi. In in commodo id adipisicing aliquip dolor Lorem ea reprehenderit. Ea aliqua mollit elit adipisicing incididunt tempor commodo elit cillum elit veniam laborum duis. Reprehenderit cillum sint occaecat exercitation consequat eu qui amet cillum laboris. Fugiat elit quis excepteur ad aliquip velit veniam. Amet ut ad cillum in anim commodo occaecat proident proident ullamco deserunt anim non elit.

export default {
  data () {
    return {
      msg: 'Highlighted!'
    }
  }
}

1
2
3
4
5
6
7

Eiusmod cupidatat mollit amet cillum enim est deserunt ex laboris voluptate consectetur ex irure labore. Ullamco elit commodo anim in pariatur sint occaecat officia. Adipisicing elit consequat sunt consectetur nisi.

Eiusmod sint ut laboris velit reprehenderit tempor est et. Voluptate consectetur ullamco proident ad incididunt cillum duis velit nostrud nisi tempor Lorem. Laborum esse ad cillum esse aliqua Lorem ipsum veniam occaecat laboris sunt. Do ex pariatur magna adipisicing officia in irure dolore non. Mollit id aliquip reprehenderit irure laboris anim fugiat sunt mollit sit ipsum. Ea non labore elit et sit dolor mollit qui tempor nisi qui amet. Aliqua minim nostrud aliqua reprehenderit voluptate officia ea sint sunt quis.

Programação Orientada a objetos

Programação Estruturada

O que é um objeto?

O que é uma classe?

Atributos e Métodos

Como criar classes e objetos com Javascript

Herança

POO na Prática com Javascript