oops concepts c object oriented programming concept tutorial
Este tutorial explica os conceitos de OOPS em C #. Você pode aprender sobre princípios de programação orientada a objetos, como polimorfismo, encapsulamento, herança e abstração:
A Programação Orientada a Objetos é um modelo de programação que funciona com base em um princípio que gira em torno de objetos em vez de ação ou lógica. Ele permite que os usuários criem objetos com base no requisito e, em seguida, criem métodos para operar sobre esses objetos.
Trabalhar nesses objetos para obter o resultado desejado é o objetivo da programação orientada a objetos.
=> Explore toda a série de tutoriais de treinamento C # aqui
Vamos revisar alguns dos conceitos que aprendemos em nossos tutoriais anteriores !!
Namespace
Um namespace em C # é uma coleção de classes. Ele fornece uma estrutura para manter um nome de classe separado de outro nome de classe, declarando-os em um namespace diferente. Para que as classes com o mesmo nome não entrem em conflito umas com as outras.
Aula
Uma classe é um projeto de um tipo de dados. Na verdade, é uma coleção de objetos. Ele contém objetos e a definição da operação que precisa ser executada nesse objeto.
Objetos
Os objetos são as instâncias da classe.
Em nossos tutoriais anteriores, já aprendemos sobre Classes e Objetos em detalhes.
O que você aprenderá:
Conceitos OOPS em C #
A programação orientada a objetos oferece várias vantagens sobre os outros modelos de programação, como:
- A abordagem modular precisa e clara para programas oferece fácil compreensão e manutenção.
- Classes e objetos criados no projeto podem ser usados em todo o projeto.
- A abordagem modular permite que diferentes módulos existam de forma independente, permitindo que vários desenvolvedores diferentes trabalhem em diferentes módulos juntos.
Neste tutorial, vamos nos concentrar mais em outros principais conceitos OOPS:
- Encapsulamento
- Polimorfismo
- Herança
- Abstração
Encapsulamento
Encapsulamento é um conceito de programação orientado a objetos que permite aos programadores empacotar dados e fragmentos de código dentro de um invólucro. Usando o programa de encapsulamento, você pode ocultar os membros de uma classe de outra classe. É como envolver um item lógico dentro de um pacote. Ele permite apenas informações relevantes disponíveis e visíveis fora e que também apenas para membros específicos.
O encapsulamento é implementado usando especificadores de acesso. O especificador de acesso é usado para definir a visibilidade e acessibilidade do membro da classe em C #.
C # contém os seguintes especificadores de acesso.
site para converter vídeos do youtube para mp3
- Público
- Privado
- Protegido
- interno
Os especificadores de acesso definem a visibilidade da classe e seus valores. Ele permite que você torne os dados visíveis para uma parte específica do código e oculte-os de outra parte. A visibilidade mais comumente usada é pública e privada.
Vamos dar uma olhada neles.
Público: A palavra-chave public permite que seus membros sejam visíveis de qualquer lugar dentro do projeto. Este especificador de acesso tem a menor restrição de visibilidade.
Privado: Os membros privados só podem ser acessados pelo membro da mesma classe. Este tem uma das visões mais restritas.
Protegido: A acessibilidade protegida permite que o membro seja acessado de dentro da classe e de outra classe que herda essa classe.
Interno: Interno fornece acessibilidade de dentro do projeto. Outra acessibilidade interna semelhante é protegida interna. Isso permite o mesmo que o interno e a única diferença é que uma classe filha pode herdar essa classe e atingir seus membros até mesmo de outro projeto.
Polimorfismo
O polimorfismo é derivado do dicionário grego, significa um com muitas formas. Poly significa muitos e Morph significa formas. Ele permite que a classe em C # tenha várias implementações com o mesmo nome.
O polimorfismo é basicamente dividido em duas partes:
- Polimorfismo de tempo de compilação
- Polimorfismo de tempo de execução
# 1) Polimorfismo estático ou de tempo de compilação
O polimorfismo em tempo de compilação também é conhecido como polimorfismo estático. A sobrecarga de método é uma das maneiras pelas quais o polimorfismo em tempo de compilação é alcançado. É conhecido como polimorfismo de tempo de compilação, pois a decisão de chamada do método é feita no momento da compilação.
Isso é conseguido mantendo o nome do método o mesmo, mas passando diferentes conjuntos de parâmetros. Na sobrecarga do método, o sistema primeiro verifica o parâmetro usado e, com base no conjunto de parâmetros, decide chamar o método apropriado.
Exemplo:
class Program { void print(int i, int j) { Console.WriteLine('Printing int: {0}', (i+j) ); } void print(string a, string b) { Console.WriteLine('Printing String: ' , (a+b)); } static void Main(string[] args) { Program prog = new Program(); // Call print for sum of integers prog.print(5, 6); // Call to concatenate strings prog.print('Hello','World'); Console.ReadKey(); } }
No exemplo acima, chamamos o mesmo método de “imprimir” duas vezes usando parâmetros diferentes. Primeiramente, passamos dois inteiros como parâmetros, depois passamos duas strings como parâmetros. Existem dois métodos de “impressão” com o mesmo nome.
Quando passamos um parâmetro com o sistema de inteiros, ele procurará o método denominado “print” que aceita dois parâmetros inteiros e o executará ignorando outros métodos com o mesmo nome.
Na segunda parte, passamos o parâmetro string. Mais uma vez, o sistema procurará o método que aceita dois parâmetros de string. Portanto, com base nos parâmetros passados, o primeiro método adicionará dois inteiros e o próximo concatenará duas strings.
# 2) Polimorfismo Dinâmico ou Polimorfismo de Tempo de Execução
O polimorfismo de tempo de execução ou polimorfismo dinâmico ocorre quando o nome do método e a assinatura do método têm o mesmo nome e parâmetros. A substituição de método é um exemplo de polimorfismo dinâmico. Ele permite ao usuário criar uma classe abstrata com implementação parcial da interface.
A substituição do método é obtida por meio de herança. Para obter o método que substitui a classe base e a classe derivada, deve haver o mesmo nome e parâmetro. Durante o tempo de compilação, o compilador não é capaz de reconhecer o método de substituição, portanto, ele não gera nenhum erro. A decisão de executar um método é tomada durante o tempo de execução.
Exemplo:
class Program { public void print() { Console.WriteLine('Printing from class Program'); } } class Execute : Program { public void print() { Console.WriteLine('Printing from class Execute'); } public static void Main(string[] args) { Execute exe = new Execute(); exe.print(); Console.ReadLine(); } }
Se executarmos o programa acima, obteremos o seguinte resultado:
Printing from class Execute
Mesmo que a classe Execute tenha herdado todos os métodos da classe Program, mas quando chamamos o método print que está presente em ambas as classes, o método presente na classe filha sobrescreverá o método da classe pai.
O polimorfismo dinâmico é usado para implementar a abstração. Ele permite que o usuário crie uma classe abstrata que é usada para fornecer uma implementação para uma interface quando ela é herdada por uma classe derivada. A classe abstrata pode conter nomes / assinatura dos métodos e a classe derivada pode ter uma definição mais especializada para o método.
Herança
Herança é uma parte importante do conceito OOPS. Na herança, definimos classes pai e filho. A classe filha pode herdar todos os métodos, objetos e propriedades da classe pai. Uma classe filha também pode ter seus próprios métodos e implementação específica.
A classe pai também é conhecida como classe base e a classe filha que herda a classe base também é conhecida como classe derivada.
Exemplo:
class Program { public void print() { Console.WriteLine('Printing from class Program'); } } class Execute : Program { public static void Main(string[] args) { Execute exe = new Execute(); exe.print(); Console.ReadLine(); } }
Aqui, temos uma classe nomeada como um programa que possui um método. Temos outra classe Execute que herda a classe Program. A classe Execute é a classe derivada e o programa da classe é conhecido como a classe base.
Agora, em vez de criar uma instância de objeto para o programa de classe, criamos uma instância de objeto para a classe Execute. Usando esta instância, podemos acessar o método de impressão da classe base.
Portanto, a saída do código acima será:
Printing from class Program
A classe derivada não herda apenas métodos, ela também herda quase todos os membros da classe, como campos, propriedades, etc., dependendo da visibilidade. Herança em C # não permite o uso de várias heranças, ou seja, uma classe não pode herdar de várias classes diferentes, no entanto, uma classe pode herdar de outra classe que pode herdar de uma classe diferente.
Abstração
Abstração é um dos principais princípios da programação orientada a objetos. A abstração permite que o programador exiba apenas os detalhes necessários para o mundo enquanto oculta os outros. A abstração é obtida em C # usando a classe e a interface Abstract.
Uma classe pode ser declarada como uma classe abstrata usando a palavra-chave “Abstract”. A classe Abstract em C # é sempre a classe base na hierarquia. O que os torna diferentes da outra classe é que eles não podem ser instanciados. Uma classe abstrata C # precisa ser herdada.
Exemplo:
class Program { static void Main(string[] args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public void Describe() { return 'Description of the car'; } } class Hyundai : Car { }
O resultado do seguinte é:
Description of the car
Se você comparar com nossos exemplos anteriores durante a herança ou polimorfismo dinâmico, você encontrará as semelhanças. A diferença mais reconhecível é o uso da palavra-chave abstract antes da classe Car. Caso você queira substituir isso ou fornecer sua própria implementação semelhante ao que fizemos no polimorfismo dinâmico. Então você pode conseguir isso da seguinte maneira.
class Program { static void Main(string[] args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public virtual string Describe() { return 'Description of the car'; } } class Hyundai : Car { public override string Describe() { return 'Description of the car is now Hyundai'; } }
Portanto, se você executar este código agora, ele fornecerá a seguinte saída:
Description of the car is now Hyundai
O método da classe derivada substitui o método da classe base. Desta forma, você pode criar uma classe derivada diferente, como Ferrari, Porsche, BMW, etc. com seus próprios métodos de implementação.
Se você olhar com atenção, verá que nosso método de descrição na classe abstrata não contém nenhuma implementação.
Então, por que estamos definindo métodos vazios?
Isso ocorre porque uma classe Abstract fornece uma assinatura dos métodos e torna uma obrigação para as subclasses criar uma implementação para todos esses métodos. Isso permite o compartilhamento da classe base, mas, ao mesmo tempo, também mantém uma verificação da implementação do método da classe derivada.
Interface
Em C #, a interface é o projeto de uma classe. A interface é semelhante a uma classe abstrata e é usada para atingir cem por cento de abstração. Todos os métodos descritos dentro da interface são abstratos por padrão. Ele não tem nenhum corpo de método e não pode ser instanciado.
A interface é usada principalmente para obter herança múltipla e abstração completa. Toda a assinatura do método declarada dentro da interface deve ser fornecida com a implementação da classe ou da estrutura que a implementa.
Exemplo:
class Program { static void Main(string[] args) { Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } interface Car { string Describe(); } class Hyundai : Car { public string Describe() { return 'Description of the car is now Hyundai'; } }
A saída do código acima será:
Description of the car is now Hyundai
Aqui, criamos uma interface Car. Como a interface não pode ter nenhuma definição de método, fornecemos apenas o nome do método e o tipo de retorno na interface. Em seguida, implementamos a interface Car para outra classe Hyundai. Na classe implementada, fornecemos a definição dos métodos definidos dentro da interface.
Conclusão
No conceito de Programação Orientada a Objetos, cada parte do programa é tratada como um objeto. Classe é uma coleção de tipos semelhantes de elementos e um objeto é a instância da classe.
O encapsulamento em C # permite ao usuário estabelecer a visibilidade da classe e de seus membros. O polimorfismo permite que os métodos tenham o mesmo nome, mas com parâmetros diferentes dentro da mesma classe ou com o mesmo parâmetro em uma classe diferente.
Herança é quando uma classe filha, também conhecida como classe derivada, herda todas as propriedades, incluindo métodos, objetos, campos, etc. da classe pai, que também é conhecida como classe base. A abstração permite que o programa exiba apenas a assinatura, enquanto oculta os detalhes de implementação.
Programa Consolidado
class Program { void print(int i, int j) { Console.WriteLine('Printing int: {0}', (i + j)); } void print(string a, string b) { Console.WriteLine('Printing String '+ a + b); } static void Main(string[] args) { Program prog = new Program(); // Call print for sum of integers prog.print(5, 6); // Call to concatenate strings prog.print('Hello', 'World'); Hyundai hyn = new Hyundai(); String descp = hyn.Describe(); Console.WriteLine(descp); Console.ReadKey(); } } abstract class Car { public virtual string Describe() { return 'Description of the car'; } } class Hyundai : Car { public override string Describe() { return 'Description of the car is now Hyundai'; } }
=> Explore toda a série de tutoriais de treinamento C # aqui
Leitura recomendada
- OOP Java: introdução à programação orientada a objetos em Java
- Programação orientada a objetos em C ++
- Tutorial de Pipes Unix: Pipes em Programação Unix
- Tutorial Python DateTime com exemplos
- Repositório de objetos em QTP - Tutorial # 22
- Conceitos de Python OOPs (classes, objetos e herança de Python)
- QTP Tutorial # 7 - QTP's Object Identification Paradigma - Como o QTP identifica objetos de forma única?
- Aprenda os conceitos avançados de script SoapUI Groovy - Tutorial # 9 do SoapUI