5. As classes e os objetos
A classe é o molde a partir do qual são criados os objetos. 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 objeto 2
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 então estender-se 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):
# à primeira vista, 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: qualquer 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):
# à primeira vista, 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 chama-se __init__. Tal como acontece com os outros métodos, o 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 próprio não pode estar 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 apelido 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. Não acrescenta qualquer funcionalidade a esta última. Existe apenas para ter uma exceção própria;
- linha 13: o construtor tem valores por predefinição para os seus parâmetros. Assim, a operação p=Personne() é equivalente a p=Pessoa("x", "x", 0);
- linhas 15-9: analisamos o parâmetro prenom. Este deve ser diferente de vazio. Caso contrário, lançamos a exceção MyError com uma mensagem de erro;
- linhas 21-25: o mesmo se aplica ao 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: instância de uma pessoa e, em seguida, exibição da sua identidade;
- linha 39: instância;
- linha 40: exibição. A operação solicita a exibição da pessoa p sob a forma de uma cadeia de caracteres. O interpretador Python chama então automaticamente o método p.__str__(), caso este exista. Este método desempenha a mesma função que o método toString() em Java ou nas linguagens .NET;
- linhas 41-42: tratamento de uma eventual exceção do tipo MyError. Em seguida, exibe a mensagem de erro associada à exceção;
- linhas 44-48: o mesmo se aplica a uma segunda pessoa instanciada com parâmetros errados;
- linhas 50-54: o mesmo se aplica a uma terceira pessoa instanciada com os parâmetros por predefinição.
Resultados
5.5. Adicionar um método que funcione como 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 próprio não pode estar 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 apelido 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-37. Foi adicionado o método initWithPersonne. Este recorre ao construtor __init__. Não é possível, tal como nas linguagens tipadas, ter métodos com o mesmo nome diferenciados pela natureza dos seus parâmetros ou do seu resultado. Por conseguinte, não é possível ter vários construtores que criem 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 destas 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 apresentar o grupo[i], o interpretador utiliza o método grupo[i].__str__(). O método __str__() utilizado é o da classe real de grupo[i], tal como 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