Inicializar variável

Programação Java
#1

Bom dia.

Por que o compilador exige que eu inicialize a variável antes de usar?

import javax.swing.JOptionPane;
import java.text.NumberFormat;

public class C0814Exercicio5{

public static void main (String[]args) {

  NumberFormat nf = NumberFormat.getCurrencyInstance();
  String nome;
  float salario = 0;
  byte i = 1;
  byte aliquota_inss = 0;
  float inss = 0;
  float aliquota_ir = 0;
  float ir = 0;
  float salario_liquido = 0;
  String relatorio = "";
  float total_salario = 0;
  float total_inss = 0;
  float total_ir = 0;
  float total_salario_liquido = 0;
  
  while (true) {
  	nome = JOptionPane.showInputDialog(null,"Informe o nome do funcionário: " + i);
  	//Tratamento do nome
  	if (nome == null) {
  		break;
  	}
  	
  	if(nome.length() <2 || nome.length()>30) {
  		JOptionPane.showMessageDialog(null, "O nome deve conter de 2 a 30 caracteres","Erro",0);
  		continue;
  	}
  	
  	//Tratamento do salário
  	while (true) {
  		salario = Float.valueOf(JOptionPane.showInputDialog(null,"Informe o salário do funcionário: " + i));

  		if (salario < 465) {
  			JOptionPane.showMessageDialog(null, "O salário deve ser um valor igual ou superior a R$ 465");
  			continue;
  		}
  		
  		//Tratamento da aliquota
  		if (salario < 965.67) {
  			aliquota_inss = 8;
  		}
  		
  		if (salario < 1609.45) {
  			aliquota_inss = 9;
  		}
  		
  		if (salario < 3218.90) {
  			aliquota_inss = 11;
  		}
  		
  		inss = (salario * aliquota_inss)/100;
  		
  		//Tratamento do IR
  		if (salario < 1434) {
  			aliquota_ir = 0f;
  		}
  		
  		if (salario < 2150) {
  			aliquota_ir = 7.5f;
  		}
  		
  		if (salario < 2886) {
  			aliquota_ir = 15f;
  		}
  		
  		if (salario < 3582) {
  			aliquota_ir = 22.5f;
  		}else {
  			aliquota_ir = 27.5f;
  		}
  		
  		ir = (salario * aliquota_ir)/100;
  		
  		if (inss < 354.08) {
  			salario_liquido = salario - ir;
  		}else {
  			salario_liquido = salario - inss - ir;
  		}			
  		
  		total_salario += salario;
  		total_inss += inss;
  		total_ir += ir;
  		total_salario_liquido += salario_liquido;
  		
  		relatorio += i + ": " + nome + " - " + nf.format(salario) + " - " + nf.format(inss) + " - " + nf.format(ir) + " = " + nf.format(salario_liquido) + "\n";
  		break;
  	}
  	i++;
  	continue;
  }//Primeiro while
  
  if (relatorio != null) { 
  	JOptionPane.showMessageDialog(null, "RELATÓRIO DA FOLHA DE PAGAMENTO: \n\n" + relatorio + 
  								  "\n\n TOTAIS: " + i + " funcionários: " +
  									nf.format(total_salario) + " - " +
  									nf.format(total_inss) + " - " +
  									nf.format(total_ir) + " - " +
  									nf.format(total_salario_liquido));
  }
  
  System.exit(0);

}
}

#2

Pode-se responder com outra pergunta: Em que situação você utilizaria uma variável não inicializada?

1 curtida
#3

No momento da execução. No algoritmo exemplificado, o usuário daria um valor para a variável salário como valor de entrada e depois o processamento seguiria seu fluxo, validações etc.

Falando nisso, só mais algumas dúvidas:

  1. numa String null é diferente de “” ?
  2. Como seria o null de um tipo numérico?

Obrigado.

#5

Esse problema não é notado em Java, mas em C sim, se você usar uma variavel sem inicializa-la, estara usando o que estiver dentro do endereço dela.

O que acontece?

int x; //reserva um endereço da memoria para tipo inteiro.

printf(x); //mostra os dados que estiverem naquele endereço,
sujeira. 1x0c2c1

x = 1; //sobrescrever os dados daquele endereço com o novo dado que no caso é 1.

printf(1); //1.

por isso o compilador não te permite usar uma variavel sem inicializa-la.

1 curtida
#6

Neste momento você estaria inicializando a variável e não lendo ela.

Sim é diferente, null é quando uma variável de tipo de dado não primitivo não foi inicializada e "" é um objeto do tipo String sem nenhum caractere.

Acho que você confundiu tipo numérico com tipo primitivo.
Não há null para tipos primitivos.

Acredito que você também está confundindo variáveis locais com variáveis de classe e variáveis de instância.
Variáveis de classe e variáveis de instância, se não forem explicitamente inicializadas, recebem um valor padrão, conforme abaixo:

Tipos Primitivos:
    byte    = 0
    boolean = false
    short   = 0
    char    = '\u0000'
    int     = 0
    float   = 0.0F
    long    = 0
    double  = 0.0

Tipos não Primitvos = null

Variáveis locais não são inicializadas com nenhum valor padrão, por isso você estava com erro de compilação, você tentou ler o conteúdo de uma variável não inicializada e o compilador “enxerga” essa mancada.

2 curtidas