ApostilaFatec - Programação orientada a objetos.pdf

5/17/2018 ApostilaFatec - Programa o orientada a objetos.pdf - slidepdf.com

http://slidepdf.com/reader/full/apostilafatec-programacao-orientada-a-objetospdf 1

Sistemas de Informação e Sistemas paraSistemas de Informação e Sistemas paraSistemas de Informação e Sistemas paraSistemas de Informação e Sistemas paraWebWebWebWeb

Programação Orientada a ObjetosProgramação Orientada a ObjetosProgramação Orientada a ObjetosProgramação Orientada a Objetos

(((( implementação:implementação:implementação:implementação: C#)C#)C#)C#)

Profa. Msc. Liliane JaconProfa. Msc. Liliane JaconProfa. Msc. Liliane JaconProfa. Msc. Liliane Jacon

2. Semestre / 2009



INDICE

1. HISTÓRICO E PRIMEIROS EXEMPLOS....................................................................................31.1 Ambiente do Visual Studio ................................................................................................. 3

2. MÉTODOS DE PROGRAMA EM C#........................................................................................... 52.1 Métodos da classe Math......................................................................................................5

3. CONCEITOS DE POO .................................................................................................................. 53.1 Encapsulamento, Atributos e métodos, Ocultação da informação........................................53.2 Modificadores de Acesso (public e private) ........................................................................73.3 Construtores .......................................................................................................................73.4 Utilização de SET´s e GET´s / Propriedades ..................................................................... 103.5 Composição: referências a objetos como variáveis de instância de outras classes.......... .... 113.6 Usando a referência THIS................................................................................................. 13

4. HERANÇA.................................................................................................................................. 145. TRABALHO DE HERANÇA......................................................................................................186. POLIMORFISMO .......................................................................................................................23

6.1 conversâo de objetos da classe derivada para objetos da classe base.......... ........... ......... .... 236.2 Classes Abstratas.............................................................................................................. 246.3 Interface ........................................................................................................................... 28

7. EXCEÇÃO .................................................................................................................................. 297.1 DivideByZeroException ................................................................................................... 297.2 Criando uma classe separada para tratamento da Exceção........ ........... .......... ......... ........... 307.3 Testando estouros com os operadores CHECKED e UNCHECKED............... ......... ......... 31

8. CONTROLES/COMPONENTES VISUAIS SIMPLES ............................................................... 328.1 Label, Textbox e Button ................................................................................................... 328.2 Groupbox e Panel ............................................................................................................. 328.4. Controle Com Guias (TabControl)................................................................................... 33



Programação Orientada a Objetos – C#

3

1. HISTÓRICO E PRIMEIROS EXEMPLOS

O C# tem raízes em C, C++ e Java.Trata-se de uma linguagem visual dirigida por eventos e total/ee orientada a objetos.A Microsoft sabedora das necessidades do mercado para :

• Aplicativos baseados na Web• Ferramentas de programação para dispositivos eletrônicos móveis (por ex telefones

celulares)Para atender essas necessidades a Microsoft anunciou sua iniciativa .NET (dot.net ou

ponto.net) em junho de 2000.A plataforma .NET possibilita que os aplicativos baseados na Web possam ser distribuídos

para uma grande variedade de dispositivos (até telefones celulares) e p/computadores de mesa.Ela é independente de uma linguagem, permitindo que os programadores criar aplicativos em umalinguagem compatível com essa tecnologia (código nas linguagens .NET compreendem C#,Visual C++.NET, Visual Basic.NET Java, JScript, Pascal, Perl entre outras)

1.1 Ambiente do Visual Studio

Solution Explorer: lista todos os arquivos da solução. Quando o Visual Studio é carregado, osolution explorer está vazio. Quando um novo projeto é criado, o solution explorer exibe oconteúdo desse projeto.

ToolBox (caixa de ferramentas): os programadores podem arrastar e soltar controles em umformulário. Existem grupos de componentes relacionados (Common Controls, Containers, Data,Components, Windows Forms).

Janela Properties: Permite a manipulação das propriedades do controle. Na ilustração abaixo,mostra as propriedades do FORM. A coluna da direita mostra seus valores atuais. O íconeEVENTS permite que o controle ou formulário responda a certas ações do usuário.




4

1o. exemplo) Imprimindo uma linha de textousing System; // acrescentando bibliotecaclass Primeiro{

static void Main (string[] args){

Console.WriteLine(“Inicio da programação com C#”);string pausa = Console.ReadLine();

} /* comentario} */

2o. exemplo) Exibindo uma caixa de textousing System; // acrescentando bibliotecausing System.Windows.Forms;class Segundo{


MessageBox.Show(“Inicio da programação com C# \n parte 2”);} /* comentario

} */

3º. Exemplo) Somando dois númerosusing System; // acrescentando bibliotecaclass SomaNumeros{


string primeiroNumero, segundoNumero;int num1, num2, soma;

Console. Write( “favor entre com primeiro numero inteiro: “); primeiroNumero = Console.ReadLine();

Console. Write( “favor entre com segundo numero inteiro: “);segundoNumero = Console.ReadLine(); num1 = Int32.Parse(primeiroNumero);num2 = Int32.Parse(segundoNumero);soma = num1 + num2;

Console.WriteLine(“\n A soma eh {0 } ”, soma);Console.WriteLine (“\nOs números foram {0} e {1} “,num1, num2);string pausa = Console.ReadLine();

} /* comentario} */

Operador Precedência = = Igualdade( ) parênteses 1ª. ! = Diferente* / ou % 2ª. > Maior + ou - 3ª < Menor

>= Maior igual<= Menor igual

Faça um algoritmo para ler as notas de 10 alunos. Calcular a média da classe.




5

using System; // acrescentando bibliotecaclass MediaClasse{


int media, somaTotal, contador, nota;somaTotal = 0;

contador = 1;

while (contador <= 10){

Console. Write( “entre com a nota do aluno: “);nota = Int32.Parse(Console.ReadLine());

somaTotal = somaTotal + nota;

contador = contador + 1;}

media = somaTotal / 10;Console. WriteLine( “\n\nMedia da classe = {0} “, media);string pausa = Console.ReadLine();

} /* comentario} */

2. MÉTODOS DE PROGRAMA EM C#

2.1 Métodos da classe MathConsole.WriteLine( Math.Sqrt(900.0)); // resultado = 30.0 (doublé)

Console.WriteLine ( Math.PI ); // exibe 3,14159265358979323846

Cos (x ) Cos (0.0) é 1.0Pow (x, y) X elevado a y

Pow (2,3) = 23 = 8Sin (x )Sqrt ( x )Tan ( x )Floor ( x ) Arredonda x para o maior inteiro não maior que x

Floor (9.2) = 9.0Ceiling (x ) Arredonda x para o menor inteiro não menor do que x

Ceiling (9.2) = 10.0

3. CONCEITOS DE POO

3.1 Encapsulamento, Atributos e métodos, Ocultação da informaçãoA orientação a objetos usa classes para encapsular (isto é reunir) dados (atributos) e métodos

(comportamentos). Os objetos tem capacidade de ocultar sua implementação de outros objetos(esse princípio é chamado de ocultamento de informações).

Embora alguns objetos possam se comunicar uns com os outros, por meio de interfaces bemdefinidas (assim como a interface do motorista com um carro inclui um volante, pedal acelerador,

double




6

pedal de freio e cambio), os objetos não sabem como os outros são implementados (assim como omotorista não sabe como o volante, o motor, o freio, e os mecanismos de transmissão sãoimplementados). Em geral dos detalhes da implementação ficam ocultos dentro dos própriosobjetos. Certamente é possível dirigir um carro sem conhecer os detalhes do funcionamento dosmotores, das transmissões e dos sistemas de escape.

Em linguagens de programação procedimentais (como C) a programação tende a ser

orientada a ações. A programação C#, entretanto é orientada a objetos. Em C, a unidade de programação é a função (as funções são chamadas de métodos em C#). Em C#, a unidade de programação é a classe. Os objetos são eventualmente instanciados (isto é, criados) dessasclasses, e as funções são encapsuladas dentro dos limites das classes como métodos.

Os programadores de C se concentram na escrita de funções. Eles agrupam em uma funçãoações que executam alguma tarefa e, então agrupam as funções para formar um programa.Certamente, os dados são importantes em C, mas eles existem principalmente para suportar asações que as funções executam. Os verbos (calcule, verifique, busque) em um documento derequisitos de um sistema descrevendo os requisitos de um novo aplicativo, ajudam o programador de C a determinar o conjunto de funções que trabalharão juntas para implementar o sistema.

Em contraste, os programadores C# se concentram na criação de seus próprios tiposdefinidos pelo usuário, chamados classes. Também nos referimos as classes como tipos definidos

pelo programador. Cada classe contem dados e um conjunto de métodos que manipulam dados.Os componentes de dados ou membros de dados de uma classe são chamados de variáveis deinstancia. Em C#, a atenção é focalizada nas classes, em vez de métodos. Os substantivos em umdocumento de requisitos (pessoa, funcionário, aluno, livro) ajudam o programador de C# adeterminar um conjunto inicial de classes com as quais vai começar o processo de projeto.

class VerificaTriangulo{

int a, b, c;public VerificaTriangulo(int va,int vb,int vc){

a = va; b = vb; c = vc;}

public bool verificaFormacao(){

if ((a < b + c)&&(b < a+c)&&(c < a + b))return true;

elsereturn false;

}public int verificaTipo(){

if (verificaFormacao()){

if ((a == b) && (b == c))return 1; //equuilatero

else if ((a != b) && (b != c) && (c != a))

return 2; //escalenoelse return 3; //isosceles}else return -1; //não eh triangulo

}public override string ToString(){

string temp;switch (verificaTipo()){

case 1: temp = "Equilatero"; break;




7

case 2: temp = "Escaleno"; break;case 3: temp = "Isosceles"; break;case -1: temp = "Nao forma triangulo"; break;

}return temp;

}}

Interface (FORM) ligação com a classe VerificaTriangulo

namespace Triangulo{

public partial class Form1 : Form{

public Form1(){ InitializeComponent(); }

private void bVerifica_Click(object sender, EventArgs e){

try{ int a = Int32.Parse(tbA.Text);

int b = Int32.Parse(tbB.Text);int c = Int32.Parse(tbC.Text);VerificaTriangulo TR = new VerificaTriangulo(a, b, c);

lSaida.Text = TR.ToString();}catch (Exception erro){ MessageBox.Show("entre com os valores primeiramente..."); }

}}

}

3.2 Modificadores de Acesso (public e private)As 3 variáveis de instância Hora, Minuto e Segundo foram declaradas com o modificador de acessPRIVATE, indicando que essas variaveis de instancia são acessíveis apenas para membros da class

– isso é conhecido como ocultamento de dados.Isto indica que apenas os métodos dentro da classe conseguem enxergar as variáveis de instanciHora,Minuto e Segundo.

Normalmente, as variáveis de instancia são declaradas como PRIVATE e os métodos como PUBLICÉ possível declarar de outra forma também (variáveis de instancia PUBLIC e/ou métodos PRIVATEconhecidos por serem métodos utilitários, usados só dentro da própria classe).

3.3 ConstrutoresOs constructores de uma classe podem ser sobrecarregados.O C# chama o constructor apropriado fazendo corresponder o número, tipos e ordem dosargumentos especificados na chamada do constructor com o número, tipos e ordem dos

parâmetros especificados em cada definição do constructor.




8

namespace Tempo{

class ClasseTempo{

private int hora; // de 0 a 23private int minuto; // de 0 a 59private int segundo; // de 0 a 59

public ClasseTempo() // constructor{ SetTempo(0, 0, 0);//meia-noite}public ClasseTempo(int hora) // constructor so com hora{

SetTempo(hora, 0, 0);}public ClasseTempo(int hora, int minuto) // constructor so com minuto{

SetTempo(hora, minuto, 0);

}public ClasseTempo(int hora, int minuto, int segundo)// constructor so c/segundo{ SetTempo(hora, minuto, segundo);}public ClasseTempo(ClasseTempo tempo)// constructor c/um tempo anterior{

SetTempo(tempo.hora, tempo.minuto, tempo.segundo);}public void SetTempo(int valorHora, int valorMinuto,int valorSegundo){

hora = (valorHora >= 0 && valorHora < 24) ? valorHora : 0;minuto = (valorMinuto >= 0 && valorMinuto < 60) ? valorMinuto : 0;segundo = (valorSegundo >= 0 && valorSegundo < 60) ? valorSegundo : 0;

}// converte a hora para uma string no formato de hora universal (24 horas)public string ToUniversalString()

{// formato D2 =formato de numero digital base 10 - de dois digitosreturn String.Format("{0:D2}:{1:D2}:{2:D2}", hora, minuto, segundo);

}public string ToAmericanoString(){

return String.Format("{0}:{1:D2}:{2:D2} {3}",((hora == 12 || hora == 0) ? 12 : hora % 12),

minuto, segundo, (hora < 12 ? "AM" : "PM"));}

}}




