Skip to content

Latest commit

 

History

History
793 lines (583 loc) · 31.5 KB

SINTAXE.md

File metadata and controls

793 lines (583 loc) · 31.5 KB

SINTAXE DA LINGUAGEM:

0) FUNDAMENTOS:

Vou fornecer alguns exemplos de código em C# que utilizam operadores aritméticos, relacionais e lógicos, juntamente com explicações para cada tipo de operador.

Operadores Aritméticos:

  1. Adição (+):

    int resultado = 5 + 3;

    Neste exemplo, o operador de adição + é usado para somar os valores 5 e 3, resultando em 8.

  2. Subtração (-):

    int resultado = 10 - 7;

    O operador de subtração - é usado para subtrair 7 de 10, resultando em 3.

  3. Multiplicação (*):

    int resultado = 4 * 6;

    O operador de multiplicação * é usado para multiplicar os valores 4 e 6, resultando em 24.

  4. Divisão (/):

    double resultado = 20.0 / 5.0;

    O operador de divisão / é usado para dividir 20.0 por 5.0, resultando em 4.0. Note que o resultado é um número de ponto flutuante devido às operações com números decimais.

Operadores Relacionais:

  1. Igual (==):

    bool igual = (5 == 5);

    O operador == verifica se os dois valores são iguais. Neste caso, igual será true porque 5 é igual a 5.

  2. Diferente (!=):

    bool diferente = (6 != 3);

    O operador != verifica se os dois valores são diferentes. Neste caso, diferente será true porque 6 não é igual a 3.

Operadores Lógicos:

  1. E Lógico (&&):

    bool condicao = (true && false);

    O operador && realiza uma operação de E lógico. condicao será false porque ambos os lados da expressão não são verdadeiros.

  2. OU Lógico (||):

    bool condicao = (true || false);

    O operador || realiza uma operação de OU lógico. condicao será true porque pelo menos um dos lados da expressão é verdadeiro (no caso, o lado esquerdo).

  3. NÃO Lógico (!):

    bool negacao = !true;

    O operador ! realiza uma negação lógica. negacao será false porque negamos o valor verdadeiro.

Esses são alguns exemplos simples de como os operadores aritméticos, relacionais e lógicos são utilizados em C#. Eles são fundamentais para criar expressões condicionais e realizar cálculos em programas C#.

1) VARIAVEIS SIMPLES:

Em C#, existem vários tipos primitivos de variáveis, cada um com um propósito específico. Aqui estão alguns exemplos dos tipos primitivos mais comuns, juntamente com explicações para cada um deles:

  1. int (inteiro):

    int idade = 25;

    O tipo int é usado para armazenar números inteiros, positivos ou negativos, sem casas decimais. No exemplo acima, idade é uma variável do tipo int que armazena o valor 25.

  2. double (ponto flutuante de precisão dupla):

    double altura = 1.75;

    O tipo double é usado para armazenar números de ponto flutuante com alta precisão, permitindo casas decimais. No exemplo, altura é uma variável do tipo double que armazena o valor 1.75.

  3. char (caractere):

    char letra = 'A';

    O tipo char é usado para armazenar um único caractere. No exemplo, letra é uma variável do tipo char que armazena o caractere 'A'.

  4. bool (booleano):

    bool estaChovendo = false;

    O tipo bool é usado para representar valores lógicos, ou seja, verdadeiro (true) ou falso (false). No exemplo, estaChovendo é uma variável do tipo bool que armazena o valor false.

  5. string (cadeia de caracteres):

    string nome = "João";

    O tipo string é usado para armazenar texto como uma sequência de caracteres. No exemplo, nome é uma variável do tipo string que armazena o texto "João".

  6. byte (byte):

    byte valor = 100;

    O tipo byte é usado para armazenar números inteiros de 0 a 255, ocupando apenas 8 bits de memória. No exemplo, valor é uma variável do tipo byte que armazena o valor 100.

  7. short (inteiro curto):

    short temperatura = -10;

    O tipo short é usado para armazenar números inteiros em um intervalo maior que byte e menor que int. No exemplo, temperatura é uma variável do tipo short que armazena o valor -10.

  8. long (inteiro longo):

    long populacaoMundial = 7800000000;

    O tipo long é usado para armazenar números inteiros longos, frequentemente usados para valores muito grandes. No exemplo, populacaoMundial é uma variável do tipo long que armazena a população mundial atual.

