5. As classes e os objetos
A classe é o molde a partir do qual os objetos são criados. Diz-se que o objeto é uma instância de uma classe.
 |
5.1. Uma classe Objeto
Programa (classes_01)
# -*- coding=utf-8 -*-
class Objet:
"""une classe Objet vide"""
# qualquer variável pode ter atributos por definição
obj1=Objet()
obj1.attr1="un"
obj1.attr2=100
# exibe o objeto
print "objet1=[{0},{1}]".format(obj1.attr1,obj1.attr2)
# altera o objeto
obj1.attr2+=100
# exibe o objeto
print "objet1=[{0},{1}]".format(obj1.attr1,obj1.attr2)
# atribui a referência objeto1 ao objeto2
obj2=obj1
# altera o objeto2
obj2.attr2=0
# exibe os dois objetos
print "objet1=[{0},{1}]".format(obj1.attr1,obj1.attr2)
print "objet2=[{0},{1}]".format(obj2.attr1,obj2.attr2)
Notas:
- linha 4: outra forma de comentário. Este, precedido por três "", pode se estender por várias linhas;
- linhas 3-4: uma classe de objeto vazia;
- linha 7: instanciação da classe Objet;
- linha 17: cópia de referências. As variáveis obj1 e obj2 são dois ponteiros (referências) para o mesmo objeto.
Resultados
5.2. Uma classe Pessoa
Programa (classes_02)
# -*- coding=utf-8 -*-
class Personne:
# atributos da classe
# não declarados — podem ser criados dinamicamente
# método
def identite(self):
# a princípio, utiliza atributos inexistentes
return "[{0},{1},{2}]".format(self.prenom,self.nom,self.age)
# ---------------------------------- main
# os atributos são públicos e podem ser criados dinamicamente
p=Personne()
p.prenom="Paul"
p.nom="Langevin"
p.age=48
# chamada de um método
print "personne={0}\n".format(p.identite())
Notas:
- linhas 3-10: uma classe com um método;
- linha 8: todo método de uma classe deve ter como primeiro parâmetro o objeto self, que designa o objeto atual.
Resultados
5.3. A classe Pessoa com um construtor
Programa (classes_03)
# -*- coding=utf-8 -*-
class Personne:
# construtor
def __init__(self,prenom,nom,age):
self.prenom=prenom;
self.nom=nom;
self.age=age;
# método
def identite(self):
# a princípio, utiliza atributos inexistentes
return "[{0},{1},{2}]".format(self.prenom,self.nom,self.age)
# ---------------------------------- main
# um objeto Pessoa
p=Personne("Paul","Langevin",48)
# chamada de um método
print "personne={0}\n".format(p.identite())
Notas:
- linha 6: o construtor de uma classe é chamado __init__. Assim como nos outros métodos, seu primeiro parâmetro é self;
- linha 18: um objeto Personne é criado com o construtor da classe.
Resultados
5.4. A classe Pessoa com verificações de validade no construtor
Programa (classes_04)
# -*- coding=utf-8 -*-
import re
# -------------------
# uma classe de exceção proprietária
class MyError(Exception):
pass
class Personne:
# construtor
def __init__(self,prenom="x",nom="x",age=0):
# o nome deve ser diferente de vazio
match=re.match(r"^\s*(\S+)\s*$",prenom)
if not match:
raise MyError("Le prenom ne peut etre vide")
else:
self.prenom=match.groups()[0]
# o sobrenome não pode estar vazio
match=re.match(r"^\s*(\S+)\s*$",nom)
if not match:
raise MyError("Le nom ne peut etre vide")
else:
self.nom=match.groups()[0]
# a idade deve ser válida
match=re.match(r"^\s*(\d+)\s*$",str(age))
if not match:
raise MyError("l'age doit etre un entier positif")
else:
self.age=match.groups()[0]
def __str__(self):
return "[{0},{1},{2}]".format(self.prenom,self.nom,self.age)
# ---------------------------------- mão
# um objeto Pessoa
try:
p=Personne(" Paul "," Langevin ",48)
print "personne={0}".format(p)
except MyError, erreur:
print erreur
# outro objeto Pessoa
try:
p=Personne(" xx "," yy "," zz")
print "personne={0}".format(p)
except MyError, erreur:
print erreur
# outra pessoa
try:
p=Personne()
print "personne={0}".format(p)
except MyError, erreur:
print erreur
Notas:
- linhas 7-8: uma classe MyError derivada da classe Exception. Ela não adiciona nenhuma funcionalidade a esta última. Ela existe apenas para ter uma exceção proprietária;
- linha 13: o construtor possui valores padrão para seus parâmetros. Assim, a operação p=Personne() é equivalente a p=Pessoa("x", "x", 0);
- linhas 15-9: analisamos o parâmetro prenom. Ele deve ser diferente de vazio. Caso contrário, lançamos a exceção MyError com uma mensagem de erro;
- linhas 21-25: o mesmo vale para o nome;
- linhas 27-31: verificação da idade;
- linhas 33-34: a função __str__ substitui o método anteriormente denominado identite;
- linhas 38-42: instanciação de uma pessoa e, em seguida, exibição de sua identidade;
- linha 39: instanciação;
- linha 40: exibição. A operação solicita a exibição da pessoa p na forma de uma sequência de caracteres. O interpretador Python então chama automaticamente o método p.__str__(), caso ele exista. Esse método desempenha a mesma função que o método toString() em Java ou nas linguagens .NET;
- linhas 41-42: tratamento de uma possível exceção do tipo MyError. Em seguida, exibe a mensagem de erro associada à exceção;
- linhas 44-48: o mesmo para uma segunda pessoa instanciada com parâmetros incorretos;
- linhas 50-54: o mesmo para uma terceira pessoa instanciada com os parâmetros padrão.
Resultados
5.5. Adicionado um método que funciona como um segundo construtor
Programa (classes_05)
# -*- coding=utf-8 -*-
import re
# -------------------
# uma classe de exceção proprietária
class MyError(Exception):
pass
class Personne:
# atributos da classe
# não declarados — podem ser criados dinamicamente
# construtor
def __init__(self,prenom="x",nom="x",age=0):
# o nome deve ser preenchido
match=re.match(r"^\s*(\S+)\s*$",prenom)
if not match:
raise MyError("Le prenom ne peut etre vide")
else:
self.prenom=match.groups()[0]
# o sobrenome não pode estar em branco
match=re.match(r"^\s*(\S+)\s*$",nom)
if not match:
raise MyError("Le nom ne peut etre vide")
else:
self.nom=match.groups()[0]
# a idade deve ser válida
match=re.match(r"^\s*(\d+)\s*$",str(age))
if not match:
raise MyError("l'age doit etre un entier positif")
else:
self.age=match.groups()[0]
def initWithPersonne(self,p):
# inicializa o objeto atual com uma pessoa p
self.__init__(p.prenom,p.nom,p.age)
def __str__(self):
return "[{0},{1},{2}]".format(self.prenom,self.nom,self.age)
# ---------------------------------- main
# um objeto Pessoa
try:
p0=Personne(" Paul "," Langevin ",48)
print "personne={0}".format(p0)
except MyError, erreur:
print erreur
# outro objeto Pessoa
try:
p1=Personne(" xx "," yy "," zz")
print "personne={0}".format(p1)
except MyError, erreur:
print erreur
# outra pessoa
p2=Personne()
try:
p2.initWithPersonne(p0)
print "personne={0}".format(p2)
except MyError, erreur:
print erreur
Notas:
- a diferença em relação ao script anterior está nas linhas 35 a 37. Foi adicionado o método initWithPersonne. Este utiliza o construtor __init__. Não é possível, como nas linguagens tipadas, ter métodos com o mesmo nome diferenciados pela natureza de seus parâmetros ou de seu resultado. Portanto, não é possível ter vários construtores que criariam o objeto a partir de parâmetros diferentes, neste caso, um objeto do tipo Personne.
Resultados
5.6. Uma lista de objetos Pessoa
Programa (classes_06)
# -*- coding=utf-8 -*-
class Personne:
...
# ---------------------------------- main
# criação de uma lista de objetos Pessoa
groupe=[Personne("Paul","Langevin",48), Personne("Sylvie","Lefur",70)]
# identidade dessas pessoas
for i in range(len(groupe)):
print "groupe[{0}]={1}".format(i,groupe[i])
Notas:
- linhas 3-5: a classe Personne já descrita
Resultados
5.7. Criação de uma classe derivada da classe Pessoa
Programa (classes_07)
# -*- coding=utf-8 -*-
import re
class Personne:
...
class Enseignant(Personne):
def __init__(self,prenom="x",nom="x",age=0,discipline="x"):
Personne.__init__(self,prenom,nom,age)
self.discipline=discipline
def __str__(self):
return "[{0},{1},{2},{3}]".format(self.prenom,self.nom,self.age,self.discipline)
# ---------------------------------- mão
# criação de uma lista de objetos “Pessoa” e derivados
groupe=[Enseignant("Paul","Langevin",48,"anglais"), Personne("Sylvie","Lefur",70)]
# identidade dessas pessoas
for i in range(len(groupe)):
print "groupe[{0}]={1}".format(i,groupe[i])
Notas:
- linhas 5-6: a classe Personne já está definida;
- linha 8: declara a classe Enseignant como uma classe derivada da classe Pessoa;
- linha 10: o construtor da classe derivada Enseignant deve chamar o construtor da classe pai Personne;
- linhas 21-22: para exibir grupo[i], o interpretador utiliza o método grupo[i].__str__(). O método __str__() utilizado é o da classe real de groupe[i], conforme mostram os resultados abaixo.
Resultados
5.8. Criação de uma segunda classe derivada da classe Pessoa
Programa (classes_08)
# -*- coding=utf-8 -*-
import re
class Personne:
...
class Enseignant(Personne):
...
class Etudiant(Personne):
def __init__(self,prenom="x",nom="x",age=0,formation="x"):
Personne.__init__(self,prenom,nom,age)
self.formation=formation
def __str__(self):
return "[{0},{1},{2},{3}]".format(self.prenom,self.nom,self.age,self.formation)
# ---------------------------------- principal
# criação de uma lista de objetos “Pessoa” e derivados
groupe=[Enseignant("Paul","Langevin",48,"anglais"), Personne("Sylvie","Lefur",70), Etudiant("Steve","Boer",22,"iup2 qualite")]
# identidade dessas pessoas
for i in range(len(groupe)):
print "groupe[{0}]={1}".format(i,groupe[i])
Notas:
- este script é semelhante ao anterior.
Resultados