9

Ligando a interface (Form) com a classe ClasseTempo

namespace Tempo{

public partial class Form1 : Form{

ClasseTempo T = new ClasseTempo();

public Form1(){ InitializeComponent(); }

private void bVerifica_Click(object sender, EventArgs e){

int h, m, s;if ((tbHora.Text == "")&&(tbMinuto.Text=="")&&(tbSegundo.Text==""))

T = new ClasseTempo();//meia noiteelse if ((tbHora.Text!= null)&&(tbMinuto.Text=="")&&(tbSegundo.Text==""))

{h = Int32.Parse(tbHora.Text);T = new ClasseTempo(h, 0, 0);//so hora

}else if ((tbHora.Text !="")&&(tbMinuto.Text != "")&&(tbSegundo.Text==""))

{h = Int32.Parse(tbHora.Text);m = Int32.Parse(tbMinuto.Text);T = new ClasseTempo(h, m, 0); //hora+minuto

}else// todos diferentes de null{

h = Int32.Parse(tbHora.Text);m = Int32.Parse(tbMinuto.Text);s = Int32.Parse(tbSegundo.Text);T = new ClasseTempo(h, m, s);

}string temp = "Americano=" + T.ToAmericanoString() + "\n" +

"Universal=" + T.ToUniversalString();

lSaida.Text = temp;}

private void Form1_Load(object sender, EventArgs e){

tbHora.Clear();tbMinuto.Clear();tbSegundo.Clear();

}

private void bValida_Click(object sender, EventArgs e){

ClasseTempo tempo1 = new ClasseTempo();//00:00:00

ClasseTempo tempo2 = new ClasseTempo(2);//02:00:00ClasseTempo tempo3 = new ClasseTempo(21, 34);//21:34:00ClasseTempo tempo4 = new ClasseTempo(12, 25, 42);//12:25:42ClasseTempo tempo5 = new ClasseTempo(27, 74, 99);//00:00:00 invalidoClasseTempo tempo6 = new ClasseTempo(tempo4);//12:25:42string saida;saida = "Constructores utilizados: " +

"\nTempo1: todos argumentos são default" +"\n " + tempo1.ToUniversalString() +"\n " + tempo1.ToAmericanoString();

saida += "\nTempo2: hora especifica, minutos e segundos são default" +




10

"\n " + tempo2.ToUniversalString() +"\n " + tempo2.ToAmericanoString();

saida += "\nTempo3: especificos Hora e minutos, segundos são default" +"\n " + tempo3.ToUniversalString() +"\n " + tempo3.ToAmericanoString();

saida += "\nTempo4: especificos Hora, minutos e segundos" +"\n " + tempo4.ToUniversalString() +

"\n " + tempo4.ToAmericanoString();saida += "\nTempo5: tempo com Hora, minutos e segundos invalidos" +"\n " + tempo5.ToUniversalString() +"\n " + tempo5.ToAmericanoString();

saida += "\nTempo6: tempo setado com o Tempo4" +"\n " + tempo6.ToUniversalString() +"\n " + tempo6.ToAmericanoString();

lTeste.Text = saida;}

}}

