Iniciando em Java

/*
 * 1- perguntar qual o tamanho do vetor -> n (salário)
 * 2- de 0 até (n-1)
 *      1- digitar um número
 * 3- ao final, dizer
 *      1- a média
 *      2- o menor
 *      3- o maior  
 */

package teste2;

public class aula_18_08 {

    public static void main(String[] args) {
        System.out.println("Informe o número de meses:");
        int m = keyboard.readInt(); // recebe o número de meses
        int[] meses; // declarando vetor
        meses = new int[m]; // criando vetor
        
        // joga os salários para dentro dentro do vetor
        int soma = 0, menor = 0, maior = 0;
        for(int i = 0; i < m; i++){
            System.out.println("Informe o salário recebido:");
            meses[i] = keyboard.readInt();
            soma += meses[i]; // faz a soma dos salários
            
            // menor
            if(meses[i] <= meses[0]){
                menor = meses[i];
            }
            
            // maior
            if(meses[i] >= meses[0]){
                maior = meses[i];
            }
       }
        
        // média
        float media;
        media = soma/m;
        System.out.println("A media é " + media);
        
        // menor
        for(int i = 0; i < m; i++){
            
            if(meses[i] <= meses[i+1]){
                menor = meses[i];
                        
                      
            }
        }
        
        System.out.println("O menor salário é " + menor);
        
        // maior
        System.out.println("O maior salário é " + maior);
    }

}

float salario = 0;

float temp = 0;

float compareMaior=0;

float compareMenor=[telefone removido];

for()

{

salario += temp = Float.parseFloat(JOptionPane.showInputDialog(null,“Digite o salário:”,“Salário”,JOptionPane.QUESTION_MESSAGE));

if( temp>compareMaior) compareMaior=temp;

if( temp<compareMenor) compareMenor=temp;

}

package javaapplication2;

public class Main {

    public static void main(String[] args) {
        keyboard = new Scanner(System.in);

        System.out.println("Informe o número de meses:");
        int m = keyboard.readInt(); // recebe o número de meses
        int[] meses; // declarando vetor
        meses = new int[m]; // criando vetor
        
        // joga os salários para dentro dentro do vetor
        int soma = 0, menor = 0, maior = 0;
        for(int i = 0; i < m; i++){
            System.out.println("Informe o salário recebido:");
            meses[i] = keyboard.readInt();
            soma += meses[i]; // faz a soma dos salários
            
            // menor
            if(meses[i] <= meses[0]){
                menor = meses[i];
            }
            
            // maior
            if(meses[i] >= meses[0]){
                maior = meses[i];
            }
       }
        
        // média
        float media;
        media = soma/m;
        System.out.println("A media é " + media);
        
        // menor
        for(int i = 0; i < m; i++){
            
            if(meses[i] <= meses[i+1]){
                menor = meses[i];
                        
                      
            }
        }
        
        System.out.println("O menor salário é " + menor);
        
        // maior
        System.out.println("O maior salário é " + maior);
    }

}

package teste2;

/**
 *
 * @author ra0896359
 */
public class JAVA_180808 {
  
  public static void main(String[] args) {
{
		int meses;
		int contador; //eh o mesmo usado como variavel "i". Vou usar no for
		//Declarando vetor. Note que o tamanho dele ainda nao foi definido.
		//O tamanho dele vai ser definido conforme entrada do usuario (meses)
		int[] vet;
		System.out.println("Digite o numero de meses:");
		meses = keyboard.readInt();
		//Construindo Vetor. Agora eu estou definindo o tamanho do vetor.
		vet = new int[meses];
		//Preenchendo Vetor......
		for (contador=0;contador<meses;contador++)
		{
			//o + serve para concatenar.
			//No caso, eu concateno a frase com o contador, que � o numero do mes
			System.out.println("Digite o salario do " + (contador+1) + " mes: ");
			vet[contador] = keyboard.readInt(); 
		}
		
		//Mostrando o Vetor
		System.out.print("["); //So enfeite
		for (contador=0;contador<meses;contador++)
		{
			System.out.print(vet[contador] + " ");
		}
		System.out.print("]"); //So enfeite
		
		//Media
		int soma = 0;
		for (contador=0;contador<meses;contador++)
		{
			soma = soma + vet[contador];
		}
		float media = soma/meses;
		System.out.print("A soma eh: " + soma);
		System.out.println("A m�dia eh: " + media);
		
		//Maior Valor
		int maior = vet[0];
		for (contador=1;contador<meses;contador++)
		{
			if (maior < vet[contador])
			{
				System.out.println(maior + " eh menor que: " + vet[contador] + ". Mudando valor.");
				maior = vet[contador];
			}
			else
			{
				System.out.println(maior + " eh maior que: " + vet[contador] + ". Mantendo valor.");
			}
		}
		
		//Menor Valor
		int menor = vet[0];
		for (contador=1;contador<meses;contador++)
		{
			if (menor > vet[contador])
			{
				System.out.println(menor + " eh maior que: " + vet[contador] + ". Mudando valor.");
				menor = vet[contador];
			}
			else
			{
				System.out.println(menor + " eh menor que: " + vet[contador] + ". Mantendo valor.");
			}
		}

		System.out.println("Media : " + media);
	        System.out.println("Maior : " + maior);
		System.out.println("Menor : " + menor);
}
  }
}

