Você está na página 1de 23

DELPHI Orientação a Objetos + Object Pascal

INDICE
1. Conceitos de Orienção a Objetos...................................................................................................................................................3 2. Componentes Básicos da Orientação a Objetos............................................................................................................................3 3. Encapsulamento...............................................................................................................................................................................3 4. Herança.............................................................................................................................................................................................3 4.1. Classes Abstratas.......................................................................................................................................................................3 5. Polimorfismo....................................................................................................................................................................................4 6. Object Pascal....................................................................................................................................................................................5 6.1. Estrutura de uma Unit................................................................................................................................................................5 7. Classes...............................................................................................................................................................................................6 7.1.1. Definição de uma Classe.....................................................................................................................................................6 7.1.2. Atributos e Métodos............................................................................................................................................................6 7.1.3. Visibilidade..........................................................................................................................................................................6 7.1.4. Declarando, Instanciando, Destruindo e Referenciando Objetos........................................................................................6 7.1.5. Método Construtor...............................................................................................................................................................7 7.1.6. Método Destrutor.................................................................................................................................................................7 7.1.7. O Parâmetro Self.................................................................................................................................................................7 7.1.8. Métodos Estáticos................................................................................................................................................................7 7.1.9. Métodos Virtuais.................................................................................................................................................................7 7.1.10. Métodos Dinâmicos...........................................................................................................................................................7 7.1.11. Métodos Abstratos.............................................................................................................................................................7 7.1.12. Propriedades......................................................................................................................................................................8 7.1.13. Verificação de Tipo...........................................................................................................................................................8 7.1.14. Conversão de Tipo.............................................................................................................................................................8 8. Tratamento de Exceção.................................................................................................................................................................19 8.1.1. Aplicações Robustas..........................................................................................................................................................19 8.1.2. Criação de um Bloco Protegido.........................................................................................................................................19 8.1.3. Exemplos:..........................................................................................................................................................................20 8.1.4. Tratando Exceções.............................................................................................................................................................20 8.1.5. Tratando Uma Exceção.....................................................................................................................................................20 8.1.6. Principais Classes de Exceção...........................................................................................................................................21 8.1.7. Exemplos:..........................................................................................................................................................................21 8.1.8. Criação de Classes de Exceção..........................................................................................................................................22 8.1.9. Exemplos:..........................................................................................................................................................................22

2

A subclasse é uma especialização da superclasse. 4.1. Seu maior objetivo é aumentar a produtividade do desenvolvimento de software através de uma maior expansibilidade e reutilização de código. 3 . • • • • • • • Herança Permite que uma nova classe seja descrita a partir de outra classe já existente (Reutilização). quando tornou-se a principal metodologia de desenvolvimento de software. Conceitos de Orienção a Objetos A Metodologia Orientada a Objetos é relativamente nova. pois por volta de 1970 surgiram as primeiras publicações. 2. Quando a metodologia orientada a objetos é utilizada. têm características e funções. Desta forma o desenvolvedor poderá alterar tranquilamente a implementação de um objeto (Classe) sem causar transtornos ao usuários. ou seja. Possui características próprias. ao contrário da metodologia estruturada. → Representa uma ação do objeto ou uma mudança de estado. A orientação a objetos permite modelar de forma mais natural o mundo real. além de controlar a complexidade e o custo da manutenção do mesmo. a fase de projeto do desenvolvimento do software está mais intimamente ligada à fase de implementação. onde a atenção era centralizada nos procedimentos. 3. • O principal objetivo é tornar o objeto independente de sua implementação interna. Toda instância da subclasse é também uma instância da superclasse. → Conjunto de mensagens que define o comportamento de um objeto (Protocolo). Classes Abstratas • • • Definida para ser a base de uma hierarquia. Um dos pontos chaves da metodologia orientada a objetos é centralização das atenções nas Estruturas de Dados. Encapsulamento • É a capacidade de "esconder" detalhes de implementação (abstração). para isso a implementação das suas propriedades e métodos são "escondidas" de forma que o usuário precise apenas conhecer a interface do objeto para poder utilizá-lo.1. → Define as característica dos objetos de uma classe. O resultado de uma seqüência de heranças é uma hierarquia de classes. redefinindo o método herdado. Possui métodos que não estão implementados. Define a comunicação entre objetos. → Define o comportamento dos objetos de uma classe. A subclasse pode ter um comportamento diferente da superclasse. Na orientação a objetos há uma maior aproximação entre dados e procedimentos. A subclasse pode adicionar novas características e comportamentos aos herdados da superclasse. A subclasse herda as características e o comportamento da superclasse. pois as estruturas de dados são vistas como objetos. Classe Objeto Instância Propriedade Método Mensagem Interface Componentes Básicos da Orientação a Objetos → São moldes através dos quais criamos objetos → Abstração que agrupa características e comportamentos. mas o seu "boom" se deu nos anos 90. → É o objeto propriamente dito. pois procedimentos são definidos em termos dos dados. Não pode ser instanciada. 4.