3.4 Utilização de SET´s e GET´s / PropriedadesOs métodos de uma classe odem manipular variáveis de instancia private desta classe. Suponha uma

classe ContaBancaria que tenha uma variável de instancia private SALDO. Um método para alterar osaldo seria CalcularTaxadeJuros, por exemplo.Frequentemente, as classes fornecem PROPRIEDADES public para permitir aos clientes configurarem (isto é, atribuírem valores as) ou obterem (isto é, obterem os valores de) variáveis de instância Private.Por exemplo, no exemplo abaixo temos três propriedades Hora, Minuto e Segundo que acessam asvariáveis de instancia hora, minuto e segundo respectivamente. Cada propriedade tem um acessor GET(para recuperar o valor do campo) e um acessor SET (para modificar o valor do campo).Se uma variável de instancia é private, um acessor get public parece permitir que outros métodosleiam os dados a vontade. Entretanto, o acessor get pode controlar a formatação e exibir os dados. Umacessor set public pode investigar tentativas de modificar o valor da variável de instancia, garantindoassim que o novo valor seja apropriado para a variável de instancia. Por exemplo, uma tentativa deconfigurar (set) o dia do mês como 37 seria rejeitada, e uma tentativa de configurar o peso de uma pessoa com um valor negativo também seria rejeitada. Assim, os acessores set e get podem fornecer

acesso a dados private, mas a implementação desses acessores controla o que o código cliente podefazer com os dados.