/*
  Name:        Keyboard.java
  Copyright:   Version 1.0
  Author:      Lewis and Loftus
  Date:        02/03/2005
  Description: Facilitates keyboard input by abstracting details about input
					parsing, conversions, and exception handling.
  Updates:
  	10/11/2005 - Rodrigo L. S. Silva - readLine Method created
*/
package teste2;
import java.io.*;
import java.util.*;

public class keyboard
{
   //*************  Error Handling Section  **************************
   private static boolean printErrors = true;
   private static int errorCount = 0;

   //-----------------------------------------------------------------
   //  Returns the current error count.
   //-----------------------------------------------------------------
   public static int getErrorCount()
   {
      return errorCount;
   }

   //-----------------------------------------------------------------
   //  Resets the current error count to zero.
   //-----------------------------------------------------------------
   public static void resetErrorCount (int count)
   {
      errorCount = 0;
   }

   //-----------------------------------------------------------------
   //  Returns a boolean indicating whether input errors are
   //  currently printed to standard output.
   //-----------------------------------------------------------------
   public static boolean getPrintErrors()
   {
      return printErrors;
   }

   //-----------------------------------------------------------------
   //  Sets a boolean indicating whether input errors are to be
   //  printed to standard output.
   //-----------------------------------------------------------------
   public static void setPrintErrors (boolean flag)
   {
      printErrors = flag;
   }

   //-----------------------------------------------------------------
   //  Increments the error count and prints the error message if
   //  appropriate.
   //-----------------------------------------------------------------
   private static void error (String str)
   {
      errorCount++;
      if (printErrors)
         System.out.println (str);
   }

   //*************  Tokenized Input Stream Section  ******************

   private static String current_token = null;
   private static StringTokenizer reader;

   private static BufferedReader in = new BufferedReader
      (new InputStreamReader(System.in));

   //-----------------------------------------------------------------
   //  Gets the next input token assuming it may be on subsequent
   //  input lines.
   //-----------------------------------------------------------------
   private static String getNextToken()
   {
      return getNextToken (true);
   }

   //-----------------------------------------------------------------
   //  Gets the next input token, which may already have been read.
   //-----------------------------------------------------------------
   private static String getNextToken (boolean skip)
   {
      String token;

      if (current_token == null)
         token = getNextInputToken (skip);
      else
      {
         token = current_token;
         current_token = null;
      }

      return token;
   }

   //-----------------------------------------------------------------
   //  Gets the next token from the input, which may come from the
   //  current input line or a subsequent one. The parameter
   //  determines if subsequent lines are used.
   //-----------------------------------------------------------------
   private static String getNextInputToken (boolean skip)
   {
      final String delimiters = " \t\n\r\f";
      String token = null;

      try
      {
         if (reader == null)
            reader = new StringTokenizer
               (in.readLine(), delimiters, true);

         while (token == null ||
                ((delimiters.indexOf (token) >= 0) && skip))
         {
            while (!reader.hasMoreTokens())
               reader = new StringTokenizer
                  (in.readLine(), delimiters,true);

            token = reader.nextToken();
         }
      }
      catch (Exception exception)
      {
         token = null;
      }

      return token;
   }

