04_Introdução ao C# (pweb)

POO, princípios básicos:
abstração
herança
encapsulamento
polimorfismo

O mundo tem objectos que possuem características e comportamentos. Todos os objectos têm: estado (conjunto de propriedades de um objecto), comportamento (conjunto de acções sobre o objecto), unicidade (todo o objecto é único).

Objecto = Dados + Código
Dados -> comunica com -> atributos
Código -> comunica com -> métodos

nivel_acesso class nome_da_classe
{
        // bloco de instruções
}

um classe tem:
nivel_acesso: nível de proteção da classe ( internal/public ou abstract ou sealed)
pode existir uma class @override -> permite substituir qualquer coisa (por exemplo um método)
pode existir numa class o virtual -> permite sobrescrever qualquer coisa  (por exemplo um método)
e o new é usado para ocultar um determinado método

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {
        static void Main(string[] args)
        {
            @override x = new @override();
            Console.WriteLine(x.Numero);
            Console.ReadKey();
        }
    }
    class @override
    {
        public int Numero { get; set; }
        public @override()
        {
            Numero = 5;
        }
    }
}

o this serve para nos referirmos ao próprio (variável, campo, método..) do objecto e não a algo “local”

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {
        static void Main(string[] args)
        {
            Aviao a= new Aviao();
            Aviao b = new Aviao("USA");

            Console.WriteLine("Vem com o nome {0}", a.ONome);
            Console.WriteLine("Vem com o nome {0}", b.ONome);
            Console.ReadKey();
        }
    }
    class Aviao
    {
        public string ONome="TAP";

        public Aviao()
        {
        }

        public Aviao(string nome)
        {
            this.ONome = nome;

        }
    }
}

assim uma classe tem os seguintes membros:
variáveis (campos ou atributos(members fields));
métodos
propriedades (gets e sets)

Os atributos têm sempre um nível de protecção:
private (por defeito),
public (acedido a partir de outras classes ou métodos),
protected (acedido a partir da classe onde foi declarado e/ou classes derivadas),

protected internal (acedido a partir de uma classe onde foi declarado ou de classes derivadas)

Podemos também dividir as classes, usando a terminologia partial

As classes também têm um nível de protecção:
internal (por defeito, a classe acedida apenas no projeto),
public (acedida de qualquer parte),
abstract ou internal abstract (acedida apenas no projeto e não pode ser instanciada, apenas derivada de)
public abstract (acessível de qualquer parte e não pode ser instanciada, apenas derivada de)
sealed (acessível apenas no projeto, não pode ser derivada, apenas instanciada)
public sealed
O encapsulamento tem como objectivo principal ocultar de pormenores internos da classe. Para fora vão apenas os métodos (se for o caso). Normalmente essa implementação é feita usando getters e setters

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {
        //exemplo do encapsulamento
        static void Main(string[] args)
        {
            Aviao a= new Aviao();
            Aviao b = new Aviao();

            Console.WriteLine("Vem com o nome {0}", a.ONome);
            Console.WriteLine("Vem com o nome {0}", b.ONome);
            Console.ReadKey();
        }
    }
    class Aviao
    {
        private string nome = "TAP";
        public string ONome
        {
            get { return nome; }
            set { nome = value; }
        }
    }
}

Os métodos (funções dentro das classes) podem ter parâmetros, sendo que estes podem ser passados por valor, ou então por referência, ou uso do out.
O uso da referência (ref) permite actualizar uma variável.
Existe tambem o formato de out

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {
        //exemplo do ref
        static void Main(string[] args)
        {
            Contas a = new Contas();
            int numero = -3;
           Console.WriteLine("mostra resultados {0}", a.FazContas(ref numero));

            Console.ReadKey();
        }
    }
    class Contas
    {
        private int valor = 10;

        public int FazContas (ref int recebe)
        {
            if (recebe < 0)
            {
                valor = this.valor;
            }
            else
            {
                valor = recebe * recebe;
            }
            return valor;
        }
    }
}

Podemos também utilizar arrays, nomeadamente parâmetros como argumentos

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {

        //exemplo do arrays
        static void Main(string[] args)
        {
            Contas a = new Contas();
            int[] numeros = {1,2,3};

            Console.WriteLine("mostra resultados {0}", a.FazContas(numeros));

            Console.ReadKey();
        }
    }
    class Contas
    {
        public int FazContas (params int[] recebeArray)
        {
            int soma = 0;
            foreach (var r in recebeArray)
            {
                soma += r;
            }
            return soma;
        }
    }
}

É possivel passar “invocar” um função ou método dependendo dos valores dos argumentos que recebe

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {
        //exemplo do argumentos
        static void Main(string[] args)
        {
            Argumentos();
            Argumentos(texto:"Peter");
            Console.ReadKey();
        }
        static void Argumentos(int numero = 0, string texto = "Portugal")
        {
            Console.WriteLine("mostra resultados {0}, {1}", numero, texto);
        }
    }
}

O polimorfismo:
definição de métodos ou interfaces, que são genéricos e que podem ser implementados de diversas formas
Vantagens do polimorfismo:
reutilizar código;
tempo de desenvolvimento;
manutenção.
A herança:
permite reutilizar o código, permite a construção de classes baseadas noutras, sendo que a subclasse:
herda todas as propriedades e métodos da classe base;
pode incluir ou sobrepor novas propriedades e métodos.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {
        //exemplo de herança
        static void Main(string[] args)
        {
            Filho f = new Filho();
            Console.WriteLine("mostrar {0}", f.Metodo2());
            Console.WriteLine("mostrar {0}", f.Metodo1());
            Console.ReadKey();
        }
        class Mae
        {
            private int numero = 10;
            public Mae() { }

            public int Metodo1()
            {
                return numero;
            }
        }

        class Filho:Mae
        {
            private int valor = 1;
            public int Metodo2()
            {
                return valor;
            }
        }
    }
}

Os membros da classe base, podem ser virtuais. A classe que herda uma classe com membros virtuais pode ser overridden pela classe que a herda, fazendo com que a classe derivada possa fornecer uma implementação alternativa para o membro.
O uso da palavra sealed evita que uma classe ou membros virtuais sejam herdados

uma classe base pode ser abstracta. É uma classe conceptual no qual se definem funcionalidades para as subclasses (que a herdam) e que possam implementá-las de forma não obrigatória.
se for estabelecido um método abstracto, então essa classe também o é. esse método não possui implementação na classe abstracta, apenas é e obrigatoriamente a sua definição e a implementação de ser feita na classe derivada.

Podem existir interfaces, usando a expressão interface
Todas as interfaces são publicas, os seus métodos não têm implementação, mas quem faz uso de uma interface tem que implementar as funcionalidades dos métodos.

Podem também tratar das excepções usando as expressões:
try
catch
finally
throw

Tags : ,