class VerificaTriangulo{

int a, b, c; public int A

{get { return a; }set { a = (value >=0)? value : 1; }

} public int B

{get { return b; }

set { b = (value >=0)? value : 1; }} public int C

{get { return c; }set { c = (value >=0)? value : 1; }

}public VerificaTriangulo(int va,int vb,int vc){

A = va; B = vb; C = vc;}




11

public bool verificaFormacao(){

if ((A < B + C) && (B < A + C) && (C < A + B))return true;

elsereturn false;

}public int verificaTipo(){

if (verificaFormacao()){

if ((A == B) && (B == C))return 1; //equuilatero

else if ((A != B) && (B != C) && (C != A))return 2; //escaleno

else return 3; //isosceles}else return -1; //não eh triangulo

}public override string ToString(){

string temp = "";

switch (verificaTipo()){

case 1: temp = "Equilatero"; break;case 2: temp = "Escaleno"; break;case 3: temp = "Isosceles"; break;case -1: temp = "Nao forma triangulo"; break;

}return temp;

}}

3.5 Composição: referências a objetos como variáveis de instância de outrasclasses

Hierarquia de Agregação/decomposiçãoAgregação - Um objeto pode ser visto como um agregado de outros objetos (suas partes). Por exemplo, numa casa típica, pode-se visualizar várias objetos que a compõem, a exemplo dodiagrama que se segue:

Este diagrama mostra que um objeto casa é composto por vários outros objetos. A relaçãoentre uma casa e suas partes componentes pode ser lida como:

- uma casa <é composta por> ..- ma casa <é um agregado de>- uma casa <é decomposta em>

...




12

e apresenta uma visão todo -> parte, ou seja, do objeto mais complexo para as partes que ocompõe. Uma mudança rápida de perspectiva possibilita um outro tipo de afirmações:

- o endereço <é parte da> casa- os móveis <são parte da> casa

Exemplo: Classe Datas – Classe Empregado – Classe TestaEmpregado(main)A classe DATE encapsula informações relacionadas a uma data específica. A classeEMPREGADO encapsula o nome do funcionário e dois objetos DATE representando a data denascimento e de contratação do funcionário. A classe TestaComposição cria um objeto da classeEmpregado para demonstrar a composiçãoO uso de referências a objetos de classes já existentes, como membros de novos objetos, échamado de composição (ou agregação).Classe DATEusing System;

public class Date {private int mes; // de 1 a 12private int dia; // 1 a 31private int ano; // qq ano

public Date(int d, int m, int a){

if (m > 0 && m <= 12)mes = m;

else{

mes = 1;Console.WriteLine("mes {0} invalido. setado como mes 1", m);

}ano = a;dia = verificaDia(d);

}// constructor Date

Classe Empregadousing System;

public class Empregado{

private string nome;private Date niver;private Date contratacao;

public Empregado(string n, int dn,int mn, int an,int dc,int mc, int ac)

{nome = n;niver = new Date(dn, mn, an);

contratacao = new Date(dc, mc, ac);}// constructor Empregado

public string ToEmpregadoString(){

return nome + " nasceu em " + niver.ToDateString() +"\n foi contratado em " + contratacao.ToDateString();

}

}// class Empregado




13

Classe TestaComposiçãousing System;using System.Windows.Forms;

public class TestaComposicao{

static void Main(string[] args)

{ Empregado e = new Empregado("Joao da Silva", 10, 10, 1980, 05, 06, 2005);MessageBox.Show(e.ToEmpregadoString(), "Testtando classe empregado");

}}// class testaComposicao

3.6 Usando a referência THIS Todo objeto pode acessar uma referência a si mesmo, chamada de referência THIS. A referência THIS pode se referir implicitamente as variáveis de instancia, propriedades e métodos de um objeto. A palavra-chave THIS é normalmente usada dentro de métodos, onde THIS é uma referência ao objeto em que ométodo esta executando operações.

using System;

public class Tempo4{

private int hora;private int minuto;private int segundo;

public Tempo4(int hora, int minuto, int segundo){

this.hora = hora;this.minuto = minuto;this.segundo = segundo;

}

public string ConstroiString()

{return "this.ToIniciaString(): " + this.ToIniciaString() +

"\n sem ToIniciaString(): " + ToIniciaString();}

public string ToIniciaString(){return String.Format("{0}:{1:D2}:{2:D2} {3}",

((this.hora==12 || this.hora==0)?12:this.hora%12),this.minuto, this.segundo,(this.hora <12? "AM":"PM"));

}}

using System;using System.Windows.Forms;

class TestaTHIS{

static void Main(string[] args){

Tempo4 tempo = new Tempo4(12,30,19);MessageBox.Show(tempo.ConstroiString(),

"Demosntrando o \"this\" referencia");}

}




14

4. HERANÇA

A herança é uma forma de reutilização de software em que as classes são criadas pelaabsorção dos dados e comportamentos de uma classe já existente e aprimorando-as com novosrecursos.

Ao criar uma classe, em vez de escrever variáveis de instancia e métodos completamentenovos, o programador pode indicar que a nova classe deve herdar as variáveis de classe, propriedades e métodos de outra classe. A classe anteriormente definida é chamada classe base ousuper classe, e a nova classe é referida como classe derivada.

Uma classe derivada, na qual variaveis de instancia, propriedades, e métodos exclusivos sãonormalmente adicionados, é frequentemente maior do que a sua classe base.

Fazemos uma distinção entre o relacionamento “é-um” e o relacionamento “tem-um”. É-UMrepresenta herança . Em um relacionamento É UM , um objeto de uma classe derivada também

pode ser tratado como um objeto de sua classe base. Por exemplo, um carro é um veículo. Emcontraste, “tem-um” significa composição. No relacionamento tem-um, um objeto da classecontém uma ou mais referências de objeto como membros. Por exemplo, um carro tem umvolante.

Um problema de herança é que uma classe derivada pode herdar propriedades e métodosque não precisa ou que não deve ter. É responsabilidade do projetista da classe garantir que osrecursos fornecidos por uma classe sejam apropriados para as futuras classes derivadas. Mesmoquando a propriedade ou método de uma classe base é apropriada para uma classe derivada, essaclasse derivada frequentemente exige que a propriedade ou método realize sua tarefa de maneiraespecifica para a classe derivada. Em tais casos, a propriedade ou o método da classe base podeser sobreposto (overriden, redefinida) na classe derivada, com uma implementação apropriada.

Circulo área= Π r 2

Cilindro área = (Π r 2) + ( 2 Π r h ) onde h é a altura

using System;// a definição da classe Ponto herda impliciatamente de Object public class Ponto

{private int x, y;

public Ponto(){ // a chamada implicita ao constructor de Object ocorre aqui}

public Ponto(int xvalor,int yvalor)

Ponto

Circulo

Cilindro




15

{X = xvalor;Y = yvalor;

}

public int X{

get { return x; }set { x = value;}

}

public int Y{

get { return y; }set { y = value; }

}

// toda classe em C# herda da classe System.Object// isto significa que ela herda 8 métodos padrão da classe Object// o método ToString da classe Ponto sobrepõe o metodo ToString original daclasse Object

public override string ToString()

{ return "["+x+", "+y+"]";}

}

using System;

class circulo : Ponto

{private double raio;

public circulo(){ // chamada implicita ao contrsuctor de Ponto ocorre aqui}

public circulo(int xvalor, int yvalor,double r): base(xvalor,yvalor)

{ // chamada implicita ao contrsuctor de Ponto ocorre aquiRaio = r;

}

public double Raio{

get { return raio; }set { if (raio>=0) raio = value; }

}

public double Diametro(){

return raio * 2;}

public double Circunferencia(){

return Math.PI * Diametro();}

public virtual double Area()

//essa palavra chave permite que as classes derivadas//sobreponham um metodo da classe base




16

{return Math.PI * Math.Pow(raio, 2);

}

public override string ToString()

{return "Centro= ["+base.ToString()+"\nRaio= "+raio;

}

}

using System;class Cilindro: circulo

{private double altura;

public Cilindro(){}

public Cilindro(int xvalor, int yvalor, double r, double alt)

: base(xvalor, yvalor, r)

{

Altura = alt;}

public double Altura{

get { return altura; }set { if (value >= 0) altura = value; }

}

public override double Area()

{return 2 * base.Area() + base.Circunferencia() * Altura;

}

public double Volume(){return base.Area() * Altura;

}

public override string ToString(){

return base.ToString() + "\n Altura "+Altura;}

}// fim da classe cilindro

using System;using System.Windows.Forms;public class TestaPonto{

public static void Main(string[] args){

/*Ponto p = new Ponto(72,118);string saida = "Coordenada X = " + p.X + "\n" + "Coordenada Y = " + p.Y;

p.X = 10;p.Y = 10;saida += "\n\nA nova localização do ponto = " + p;

// note aqui a chamada ao ToStringMessageBox.Show(saida, "demonstração da classe ponto");




17

*///====================================================================/*circulo c = new circulo(37,43,2.5);string saida = "Coordenada X = " + c.X + "\n" + "Coordenada Y = " + c.Y+

"\n Raio = "+c.Raio;c.X = 2;c.Y = 2;c.Raio = 4.25;

saida += "\n\n" + "Nova localização e raio do circulo = " +"\n" + c + "\n";

saida += "Diametro = " + String.Format("{0:F}", c.Diametro()) + "\n";saida += "Circunferencia = " + String.Format("{0:F}",

c.Circunferencia()) + "\n";saida += "Area = " + String.Format("{0:F}",c.Area()) + "\n";

MessageBox.Show(saida, "demonstração da classe circulo");*/

//===================================================================Cilindro cil = new Cilindro(12,23,2.5,5.7);string saida = "Coordenada X = " + cil.X + "\n" +

"Coordenada Y = " + cil.Y +"\n Raio = " + cil.Raio + "\n"+ "Altura = "+cil.Altura;

cil.X = 2;cil.Y = 2;cil.Raio = 4.25;cil.Altura = 10;

saida += "\n\n" + "Nova localização: raio e altura do cilindro = " +"\n" + cil + "\n";

saida += "Diametro = " + String.Format("{0:F}", cil.Diametro()) + "\n";saida += "Circunferencia = " + String.Format("{0:F}",

cil.Circunferencia()) + "\n";saida += "Area = " + String.Format("{0:F}", cil.Area()) + "\n";

saida += "Volume = " + String.Format("{0:F}", cil.Volume()) + "\n";

MessageBox.Show(saida, "demonstração da classe cilindro");

}}




18

5. TRABALHO DE HERANÇAObservações:

- o método CalculaSalário tem que ser refeito acada especialização

- o método toString tem que ser refeito a cadaespecialização, mas deve-ser aproveitado aimplementação da classe Base imediata(acima)

- novos métodos podem ser acrescentados ao projeto, conforme a necessidade

- Utilizar variáveis de instância commodificadores PRIVATE somente.

- Cada classe tem suas propriedades

Empregado

Matrícula NomeSalarioBrutoSalarioLiquidoDataAdmissão

Constructor sem argsConstructor com argsPropriedadesToString

Operador Britadeira

Insalubridade

Constructor sem argsConstructor com argsCalculaSalarioToString

propriedades

Técnico de Explosivos

Adicional Periculosidade

Constructor sem argsConstructor com argsCalculaSalarioToString

propriedades

DATAS

Dia, mês, ano

Constructor sem argsConstructor com argsToStringPropriedadesverifica()getData()

bissexto()




19

CLASSE DATASusing System;public class datas{

private int dia, mes, ano;public datas(){

dia = 0; mes = 0; ano = 0;}

public datas(int d, int m, int a){

Dia = d; Mes = m; Ano = a;verifica();

}

public int bissexto() // se = 0 e bissexto, caso contrario nao eh{

if (((ano % 4 == 0) && (ano % 100 > 0)) || (ano % 400 == 0))return 0;

else return 1;}

public int Dia{

set { dia = value; }get { return dia; }

}

public int Mes{

set { mes = value; }get { return mes; }

}

public int Ano{

set { ano = value; }get { return ano; }

}

public void verifica(){int[] dmes={0,31,28,31,30,31,30,31,31,30,31,30,31};ano = ano > 0 ? ano:1;dmes[2] = dmes[2]+bissexto();mes = mes > 0 && mes < 13 ? mes:1;dia = dia > 0 && dia <= dmes[mes] ? dia:1;

} // fecha verifica

public String getData(){

verifica();string[] nomes={"zero", "Janeiro","Fevereiro","Marco", "Abril", "Maio","Junho", "Julho", "Agosto", "Setembro", "Outubro","Novembro","Dezembro"};string temp = dia+"/"+nomes[mes]+"/"+ano;

return (temp);}

}// classe datas




20

CLASSE EMPREGADO

using System;

public class empregado{

// variaveis de instanciaprivate string matricula;private string nome;private double salarioLiquido;private double salarioBruto;private datas dataAdm;

// metodospublic empregado(){

nome = "";matricula = ""; salarioLiquido = 0.0; salarioBruto = 0.0;dataAdm = new datas();

}

public empregado(string n, string matr,double sal, int da, int ma, int aa)

{Nome = n;Matricula = matr;SalarioBruto = sal;salarioLiquido = 0.0;dataAdm = new datas(da, ma, aa);

}

public string Matricula{

get { return matricula;}set { matricula = value;}

}

public string Nome{

get { return nome;}set { nome = value;}

}

public double SalarioBruto{

get { return salarioBruto;}set { salarioBruto = (value >= 0)? value: 0;}

}

public double SalarioLiquido{

get { return salarioLiquido;}set { salarioLiquido = (value >= 0)? value: 0;}}

public void setAdmissao(int d, int m, int a){

dataAdm.Dia = d;dataAdm.Mes = (m);dataAdm.Ano = (a);

}




21


string temp = "\n\nMatricula= " + Matricula + " Nome= " + Nome + "Salario Bruto= " + SalarioBruto;

return (temp);}

public virtual void calculaSalario(){

salarioLiquido = salarioBruto;}

} // fecha classe empregado

CLASSE OPERADOR DE BRITADEIRA

using System;

public class operadorBritadeira : empregado{

// variaveis de instanciaprivate double insalubridade;

// metodospublic operadorBritadeira(): base(){

Insalubridade=0;}

public double Insalubridade{

get { return insalubridade;}set { insalubridade = (value >= 0)? value: 0;}

}

public operadorBritadeira(String n, String matr,double sal, int da,int ma, int aa,double insalub): base(n,matr,sal,da,ma,aa)

{Insalubridade = insalub;

}

public override void calculaSalario(){

SalarioLiquido = SalarioBruto+Insalubridade;}

public override String ToString(){

String temp = "\n"+base.ToString()+String.Format("\n Insalubridade= "+Insalubridade);

return (temp);

}}// fecha classe operadorBritadeira