Esses são alguns dos tipos primitivos de variáveis em C#. Cada um deles serve a um propósito específico e é importante escolher o tipo adequado com base nos requisitos do seu programa para otimizar o uso de memória e garantir a precisão dos dados.

Em C#, variáveis simples são amplamente usadas para armazenar informações, ponteiros são menos comuns devido à segurança e ao gerenciamento de memória automatizado da linguagem, e entrada de dados é frequentemente feita com a ajuda da classe Console. Aqui estão alguns exemplos que envolvem variáveis simples, entrada de dados e uma breve menção aos ponteiros:

Exemplo 1: Variáveis Simples e Entrada de Dados

using System;

class Program
{
    static void Main()
    {
        // Declaração de variáveis simples
        string nome;
        int idade;

        // Solicita ao usuário para inserir seu nome
        Console.Write("Digite seu nome: ");
        nome = Console.ReadLine();

        // Solicita ao usuário para inserir sua idade
        Console.Write("Digite sua idade: ");
        idade = Convert.ToInt32(Console.ReadLine());

        // Exibe as informações fornecidas pelo usuário
        Console.WriteLine("Nome: " + nome);
        Console.WriteLine("Idade: " + idade);

        // Aguarda a pressão de uma tecla antes de sair
        Console.ReadKey();
    }
}

Neste exemplo, declaramos variáveis simples nome e idade para armazenar informações fornecidas pelo usuário. Usamos a classe Console para receber dados de entrada do usuário e exibir informações na saída.

Exemplo 2: Uso de Ponteiros (Pouco Comum em C#)

using System;

class Program
{
    static unsafe void Main()
    {
        int numero = 42;
        int* ponteiro = №

        Console.WriteLine("Valor de numero: " + numero);
        Console.WriteLine("Endereço de memória de numero: " + (long)ponteiro);

        // Modificando o valor usando ponteiro
        *ponteiro = 100;

        Console.WriteLine("Novo valor de numero: " + numero);

        // Aguarda a pressão de uma tecla antes de sair
        Console.ReadKey();
    }
}

Neste exemplo, usamos um ponteiro (int* ponteiro) para acessar o endereço de memória de uma variável numero. Note que o uso de ponteiros em C# geralmente é restrito e requer a declaração do método como "unsafe". Ponteiros são mais comuns em linguagens de baixo nível como C e C++ e não são recomendados para uso geral em C# devido à segurança e ao gerenciamento de memória automáticos.

A entrada de dados é feita através do Console.ReadLine(), e a saída é exibida no console usando Console.WriteLine(). Certifique-se de entender a importância da segurança ao lidar com ponteiros, pois seu uso incorreto pode causar problemas de segurança e acesso à memória inválida.

2) ESTRUTURA CONDICIONAL:

ESTRUTURA IF-ELSE:

A estrutura de controle if-else é uma parte fundamental da programação em C# (e em muitas outras linguagens de programação). Ela permite que você tome decisões no seu código com base em condições lógicas. Aqui está a sintaxe básica da estrutura if-else em C#:

if (condição)
{
    // Código a ser executado se a condição for verdadeira
}
else
{
    // Código a ser executado se a condição for falsa
}

Aqui está uma explicação de como a estrutura if-else funciona:

  • condição: Uma expressão lógica que é avaliada como verdadeira ou falsa. Se a condição for verdadeira, o código dentro do bloco if será executado. Se for falsa, o código dentro do bloco else (opcional) será executado.

  • if: O bloco de código dentro do if é executado apenas se a condição for verdadeira.

  • else: O bloco de código dentro do else é executado apenas se a condição for falsa. O else é opcional, e você pode usar apenas um if sem um else se desejar.

Aqui estão alguns exemplos de uso da estrutura if-else em C#:

Exemplo 1: Verificação de Idade

int idade = 18;

