A abstração de dados é a propriedade em virtude da qual apenas os detalhes essenciais são exibidos ao usuário. As unidades triviais ou não essenciais não são exibidas para o usuário. Ex: um carro é visto como um carro ao invés de seus componentes individuais.

A abstração de dados também pode ser definida como o processo de identificar apenas as características necessárias de um objeto, ignorando os detalhes irrelevantes. As propriedades e comportamentos de um objeto o diferenciam de outros objetos de tipo semelhante e também ajudam na classificação / agrupamento dos objetos.

Considere um exemplo da vida real de um homem dirigindo um carro. O homem só sabe que pisar no acelerador vai aumentar a velocidade do carro ou pisar no freio vai parar o carro, mas ele não sabe como ao pisar no acelerador a velocidade está realmente aumentando, ele não sabe sobre o mecanismo interno do carro ou a implementação do acelerador, freios, etc. no carro. Isso é abstração. 

Em java, a abstração é obtida por interfaces e classes abstratas . Podemos atingir 100% de abstração usando interfaces.

Classes abstratas e métodos abstratos:  

  1. Uma classe abstrata é aquela que é declarada com a palavra-chave abstract.
  2. Um método abstrato é um método declarado sem implementação.
  3. Uma classe abstrata pode ou não ter todos os métodos abstratos. Alguns deles podem ser métodos concretos
  4. Um método definido como abstrato deve sempre ser redefinido na subclasse, tornando assim a substituição obrigatória OU tornando a própria subclasse abstrata.
  5. Qualquer classe que contenha um ou mais métodos abstratos também deve ser declarada com a palavra-chave abstract.
  6. Não pode haver objeto de uma classe abstrata. Ou seja, uma classe abstrata não pode ser instanciada diretamente com o novo operador .
  7. Uma classe abstrata pode ter construtores parametrizados e o construtor padrão está sempre presente em uma classe abstrata.

Quando usar classes abstratas e métodos abstratos com um exemplo

Existem situações em que queremos definir uma superclasse que declare a estrutura de uma dada abstração sem fornecer uma implementação completa de todos os métodos. Ou seja, às vezes queremos criar uma superclasse que defina apenas uma forma de generalização que será compartilhada por todas as suas subclasses, cabendo a cada subclasse o preenchimento dos detalhes.

Considere um exemplo clássico de “forma”, talvez usado em um sistema de design auxiliado por computador ou simulação de jogo. O tipo base é “forma” e cada forma tem uma cor, tamanho e assim por diante. A partir disso, tipos específicos de formas são derivados (herdados) - círculo, quadrado, triângulo e assim por diante - cada um dos quais pode ter características e comportamentos adicionais. Por exemplo, certas formas podem ser invertidas. Alguns comportamentos podem ser diferentes, como quando você deseja calcular a área de uma forma. A hierarquia de tipos incorpora as semelhanças e diferenças entre as formas.
 


// Java program to illustrate the
// concept of Abstraction
abstract class Shape {
    String color;
 
    // these are abstract methods
    abstract double area();
    public abstract String toString();
 
    // abstract class can have constructor
    public Shape(String color)
    {
        System.out.println("Shape constructor called");
        this.color = color;
    }
 
    // this is a concrete method
    public String getColor() { return color; }
}
class Circle extends Shape {
    double radius;
 
    public Circle(String color, double radius)
    {
 
        // calling Shape constructor
        super(color);
        System.out.println("Circle constructor called");
        this.radius = radius;
    }
 
    @Override double area()
    {
        return Math.PI * Math.pow(radius, 2);
    }
 
    @Override public String toString()
    {
        return "Circle color is " + super.getColor()
            + "and area is : " + area();
    }
}
class Rectangle extends Shape {
 
    double length;
    double width;
 
    public Rectangle(String color, double length,
                     double width)
    {
        // calling Shape constructor
        super(color);
        System.out.println("Rectangle constructor called");
        this.length = length;
        this.width = width;
    }
 
    @Override double area() { return length * width; }
 
    @Override public String toString()
    {
        return "Rectangle color is " + super.getColor()
            + "and area is : " + area();
    }
}
public class Test {
    public static void main(String[] args)
    {
        Shape s1 = new Circle("Red", 2.2);
        Shape s2 = new Rectangle("Yellow", 2, 4);
 
        System.out.println(s1.toString());
        System.out.println(s2.toString());
    }
}
Saída
Construtor de forma chamado
Construtor de círculo chamado
Construtor de forma chamado
Construtor de retângulo chamado
A cor do círculo é a área vermelha e é: 15.205308443374602
A cor do retângulo é amarelo e a área é: 8,0

Encapsulamento vs abstração de dados

  1. O encapsulamento é a ocultação de dados (ocultação de informações), enquanto a abstração é a ocultação de detalhes (ocultação de implementação).
  2. Enquanto o encapsulamento agrupa dados e métodos que agem sobre os dados, a abstração de dados trata de expor a interface ao usuário e ocultar os detalhes de implementação.

Vantagens da abstração

  1. Reduz a complexidade de ver as coisas.
  2. Evita a duplicação de código e aumenta a capacidade de reutilização.
  3. Ajuda a aumentar a segurança de um aplicativo ou programa, pois apenas detalhes importantes são fornecidos ao usuário.

Artigos relacionados :