CLASSE TECNICO DE EXPLOSIVO

using System;

public class tecnicoExplosivo : operadorBritadeira{

// variaveis de instanciaprivate double periculosidade;

// metodos




22

public tecnicoExplosivo(): base (){

Periculosidade=0;}

public tecnicoExplosivo(string n, string matr,double sal, int da,int ma, int aa,double insalub,double pericul) : base (n,matr,sal,da,ma,aa,insalub)

{Periculosidade = pericul;

}

public double Periculosidade{

get { return periculosidade;}set { periculosidade = (value >= 0)? value: 0;}

}

public override void calculaSalario(){ SalarioLiquido = SalarioBruto+Insalubridade+Periculosidade; }

public override string ToString() {string temp = "\n"+base.ToString()+String.Format(" Periculosidade="+Periculosidade);

return (temp);}

}// fecha classe tecnicoExplosivo

PRINCIPAL – Testa HERANÇApublic class TestaHeranca{


Console.WriteLine("\nTestando Heranca Empregado Tecnico Operador");empregado e = new empregado("joao", "1234",4000, 10, 12, 2002);e.calculaSalario();

string temp= "\n\nEmpregado Comum "+e.ToString()+"Liquido="+e.SalarioLiquido;Console.WriteLine(temp);string pausa = Console.ReadLine();

operadorBritadeira op = new operadorBritadeira("operadTil", "2345",1300, 13, 08, 2002, 500);

op.calculaSalario();temp = "\n\nOperador Britadeira " + op.ToString()+"

Liquido="+op.SalarioLiquido;Console.WriteLine(temp);pausa = Console.ReadLine();

tecnicoExplosivo te = new tecnicoExplosivo("explosão ", "2345", 1300,13, 08, 2002, 500,450);

te.calculaSalario();temp = "\n\nTecnico Explosivo " + te.ToString()+

" Liquido="+te.SalarioLiquido;Console.WriteLine(temp);pausa = Console.ReadLine();

}}