desde que possuam quantidade ou tipo de parâmetros diferentes. inclusive com parâmetros iguais.5. • Métodos da classe derivada podem ter nomes iguais aos da classe base. • Métodos da mesma classe podem ter o mesmo nome. Polimorfismo • É a capacidade de tratarmos objetos de diferentes tipos de uma mesma maneira desde que eles tenham um ancestral em comum • Objetos de classes diferentes podem ter métodos com mesmo nome e cada objeto responderá adequadamente de acordo com seu método. 4 .

] <seções de declaração> Implementation {Declaração de Variáveis.1.6. Constante e tipos locais a UNIT e Implementação dos métodos. Interface {Especifica o que será exportado pela UNIT afim de ser utilizados por outros módulos } [uses <lista de units>. Object Pascal 6. Estrutura de uma Unit Unit <identificador>.] <definições> [Initialization <instruções>] [Finalization {Código executado automaticamente quando um aplicativo que utiliza a UNIT é finalizado} {Código executado automaticamente quando um aplicativo que utiliza a UNIT é executado} <instruções>] end. [uses <lista de units>. 5 .

<Objeto>. Atributos e Métodos <visibilidade 1> <lista de variáveis> <lista de procedimentos ou funções> <visibilidade 2> <lista de variáveis> <lista de procedimentos ou funções> .onde Identificador representa uma propriedade referência a Dados é idêntica a referência a código. 6 . • Em uma mesma classe pode existir atributos e métodos com visibilidades diferentes. Instanciando. Visibilidade • Define quem tem permissão de acessar e alterar os atributos e métodos da classe. .3. <Objeto> : Classe. Semelhante a visibilidade public sendo que permite o acesso em tempo de projeto. Destruindo e Referenciando Objetos • • • • É declarado da mesma maneira que uma variável. <visibilidade n> <lista de variáveis> <lista de procedimentos ou funções> 7. • Deve ser feita na seção de declaração de tipos principal de um programa ou de uma unit.1. <Objeto>.1.Free. 7.7. Os atributos e métodos só podem ser manipulados pela própria classe. Declarando. <Objeto> = Classe. todas as classes são descendentes de TObject.1. Os atributos e métodos podem ser manipulados pela própria classe ou por qualquer subclasse desta e por demais classes declaradas na mesma UNIT. Classes 7.4.1.2.Identificador {Declarando} {Instanciando} {Destruindo} {Referenciando} ou um método. A .1.Create. . Definição de uma Classe <identificador> = class[(Descendência)] <atributos e métodos> end. 7. • No caso do Delphi. Pode ser atribuído o valor nil. mas é manipulado como uma variável normal. Visibilidade Public Private Protected Published Descrição Os atributos e métodos podem ser manipulados por qualquer classe. este deve ser instanciado e após o seu uso o mesmo deve ser liberado Se comporta como um ponteiro. Para que um objeto possa ser utilizado.

e libera a memória alocada para ele.1. 7. • Normalmente a última ação é invocar o destrutor da classe base.6.10. contendo os mesmo parâmetros. baseado nos parâmetros passados. • Destroi o objeto. a palavra virtual.9. Métodos Virtuais • O objetivo dos métodos virtuais é a possibilidade de substituí-los por novos métodos. basta acrescentar no final de sua declaração na classe. é necessário que ele seja também virtual. através da instrução: inherited <construtor> ( <parâmetros reais > ). basta acrescentar no final de sua declaração na classe.7. • Para um método ser abstrato.11. 7. • Aloca memória e inicializa o objeto. É utilizado para evitar conflitos de nomes de objetos 7. 7.1.1. Método Construtor constructor <identificador> ( <parâmetros formais> ). Métodos Estáticos • • Os métodos declarados numa classe são por default estáticos Tem suas referências determinadas em tempo de compilação 7. servem apenas para definir a estrutura de uma hierarquia. 7 .1. Método Destrutor destructor <identificador> ( <parâmetros formais> ). das classes descendentes. Métodos Abstratos • São métodos que não fazem nada. 7. Métodos Dinâmicos • Métodos dinâmicos são basicamente idênticos a métodos virtuais sendo declarados com o uso da diretiva dynamic OBS :Os métodos dinâmicos favorecem o tamanho do código enquanto os métodos virtuais favorecem a velocidade. • Normalmente a primeira ação é invocar o construtor da classe base. baseado nos parâmetros passados. • Para tornar um método virtual.8.5.1. • Um método virtual pode ser substituído em uma classe descendente através de sua redeclaração seguida da diretiva override.7. a palavra abstract. O Parâmetro Self • • Representa um parâmetro invisível passado a todos os métodos de uma classe e representa a instância da classe que esta chamando o método.1.1. • Para tornar um método abstrato. através da instrução: inherited <destrutor> ( <parâmetros reais > ).

. • Retorna true ou false. enquanto na realidade está executando chamadas a métodos. TIPO o tipo da propriedade. Identificador representa a propriedade. Propriedades • • • Representa um mecanismo para encapsular os campos de uma Classe sobrecarrgando as operações de leitura e escrita São uma extensão natural às variáveis de instância de uma classe.1. MédodoDeEscrita o método associado a escrita da propriedade. property Identificador : TIPO [read MétodoDeLeitura] [write MétodoDeEscrita]. Verificação de Tipo • Verifica.13. em tempo de execução.7.1. <objeto> is <classe> 7.1. MétodoDeLeitura o método associado a leitura da propriedade.<Métodos ou Propriedade> 8 .12. e as propriedades como public.onde. se possível.14. Conversão de Tipo • Converte. se o objeto é uma instância da classe ou de alguma subclasse desta. Para utilizar as propriedades os campos (atributos) devem ser declarados como private. 7. os métodos como protected. uma referência para o objeto de uma classe base em uma referência para objeto da subclasse. pois permitem que o desenvolvedor pareça esta trabalhando com estas. (<objeto> as <classe>).

Ano : Integer. begin dia := d. implementation constructor TData. 4.Exemplos de Orientação a Objetos unit Datas. procedure Subtrai (NumDeDias : integer). 2 : if (AnoBis) then DiasNoMes := 29 else DiasNoMes := 28. function AnoBis : boolean. begin if (ano mod 4 <> 0) then AnoBis := false else if (ano mod 100 <> 0) then AnoBis := true else if (ano mod 400 <> 0) then AnoBis := False else AnoBis := True. end. procedure Adiciona (NumDeDias : integer).a : integer). Mes := m. Mes := m. public constructor Init (d. end. procedure DefVal (d.3.m.m. ano := a.AnoBis : boolean.m. function TData. end. procedure Decrementa.m.a : integer). procedure Incrementa. end.DiasNoMes : integer. Mes.6.DefVal (d. ano := a. function GetText : string.9. 9 .5.10. begin dia := d. private function DiasNoMes : Integer.12 : DiasNoMes := 31.Init (d. procedure TData. interface type TData = Class(TObject) private Dia.8.11 : DiasNoMes := 30. function TData. end.7. begin case Mes of 1.a : integer).a : integer). end.

dia := 1. end.GetText : string. end else {se for o dia de ano novo} begin inc(ano). 4 : m := 'Abril'. m. 2 : m := 'Fevereiro'. 9 : m := 'Setembro'. Mes := 1. begin d := IntToStr(dia). 12: m := 'Dezembro'. dia := 1. dia := DiasNoMes. end else begin Dec(ano). dia := DiasNoMes. 7 : m := 'Julho'. function TData. procedure TData. end.Incrementa. 3 : m := 'Março'. var d. end. a := IntToStr(ano). end.procedure TData. Mes := 12. 10 . begin if (dia < DiasNoMes) {se não for o último dia do Mes} then inc(dia) else if (Mes < 12) {se não for dezembro} then begin inc(Mes). 5 : m := 'Maio'. 11: m := 'Novembro'. case Mes of 1 : m := 'Janeiro'. end. GetText := d + '. end. a : string. 8 : m := 'Agosto'. 6 : m := 'Junho'.Decrementa. 10: m := 'Outubro'. begin if (dia > 1) then Dec(dia) {se não for o primeiro dia do mês} else if (Mes > 1) {se não for o primeiro dia do ano} then begin Dec(Mes). ' + m + ' de ' + a.

end. var n : integer. end.Subtrai (NumDeDias : integer).procedure TData. 11 . begin for n := 1 to NumDeDias do Incrementa. var n : integer. begin for n := 1 to NumDeDias do Decrementa.Adiciona (NumDeDias : integer). end. procedure TData.

function GetBairro : string. constructor Create. End.unit Universidade. property AulasMes : byte read GetAulasMes write SetAulasMes. property Bairro : string read GetBairro write SetBairro. 12 . function GetNumero : string. property Nome : string read GetNome write SetNome. TProfessor = Class(TPessoa) private FDepartamento : string. property Numero : string read GetNumero write SetNumero. override. function GetNome : string. FNumero : String. procedure SetDepartamento (Value : string). End. destructor Destroy. public Endereco : TEndereco. function GetAulasMes : byte. TPessoa = Class private FMatricula : string. procedure SetMatricula (Value : string). public property Rua : string read GetRua write SetRua. interface type TEndereco = Class private FRua. FAulasMes : byte. procedure SetNome (Value : string). public property Departamento : String read GetDepartamento write SetDepartamento. procedure SetNumero (Value : string). procedure SetAulasMes (Value : byte). protected function GetMatricula : string. protected function GetRua : string. FBairro. procedure SetRua (Value : string). procedure SetBairro (Value : string). FNome : string. property Matricula : string read GetMatricula write SetMatricula. End. protected function GetDepartamento : string.

Begin Self. function GetSalario : real. procedure TEndereco.FRua. protected function GetCurso : string.FNumero. procedure TEndereco.SetRua Begin Self.FNumero := Value. End. Begin Result := Self. property Salario : real read GetSalario write SetSalario.FBairro := Value. FMGP : real. procedure SetSetor (Value : string). Begin Self. function TEndereco. End. function TEndereco. End. function GetMGP : real. End.FBairro.FRua := Value. procedure SetMGP (Value : byte). FSalario : real. End. End. : string.GetNumero : string. procedure SetSalario (Value : byte). procedure SetCurso (Value : string). (Value : string).{ TAluno = Class(TPessoa) private FCurso : string. End. public property Curso : string read GetCurso write SetCurso. public property Setor : string read GetSetor write SetSetor. 13 . protected function GetSetor : string. procedure TEndereco. } implementation {********************** TEndereco******************} function TEndereco. TFuncionario = Class(TPessoa) private FSetor : string.GetBairro : string.SetNumero (Value : string). Begin Result := Self. property MGP : string read GetMGP write SetMGP. End.SetBairro (Value : string).GetRua Begin Result := Self.

Create. End. End.FAulasMes. End.GetDepartamento : string.FDepartamento.FNome := Value.FAulasMes := Value. Begin Result := Self.Endereco := TEndereco. function TProfessor. Begin Self. End. Begin Self.Endereco. inherited Destroy. procedure Tprofessor.FMatricula.Create.Destroy. end. (Value : string). function TPessoa. procedure Tprofessor.FNome. End. End. Self.SetDepartamento (Value : string).FMatricula := Value. procedure TPessoa. Begin Self.FDepartamento := Value.Free. End. 14 . Begin inherited Create. End. destructor TPessoa. : string. {********************** TProfessor******************} function TProfessor. End. Begin Result := Self. function TPessoa.GetNome Begin Result := Self.{********************** TPessoa******************} constructor TPessoa.GetAulasMes : byte.SetMatricula (Value : string).GetMatricula : string.SetAulasMes (Value : byte). procedure TPessoa.SetNome Begin Self. Begin Result := Self. End. Begin Self.

override. override. protected function GetX : real. public procedure Desenhe . TCirculo = Class (TFigura) private FRaio : real. {************TFigura************} function TFigura. : string. procedure SetCor (Value : string). public procedure Desenhe . procedure SetY (Value : real). TRetangulo = Class (TQuadrado) private FY : real. protected function GetRaio : real. procedure SetX (Value : real). Begin Self.GetCor Begin Result := Self. property X : real read GetX write SetX. End. SysUtils. property Raio : real read GetRaio write SetRaio. protected function GetCor : string. procedure SetRaio (Value : Real). protected function GetY : real. property Cor : string read GetCor write SetCor. End. End. public procedure Desenhe. virtual. public procedure Desenhe. property Y : real read GetY write End.SetCor (Value : string). interface type TFigura = Class private FCor : string. TQuadrado = Class (TFigura) private FX : real.FCor.FCor := Value. procedure TFigura.unit Figura.override. 15 . implementation uses dialogs. End. End. SetY. abstract.

X)).FRaio := Value. End. procedure TCirculo. function TCirculo.Raio)).Desenhe.GetX : real.FRaio. End. End. procedure TRetangulo. End. Begin showMessage('Retangulo' + FloatToStr(Self. End. Begin Self. End.FX := Value. Begin Result := Self.GetY : real.GetRaio : real. {**********TCirculo*********} procedure TCirculo.SetX (Value : real). Begin Result := Self.Desenhe. End.{************TQuadrado************} procedure TQuadrado.SetY (Value : real). function TQuadrado. Begin Self. Begin showMessage('Quadrado' + FloatToStr(Self. End. function TRetangulo. Begin Self. 16 .X)). End.FX.X) + FloatToStr(Self.FY. Begin Result := Self.FY := Value. Begin showMessage('Circulo' + FloatToStr(Self. procedure TQuadrado. end.SetRaio (Value : Real).Desenhe. {************TRetangulo************} procedure TRetangulo.

type Vetor_T = array[1. public property Tamanho : integer read GetTamanho write SetTamanho .SetDados (Posicao . End. Begin Result := Self. End.FTamanho.unit Vetor. Begin Result := Self. End. 17 . procedure TVetorInteiro. interface const Tam = 100. function GetTamanho : integer. function TVetorInteiro. Value : integer). procedure SetTamanho (Value : integer). Begin Self. protected function GetDados (Posicao : integer) : integer. FTamanho : integer.Tam] of integer.. procedure TVetorInteiro. procedure Inverte.GetTamanho : integer. property Dados[Posicao : integer] : integer read GetDados write SetDados.FDados[Posicao] := Value. Procedure Insere( Value : integer). End.FDados[Posicao].Value : integer). TVetorInteiro = class private FDados : Vetor_T.GetDados ( Posicao : integer) : integer. default. End.SetTamanho (Value : integer).FTamanho := Value. Begin Self. procedure SetDados (Posicao . implementation { TVetorInteiro} function TVetorInteiro.

aux : integer. Self[f] := aux. try Dados[Tamanho] := Value except Tamanho := Tamanho . End. End. f : byte.-1). f := Self. end. inc(i). Begin with Self do Tamanho := Tamanho + 1. while i < f do Begin aux := Self[i]. inc(f.Tamanho.Insere( Value : integer).1. End. Var i. Begin i := 1. procedure TVetorInteiro.Inverte. Self[i] := Self[f]. 18 . end.procedure TVetorInteiro.

1.1. sem perda de dados ou recursos.. Uma exceção deve ser respondida sempre que houver perigo de perda de dados ou de recursos do sistema. . seu código necessita reconhecer uma exceção quando esta ocorrer e respondê-la.1. será exibida uma mensagem descrevendo o erro. . • Se houver uma exceção em qualquer das instruções da cláusula try o controle de execução será desviado para a primeira instrução da cláusula finally. No object pascal os tratadores de exceções não tendem a obscurecer o algoritmo dos programas. finally não trata exceção em particular. permitindo que os erros sejam manipulados de uma maneira consistente e fazendo com que a aplicação possa se recuperar de erros se possível ou finalizar a execução quando necessário. Memória. Aplicações Robustas O tratamento de exceção é um mecanismo capaz de dar robustez a uma aplicação. • As instruções da cláusula finally são sempre executadas. assim como fazem a técnicas convencionais de tratamento de erros Para que uma aplicação seja segura.2. <instrução finally <instrução . O Delphi possui uma classe especial para tratar exceções e quando o programador não define um código para tratar determinada exceção o Delphi irá utilizar um tratador default de exceções. n> n + 1>. Recursos do Windows e Objetos. .8. mesmo que não haja exceção. 1>. <instrução end. Tratamento de Exceção 8. . m> • Tanto as instruções da cláusula try quanto as instruções da cláusula finally são executadas sequencialmente. Os Recursos do Sistema que necessitam proteção e podem causar danos na execução caso sejam perdidos são: Arquivos. Criação de um Bloco Protegido try <instrução . 8.. 19 . • try . Se não houver tratamento para uma exceção. apenas permite a garantia de que não haja perda de recursos.

Tratando Uma Exceção on <tipo de exceção> do <instrução>. . end. o fluxo de execução continua na instrução seguinte ao tratamento. Exemplos: var F : File. . .5. <instrução n>] end. 20 . 8. .1. begin AssignFile(F. end. • Para permitir que o tratamento da exceção prossiga no tratamento default. 8. Tratando Exceções try <instrução 1>.1. .1. Reset(F).8. . <instrução n> except <lista de tratamentos> [else <instrução 1>.3.xxx’).4. try { código que atualiza o arquivo F} finally CloseFile(F). • Quando uma exceção é tratada.’Arquivo. utiliza-se a palavra-chave raise no fim do bloco de instruções do tratamento para que a exceção seja lançada novamente.

end. end.6.1.1.7. NumeroDeItens: Integer): real. As funções StrToInt ou StrToFloat não consegue converte uma string num valor numérico válido Divisão de inteiro por zero Acesso a memória não permitido Erro de I/O de arquivo Operação inválida com número inteiro Typecast inválido utilizando o operado As Operação inválida com número real Memória Livre insuficiente para alocar objeto Número real excedeu a faixa válida Valor excede a faixa definida para o inteiro Quando a pilha (stack) não pode crescer dinamicamente Número real menor que a faixa válida Divisão de real por zero 8. Principais Classes de Exceção Classe EAceessViolation EConvertError EDivByZero EGPFault EInOutError EIntOverFlow EInvalidCast EInvalidOp EOutOfMemory EOverflow ERangeError EStackOverflow EUnderflow EZeroDivide Descrição Acesso inválido a uma região de memória. 21 . begin try Result := Soma div NumeroDeItens. except on EZeroDivide do Result := 0. Exemplos: function Media(Soma.8.

Create( <descrição> ). • No momento em que houver uma anormalidade. begin inherited Create('Fatorial Negativo'). Exemplos: type EFatorialNegativo = class(Exception) public constructor Create. . • As classes de exceção devem ser subclasses da classe Exception.9.Create. end. Criação de Classes de Exceção <identificador> = class(Exception). 8. end.1. if n = 0 then Result := 1 else Result := n * Fatorial(n .8. um objeto do classe de exceção criada deve ser lançado.1).8. • Qualquer anormalidade na execução de um programa pode ser transformada em uma exceção pela criação de uma classe para fazer esse tratamento. . 22 . end. constructor EFatorialNegativo. function Fatorial(const n: Longint): Longint.Create. seguindo o modelo: if <condição anormal> then raise <classe de exceção >. .1. begin if n < 0 then raise EFatorialNegativo.

Read(N). end.var N: Longint. end. 23 . except on E:EFatorialNegativo do Writeln(E.Message). begin Write('Digite um valor (-1 para sair): '). Write('Digite um valor (-1 para sair): '). end. Fatorial(N)). while N <> -1 do begin try Writeln(n. '! = '. Read(N).