1_Classes

Prévia do material em texto

Classes 
Prof. José Augusto Sapienza Ramos – ja_sapienza@dcc.ufrj.br 
DCC/IM/UFRJ 
O que é? 
 Programação orientada a objetos é uma estratégia 
pertinente de estruturarmos nosso código; 
 Um das estratégias mais difundidas hoje; 
 Particularmente importante para códigos mais extensos. 
 
 Há um arcabouço conceitual por trás; 
 Também aplicado em outras áreas da computação como banco 
de dados, classificação de imagens e engenharia de software. 
 
 O Objeto é uma unidade de software que encapsula 
algoritmos e dados para um determinado fim; 
 
 
 
Em Python… 
Python é uma linguagem de programação 
orientada a objetos! 
Classes 
 Podemos entender a classe como uma “fábrica” de 
objetos de mesmas características; 
 
 As classes possuem: 
 Variáveis para guardar dados; 
 Métodos para estruturar os algoritmos. 
 
 Em uma boa estretágia de programação, uma classe 
agrupa variáveis e métodos segundo um claro objetivo 
na estrutura de nosso programa. 
 
 
Primeiro exemplo em Python 
# a primeira classe a gente nunca esquece… 
 
class retangulo: 
 def __init__(self,altura,largura): 
 self.alt = altura 
 self.larg = largura 
 def area(self): 
 return self.alt * self.larg 
 def perimetro(self): 
 return self.alt * 2 + self.larg * 2 
 
Primeiro exemplo em Python 
# a primeira classe a gente nunca esquece… 
 
class retangulo: 
 def __init__(self,altura,largura): 
 self.alt = altura 
 self.larg = largura 
 def area(self): 
 return self.alt * self.larg 
 def perimetro(self): 
 return self.alt * 2 + self.larg * 2 
 
Nome da classe 
Bloco que define variáveis 
e métodos que a classe 
fabricará em seus objetos 
Primeiro exemplo em Python 
# a primeira classe a gente nunca esquece… 
 
class retangulo: 
 def __init__(self,altura,largura): 
 self.alt = altura 
 self.larg = largura 
 def area(self): 
 return self.alt * self.larg 
 def perimetro(self): 
 return self.alt * 2 + self.larg * 2 
 
Métodos e seus 
respectivos blocos 
de código. 
Método tem seu 
código de definição 
igual a uma função. 
Primeiro exemplo em Python 
# a primeira classe a gente nunca esquece… 
 
class retangulo: 
 def __init__(self,altura,largura): 
 self.alt = altura 
 self.larg = largura 
 def area(self): 
 return self.alt * self.larg 
 def perimetro(self): 
 return self.alt * 2 + self.larg * 2 
 
Variáveis sendo 
definidas e lidas 
Primeiro exemplo em Python 
# a primeira classe a gente nunca esquece… 
 
class retangulo: 
 def __init__(self,altura,largura): 
 self.alt = altura 
 self.larg = largura 
 def area(self): 
 return self.alt * self.larg 
 def perimetro(self): 
 return self.alt * 2 + self.larg * 2 
 
Variáveis de escopo 
apenas dentro do 
respectivo método 
Primeiro exemplo em Python 
# a primeira classe a gente nunca esquece… 
 
class retangulo: 
 def __init__(self,altura,largura): 
 self.alt = altura 
 self.larg = largura 
 def area(self): 
 return self.alt * self.larg 
 def perimetro(self): 
 return self.alt * 2 + self.larg * 2 
 
Variáveis de escopo 
em toda a classe TEM 
QUE ter “self.” antes. 
Ou seja, podemos 
associar e ler valores 
em qualquer parte do 
código da classe. 
O que é o método __init__? 
 Esse é um método especial invocado toda a vez que a 
classe fabrica um objeto; 
 Esse nome __init__ é pré-determinado pelo Python. 
 
 Esse método deve conter o código de inicialização de 
nosso objeto – conjunto de variáveis configuradas e 
algoritmos executados para que o objeto possa ser 
utilizado; 
 
 Há outros métodos de nomes pré-determinados pelo 
Python e que possuem aplicações específicas [veremos 
alguns mais tarde]. 
 
 
Qual o significado do self? 
 
 O termo self aparece principalmente em dois momentos 
[isso é obrigatório]: 
 Como primeiro parâmetro de entrada quando definirmos um 
método da classe; 
 Para referenciar uma variável ou um método pertencente a 
classe em questão (ex. self.alt); 
 
 Podemos entender o self como “o próprio objeto”. 
 
 
Continuando o exemplo em 
Python 
# a primeira classe a gente nunca esquece… 
 
class retangulo: 
 def __init__(self,altura,largura): 
 self.alt = altura 
 self.larg = largura 
 def area(self): 
 return self.alt * self.larg 
 def perimetro(self): 
 return self.alt * 2 + self.larg * 2 
 
Continuando o exemplo em 
Python 
# usando a classe para fabricar objetos 
 
ret1 = retangulo(30,40) 
 
# ret1 é fabricado como uma instância da classe retangulo 
# o método __init__(self,altura,largura) foi implicitamente 
# invocado com altura = 30 e largura = 40 
# o parametro self é ignorado na chamada 
 