===============================================================




23

6. POLIMORFISMOO polimorfismo nos permite escrever programas que tratam uma ampla variedade de classesrelacionadas de uma maneira genérica e facilita a adição de novas classes e recursos em umsistema.Os programas podem processar objetos de todas as classes genericamente em uma hierarquia declasses, como objetos de uma classe base comum. Alem disso, novas classes podem ser

adicionadas com pouca ou nenhuma modificação nas partes genéricas do programa.Polimorfismo ocorre quando uma subclasse tem um método com a mesma

assinatura da superclasse (classe base), ou seja, contêm a mesma assinatura. Assinatura significa número, tipo e ordem dos parâmetros. Polimorfismo também édefinido da seguinte forma: Trata-se da criação de uma família de funções (métodos)que compartilham do mesmo nome, mas cada uma tem código independente.

6.1 conversâo de objetos da classe derivada para objetos da classe baseusing System;class Ponto{

private int x, y;

public Ponto(){}

public Ponto(int xValor, int yValor){

X = xValor;Y = yValor;

}

public int X{

get { return x; }set { x = value; }

}

public int Y{


}


return "["+X+", "+Y+"]";}

}

using System;class Circulo: Ponto

{

private double raio; public Circulo()

{} public Circulo(int xValor, int yValor, double r)

: base(xValor, yValor)

{raio = r;

} public double Raio

{get { return raio; }set { raio = ((value > 0) ? value : 1); }

}




24

public double Diametro(){

return raio * 2;} public double circunferencia(){


public virtual double Area(){

return Math.PI * Math.Pow(raio, 2);} public override string ToString(){

return "Centro= "+base.ToString()+"; Raio= "+Raio;}

}


class testaConversao

{static void Main(string[] args){

Ponto p = new Ponto(30, 50);Circulo c = new Circulo(120, 89, 2.7);string saida = "Ponto p " + p.ToString() +

"\nCirculo c " + c.ToString();

//relacionamento é-um para atribuir circulo c ao um objeto PontoPonto p2 = c;

saida += "\nCirculo foi atribuido ao Ponto p2 " + p2.ToString();

//converte ponto p2 novamente para circulo c2

Circulo c2 = (Circulo)p2;

saida += "\nPonto p2 (que era circulo) volta a origem circulo c2 " + c2.ToString();

saida += "\nArea de circulo c2 " + c2.Area().ToString("F");

if (p is Circulo){

c2 = (Circulo)p;saida += "\n\nCast realizado com sucesso";

}

else saida += "\n\nPonto p não é um circulo";

MessageBox.Show(saida, "Demonstrativo do Relacionamento é-um");}

}

6.2 Classes Abstratas

Existem casos em que é interessante definir classes para as quais o programador nunca pretendeinstanciar quaisquer objetos. Tais classes são chamadas classes abstratas. Essas classes não podemser usadas para instanciar objetos, pois as classes abastratas são incompletas. As classes derivadasdevem definir as partes faltantes. As classes abstratas contem um ou mais métodos abstratos ou




25

propriedades abstratas, que são métodos e propriedades que não fornecem implementação. Asclasses a partir das quais objetos podem ser instanciados são chamados de classes concretas.

using System;

public abstract class Figura{

//retorna a area da figurapublic virtual double Area(){

return 0;}//retorna o volume da figurapublic virtual double Volume(){

return 0;}public abstract string Nome{

get;//as classes derivadas devem implementar essa propriedade

//para se tornar classes concretas}

}

