Aula 05 Orientacao a Objeto

Prévia do material em texto

Desenvolvimento de Software
Orientação a Objeto
Prof. Henrique Mota
mota.henrique@gmail.com
http://www.henriquemota.com.br
 
Métodos
 
Métodos
• Métodos em C# são análogos a funções e 
procedimentos em outras linguagens como C e 
Pascal.
• O uso do nome método ao invés de função ou 
procedimento está relacionado a conceitos de 
orientação a objetos.
 
Um exemplo
static int mdc(int a, int b){
while(a != b) 
if(a > b) a -=b; else b -=a;
return a;
}
 
Métodos
Neste exemplo
– int mdc define o nome (mdc) e o tipo do valor 
retornado (int) pelo método mdc.
– (int a, int b) define os parâmetros (a e b, inteiros) 
usados pelo método.
– o modificador static indica que o método não está 
vinculado a nenhum objeto (objetos serão tratados 
mais adiante).
– os comandos entre { e } correspondem ao 'corpo' do 
método e serão executados cada vez que o mesmo for 
ativado.
– o comando return encerra a execução do método e 
define o valor devolvido pelo mesmo.
 
using System;
class Exemplo {
static int mdc(int a, int b){
while(a != b) if(a > b) a -=b; else b -=a;
return a;
}
public static void Main(string[] args){
int x = 33; int y = 605;
int m = mdc(x,y);
Console.WriteLine("mdc({0},{1})={2}",x,y,m);
}
}
Métodos
 
Métodos
Neste exemplo
– o comando int m = mdc(x,y); atribui como valor inicial da 
variável m o valor retornado pela ativação do método feita 
em mdc(x,y).
– Os parâmetros usados nessa ativação são os valores de x 
e y: durante execução do método, o parâmetro a é 
substituído pelo valor de x e o parâmetro b é substituído 
pelo valor de y.
 
Métodos: variáveis locais
• Um método pode ter variáveis locais, que são 
variáveis declaradas ‘dentro’ do método.
• Variáveis locais podem ser utilizadas apenas dentro 
do método onde foram declaradas.
• Os parâmetros do método também são locais a ele.
 
Um exemplo
static float media(float[] v){
float s = 0;
for(int i = 0; i < v.Length; i++) s += v[i];
return s/v.Length;
}
Neste exemplo
– v, s e i são variáveis locais ao método media.
– v é parâmetro do método, que é usado como uma 
variável local.
 
Um exemplo
using System;
class Exemplo{
 static float media(float[] v){
 float s = 0.0F;
 for(int i = 0; i < v.Length; i++) s += v[i];
 return s/v.Length;
 }
 public static void Main(string[] args){
 float[] dados = { 5.0F, 3.5F, 4.2F, 0.1F,
 9.2F, 10.8F, 12.0F 
};
 float M = media(dados);
 Console.WriteLine("media: {0}",M);
 }
}
 
Variáveis locais
• Métodos diferentes podem ter parâmetros ou 
variáveis locais com nomes comuns.
• Nesse caso, cada método tem os seus próprios 
parâmetros e variáveis locais, independentemente de 
os nomes serem os mesmos.
 
Valor de retorno
• Todos exemplos de métodos apresentados até aqui 
retornam um valor ao serem chamados. 
• Esse valor pode ser usado para atribuir um valor a 
uma variável ou mesmo numa expressão, como por 
exemplo:
m = mdc(x,y)*10;
 
Valor de retorno
• Em alguns casos, não se deseja que o método 
retorne um valor. Nesse caso, o tipo retornado pelo 
método é definido como void. 
Exemplo: 
static void writeMax(float[] v){
float m = v[0];
for(int i = 1; i < v.Length; i++)
if(v[i] > m) m = v[i];
Console.WriteLine(" maximo: {0}",m);
}
 
Um exemplo
 static void writeMax(float[] v){
 float m = v[0];
 for(int i = 1; i < v.Length; i++) if(v[i] > m) m = v[i];
 Console.WriteLine(" maximo: {0}",m);
 }
 static void writeMin(float[] v){
 float m = v[0];
 for(int i = 1; i < v.Length; i++) if(v[i] < m) m = v[i];
 Console.WriteLine(" minimo: {0}",m);
 }
 public static void Main(string[] args){
 float[] dados = { 5.0F, 3.5F, 4.2F, 0.1F, 
 9.2F, 10.8F, 12.0F };
 writeMin(v);
 writeMax(v);
 }
 