if (idade >= 18)
{
    Console.WriteLine("Você é maior de idade.");
}
else
{
    Console.WriteLine("Você é menor de idade.");
}

Neste exemplo, a condição verifica se a idade é maior ou igual a 18. Se for verdadeira, a mensagem "Você é maior de idade" é exibida; caso contrário, a mensagem "Você é menor de idade" é exibida.

Exemplo 2: Classificação de Números

int numero = 7;

if (numero > 0)
{
    Console.WriteLine("O número é positivo.");
}
else if (numero < 0)
{
    Console.WriteLine("O número é negativo.");
}
else
{
    Console.WriteLine("O número é zero.");
}

Neste exemplo, usamos if, else if e else para classificar um número como positivo, negativo ou zero, com base na condição.

A estrutura if-else é uma maneira poderosa de controlar o fluxo do seu programa, permitindo que você execute diferentes blocos de código com base nas condições especificadas. Você também pode aninhar várias instruções if-else para criar lógica de decisão mais complexa.

ESTRUTURA IF-ELSE, ELSE IF:

A estrutura if-else if (ou else if encadeado) é uma extensão da estrutura if-else que permite testar várias condições em sequência. Ela é usada quando você tem várias condições a serem verificadas e deseja executar o bloco de código associado à primeira condição verdadeira encontrada. Aqui está a sintaxe da estrutura if-else if em C#:

if (condição1)
{
    // Código a ser executado se a condição1 for verdadeira
}
else if (condição2)
{
    // Código a ser executado se a condição2 for verdadeira
}
else if (condição3)
{
    // Código a ser executado se a condição3 for verdadeira
}
// ...
else
{
    // Código a ser executado se nenhuma das condições anteriores for verdadeira
}

Aqui estão algumas explicações sobre como a estrutura if-else if funciona:

  • Você começa com um if para verificar a primeira condição. Se essa condição for verdadeira, o bloco de código associado a essa condição será executado, e o restante do bloco if-else if será ignorado.

  • Se a primeira condição não for verdadeira, o programa verificará a próxima condição no else if subsequente. Se essa segunda condição for verdadeira, o bloco de código associado a ela será executado.

  • Esse processo continua até que uma condição verdadeira seja encontrada ou até que o bloco else final seja executado caso nenhuma das condições seja verdadeira.

  • O bloco else é opcional e é executado se nenhuma das condições anteriores for verdadeira.

Aqui está um exemplo de uso da estrutura if-else if em C#:

int nota = 85;

if (nota >= 90)
{
    Console.WriteLine("Aprovado com nota A");
}
else if (nota >= 80)
{
    Console.WriteLine("Aprovado com nota B");
}
else if (nota >= 70)
{
    Console.WriteLine("Aprovado com nota C");
}
else if (nota >= 60)
{
    Console.WriteLine("Aprovado com nota D");
}
else
{
    Console.WriteLine("Reprovado");
}

Neste exemplo, estamos avaliando a nota de um aluno e imprimindo a classificação com base nas faixas de notas especificadas. A primeira condição verdadeira encontrada determina a classificação e encerra a verificação. Se nenhuma das condições for verdadeira, o bloco else será executado, indicando que o aluno foi reprovado.

A estrutura if-else if é útil quando você precisa de lógica de decisão mais complexa que envolve várias condições exclusivas. Ela permite que você especifique ações diferentes para cenários diferentes.

ESTRUTURA SWITCH:

A estrutura switch é uma estrutura de controle de decisão em C# que permite que você avalie uma expressão e execute diferentes blocos de código com base no valor dessa expressão. Ela é especialmente útil quando você deseja comparar o valor de uma variável com várias opções e tomar ações diferentes para cada opção. Aqui está a sintaxe básica da estrutura switch em C#:

switch (expressão)
{
    case valor1:
        // Código a ser executado quando a expressão é igual a valor1
        break;
    case valor2:
        // Código a ser executado quando a expressão é igual a valor2
        break;
    // ...
    default:
        // Código a ser executado se a expressão não corresponder a nenhum dos casos anteriores
        break;
}