   //-----------------------------------------------------------------
   //  Returns true if there are no more tokens to read on the
   //  current input line.
   //-----------------------------------------------------------------
   public static boolean endOfLine()
   {
      return !reader.hasMoreTokens();
   }

   //*************  Reading Section  *********************************

   //-----------------------------------------------------------------
   //  Returns a string read from standard input.
   //-----------------------------------------------------------------
   public static String readString()
   {
      String str;

      try
      {
         str = getNextToken(false);
         while (! endOfLine())
         {
            str = str + getNextToken(false);
         }
      }
      catch (Exception exception)
      {
         error ("Error reading String data, null value returned.");
         str = null;
      }
      return str;
   }

   //-----------------------------------------------------------------
   //  Returns a string read from standard input.
   //-----------------------------------------------------------------
   public static String readLine()
   {
      String str;

      try
      {
         str = getNextToken(false);
         while (! endOfLine())
         {
            str = str + getNextToken(false);
         }
      }
      catch (Exception exception)
      {
         error ("Error reading String data, null value returned.");
         str = null;
      }
      return str;
   }

   //-----------------------------------------------------------------
   //  Returns a space-delimited substring (a word) read from
   //  standard input.
   //-----------------------------------------------------------------
   public static String readWord()
   {
      String token;
      try
      {
         token = getNextToken();
      }
      catch (Exception exception)
      {
         error ("Error reading String data, null value returned.");
         token = null;
      }
      return token;
   }

   //-----------------------------------------------------------------
   //  Returns a boolean read from standard input.
   //-----------------------------------------------------------------
   public static boolean readBoolean()
   {
      String token = getNextToken();
      boolean bool;
      try
      {
         if (token.toLowerCase().equals("true"))
            bool = true;
         else if (token.toLowerCase().equals("false"))
            bool = false;
         else
         {
            error ("Error reading boolean data, false value returned.");
            bool = false;
         }
      }
      catch (Exception exception)
      {
         error ("Error reading boolean data, false value returned.");
         bool = false;
      }
      return bool;
   }

   //-----------------------------------------------------------------
   //  Returns a character read from standard input.
   //-----------------------------------------------------------------
   public static char readChar()
   {
      String token = getNextToken(false);
      char value;
      try
      {
         if (token.length() > 1)
         {
            current_token = token.substring (1, token.length());
         } else
            current_token = null;

         value = token.charAt (0);
      }
      catch (Exception exception)
      {
         error ("Error reading char data, MIN_VALUE value returned.");
         value = Character.MIN_VALUE;
      }

      return value;
   }

   //-----------------------------------------------------------------
   //  Returns an integer read from standard input.
   //-----------------------------------------------------------------
   public static int readInt()
   {
      String token = getNextToken();
      int value;
      try
      {
         value = Integer.parseInt (token);
      }
      catch (Exception exception)
      {
         error ("Error reading int data, MIN_VALUE value returned.");
         value = Integer.MIN_VALUE;
      }
      return value;
   }

   //-----------------------------------------------------------------
   //  Returns a long integer read from standard input.
   //-----------------------------------------------------------------
   public static long readLong()
   {
      String token = getNextToken();
      long value;
      try
      {
         value = Long.parseLong (token);
      }
      catch (Exception exception)
      {
         error ("Error reading long data, MIN_VALUE value returned.");
         value = Long.MIN_VALUE;
      }
      return value;
   }

   //-----------------------------------------------------------------
   //  Returns a float read from standard input.
   //-----------------------------------------------------------------
   public static float readFloat()
   {
      String token = getNextToken();
      float value;
      try
      {
         value = (new Float(token)).floatValue();
      }
      catch (Exception exception)
      {
         error ("Error reading float data, NaN value returned.");
         value = Float.NaN;
      }
      return value;
   }

   //-----------------------------------------------------------------
   //  Returns a double read from standard input.
   //-----------------------------------------------------------------
   public static double readDouble()
   {
      String token = getNextToken();
      double value;
      try
      {
         value = (new Double(token)).doubleValue();
      }
      catch (Exception exception)
      {
         error ("Error reading double data, NaN value returned.");
         value = Double.NaN;
      }
      return value;
   }
}