ret2 = retangulo(3,2) 
ret3 = retangulo(10,15) 
Continuando o exemplo em 
Python 
# acessando as variáveis do objeto 
 
ret4 = retangulo(1.2,2.5) 
 
print ret4.alt # imprime 1.2 
print ret4.larg # imprime 2.5 
 
# observe que na declaração da classe referenciamos 
# como self.alt e self.larg, porém substituímos o self 
# pelo nome do objeto quando o estamos manipulando 
Continuando o exemplo em 
Python 
# acessando os métodos do objeto 
 
ret5 = retangulo(2,3) 
 
print ret5.area() # imprime 6 
print ret5.perimetro() # imprime 10 
 
# ao chamar um método, também ignoramos o primeiro 
# parâmetro self e o cálculo com a altura e a largura da 
# instância (ou objeto) ret5 são utilizados no cálculo 
Conceitos importantes da 
orientação a objeto 
 
 Temos três conceitos importantes que estão refletidos 
nos recursos para construirmos nossas classes: 
 Encapsulamento (Abstração) 
 Herança 
 Poliformismo 
 
 
Abstração (encapsulamento) 
 Podemos abstrair o código de dentro da classe, apenas 
utilizando a sua interface; 
 Não precisamos conhecer a implementação dos métodos, 
apenas como chamá-los e o que ele retorna; 
 
 Podemos promover também o isolamento de variáveis e 
métodos de uma classe colocando dois “_” antes do 
nome do mesmo. 
 Assim o código que manipulado o objeto fabricado pela classe 
não interfere em partes que não nos convém. 
 
 
Exemplo de encapsulamento 
class retangulo: 
 def __init__(self,altura,largura): 
 self.__alt = altura 
 self.__larg = largura 
 def area(self): 
 return self.__alt * self.__larg 
 def perimetro(self): 
 return self.__alt * 2 + self.__larg * 2 
 
Exemplo de encapsulamento 
class retangulo: 
 def __init__(self,altura,largura): 
 self.__alt = altura 
 self.__larg = largura 
 def area(self): 
 return self.__alt * self.__larg 
 def perimetro(self): 
 return self.__alt * 2 + self.__larg * 2 
 
Dois underlines _ 
Exemplo de encapsulamento 
class retangulo: 
 def __init__(self,altura,largura): 
 self.__alt = altura 
 self.__larg = largura 
 def area(self): 
 return self.__alt * self.__larg 
 def perimetro(self): 
 return self.__alt * 2 + self.__larg * 2 
 
r1 = retangulo(1,2) 
print r1.alt # erro, r1.alt é desconhecido 
print r1.__alt # erro, r1.__alt é desconhecido 
Herança 
 Podemos construir classes mais genéricas e classes 
herdeiras mais especializadas; 
 Exemplo: retângulo e quadrado, arquivo e arquivo texto, pessoa 
e estudante, veículo e carro, … 
 
 A classe genérica possui os métodos e variáveis 
comuns as classes especializadas, enquanto as classes 
especializadas possuem as respectivas especificidades. 
 
 
Exemplo de herança 
# classe genérica 
class retangulo: 
 def __init__(self,altura,largura): 
 self.__alt = altura 
 self.__larg = largura 
 def area(self): 
 return self.__alt* self.__larg 
 def perimetro(self): 
 return self.__alt * 2 + self.__larg * 2 
 
Exemplo de herança 
# classe especializada 
class quadrado(retangulo): 
 def __init__(self,lado): 
 self.__alt = lado 
 self.__larg = lado 
 
# os métodos area e perímetro são herdados do pai e 
# não precisam ser reescritos 
 
q1 = quadrado(2) 
print q1.area() # imprime 4 
Exemplo de herança 
 Podemos chamar o método sobrecarregado* da classe 
generalizada a partir do código da classe especializada. 
Então poderíamos reescrever: 
 
# classe especializada 
class quadrado(retangulo): 
 def __init__(self,lado): 
 retangulo.__init__(self,lado,lado) 
 
* Quando um método de mesmo nome existe na classe especializada, 
dizemos que o método da classe generalizada foi sobrecarregado 
(overloaded). É o caso do __init__ entre as classes quadrado e 
retangulo. 
 
Herança Múltipla 
 
 É possível que uma classe especializada receba 
herança de duas ou mais classes. 
 
# exemplo simples onde C herda de A e B 
 
class C(A,B): 
 # resto do codigo… 
 
Poliformismo 
 Objetos de classes diferentes podem ser utilizados de 
forma semelhante; 
 Ex: len() pode receber uma lista, uma string, uma tupla, ... 
 Vários objetos se comportando semelhantemente; 
 
 Particularmente útil com herança: objeto especializado 
se comportando como o objeto generalizado. 
 
# isinstance() diz se um objeto é instância de uma classe 
print isinstance(q1,quadrado) # imprime True 
print isinstance(q1,retangulo) # imprime True 
 
 
 
Perguntas? 
Obrigado 
Prof. José Augusto Sapienza Ramos – ja_sapienza@dcc.ufrj.br