public class Ponto: Figura{

private int x, y;

public Ponto(){}

public Ponto(int xValor, int yValor){

X = xValor;Y = yValor;

}

public int X{

get { return x; }set { x = value; }

}

public int Y{


}


return "[" + X + ", " + Y + "]";}

public override string Nome{

get { return " Ponto "; }}




26

}

public class Circulo: Ponto{

private double raio;

public Circulo(){

}

public Circulo(int xValor, int yValor, double r): base(xValor, yValor)

{raio = r;

}

public double Raio{

get { return raio; }set { raio = ((value > 0) ? value : 1); }

}

public double Diametro(){return raio * 2;

}

public double Circunferencia(){


public override double Area(){

return Math.PI * Math.Pow(raio, 2);}


return "Centro= "+base.ToString()+"; Raio= "+Raio;}

public override string Nome{

get { return " Circulo "; }}

}

public class Cilindro: Circulo{

private double altura;

public Cilindro(){}

public Cilindro(int xValor, int yValor, double r,double h):base (xValor, yValor, r)

{altura = h;

}




27

public double Altura{

get { return altura; }set { altura = ((value >= 0) ? value : 0); }

}

public override double Area(){

return 2 * base.Area() + base.Circunferencia() * Altura;}

public override double Volume(){

return base.Area()* Altura;}


return base.ToString()+"; Altura = "+Altura;}

public override string Nome

{get { return " Cilindro "; }

}}


public class testaAbstrata{

public static void Main(string[] args)

{Ponto p = new Ponto(7, 11);Circulo cir = new Circulo(22, 8, 3.5);Cilindro cil = new Cilindro(10, 10, 3.3, 10);

// cria um vetor vazio de FigurasFigura[] vetor = new Figura[3];

vetor[0] = p;vetor[1] = cir;vetor[2] = cil;string saida="";

foreach (Figura atual in vetor){

saida += "\n\n"+atual.Nome+": "+atual+"\nArea= "+atual.Area().ToString("F")+"\nVolume= "+atual.Volume().ToString("F");

}

MessageBox.Show(saida,"Testando array de objetos abstratos");

}}




28

6.3 Interface

Interfaces especificam conjuntos de serviços PUBLIC (isto é, métodos e propriedades) que asclasses DEVEM implementar. Uma interface é usada quando não existe nenhuma implementação

padrão para herdar (nenhuma variável de instancia e nenhuma implementação de método).Uma classe abstrata é usada para fornecer DADOS e serviços (MÉTODOS e PROPRIEDADES).

Uma interface é usada para fornecer serviços SEM IMPLEMENTAÇÃO (Métodos ePropriedades) que “reúnem” objetos díspares, que se relacionam entre si apenas por meio destainterface.

public interface InterfaceIdade{

int Idade { get; }string Nome { get; }

}

using System;

public class Arvore: InterfaceIdade

{private int aneis;// numero de

//aneis no tronco da arvorepublic Arvore(int anoPlantado){

aneis = DateTime.Now.Year - anoPlantado;}public void AddAneis(){

aneis++;}public int Idade{

get { return aneis; }

}public string Nome{

get { return "Arvore"; }}

}

public class Pessoa : InterfaceIdade{

private string primNome;private string ultNome;private int anoNasc;

public Pessoa(string pN, string uN, int ano){

primNome = pN;ultNome = uN;if (ano > 0 & ano <= DateTime.Now.Year)

anoNasc = ano;else

anoNasc = DateTime.Now.Year;}

public int Idade{

get { return DateTime.Now.Year - anoNasc; }




29

}

public string Nome{

get { return primNome + " " + ultNome; }}

}


public class TestaInterface

{public static void Main(string[] args){

Arvore tree = new Arvore(1978);Pessoa p = new Pessoa("Joao", "Pereira", 1990);

InterfaceIdade[] vetor = new InterfaceIdade[2];

vetor[0] = tree;vetor[1] = p;

string saida = tree + ": " + tree.Nome + "\nIdade = " + tree.Idade + "\n\n";

saida += p + ": " + p.Nome + "\nIdade = " + p.Idade + "\n\n";

foreach (InterfaceIdade atual in vetor){saida += atual.Nome + ": Idade= " + atual.Idade + "\n";

}

MessageBox.Show(saida, "Demonstrando Polimorfismo com Interface");}

}

7. EXCEÇÃO

Uma exceção é uma indicação de um problema que ocorre durante a execução de um programa. Onome “exceção” vem do fato de que, embora um problema possa ocorrer, ele ocorre raramente. Aidéia é que programadores escrevam programas mais robustos, claros e mais tolerantes a falhas.

7.1 DivideByZeroExceptionusing System;using System.Windows.Forms;

public class Divisao{

static void Main(string[] args)

{try

{

Console.WriteLine("\n Entre com o numerador ");int numerador = Int32.Parse(Console.ReadLine());

Console.WriteLine("\n Entre com o denominador ");int denominador = Int32.Parse(Console.ReadLine());

double result = numerador / denominador;

string saida = String.Format("{0:F}", result);




30

MessageBox.Show(saida, "testando exceção de divisão por zero");}

catch (FormatException) // entrada (formato) invalido{

MessageBox.Show("vc deve entrar com 2 numeros inteiros","formato invalido de entrada",MessageBoxButtons.OK, MessageBoxIcon.Error);

}

catch (DivideByZeroException erroDivisao)// tentou dividir por zero{

MessageBox.Show(erroDivisao.Message,"tentou dividir por zero",MessageBoxButtons.OK, MessageBoxIcon.Error);

}

}// fim do main}// fim da classe

