Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Classes, herança, mescla e estáticos

Classes juntam dados e comportamento num só lugar. No CGD você conta com inicializadores por instância, herança (herda), composição por mixins (mescla), campos e métodos estáticos, privacidade e destrutores explícitos.

Atributos, defaults e inicializadores por objeto

Você pode dar valores iniciais direto nos campos da classe. Cada instância nova recebe sua própria avaliação — então um campo historico: inteiro[] = [] nunca é compartilhado por acidente entre dois objetos. Os campos da classe base inicializam primeiro, depois os da derivada e por fim roda o construtor.

classe Contador {
    estatico totalCriados: inteiro = 0
    valor: inteiro = 1
    historico: inteiro[]

    construtor() {
        Contador.totalCriados++
    }
}

Herança (herda) e composição (mescla)

Use herda para especializar uma classe base (chamando super quando quiser reaproveitar a implementação do pai). Quando quiser reutilizar métodos e campos de várias classes sem cair em herança múltipla, use classe MinhaClasse mescla MixinA, MixinB.

Cada mixin mantém sua própria privacidade, seus inicializadores de campo funcionam automaticamente e eInstanciaDe reconhece tanto a hierarquia de herança quanto os mixins e interfaces.

Privacidade, acessores e destrutor explícito

Agrupe membros em publico { }, protegido { } ou privado { }. Propriedades aceitam acessores personalizados obter() e definir(valor). Para liberar recursos determinísticos, declare destrutor(): vazio e chame destruir(objeto) dentro de um bloco finalmente — o Boehm GC cuida da memória, não de destrutores Delégua.

Experimente: 14_classes

classe Ponto {
    x: numero

    construtor(x: numero) {
        isto.x = x
    }

    dobro(): qualquer {
        retorna isto.x * 2
    }
}

var ponto: Ponto = Ponto(3)
escreva(ponto.x, ponto.dobro())
ponto.x = 4
escreva(ponto.dobro())

Ver exemplo completo e contrato de teste no GitHub

Experimente: 15_heranca

classe Base {
    protegido {
        x: numero
    }

    construtor(x: qualquer) {
        isto.x = x
    }

    valor(): qualquer {
        retorna isto.x
    }
}

classe Filha herda Base {
    construtor(x: qualquer) {
        super(x + 1)
    }

    valor(): qualquer {
        retorna super.valor() * 2
    }

    dado(): qualquer {
        retorna isto.x
    }
}

var filha: Filha = Filha(3)
var metodo: funcao = filha.valor // Receptor explícito, gerenciado pelo GC.
escreva(metodo(), filha.dado())
escreva(filha.eInstanciaDe(Base))

Ver exemplo completo e contrato de teste no GitHub

Experimente: 16_privacidade_acessores

classe Conta {
    privado {
        _saldo: numero
    }

    saldo: numero {
        obter() {
            retorna isto._saldo
        }
        definir(valor: qualquer) {
            isto._saldo = valor * 2
        }
    }

    construtor() {
        isto._saldo = 0
    }
}

var conta: Conta = Conta()
conta.saldo = 3
escreva(conta.saldo)

Ver exemplo completo e contrato de teste no GitHub

Experimente: 32_objeto_e_metodos

classe Pessoa {
    nome: texto

    construtor(nome: qualquer) {
        isto.nome = nome
    }

    paraTexto(): qualquer {
        retorna "Pessoa: ${isto.nome}"
    }
}

var p: Pessoa = Pessoa("Ada")
escreva(p.tipo())
escreva(p.respondeA("paraTexto"), p.eInstanciaDe(Objeto))
escreva(p)

Ver exemplo completo e contrato de teste no GitHub

Experimente: 36_destrutores

classe Base {
    destrutor(): vazio {
        escreva("base")
    }
}

classe Filha herda Base {
    destrutor(): vazio {
        escreva("filha")
    }
}

var recurso: Filha = Filha()
tente {
    assercao(verdadeiro)
} finalmente {
    destruir(recurso)
}

destruir(recurso)
escreva("fim")

Ver exemplo completo e contrato de teste no GitHub

Experimente: 39_inicializacao

var n: numero
var texto: texto
var logico: logico
escreva(n, texto, logico)
classe Base {
    valor: inteiro = 7
    itens: inteiro[]
}

classe Filha herda Base {
    copia: inteiro = isto.valor
}

var primeira: Filha = Filha()
var segunda: Filha = Filha()
primeira.itens.adicionar(1)
escreva(primeira.copia)
escreva(tamanho(segunda.itens), tamanho(primeira.itens))
var ch: texto = "5"
escreva(ch >= '0' e ch <= '9', "ação" > "a")

Ver exemplo completo e contrato de teste no GitHub

Experimente: 43_estaticos_mescla

funcao de decorador triplicar(original: funcao): funcao {
    retorna funcao(alvo: qualquer, x: inteiro): inteiro {
        retorna x * 3
    }
}

classe Etiquetavel {
    prefixo: texto = "Etiqueta:"

    rotulo(nome: texto): texto {
        retorna isto.prefixo + nome
    }
}

classe Registro mescla Etiquetavel {
    estatico criados: inteiro = 0
    nome: texto

    construtor(nome: texto) {
        isto.nome = nome
        Registro.criados = Registro.criados + 1
    }

    @triplicar
    escalar(x: inteiro): inteiro {
        retorna x
    }
}

const a: Registro = Registro("Ana")
const b: Registro = Registro("Bia")
escreva(Registro.criados)
escreva(a.rotulo(a.nome))
escreva(b.eInstanciaDe(Etiquetavel))
escreva(a.escalar(10))

Ver exemplo completo e contrato de teste no GitHub

Classes são declaradas no nível do módulo. Campos precisam ser declarados na classe; acessar um campo ou método que não existe gera erro estático E3109 com sugestão do nome mais parecido (preservando acesso polimórfico a subclasses).