Pausa para café #133. Como obter apenas parte de um array em Java. Interfaces e classes abstratas em Java

Como obter apenas parte de um array em Java

Fonte: Asyncq Copiar parte de um array é uma operação muito comum que todo desenvolvedor encontra. Neste artigo, veremos o estilo imperativo tradicional e o código de estilo declarativo moderno com expressão lambda e API de streaming.

Abordagem imperativa

O estilo de programação imperativo é comum em Java há muito tempo. Portanto, é natural que os desenvolvedores Java escrevam o código abaixo para copiar uma parte específica do array original. Para fazer isso, basta percorrer os elementos, filtrando apenas aqueles que são necessários, e gravá-los no array final.

private static int[] copyArray(){
       int[] numbers = {1,2,3,4,5,6,7};
       int[] subArray = new int[numbers.length-3];
       int j =3;
       for (int i=0;i<subArray.length;i++){
           subArray[i] = numbers[j+i];
       }
       System.out.println(Arrays.toString(subArray));
       return subArray;
   }

Muitos de nós muitas vezes esquecemos que a biblioteca Java Arrays possui um método copyOfRange conveniente . Este método pode ser usado para copiar parte de um array passando de e para o índice.

private static int[] copyArray1(){
  int[] numbers = {1,2,3,4,5,6,7};
  int[] subArray = Arrays.copyOfRange(numbers,3,numbers.length);
  System.out.println(Arrays.toString(subArray));
  return subArray;
}

Abordagem declarativa

Desde o Java 8 podemos usar a API Streams para copiar parte de um array. No código abaixo, podemos passar int[] e filtrar apenas valores maiores que 3 e finalmente copiá-los em um array.

private static void copyArray2(){
        int[] numbers = {1,2,3,4,5,6,7};
        // copy with values
        int[] subArray = Arrays.stream(numbers).filter(a-> a>3).toArray();
        System.out.println(Arrays.toString(subArray));
    }

O código acima é uma cópia baseada em valor de uma parte do array, mas também podemos copiar com base em um índice. Abaixo do código transmitimos Intstream de i=0; i=len(matriz) . Normalmente, em código imperativo, escrevemos um loop for do índice inicial ao índice final e iteramos sobre cada elemento. Podemos fazer a mesma coisa usando Intstream e acessar o elemento index .

// copy with index
int[] subArray1 = IntStream
                .range(0, numbers.length)
                .filter(i -> i > 3)
                .map(a->numbers[a]).toArray();

System.out.println(Arrays.toString(subArray1));

Embora o método acima funcione, temos outra maneira de usar AtomicInteger para copiar parte do array. Possui um método getAndIncrement que essencialmente fornece um índice e o incrementa em 1.

// copy with index
AtomicInteger atomicInteger = new AtomicInteger();
int[] subArray2 = Arrays.stream(numbers).filter(i -> atomicInteger.getAndIncrement() > 3).toArray();
System.out.println(Arrays.toString(subArray2));

Conclusão

Neste artigo, discutimos como você pode copiar parte de um array Java usando estilos imperativos e declarativos. Eu preferiria trabalhar em estilo declarativo, pois torna meu código mais legível e menos detalhado.

Interfaces e classes abstratas em Java

Fonte: Devgenius Ao aprender a linguagem Java, certamente nos deparamos com um conceito chamado Interfaces. As interfaces são um dos principais recursos do Java, portanto, todo desenvolvedor deve saber como usá-las. É importante lembrar que as interfaces têm vantagens e desvantagens. Vamos nos aprofundar na compreensão das interfaces. Ao implementar interfaces, encontramos classes abstratas. O que são classes abstratas? Para que eles são necessários? O que é uma interface? Como eles são usados? Por que as interfaces usam classes abstratas? Você obterá respostas para todas essas perguntas neste artigo.

O que é uma interface?

Uma interface é um mecanismo especial em Java que descreve o comportamento e ajuda a obter abstração. É semelhante a uma classe em muitos aspectos porque possui constantes estáticas e métodos abstratos. As interfaces só podem ter métodos abstratos (métodos sem corpo). Breve diferença entre interface e classe abstrata:

• A interface não possui nenhum método implementado; todos são públicos e não há variáveis ​​de classe.
• Uma classe abstrata é uma classe que não possui um ou mais métodos implementados.

Desde o Java 9, também podemos usar métodos private , default e static em interfaces . Agora vamos passar para a lógica de interface simples usada para alcançar a abstração.

O que é abstração?

Vamos dar um exemplo da vida real. Todos nós usamos aplicativos em nossos celulares. Sempre que quisermos utilizar qualquer aplicativo, temos que criar uma conta nele. Quando nos cadastramos através do nosso número de telefone, uma senha de uso único é enviada para o nosso celular. Sabemos que a senha é recebida após clicar no botão “Obter Senha” do aplicativo, mas não sabemos como funciona esse sistema no backend e o que realmente acontece após clicar no botão. Agora, o processo de concluir tarefas com êxito sem mostrar ao usuário o que realmente está acontecendo no back-end é conhecido como abstração. Em Java, podemos obter abstração usando interfaces e classes abstratas.