7.2 Criando uma classe separada para tratamento da ExceçãoExemplo: Extrair a raiz quadrada de um número negativousing System;

class NumeroNegativoExcecao : ApplicationException

{

public NumeroNegativoExcecao(): base("Operacao Ilegal devido a numero negativo")

{}

public NumeroNegativoExcecao( string mensagem): base(mensagem)

{}

public NumeroNegativoExcecao(string mensagem, Exception erro): base(mensagem, erro)

{}

}

using System;using System.Windows.Forms; public class raizQuadrada{


try{

Console.WriteLine("\n Entre com um numero real: ");double numero = Double.Parse(Console.ReadLine());

if (numero < 0) throw new NumeroNegativoExcecao("Não épermitido raiz quadrada de nro negativo");

double result = Math.Sqrt(numero);

string saida = String.Format("{0:F}", result);

MessageBox.Show(saida, "testando exceção raiz quadrada");}

catch (FormatException) // entrada (formato) invalido{

MessageBox.Show("vc deve entrar com numero inteiro positivo","formato invalido de entrada",MessageBoxButtons.OK, MessageBoxIcon.Error);

}

catch (NumeroNegativoExcecao erroNegativo)// tentou dividir por zero

{




31

MessageBox.Show(erroNegativo.Message,"raiz quadrada de Nro Negativo não existe",MessageBoxButtons.OK, MessageBoxIcon.Error);

}}// fim do main

}// fim da classe

7.3 Testando estouros com os operadores CHECKED e UNCHECKEDusing System;

class Overflow{


int numero1 = Int32.MaxValue; ;// 2.147.483.647int numero2 = Int32.MaxValue;int soma = 0;

Console.WriteLine("numero 1 {0:D} \n Numero 2: {0:D}", numero1, numero2);

try{

Console.WriteLine("\nSoma de inteiros ");soma = checked(numero1 + numero2);

}

catch (OverflowException overExcecao){

Console.WriteLine(overExcecao.ToString());}

Console.WriteLine("\nSoma depois de checar a operação {0}",soma);Console.WriteLine("\nSoma de inteiros não checados ");soma = unchecked(numero1+numero2);Console.WriteLine("soma depois de operação não checada {0}",soma);string pausa = Console.ReadLine();

}// main}// Overflow

Resumo sobre Exceção:• Uma exceção é uma indicação de um problema que ocorre durante a execução de um

programa;• O tratamento de exceções permite que os programadores criem aplicações que podem

resolver exceções, frequentemente permitindo que o programa continue sua execuçãocomo se nenhum problema tivesse sido encontrado.• O tratamento de exceções permite que os programadores escrevam programas claros,

robustos e mais tolerantes a falhas.• O tratamento de exceções permite que o programador remova o código de tratamento

de erros da “linha principal” da execução do programa. Isso melhora a clareza do programa e também sua capacidade de modificação.




32

8. CONTROLES/COMPONENTES VISUAIS SIMPLES

8.1 Label, Textbox e Button

TextBox – propriedades: Name: tB1

PasswordChar: *Label – propriedades:

Name: l1BorderStyle: Fixed3DAutosize: falseText: vazio

Button – propriedades: Name: b1Text: Mostrar Texto

Evento Click do botãoprivate void b1_Click(object sender, EventArgs e)

{l1.Text = tB1.Text;

}

8.2 Groupbox e Panel

GroupBox (caixas de grupo) pode exibir uma legendaPanel (painéis) pode ter barra de rolagem

GroupBox – propriedades: Name gB1Text: sexo

Panel – propriedades:AutoScroll: padrão é false

(se true aparece as barras de rolagem)BorderStyle: borda (padrão é none) outras opções Fixed3D e FixedSingle

RadioButton – propriedades: Name (masculino/femino)Text (masculino/feminino)Checked: true para masculino

Label – propriedades: Name: l1 e l2Text: (vazio)

private void feminino_CheckedChanged(object sender, EventArgs e){ l1.Text = "Feminino selecionado"; }

private void masculino_CheckedChanged(object sender, EventArgs e){ l1.Text = "Masculino selecionado"; }

private void bsoma_Click(object sender, EventArgs e){ l2.Text = "botão soma"; }

private void bsubtrai_Click(object sender, EventArgs e){ l2.Text = "botão subtrai"; }

private void bdivide_Click(object sender, EventArgs e){ l2.Text = "botão divide"; }




33

private void bmultiplica_Click(object sender, EventArgs e){ l2.Text = "botão multiplica"; }

Exercicio

8.4. Controle Com Guias (TabControl)Form1.cs [Design]

1 Label : posicione-o abaixo do TabControl. Mude o Name para msg1 TabControl. Para adicionar PagPages, clique botão direito no TabControl e dê ADD TAB

Verifique na caixa de Propriedades se está selecionado o TabControl ou o TabPageModifique a propriedade Text dos TabPage´s: Cor, Tamanho, Msg e Sobre

Dentro de cada TabPage, coloque RadioButton´s (mude Name e Text)

Form1.cs public partial class Form1 : Form




34

{ public Form1(){ InitializeComponent(); }

private void Azul_CheckedChanged(object sender, EventArgs e){ msg.ForeColor = Color.Blue; }

private void Preto_CheckedChanged(object sender, EventArgs e){ msg.ForeColor = Color.Black; }

private void vermelho_CheckedChanged(object sender, EventArgs e){ msg.ForeColor = Color.Red; }

private void doze_CheckedChanged(object sender, EventArgs e){ msg.Font = new Font(msg.Font.Name, 12); }

private void catorze_CheckedChanged(object sender, EventArgs e){ msg.Font = new Font(msg.Font.Name, 14); }

private void dezesseis_CheckedChanged(object sender, EventArgs e){ msg.Font = new Font(msg.Font.Name, 16); }

private void oi_CheckedChanged(object sender, EventArgs e){ msg.Text = "Oiiiiii"; }

private void tchau_CheckedChanged(object sender, EventArgs e){ msg.Text = "Tchauuuuuu"; }

}// fecha class

Documents

ApostilaFatec - Programação orientada a objetos.pdf