Aqui estão algumas explicações sobre como a estrutura switch funciona:

  • expressão: É uma expressão que é avaliada e comparada com os valores especificados nos casos case.

  • case valor1: Cada case define um valor que a expressão pode assumir. Se a expressão for igual a valor1, o bloco de código associado a esse case será executado. O break é usado para sair do switch após a execução do bloco de código do case.

  • default: O default é opcional e é usado quando nenhum dos case corresponde ao valor da expressão. O bloco de código associado ao default será executado.

Aqui está um exemplo de uso da estrutura switch em C#:

int diaDaSemana = 3;
string mensagem;

switch (diaDaSemana)
{
    case 1:
        mensagem = "Segunda-feira";
        break;
    case 2:
        mensagem = "Terça-feira";
        break;
    case 3:
        mensagem = "Quarta-feira";
        break;
    case 4:
        mensagem = "Quinta-feira";
        break;
    case 5:
        mensagem = "Sexta-feira";
        break;
    default:
        mensagem = "Fim de semana";
        break;
}

Console.WriteLine("Hoje é " + mensagem);

Neste exemplo, avaliamos o valor da variável diaDaSemana usando a estrutura switch e definimos uma mensagem com base no dia da semana. O default é usado para lidar com casos que não correspondem a nenhum dos valores dos case.

A estrutura switch é útil quando você tem uma variável com várias opções e deseja evitar uma série de instruções if-else if. Ela torna o código mais legível e eficiente em situações onde você precisa fazer múltiplas comparações de igualdade.

3) ESTRUTURA DE REPETIÇÃO:

ESTRUTURA FOR:

A estrutura for é uma estrutura de controle de repetição em C# que permite que você execute um bloco de código repetidamente por um número específico de vezes. É uma das estruturas mais utilizadas para criar loops em programas. Aqui está a sintaxe básica da estrutura for em C#:

for (inicialização; condição; incremento)
{
    // Código a ser executado repetidamente
}

Aqui estão as partes fundamentais da estrutura for:

  • inicialização: É onde você inicializa uma variável de controle ou define as condições iniciais necessárias. Isso é executado apenas uma vez no início do loop.

  • condição: É uma expressão booleana que é avaliada antes de cada iteração do loop. Se a condição for verdadeira, o código dentro do loop é executado; caso contrário, o loop é encerrado.

  • incremento: Geralmente, é uma instrução que altera o valor da variável de controle do loop de uma forma que, eventualmente, faça com que a condição do loop seja falsa. Isso é executado após cada iteração do loop.

Aqui está um exemplo simples de uso da estrutura for:

for (int i = 1; i <= 5; i++)
{
    Console.WriteLine("Número: " + i);
}

Neste exemplo, a estrutura for cria um loop que imprime os números de 1 a 5. Aqui está como funciona o loop:

  • int i = 1;: Inicializamos a variável de controle i com o valor 1 no início do loop.

  • i <= 5;: A condição verifica se i é menor ou igual a 5. Enquanto essa condição for verdadeira, o loop continuará a ser executado.

  • i++: Após cada iteração do loop, incrementamos i em 1, para que ele aumente de valor a cada passagem pelo loop.

O resultado será:

Número: 1
Número: 2
Número: 3
Número: 4
Número: 5

A estrutura for é muito útil quando você precisa realizar uma ação repetidamente por um número específico de vezes, como percorrer elementos em uma matriz, gerar uma sequência de números, ou realizar qualquer tipo de tarefa iterativa. Ela oferece controle preciso sobre o número de iterações e é uma das construções de loop mais comuns em C#.

ESTRUTURA WHILE:

A estrutura while é uma das estruturas de controle de repetição em C# que permite que você execute um bloco de código repetidamente enquanto uma condição específica for verdadeira. Diferentemente da estrutura for, o while não tem uma contagem explícita de iterações; ele continuará executando o código dentro dele até que a condição se torne falsa. Aqui está a sintaxe básica da estrutura while em C#:

while (condição)
{
    // Código a ser executado repetidamente enquanto a condição for verdadeira
}

Aqui está uma explicação do funcionamento da estrutura while:

  • condição: É uma expressão booleana que é avaliada antes de cada iteração do loop. Enquanto a condição for verdadeira, o código dentro do loop é executado. Quando a condição se tornar falsa, o loop é encerrado, e o controle é transferido para a próxima instrução após o while.