Passagem de parâmetros
• Nos métodos apresentados até agora, os parâmetros 
são passados por valor.
• Exemplo: numa chamada de método como
m = mdc(x,y);
 os valores das variáveis x e y são atribuídos aos 
parâmetros a e b do método mdc.
 
Passagem de parâmetros
• Numa chamada a um método com parâmetros 
passados por valor, o valor passado como parâmetro 
pode ser uma constante ou mesmo o resultado de 
uma expressão, como por exemplo:
m = mdc(115,x+y*8);
• Durante a execução do método mdc, o valor dos 
parâmetros é alterado. As alterações são feitas nas 
variáveis locais do método, correspondentes aos 
parâmetros e não afetam as variáveis usadas na 
chamada ao método.
 
Passagem de parâmetros
C# oferece 4 modos de passagem de parâmetros:
– valor (mostrado nos exemplos anteriores)
– referência
– saída
– número variável de parâmetros
 
Passagem por referência
• Durante a sua execução, o método manipula 
diretamente as variáveis associadas aos parâmetros 
passados por referência.
• A alteração no valor de um parâmetro passado por 
referência corresponde a uma alteração na variável 
associada ao mesmo.
• A passagem de um parâmetro por referência é 
indicada pela palavra ref antes do parâmetro.
 
Um exemplo
using System;
class Referencia {
static void troca(ref int a, ref int b){
int t = a;
a = b; b = t;
}
public static void Main(string[] args){
int x = 5; int y = 21;
Console.WriteLine("antes - x:{0} y:{1}",x,y);
troca(ref x,ref y);
Console.WriteLine("depois - x:{0} y:{1}",x,y);
}
}
 
Vetores como parâmetro
• Ao se passar um vetor como parâmetro por valor, os 
seus elementos se comportam como se fossem 
passados por referência.
• Isso significa que se alterarmos o valor de um 
elemento do vetor dentro do método, essa alteração 
vai ocorrer também no elemento do vetor passado 
como parâmetro.
 
Um exemplo
public static void inverte(int[] v){
int k = v.Length-1;
for(int i = 0; i < v.Length/2; i++){
int t = v[i];
v[i] = v[k-i];
v[k-i] = t;
}
}
• Após uma chamada a este método, como por 
exemplo em "inverte(w);", os elementos do 
vetor w serão invertidos. 
 
Parâmetros de saída
• Um parâmetro de saída pode ter o seu valor alterado 
durante a execução do método mas esse valor não 
pode ser usado pelo método.
• O modo de passagem, de saída, é indicado pela 
palavra out antes do parâmetro. 
 
Um exemplo
...
public static void min_max( int[] v,
out int max, 
out int min )
{
max = v[0]; min = v[1];
for(int i = 1; i < v.Length; i++){
if(v[i] > max) max = v[i];
if(v[i] < min) min = v[i];
}
}
...
 
Variáveis globais
• Os exemplos apresentados até aqui usam variáveis 
locais aos métodos.
• Em C# é possível definir variáveis ‘fora’ dos métodos, 
ou variáveis globais às classes.
• Essas variáveis podem ser usadas pelos métodos da 
classe.
 
Um exemplo
using System;
class MainClass{
static int[] v = { 33, 21, 44, 2, 3, 4, 1, 9 };
static void min_max(out int min, out int max){
max = v[0]; min = v[0];
for(int i = 1; i < v.Length; i++){
if(v[i] < min) min = v[i];
if(v[i] > max) max = v[i];
}
}
public static void Main(string[] args){
int mi, mx;
min_max(out mi,out mx);
...
}
}
 
Classes
 
Classes
Uma classe é um poderoso tipo de dado em C#. 
Como estrutura, uma classe define os dados e o 
comportamento dos tipos de dados.
 
class NomeDaClasse {
// definição dos atributos
private int atributo1;
// método construtor
public NomeDaClasse(int param1, string param2) 
{
}
// definição de um método
public tipoRetorno MetodoUm(lista de parametros) {
}
}
 
Classes
• Atributos definem através de tipos de dados as 
características que um objeto venha a 
apresentar
• O método construtor sempre é chamado 
quando se cria um novo objeto (instância da 
classe) podendo ou não conter uma assinatura
• Outros métodos definem através de rotinas as 
ações que um objeto venha a apresentar
 
Classe Exemplo
class Carro {
 int anoCarro;
 public Carro() {
 
 }
 public void Acelerar(double kilometragem) {
 
 }
}
 
Propriedades
• Propriedades são recursos oferecidos pelas classes 
para que possam alterar seus valores
• Os recursos gets e sets são comuns às propriedades
 
