Modularidade em Java explicada com exemplo passo a passo [2022]

Publicados: 2021-01-02

Quando você se propõe a ser um programador Java, há uma ampla quantidade de oportunidades. Em média, um programador Java ganha cerca de US$ 69.722 por mês, o que é um bom pagamento . Saiba mais sobre o salário de desenvolvedor Java na Índia. Se você planeja ter uma carreira sólida em programação Java, a modularidade é algo que você deve aprender primeiro. É uma das partes vitais da programação de software moderna. Então, vamos primeiro entender o que é um módulo?

O que é modularidade em Java?

Um módulo é mais como uma partição independente de software que é comunicada por meio de uma interface. A modularidade explora a criação de um programa usando módulos diferentes de uma única arquitetura legada. É mais como microsserviços em uma arquitetura MVC, onde todo o sistema é um conjunto de serviços independentes.

Com modularidade, o particionamento do ambiente de software em diferentes módulos torna todo o processo mais otimizado e reduz o efeito de acoplamento. Ele ajuda os desenvolvedores Java a realizar testes de funcionalidade em movimento enquanto o processo de desenvolvimento está em andamento simultaneamente.

A modularidade em Java garante que o tempo de desenvolvimento seja reduzido com testes e depuração em tempo real.

Agora que sabemos sobre modularidade, vamos entender por que você precisa dela?

Leia: Perguntas e respostas da entrevista sobre Java

Inscreva-se em cursos de engenharia de software das melhores universidades do mundo. Ganhe Programas PG Executivos, Programas de Certificado Avançado ou Programas de Mestrado para acelerar sua carreira.

Por que precisamos da modularidade Java?

A modularidade ajuda um desenvolvedor Java de três maneiras,

Reutilização: a reutilização pode ajudar os desenvolvedores a economizar tempo usando o mesmo código ao criar uma versão mais recente do software ou aplicativo. Com a modularidade em Java, você pode reutilizar os módulos em outro lugar que não o software desenvolvido inicialmente.

Estabilidade: A modularidade ajuda a manter a estabilidade do software ao fazer alterações em seções individuais do código. Isso significa que as novas modificações permanecem ocultas dos consumidores e podem ser facilmente testadas sem afetar o software existente.

Desenvolvimento paralelo: os desenvolvedores Java podem desenvolver rapidamente módulos paralelos entre si. Uma vez que todos os módulos são desenvolvidos, eles podem ser combinados através de uma interface para criar uma suíte. Usar o desenvolvimento paralelo pode economizar tempo.

Agora vamos explorar diferentes aspectos da modularidade em Java.

Embora a modularidade tenha sido introduzida no Java 9, exploraremos o conceito do Java 11 com um exemplo simples de criação de uma calculadora. Vamos criar uma calculadora simples e avançada que verifica os números primos, calcula sua soma, se um número é par ou não.

Passo 1: Criando o módulo

O primeiro passo é criar módulos, e você pode optar por criar vários módulos de acordo com a complexidade. Aqui, estamos criando dois módulos distintos,

  1. Matemática. módulo útil
  2. Módulo calculadora

O primeiro módulo possui uma API ou Application Program Interface para execução de cálculos matemáticos. Ao mesmo tempo, o segundo módulo inicia a calculadora.

Passo 2: Executando os módulos

Executaremos o módulo da API no navegador implementando-o na classe com.upgrad.math.MathUtil,

public static Boolean isPrime(Número inteiro){

if ( número == 1 ) { return false; }

return IntStream.range(2,num).noneMatch(i -> num % i == 0 );

}

Podemos verificar o módulo com uma função.

public static Boolean isEven(Número inteiro){

número de retorno % 2 == 0;

}

Se você está pensando em verificar se os números são pares ou ímpares, podemos executar outra função.

public static Integer sumOfFirstNEvens(contagem de inteiros){

return IntStream.iterate(1,i -> i+1)

.filter(j -> éPar(j))

.limit(count).sum();

}

public static Integer sumOfFirstNOdds(Integer count){ return IntStream.iterate(1,i -> i+1) .filter(j -> !isEven(j)) .limit(count).sum(); }

Até agora, executamos duas funções nos modelos da API e fizemos as seguintes observações.

  • Existe uma sequência infinita a partir do número 1
  • A filtragem de números é repetida.
  • O fluxo de números é limitado.
  • Encontrando a soma dos números

Com base nessas observações, um desenvolvedor pode refatorar a API e executá-la.

Inteiro computaFirstNSum(Contagem de inteiros,

Filtro IntPredicate){

return IntStream.iterate(1,i -> i+1)

.filter(filtro)

.limit(count).sum();

}

Aqui, precisamos encontrar a soma dos números que é limitada pela contagem. Também precisaremos encontrar o filtro para números em condições para as quais a soma será executada.

Vamos recriar as APIs com base nas novas condições que exploramos.

public static Integer sumOfFirstNPrimes(contagem de inteiros){

return computeFirstNSum(count, (i -> isPrime(i)));

}

public static Integer sumOfFirstNEvens(Integer count){ return computeFirstNSum(count, (i -> isEven(i))); }

public static Integer sumOfFirstNOdds(Integer count){ return computeFirstNSum(count, (i -> !isEven(i)));

Agora que testamos as APIs e as refatoramos, vamos colocar a classe com.upgrad.math.MathUtil em um módulo.

Etapa 3: Inserindo classe de utilitário em um módulo

Para inserir uma pequena classe de utilitário no módulo chamado math. util, você precisa seguir algumas convenções como

  • Coloque todo o código relacionado ao módulo da API em um diretório de mesmo nome e use-o como diretório raiz.
  • Insira module-info.java na pasta raiz
  • Coloque todos os pacotes e códigos no diretório raiz.

Etapa 4: Criando uma definição de módulo para calculadora

Vamos criar um módulo de uma calculadora que requer math.utl.

calculadora de módulo{

requer math.util;

}

Podemos compilar o código seguindo,

javac -d mods –module-source-path . $(encontrar . -name “*.java”)

Assim que compilarmos os códigos dos módulos calculadora e math.utl no diretório mods, um único comando incluirá dependências entre esses dois módulos, o que é feito através de um compilador. Não há necessidade de criar ferramentas dedicadas para criar dependências entre calculadora e maths.utl.

Passo 5: Execute o código

Uma vez que você tenha os módulos no diretório mods e as dependências no lugar, agora é a hora de executar o código. A execução colocará nossa calculadora simples e avançada em ação.

java –module-path mods -m calculator/com.upgrad.calculator.Calculator

Deve ler: Projetos e tópicos Java interessantes

Conclusão

De acordo com uma pesquisa , Java é a segunda linguagem preferida em termos de um novo anúncio de emprego, o que o torna uma ótima opção para iniciantes.

Se você estiver interessado em aprender mais sobre Java, OOPs e desenvolvimento de software full-stack, confira o Programa PG Executivo do upGrad & IIIT-B em Desenvolvimento de Software Full-stack, projetado para profissionais que trabalham e oferece mais de 500 horas de treinamento rigoroso, Mais de 9 projetos e atribuições, status de ex-alunos do IIIT-B, projetos práticos práticos e assistência de trabalho com as principais empresas.

Prepare-se para uma carreira do futuro

Inscreva-se agora para Mestrado em Engenharia de Software