Aqui está um exemplo simples de uso da estrutura while:

int contador = 1;

while (contador <= 5)
{
    Console.WriteLine("Número: " + contador);
    contador++;
}

Neste exemplo, o while cria um loop que imprime os números de 1 a 5. Aqui está como funciona o loop:

  • contador = 1;: Inicializamos a variável contador com o valor 1 no início do loop.

  • contador <= 5;: A condição verifica se contador é menor ou igual a 5. Enquanto essa condição for verdadeira, o código dentro do loop será executado.

  • contador++;: Após cada iteração do loop, incrementamos contador em 1 para aumentar seu valor.

O resultado será:

Número: 1
Número: 2
Número: 3
Número: 4
Número: 5

A estrutura while é útil quando você precisa executar um bloco de código repetidamente com base em uma condição que pode não ser conhecida com antecedência. Você deve ter cuidado ao usar o while para evitar criar loops infinitos, certificando-se de que a condição se torne falsa em algum ponto durante a execução do loop.

ESTRUTURA DO-WHILE:

A estrutura do-while é outra estrutura de controle de repetição em C# que permite que você execute um bloco de código repetidamente enquanto uma condição específica for verdadeira, assim como a estrutura while. No entanto, a diferença chave entre as duas é que a estrutura do-while garante que o bloco de código seja executado pelo menos uma vez, mesmo que a condição seja falsa desde o início. Aqui está a sintaxe básica da estrutura do-while em C#:

do
{
    // Código a ser executado repetidamente
} while (condição);

Aqui estão algumas explicações sobre como a estrutura do-while funciona:

  • O código dentro do bloco do é executado primeiro, independentemente da condição.

  • Após a execução do bloco do, a condição especificada no while é avaliada.

  • Se a condição for verdadeira, o bloco do será executado novamente, e esse processo continuará enquanto a condição permanecer verdadeira.

  • Se a condição for falsa desde o início, o bloco do ainda será executado pelo menos uma vez antes que a condição seja verificada.

Aqui está um exemplo de uso da estrutura do-while:

int contador = 1;

do
{
    Console.WriteLine("Número: " + contador);
    contador++;
} while (contador <= 5);

Neste exemplo, o do-while cria um loop que imprime os números de 1 a 5. O loop sempre começa com a execução do bloco de código dentro do do, independentemente da condição. Aqui está como funciona o loop:

  • contador = 1;: Inicializamos a variável contador com o valor 1 antes da primeira execução.

  • A mensagem é impressa com o valor atual de contador.

  • contador++: Após cada iteração do loop, incrementamos contador em 1 para aumentar seu valor.

  • contador <= 5;: A condição é verificada após a primeira execução do bloco do, e o loop continuará a ser executado enquanto a condição for verdadeira.

O resultado será:

Número: 1
Número: 2
Número: 3
Número: 4
Número: 5

A estrutura do-while é útil quando você deseja garantir que um bloco de código seja executado pelo menos uma vez, independentemente da condição. É especialmente útil quando a avaliação da condição depende de algum processamento interno no bloco do.

4) VARIAVEIS COMPOSTAS:

Em C#, existem vários tipos de variáveis compostas, também conhecidas como tipos de dados compostos. Esses tipos permitem que você armazene coleções de valores ou objetos de maneira organizada. Aqui estão alguns dos tipos de variáveis compostas mais comuns em C#, com exemplos de código e explicações para cada um deles:

Arrays:

Um array é uma coleção de elementos do mesmo tipo, acessados por um índice numérico.

Exemplo de declaração e inicialização de um array de inteiros:

int[] numeros = new int[] { 1, 2, 3, 4, 5 };

Explicação: Neste exemplo, criamos um array de inteiros chamado numeros que contém cinco elementos.

Listas (List):

Uma lista é uma coleção dinâmica de elementos de qualquer tipo.

Exemplo de uso da classe List para armazenar strings:

List<string> nomes = new List<string>();
nomes.Add("Alice");
nomes.Add("Bob");