Por que usar a interface?

Existem três razões para usar a interface:

• Para alcançar a abstração.
• Para oferecer suporte à funcionalidade de herança múltipla.
• Para conseguir um acoplamento fraco.

Como usar a interface?

Uma interface é declarada usando a palavra-chave interface . Fornece abstração, ou seja, declara a estrutura da classe. Todos os métodos em uma interface são abstratos e definidos como public, static e final por padrão ( public , static , final ). Qualquer classe que implemente uma interface deve implementar todos os métodos declarados na interface.

interface <interface_name>{

     // declare constant fields
     // declare methods that abstract
     // by default.
 }

Semelhante à abstração de interface, a abstração também pode ser alcançada usando classes abstratas.

O que são classes abstratas?

Classes abstratas são classes com a palavra-chave abstrata na frente delas. Eles contêm métodos abstratos e concretos (com corpo). Classes abstratas não podem ser instanciadas, elas devem ser estendidas e seus métodos implementados. Uma classe abstrata descreve algum objeto abstrato (carro, pessoa, etc.), não apenas comportamento. Lembrar:

• Uma classe abstrata deve ser declarada com a palavra-chave abstract .
• Pode haver métodos abstratos e não abstratos.
• Uma instância de uma classe abstrata não pode ser criada.
• Pode ter construtores e métodos estáticos.
• Pode ter métodos finais que forçarão a subclasse a não alterar o corpo do método.

Exemplo de uma classe abstrata com um método abstrato: Neste exemplo , Bike é uma classe abstrata que contém apenas um método abstrato executado. Sua implementação é fornecida pela classe Honda .

abstract class Bike{
  abstract void run();
}
class Honda4 extends Bike{
void run(){System.out.println("running safely");}
public static void main(String args[]){
 Bike obj = new Honda4();
 obj.run();
}
}

Classe abstrata tendo um construtor, membro de dados e métodos: Uma classe abstrata pode ter um membro de dados, método abstrato, corpo de método (método não abstrato), construtor e até mesmo um método main() .

//Example of an abstract class that has abstract and non-abstract methods
 abstract class Bike{
   Bike(){System.out.println("bike is created");}
   abstract void run();
   void changeGear(){System.out.println("gear changed");}
 }
//Creating a Child class which inherits Abstract class
 class Honda extends Bike{
 void run(){System.out.println("running safely..");}
 }
//Creating a Test class which calls abstract and non-abstract methods
 class TestAbstraction2{
 public static void main(String args[]){
  Bike obj = new Honda();
  obj.run();
  obj.changeGear();
}
}

Agora surge a questão principal. Se interfaces e classes abstratas ajudam na abstração, qual é melhor usar? A resposta é que Java não suporta herança múltipla como o C++. Ou seja, se precisarmos obter herança múltipla, devemos usar interfaces. Ou seja, classes abstratas auxiliam de 1 a 100% dos casos, e interfaces auxiliam em 100% dos casos. Se precisarmos de comportamento, precisamos usar uma interface. Se estamos falando de um objeto conceitual, devemos usar uma classe abstrata.

Exemplo de interface Java

Neste exemplo, a interface Drawable possui apenas um método. Sua implementação é fornecida pelas classes Rectangle e Circle . Num cenário real, a interface é definida por outra pessoa e a sua implementação é fornecida por diferentes fornecedores de implementação. Além disso, está sendo usado por outra pessoa. Parte da implementação é ocultada pelo usuário por meio da interface.

//Interface declaration: by first user
interface Drawable{
void draw();
}
//Implementation: by second user
class Rectangle implements Drawable{
public void draw(){System.out.println("drawing rectangle");}
}
class Circle implements Drawable{
public void draw(){System.out.println("drawing circle");}
}
//Using interface: by third user
class TestInterface1{
public static void main(String args[]){
Drawable d=new Circle();//In real scenario, object is provided by method e.g. getDrawable()
d.draw();
}}

Herança múltipla em Java usando interface

Se uma classe implementa múltiplas interfaces ou uma interface estende múltiplas interfaces, isso é chamado de herança múltipla.

interface Printable{
void print();
}
interface Showable{
void show();
}
class A7 implements Printable,Showable{
public void print(){System.out.println("Hello");}
public void show(){System.out.println("Welcome");}

public static void main(String args[]){
A7 obj = new A7();
obj.print();
obj.show();
 }
}

Pergunta: Herança múltipla não é suportada através de uma classe em Java, mas é possível através de uma interface, por quê? Conforme já explicado na seção sobre herança, a herança múltipla não é suportada no exemplo da classe devido à ambiguidade. No entanto, é suportado pelo exemplo de interface porque não há ambiguidade nele. A razão é que sua implementação é fornecida pela classe de implementação.