Propriedades
public tipodedado NomeDaPropriedade {
 get { return nomeAtributo;}
 set { nomeAtributo = value; }
}
 
Modificadores de visibilidade
C# apresenta os modificadores de visibilidade listados a 
seguir
• private Significa que, exceto a classe incluída, nada 
pode acessar o objeto, método ou variável
• public Significa que todos tem acesso livre a este 
membro
• protected Significa que são apenas visíveis para as 
classes derivadas por meio de herança
• Internal Todos tem acesso livre a este membro dentro 
do assembly. Fora do assembly a classe é 
inacessível
 
Modificadores de visibilidade
• Atributos internal são utilizados geralmente para 
criação de bibliotecas, já que uma biblioteca pode ter 
vários namespaces
 
Herança
• Recurso utilizado para derivar classes que tem 
métodos e atributos em comum
• Tem como principal vantagem reaproveitamento de 
código
• Em C# todas as classes derivam da classe Object
• A declaração de uma classe com herança deve ser:
class NomeDaClasse : ClasseBase
 
This e Base
• As cláusulas This e Base são referências que 
indicam a própria classe e a classe base
• Entende-se como classe Base a classe cuja a classe 
atual herda as propriedades e atributos
 
Declaração e chamada de 
métodos e objetos
• Para se instanciar um objeto, deve-se utilizar a 
operação new. 
• Essa operação atribui um <objeto> montado 
dentro de uma variável do tipo <objeto>
MinhaClasse obj = new MinhaClasse();
• Para acessar seus atributos e métodos 
utilizamos a instrução ”.”
 
Métodos e atributos static
• A operação static define um método ou atributo 
como pertencentes à classe em questão e não aos 
objetos.
• Esses atributos ou métodos terão apenas 1 cópia 
para n objetos que gerarem.
• Sua declaração é feita com a palavra static depois 
do modificador de acesso (public, private) e 
antes do tipo de dado (int, string)
• O seu acesso é feito pelo nome da classe e não mais 
pela referência da classe ou pelo nome do objeto
 
Classes e métodos abstratos
• A classe abstrata é um tipo de classe que 
somente pode ser herdada e não instanciada.
• Pode se dizer que este tipo de classe é uma 
classe conceitual que pode definir 
funcionalidades para que as suas subclasses 
(classes que herdam desta classe) possam 
implementa-las de forma não obrigatória.
 
Métodos virtuais
• Quando queremos possibilitar a algum método que 
ele seja sobrescrito, utilizamos o operador virtual.
• Os métodos virtuais podem possuir corpo.
• Caso um método não seja declarado como virtual 
ou abstract não será possível sobrescrevê-lo.
 
Interfaces
• Segue mais ou menos o mesmo princípio dos 
métodos abstratos: apenas define o formato de 
uma classe sem implementar seu código. 
• Existe uma característica que torna as 
interfaces bastante diferentes de simples 
classes abstratas: fornecem subsídio para a 
criação de novas classes numa forma mais 
parecida com a montagem de um quebra-
cabeça.
 
Interfaces
• O C# não suporta herança multipla. Isso significa que 
uma classe filha só pode ter um unica classe como 
pai. 
• Interfaces permitem criar algo parecido com herança 
multipla em C++. 
• Por definição, em OOP, Interfaces são coleções de 
métodos abstratos relacionados semanticamente. 
• Em bom português: peças de um quebra-cabeça que 
podem ser encaixadas conforme a conveniência de 
quem estiver jogando...
 
Namespaces
 
Namespaces
• Namespaces tem a função de ajudar a organizar 
os programas.
• Possibilita a existência de classes com o mesmo 
nome em namespaces diferentes.
• Correspondente ao nome de um arquivo ou diretório 
no Java.
	Slide 1
	Slide 2
	Slide 3
	Slide 4
	Slide 5
	Slide 6
	Slide 7
	Slide 8
	Slide 9
	Slide 10
	Slide 11
	Slide 12
	Slide 13
	Slide 14
	Slide 15
	Slide 16
	Slide 17
	Slide 18
	Slide 19
	Slide 20
	Slide 21
	Slide 22
	Slide 23
	Slide 24
	Slide 25
	Slide 26
	Slide 27
	Slide 28
	Slide 29
	Slide 30
	Slide 31
	Slide 32
	Slide 33
	Slide 34
	Slide 35
	Slide 36
	Slide 37
	Slide 38
	Slide 39
	Slide 40
	Slide 41
	Slide 42
	Slide 43
	Slide 44