Explicação: Aqui, usamos uma lista para armazenar nomes de pessoas. A lista é dinâmica, o que significa que podemos adicionar ou remover elementos conforme necessário.

Dicionários (Dictionary):

Um dicionário é uma coleção de pares chave-valor, onde cada chave está associada a um valor.

Exemplo de uso da classe Dictionary para armazenar informações de estudantes:

Dictionary<string, int> notas = new Dictionary<string, int>();
notas["Alice"] = 95;
notas["Bob"] = 87;

Explicação: Criamos um dicionário onde as chaves são os nomes dos estudantes e os valores são suas notas. Isso permite que você associe informações relacionadas.

Matrizes (Multidimensional Arrays):

Uma matriz multidimensional é uma coleção de elementos organizados em várias dimensões.

Exemplo de uma matriz bidimensional:

int[,] matriz = new int[3, 3] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

Explicação: Neste exemplo, criamos uma matriz 3x3 de inteiros. É semelhante a uma tabela com linhas e colunas.

Tuplas (Tuple):

Uma tupla é uma estrutura de dados que pode conter uma combinação heterogênea de elementos.

Exemplo de uma tupla que armazena informações de um ponto em um plano:

(int, int) ponto = (3, 4);

Explicação: Aqui, criamos uma tupla que contém dois inteiros, representando as coordenadas x e y de um ponto.

Classe (Class):

Uma classe é uma estrutura de dados que define um objeto com atributos e métodos.

Exemplo de uma classe que representa uma pessoa:

class Pessoa
{
    public string Nome { get; set; }
    public int Idade { get; set; }
}

Explicação: Criamos uma classe chamada Pessoa que tem propriedades Nome e Idade. As classes são usadas para criar objetos com comportamentos e propriedades personalizadas.

Estruturas (Struct):

Uma estrutura é semelhante a uma classe, mas é um tipo de valor (value type).

Exemplo de uma estrutura que representa um ponto:

struct Ponto
{
    public int X { get; set; }
    public int Y { get; set; }
}

Explicação: Esta estrutura Ponto é semelhante à classe Pessoa, mas é um tipo de valor, o que significa que é copiada diretamente quando atribuída a outra variável.

Esses são alguns dos tipos de variáveis compostas em C# que permitem armazenar e organizar dados de maneira mais complexa e estruturada. Cada tipo tem seus próprios usos e características específicas.

5) FUNÇÕES:

As funções são blocos de código reutilizáveis em C# que realizam tarefas específicas. Elas são uma parte fundamental da programação modular, permitindo dividir um programa em partes menores e mais gerenciáveis. Aqui está uma visão geral das funções em C#:

Declaração de Função:

A declaração de uma função em C# inclui os seguintes elementos:

tipo_retorno NomeDaFunção(parâmetros)
{
    // Código da função
    return valor_retorno; // (opcional)
}

  • tipo_retorno: É o tipo de dado que a função retorna. Pode ser um tipo primitivo (como int, string, bool, etc.) ou um tipo de objeto.

  • NomeDaFunção: É o nome da função, que deve ser único no escopo em que a função é definida.

  • parâmetros: São variáveis usadas para receber valores de entrada na função. Eles são opcionais e podem ser de vários tipos e quantidades.

  • return valor_retorno: É uma instrução que retorna um valor da função. Esta parte é opcional e depende do tipo de retorno especificado. Funções que não retornam um valor (tipo void) não usam o return.

Exemplo de Declaração de Função:

// Função que soma dois números inteiros
int Soma(int a, int b)
{
    return a + b;
}

Chamada de Função:

Para usar uma função, você a chama em algum lugar no seu código, passando os argumentos necessários (se houver). A chamada de função geralmente é feita pelo nome da função seguido de parênteses.

Exemplo de Chamada de Função:

int resultado = Soma(5, 3);

Neste exemplo, chamamos a função Soma com os argumentos 5 e 3, e ela retorna o valor 8, que é atribuído à variável resultado.

Funções com Retorno de Valor:

Funções que retornam um valor (ou seja, não têm um tipo de retorno void) devem usar a instrução return para retornar um valor correspondente ao tipo de retorno.

Exemplo de Função com Retorno:

int Multiplica(int a, int b)
{
    return a * b;
}

