(Java) Sub-rotinas: procedimentos e funções - 1

A utilização de sub-rotinas permite evitar a duplicação de código, caso seja necessário escrever o mesmo código em locais diferentes do programa. 
As bibliotecas que são importadas para o programa (por exemplo, a biblioteca matemática Math) consistem em sub-rotinas que já foram compiladas por alguém. Os programadores não precisam pensar em quais algoritmos implementam, mas simplesmente aplicá-los, pensando apenas no que exatamente estão fazendo. Esta é uma grande economia de tempo. Não há necessidade de escrever um algoritmo que já foi escrito por outra pessoa.

Cada rotina deve fazer apenas uma tarefa,  apenas calcule algo, ou forneça alguns dados, ou faça outra coisa. 

Existem dois tipos de sub-rotinas - procedimentos e funções

Os subprocedimentos executam algumas ações, por exemplo, exibem o resultado na tela de uma determinada forma (um exemplo simples, o operador println()  é um subprocedimento padrão que imprime informações para o tela)

As sub-rotinas de função retornam um resultado (número, cadeia de caracteres, etc.) que podemos usar no programa principal.

Vamos tentar escrever um procedimento simples:
Suponha que precisamos exibir a string "Error" na tela toda vez que um erro pode ocorrer no código devido à falha do usuário (por exemplo, quando ele insere dados incorretos)
Isso pode ser feito escrevendo a declaração System.out.println("Erro"); E agora imagine que tal linha precise ser inserida em vários lugares do programa. Claro, você pode simplesmente escrevê-lo em todos os lugares. Mas esta solução tem duas desvantagens.
1) esta string será armazenada na memória muitas vezes
2) se quisermos alterar a saída em caso de erro, teremos que alterar esta linha ao longo do programa, o que é bastante inconveniente

Para tais casos, são necessários procedimentos.
Um programa com um procedimento pode se parecer com isto: ... static void printError() // descrição do procedimento { System.out.println("Erro"); // corpo do procedimento - comandos que o procedimento irá executar } public static void main(String[] args) { ... printError() // inicia o procedimento para execução. Apenas especificamos o nome do procedimento que queremos executar. ... printError() ... } O procedimento começa com a palavra void. Existem colchetes vazios após o nome do procedimento.
Todas as instruções executadas em um procedimento são recuadas. 

Os procedimentos são escritos antes da função principal main()

Para executar um procedimento, no programa principal você precisa chamá-lo pelo nome e lembre-se de colocar parênteses!
Você pode chamar um procedimento em um programa quantas vezes quiser.

Agora vamos imaginar que precisamos exibir diferentes mensagens em resposta ao erro de um usuário, dependendo do tipo de erro que ele cometeu.
Nesse caso, você pode escrever seu próprio procedimento para cada erro:   static void printErrorZero() { System.out.println("Erro. ​​Divisão por zero!"); } static void printErrorInput() { System.out.println("Erro na entrada!"); } E se houver muitos outros erros possíveis? Esta solução não nos convém!
Precisamos aprender a controlar o procedimento, informando qual mensagem de erro exibir.
Para fazer isso, precisamos de parâmetros que escreveremos entre parênteses após o nome do procedimento static void printError(String s) { System.out.println(s); } Neste procedimento, s é um parâmetro - uma variável especial que permite controlar o procedimento.

O parâmetro é uma variável que determina como a sub-rotina funciona. Os nomes dos parâmetros são listados separados por vírgulas no cabeçalho do subprograma. O tipo de parâmetro é escrito antes do parâmetro.

Agora, ao chamar o procedimento, você precisa indicar entre parênteses o valor real que será atribuído ao parâmetro (variável s) dentro do nosso procedimento printError("Erro! Divisão por zero!"); Esse valor é chamado de argumento.

O argumento é o valor do parâmetro que é passado para a sub-rotina quando ela é chamada.

Um argumento pode ser não apenas um valor constante, mas também uma variável ou uma expressão aritmética.

Muitas vezes é necessário utilizar variáveis ​​adicionais que serão utilizadas somente na sub-rotina. Tais variáveis ​​são denominadas locais (ou locais) e só podem ser manipuladas dentro da sub-rotina em que são criadas.
 
O programa principal em Java também é uma sub-rotina, então todas as variáveis ​​declaradas dentro de main() são variáveis ​​locais 
Outras sub-rotinas não "sabem" nada sobre as variáveis ​​locais de outras sub-rotinas.

Assim, é possível limitar o escopo (scope) de uma variável apenas à sub-rotina onde ela é realmente necessária. Na programação, essa técnica é chamada de encapsulamento  - ocultar uma variável de ser alterada de fora.

Se for necessário declarar uma variável que seria visível em qualquer lugar do programa (em qualquer sub-rotina), então tais variáveis ​​são declaradas fora de todas as sub-rotinas (ver programa 3 da tabela abaixo)
Essas variáveis ​​são chamadas globais.

Em Java, quando o programa inicia, todas as variáveis ​​globais são automaticamente zeradas (as variáveis ​​booleanas tornam-se falsas)


Analise três programas: é exibido na tela

1) Neste programa, a variável i é local. Uma variável local é declarada dentro de uma sub-rotina	2) Aqui, mesmo que exista uma variável i no programa principal (com valor 7), uma nova variável local i com valor 5 será criada.  Ao executar este programa, a tela exibirá o valor 75	3) Este programa possui uma variável global i. Seu valor pode ser alterado dentro de uma sub-rotina, e dentro do programa principal O procedimento funcionará com a variável global i e será atribuído a ela um novo valor igual a 2. O valor 2
teste de vazio estático () {   int i = 5; System.out.println(i); }	teste de vazio estático () {   int i = 5;   System.out.println(i); } public static void main(String[] args) { { int i = 7;   System.out.println(i);   teste(); }	public class Principal { int eu; teste de vazio estático () {   i = 2; } public static void main(String[] args) { { teste(); System.out.println(i); }