Funções sem Retorno (void):

Funções que não retornam um valor têm um tipo de retorno void. Elas executam uma tarefa, mas não produzem um resultado que possa ser atribuído a uma variável.

Exemplo de Função sem Retorno (void):

void ExibeMensagem(string mensagem)
{
    Console.WriteLine(mensagem);
}

As funções são uma maneira eficaz de organizar e reutilizar código em C#. Elas melhoram a legibilidade do código, facilitam a manutenção e promovem a modularidade do programa. Você pode criar funções para realizar tarefas específicas e usá-las em diferentes partes do seu programa conforme necessário.

6) CLASS POO:

A Programação Orientada a Objetos (POO) tem quatro pilares fundamentais que são princípios-chave para o design de classes e objetos em um programa. Vou fornecer um exemplo para cada um desses pilares e explicar como cada um deles é aplicado:

  1. Encapsulamento:

    O encapsulamento é o princípio de esconder os detalhes de implementação de uma classe e fornecer uma interface pública para interagir com ela. Isso ajuda a proteger os dados e a funcionalidade da classe, permitindo um controle mais eficiente sobre o acesso a eles.

    Exemplo:

    public class ContaBancaria
{
    private double saldo;

    public void Depositar(double valor)
    {
        if (valor > 0)
            saldo += valor;
    }

    public void Sacar(double valor)
    {
        if (valor > 0 && valor <= saldo)
            saldo -= valor;
    }

    public double ConsultarSaldo()
    {
        return saldo;
    }
}

    Neste exemplo, a classe ContaBancaria encapsula o saldo e fornece métodos públicos (Depositar, Sacar e ConsultarSaldo) para interagir com o saldo. O saldo é privado, o que significa que não pode ser acessado diretamente de fora da classe.

  2. Abstração:

    A abstração é o processo de simplificação de objetos complexos, modelando-os apenas com as informações essenciais para o programa. Isso ajuda a ocultar detalhes não essenciais e a concentrar-se nos aspectos relevantes do objeto.

    Exemplo:

    public abstract class Animal
{
    public abstract void EmitirSom();
}

    Neste exemplo, a classe abstrata Animal define uma abstração para animais em geral. Ela possui um método abstrato EmitirSom que representa um comportamento comum a todos os animais, mas não fornece uma implementação específica. Classes derivadas, como Cachorro e Gato, devem fornecer suas próprias implementações desse método.

  3. Herança:

    A herança permite criar uma nova classe com base em uma classe existente, reutilizando seus atributos e métodos. Isso promove a reutilização de código e permite criar hierarquias de classes.

    Exemplo:

    public class Veiculo
{
    public string Marca { get; set; }
    public string Modelo { get; set; }
}

public class Carro : Veiculo
{
    public int Portas { get; set; }
}

    Neste exemplo, a classe Carro herda os atributos Marca e Modelo da classe Veiculo. Isso significa que um objeto Carro possui todos os atributos de um Veiculo, além de seus próprios atributos específicos.

  4. Polimorfismo:

    O polimorfismo permite que objetos de classes diferentes respondam de maneira diferente ao mesmo método. Isso é alcançado por meio de herança e interfaces, permitindo que um método seja implementado de várias maneiras em classes diferentes.

    Exemplo:

    public interface IAnimal
{
    void EmitirSom();
}

public class Cachorro : IAnimal
{
    public void EmitirSom()
    {
        Console.WriteLine("O cachorro late.");
    }
}

public class Gato : IAnimal
{
    public void EmitirSom()
    {
        Console.WriteLine("O gato mia.");
    }
}

    Neste exemplo, ambas as classes Cachorro e Gato implementam a interface IAnimal com um método EmitirSom, mas cada uma delas fornece sua própria implementação específica. Isso permite que objetos de ambas as classes sejam tratados genericamente como IAnimal, independentemente de serem cachorros ou gatos, e respondam de maneira adequada quando o método EmitirSom é chamado.

Esses quatro pilares da POO são fundamentais para criar sistemas de software bem estruturados, flexíveis e fáceis de manter, promovendo a reutilização de código e a organização eficaz dos elementos do programa.