Até o momento, em nosso curso de Java, sempre especificamos o número exato de argumentos que um método pode receber.
Quando estudarmos Arrays e ArrayLists logo mais veremos que podemos passar uma quantidade qualquer de valores aos métodos.Há, porém, uma outra maneira de fazer isso em Java, através das reticências: ...
Com o uso desse artifício, podemos passar um, dois, três ou um número qualquer de argumentos para um mesmo método que ele vai saber como tratar esses dados.
Sintaxe:
Na hora de declarar seu método, use as reticências logo após o tipo do parâmetro:tipo_de_retorno nomeDoMétodo( tipo... nomeDoParametro ){
//código do seu method
}
Pronto.
O Java é esperto o bastante para saber que 'nomeDoParametro' é, na verdade, uma lista de valores.
Exemplo de uso
Código Java: Crie um aplicativo que receba 5 valores do usuário e calcule a média dos 5, dos primeiros 4, 3 e 2 valores inseridos. Use apenas um método que receba uma lista de argumentos de tamanho qualquer.import java.util.Scanner;
public class medias{
public static float media(float... valores){
float media=0;
for(float valor: valores){
media +=valor;
}
return media/valores.length;
}
public static void main(String[] args){
float valor1, valor2, valor3, valor4, valor5;
Scanner entrada = new Scanner(System.in);
System.out.print("Entre com o valor 1: ");
valor1 = entrada.nextFloat();
System.out.print("Entre com o valor 2: ");
valor2 = entrada.nextFloat();
System.out.print("Entre com o valor 3: ");
valor3 = entrada.nextFloat();
System.out.print("Entre com o valor 4: ");
valor4 = entrada.nextFloat();
System.out.print("Entre com o valor 5: ");
valor5 = entrada.nextFloat();
System.out.println("A média dos 5 números é: "+media(valor1,valor2,valor3,valor4,valor5));
System.out.println("A média dos 4 primeiros números é: "+media(valor1,valor2,valor3,valor4));
System.out.println("A média dos 3 primeiros números é: "+media(valor1,valor2,valor3));
System.out.println("A média dos 2 primeiros números é: "+media(valor1,valor2));
}
}
Nesse exemplo, usamos um tipo especial de laço for, que usaremos bastante em Arrays.
Mas não se assuste, ele é bem fácil de entender: ele simplesmente percorre todos os elementos de uma lista de variáveis.
No nosso caso, nossa lista de variáveis é 'valores'. Por que lista de valores?
Ora, porque não é um só valor. Podemos mandar um, dois, três...mil valores.
Usando esse tipo de laço for, ele vai percorrer, sempre, TODOS os valores dessa lista de variáveis.
A cada iteração, cada valor dessa lista será atribuído a variável 'valor'.
A lógica do laço é somar cada elemento da lista, ou seja, soma 'valor' à variável 'media'.
Ao final do cálculo, dividimos o valor dessa variável 'media' pelo número de elementos da lista.
Esse número está armazenado em um método chamado length e pode ser acessado através de: media.length
Essa é uma propriedade especial dessa lista de valores. Ela já vai com um conjunto de informações. Uma dessas informações é o seu número de elementos.
Você aprenderá mais sobre essas 'listas' de valores quando estudar Arrays.
Sábio, esse Java, não?
Exercício:
Um professor, muito legal, fez 3 provas durante um semestre mas só vai levar em conta as duas notas mais altas para calcular a média.
Faça uma aplicação em Java que peça o valor das 3 notas, mostre como seria a média com essas 3 provas, a média com as 2 notas mais altas, bem como sua nota mais alta e sua nota mais baixa. Essas médias devem ser calculadas usando o mesmo método, pois você é um programador Java e não vai ficar criando métodos à toa.
Crie outro método que receba as 3 notas e retorna a maior delas. E outro que retorna a menor.
Solução
18 comentários:
EU me confundi na hora de fazer o exercício, no enunciado da questão diz para fazermos as medias usando o mesmo metodo, tentei fazer, mas gostaria de saber como retornar mais de um valor float por exemplo. Na solução vc s fizeram varios metodos, assim fica mais facil
Oi "Anônimo": Tive a mesma dúvida que você no começo, mas o negócio não é retornar mais de um valor e sim criar um método que receba qualquer quantidade de valores. Como o exemplo acima onde é passada uma lista ao método média. "media(float... valores);"
Dessa forma é possível que um único método realize a média de 2,3...n elementos.
Pensei muito pra descobrir a 2 maior nota, e decidi fazer desse modo (foi o mais facil que achei):
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package Utilitarios;
import java.util.Scanner;
/**
*
* @author Rafael
*/
public class Notas_Medias_Metodos {
public static float media(float... valores) {
float media = 0;
for (float valor:valores) {
media+=valor;
}
return media/valores.length;
}
public static float maiornota(float nota1, float nota2, float nota3) {
float maior;
maior = Math.max(Math.max(nota1, nota2), nota3);
return maior;
}
public static float menornota(float nota1, float nota2, float nota3) {
float menor;
menor = Math.min(Math.min(nota1, nota2), nota3);
return menor;
}
public static void main(String[] args) {
float valor1, valor2, valor3;
Scanner entrada = new Scanner(System.in);
System.out.print("Digite a nota 1: ");
valor1 = entrada.nextFloat();
System.out.print("Digite a nota 2: ");
valor2 = entrada.nextFloat();
System.out.print("Digite a nota 3: ");
valor3 = entrada.nextFloat();
System.out.printf("Maior nota: %.2f\n", maiornota(valor1, valor2, valor3));
System.out.printf("Menor nota: %.2f\n", menornota(valor1, valor2, valor3));
System.out.printf("Media das 3 notas: %.2f\n", media(valor1, valor2, valor3));
System.out.printf("Media das 2 maiores notas: %.2f\n", (valor1+valor2+valor3-menornota(valor1, valor2, valor3))/2);
}
}
Por favor, pode postar a solução do exercício:
Desafio: Crie um programa em Java que receba um número e imprima ele na ordem inversa.
Ou seja, se recebeu o inteiro 123, deve imprimir o inteiro 321.
??
package metodos;
import java.util.Scanner;
/*
//@Autor Eduardo Nunes
*/
public class Metodos {
public static float media(float... notas){
float m=0;
for(float nota: notas){
m +=nota;
}
return m/notas.length;
}
public static float maiorn(float n,float n2,float n3) {
float maiorn;
maiorn = Math.max(Math.max(n, n2), n3);
return maiorn;
}
public static float menorn(float n,float n2,float n3) {
float menorn;
menorn = Math.min(Math.min(n, n2),n3);
return menorn;
}
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
float n,n2,n3;
System.out.println("Digite a primeira nota:");
n = entrada.nextFloat();
if((n<0)||(n>10)){
do{
System.out.println("A nota é inválida.");
System.out.println("Digite a primeira nota:");
n = entrada.nextFloat();
}while((n<0)||(n>10));
}
System.out.println("Digite a segunda nota:");
n2 = entrada.nextFloat();
if((n2<0)||(n2>10)){
do{
System.out.println("A nota é inválida.");
System.out.println("Digite a segunda nota:");
n2 = entrada.nextFloat();
}while((n2<0)||(n2>10));
}
System.out.println("Digite a terceira nota:");
n3 = entrada.nextFloat();
if((n3<0)||(n3>10)){
do{
System.out.println("A nota é inválida.");
System.out.println("Digite a terceira nota:");
n3 = entrada.nextFloat();
}while((n3<0)||(n3>10));
}
System.out.println("A media das três notas é: "+media(n,n2,n3));
if((n<n2)&&(n<n3)){
System.out.println("A media das duas maiores notas é: "+media(n2,n3));
}
if((n2<n)&&(n2<n3)){
System.out.println("A media das duas maiores notas é: "+media(n,n3));
}
if((n3<n2)&&(n3<n)){
System.out.println("A media das duas maiores notas é: "+media(n,n2));
}
System.out.println("A maior nota é: "+maiorn(n,n2,n3));
System.out.println("A menor nota é: "+menorn(n,n2,n3));
}
}
package MetodosJP;
import java.util.Scanner;
public class mediaSemestre {
public static float recebeNota(int seq, float vlrNota){
Scanner entrada = new Scanner(System.in);
System.out.print("Informe a nota[" + seq + "] , de (0,00 até 100,00) => ");
vlrNota = entrada.nextFloat();
return vlrNota;
// considerando que o foco da lição é chamada de métodos,
// não me preocupei com a validação da nota informada....
}
public static float calculaMedia(float... valores){
float soma = 0;
for(float valor: valores){
soma += valor;
} return soma/valores.length;
}
public static float buscaMenor(float... notas){
float menorNota=100;
for(float nota: notas){
if (menorNota>nota)
menorNota=nota;
} return menorNota;
}
public static float buscaMaior(float... notas){
float maiorNota=0;
for(float nota: notas){
if (maiorNota %.2f \tMaior => %.2f", notaMinima, notaMaxima);
System.out.printf("\n\nMédia GERAL : %.4f", calculaMedia(nota1,nota2,nota3));
if (nota1==notaMinima)
mediaFinal = calculaMedia(nota2,nota3);
if (nota2==notaMinima)
mediaFinal = calculaMedia(nota1,nota3);
if (nota3==notaMinima)
mediaFinal = calculaMedia(nota1,nota2);
System.out.printf("\tMédia FINAL : %.4f\n\n", mediaFinal);
}
}
package somarmaioresnotas;
/**
*
* @author Felipe Bedana (D.T)
*/
public class SomarMaioresNotas
{
public static float media(float... notas)
{
float mediaGeral=0;
for (float valor: notas)
{
mediaGeral+=valor;
}
mediaGeral=mediaGeral-menor(notas);
return mediaGeral/2;
}
public static float maior(float... notas)
{
float maior;
maior=0;
for (float valor: notas)
{
if(maior <= valor)
{
maior=valor;
}
}
return maior;
}
public static float menor(float... notas)
{
float menor;
menor=10;
for (float valor: notas)
{
if(menor >= valor)
{
menor=valor;
}
}
return menor;
}
public static float mediaGeral(float... notas)
{
float media;
media=0;
for (float med: notas)
{
media +=med;
}
media=media/notas.length;
return media;
}
public static void main(String[] args)
{
float nota1, nota2, nota3;
nota1=10;nota2=8;nota3=7;
System.out.println("Média geral: "+mediaGeral(nota1, nota2, nota3));
System.out.println("Média: "+media(nota1, nota2, nota3));
System.out.println("Nota mais alta: "+maior(nota1, nota2, nota3));
System.out.println("Nota mais baixa: "+menor(nota1, nota2, nota3));
}
}
Desenvolvi o exercicio mas acho que minha lógica ficou meio fraca tentei usar o metodo Max() da Math, mas não consegui acabei por fazer da forma manual com fazia em c.
import java.util.Scanner;
public class notas
{
public static void main(String[] Args)
{
float valor1, valor2, valor3;
Scanner entrada = new Scanner(System.in);
System.out.print("Entre com o valor 1: ");
valor1 = entrada.nextFloat();
System.out.print("Entre com o valor 2: ");
valor2 = entrada.nextFloat();
System.out.print("Entre com o valor 3: ");
valor3 = entrada.nextFloat();
media(valor1,valor2,valor3);
}
public static void media(float... valores){
float media=0;
float maior=0,menor=99999;
for(float valor: valores)
{
if(valor>maior)
maior=valor;
if(valor<menor)
menor=valor;
media +=valor;
}
System.out.println("Média das tres notas" + media/valores.length);
System.out.println("Maior " + maior);
System.out.println("Menor " + menor);
System.out.println("Média das duas notas maiores" + (media-menor)/(valores.length-1));
}
}
package exerciciometodo;
import java.util.Scanner;
public class ExercicioMetodo {
public static float media(float... valores){
float media = 0;
for(float valor: valores){
media += valor;
}
return media / valores.length;
}
public static float minimo(float nota1, float nota2, float nota3){
return Math.min((Math.min(nota1, nota2)),nota3);
}
public static float maximo(float nota1, float nota2, float nota3){
return Math.max((Math.max(nota1, nota2)),nota3);
}
public static void main(String[] args) {
float n1,n2,n3;
Scanner entrada = new Scanner(System.in);
System.out.print("Nota 1: ");
n1 = entrada.nextFloat();
System.out.print("Nota 2: ");
n2 = entrada.nextFloat();
System.out.print("Nota 3: ");
n3 = entrada.nextFloat();
System.out.printf("Nota mais alta:%.2f\n",maximo(n1,n2,n3));
System.out.printf("Nota mais baixa:%.2f\n",minimo(n1,n2,n3));
System.out.printf("Media das 3 notas: %.2f\n",media(n1,n2,n3));
if(n1 == minimo(n1,n2,n3)){
System.out.printf("Media das 2 mais altas: %.2f\n",media(n2,n3));
}
else{
if(n2 == minimo(n1,n2,n3)){
System.out.printf("Media das 2 mais altas: %.2f\n",media(n1,n3));
}
else{
if(n3 == minimo(n1,n2,n3)){
System.out.printf("Media das 2 mais altas: %.2f\n",media(n1,n2));
}
}
}
}
}
//media com as tres notas
media(nota1,nota2,nota3));
//media com a maior e a segunda maior notas
media(maiorNota(nota1,nota2,nota3),nota1+nota2+nota3 - menorNota(nota1,nota2,nota3)- maiorNota(nota1,nota2,nota3)));
//media com a maior e a menor nota media(maiorNota(nota1,nota2,nota3),menorNota(nota1, nota2, nota3)));
import java.util.Scanner;
public class Metodo{
public static float media(float... valores){
float media=0;
for(float valor: valores){
media +=valor;
}
return media/valores.length;
}
public static void main(String[] args){
float valor1,
valor2,
valor3;
Scanner entrada = new Scanner(System.in);
System.out.println("entre com valor 1");
valor1 = entrada.nextFloat();{
System.out.println("entre com valor 2");
valor2 = entrada.nextFloat();
System.out.print("entre com valor 3");
valor3 = entrada.nextFloat();
System.out.println("sua media com as tres provas e "
+ media(valor1, valor2, valor3));
System.out.print("sua media com os dois maiores valores e"
+ Math.max(valor1, valor2)+(valor3)/2);}}}
import java.util.Scanner;
public class Metodo{
public static float media(float... valores){
float media=0;
for(float valor: valores){
media +=valor;
}
return media/valores.length;
}
public static void main(String[] args){
float valor1,
valor2,
valor3;
Scanner entrada = new Scanner(System.in);
System.out.println("entre com valor 1");
valor1 = entrada.nextFloat();{
System.out.println("entre com valor 2");
valor2 = entrada.nextFloat();
System.out.print("entre com valor 3");
valor3 = entrada.nextFloat();
System.out.println("sua media com as tres provas e "
+ media(valor1, valor2, valor3));
System.out.print("sua media com os dois maiores valores e"
+ Math.max(valor1, valor2)+(valor3)/2);}}}
package exerciciomedianotas;
public class gerenciador {
float not1 , not2 , not3 ;
void ordenacaoCresent(float... notas){
for(float not : notas){
if((not > this.not1)&&(this.not1 == 0)){
this.not1 = not;
}
else if((not >this.not2)&&(this.not2 == 0)){
this.not2 = not;
}
else this.not3 = not;
}
}
public float mediaDeTresProvas(){
float media = (this.not1+this.not2+this.not3)/3;
return media ;
}
public float mediaDeDuasProvas(){
float media = (this.not1+this.not2)/2;
return media ;
}
public float mediaDeAltBaixo(){
float media = (this.not1+this.not3)/2;
return media ;
}
}
package exerciciomedianotas;
import java.util.Scanner;
public class EXERCICIOMEDIANOTAS {
public static void main(String[] args) {
Scanner input = new Scanner (System.in);
gerenciador gen = new gerenciador();
System.out.print("INFORME O VALOR DA 1 NOTA : ");
float value =input.nextFloat();
System.out.print("INFORME O VALOR DA 2 NOTA : ");
float value2 =input.nextFloat();
System.out.print("INFORME O VALOR DA 3 NOTA : ");
float value3 =input.nextFloat();
gen.ordenacaoCresent(value,value2,value3);
System.out.printf("MEDIA COM AS 3 PROVAS :%f \nMEDIA COM AS 2 NOTAS MAIS ALTA :%f \nMEDIA COM A NOTA ALTA E A MENOR :%f ",gen.mediaDeTresProvas(),gen.mediaDeDuasProvas(),gen.mediaDeAltBaixo());
}
Minha solução:
import java.util.Scanner;
public class Operacoeesmatematica {
public static double Media(double... valores){
double media=0;
for(double valor:valores){
media +=valor;}
return media/valores.length;
}
public static double MaiorPositivo(double ... valores){
double maior=0;
for(double n: valores ){
if(n>maior){
maior=n;}
}
return maior;
}
public static double MenorPositivo(double ... valores){
double menor=99999999;
for(double n:valores){
if(n<menor){
menor=n;}
}
return menor;
}
public static void main(String[] args) {
double p1,p2,p3;
Scanner entrada=new Scanner (System.in);
System.out.println("Nota da P1:");
p1=entrada.nextDouble();
System.out.println("Nota da P2:");
p2=entrada.nextDouble();
System.out.println("Nota da P3:");
p3=entrada.nextDouble();
System.out.println("\nA MAIOR nota é: "+MaiorPositivo(p1,p2,p3));
System.out.println("A MENOR nota é "+ MenorPositivo(p1,p2,p3));
System.out.println("Media com as TRES notas ="+Media(p1,p2,p3));
System.out.println("A media com as DUAS MAIORES NOTAS é:"+Media(MaiorPositivo(p1,p2,p3),(p1+p2+p3-MenorPositivo(p1,p2,p3)-MaiorPositivo(p1,p2,p3))));
}
}
package pkg04.pkg05.exercicio.pkg01;
import java.util.Scanner;
public class Exercicio01 {
public static float media(float... notas) {
float nMedia = 0;
for (float nNota : notas) {
nMedia += nNota;
}
return nMedia / notas.length;
}
public static float maior(float... notas) {
float nMaior = 0;
for (float nNota : notas) {
nMaior = Math.max(nMaior, nNota);
}
return nMaior;
}
public static float menor(float... notas) {
float nMenor = 99; // Iniciado em 99 para primeira comparação
for (float nNota : notas) {
nMenor = Math.min(nMenor, nNota);
}
return nMenor;
}
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
float nNota1 = 0, nNota2 = 0, nNota3 = 0;
System.out.println("Informe a nota 1");
nNota1 = s.nextFloat();
System.out.println("Informe a nota 2");
nNota2 = s.nextFloat();
System.out.println("Informe a nota 3");
nNota3 = s.nextFloat();
System.out.printf("Média com as 3 provas: %.2f \n", media(nNota1, nNota2, nNota3));
System.out.printf("Média com 2 notas mais altas: %.2f \n", media(maior(nNota1, nNota2, nNota3), nNota1 + nNota2 + nNota3 - menor(nNota1, nNota2, nNota3) - maior(nNota1, nNota2, nNota3)));
System.out.printf("Média com a maior e com a menor nota: %.2f \n", media(maior(nNota1, nNota2, nNota3),menor(nNota1, nNota2, nNota3)));
System.out.printf("Maior nota: %.2f \n", maior(nNota1, nNota2, nNota3));
System.out.printf("Menor nota: %.2f \n", menor(nNota1, nNota2, nNota3));
}
}
import java.util.Scanner;
public class ListaDeArgumentos {
public static void main(String[] args) {
float n1=0, n2=0, n3=0;
float[] retornos = {} ;
n1 = solicitaValor(n1);
n2 = solicitaValor(n2);
n3 = solicitaValor(n3);
retornos = media(n1,n2,n3);
System.out.printf("Média das três notas: %.2f \n", retornos[1]);
System.out.printf("Média das duas maiores notas: %.2f \n", retornos[0]);
}
public static float solicitaValor(float n){
Scanner s = new Scanner(System.in);
System.out.printf("Digite a nota: ");
n = s.nextFloat();
System.out.println();
return n;
}
public static float[] media(float... n){
float mediaTres=0, maior1=0, maior2=0;
float retorno[] = new float[2];
for (float notas : n){
mediaTres += notas;
if (notas > maior1){
maior1 = notas;
} else if(notas > maior2){
maior2 = notas;
}
}
retorno[0]= (maior1 + maior2)/2;
retorno[1]=mediaTres/3;
return retorno;
}
}
package excercicioalunosparametros;
import java.util.Scanner;
/**
*
* @author Leandro
*/
public class ExcercicioAlunosParametros {
public static float[] media(float... valores){
float Soma=0, media3, media2, Maior=0, Menor=0,
ValorAnterior;
ValorAnterior=valores[0];
for(float valor: valores){
Soma +=valor;
Maior = Math.max(ValorAnterior,valor);
Menor = Math.min(valor, ValorAnterior);
ValorAnterior=valor;
}
media3=Soma/valores.length;
media2=(Soma-Menor)/2;
float[] retorno = new float[] {Soma, media3, media2, Maior, Menor};
return retorno;
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
float nota1, nota2, nota3, valores[];
Scanner entrada = new Scanner(System.in);
System.out.println("Informa a primeira nota: ");
nota1=entrada.nextFloat();
System.out.println("Informa a segunda nota: ");
nota2=entrada.nextFloat();
System.out.println("Informa a terceira nota: ");
nota3=entrada.nextFloat();
System.out.println("A Soma das 3 notas é: " + media(nota1,nota2,nota3)[0]);
System.out.println("A média das 3 notas é: " + media(nota1,nota2,nota3)[1]);
System.out.println("A média das 2 maiores notas é: " + media(nota1,nota2,nota3)[2]);
System.out.println("A maior nota é: " + media(nota1,nota2,nota3)[3]);
System.out.println("A menor nota é: " + media(nota1,nota2,nota3)[4]);
}
}
take my code bitch:
public class Treino {
public static float notamax(float...vnotaM) {
float notabig=Float.MIN_VALUE;
for(float valor: vnotaM){
if(valor>notabig) {
notabig=valor;
}
}
return notabig;
}
public static float notami(float...vnotami) {
float notamin=Float.MAX_VALUE;
for(float valor: vnotami){
if(notamin>valor){
notamin=valor ;
}
}
return notamin;
}
public static float media(float...valores) {
float media=0;
for(float valor: valores){
media+=valor;
}
return media/valores.length;
}
public static void main(String []agrs) {
Scanner sc=new Scanner(System.in);
System.out.println("Diga um nota ai seu fresco:");
float nota1=sc.nextFloat();
System.out.println("Diga um nota ai seu despregado:");
float nota2=sc.nextFloat();
System.out.println("Diga um nota ai seu beiço de chupa jegue:");
float nota3=sc.nextFloat();
System.out.println("Olha o miseravi estudou hein? A sua maior nota"
+ "é "+notamax(nota1,nota2,nota3));
System.out.println("Porra é essa Sergio?! ta ai a prova que vc fracassou como"
+ " ser humano"+notami(nota1,nota2,nota3));
System.out.println("Ainda não acabou,zé bunitinha ,se pégassemos as três notas a sua media seria:"+media(nota1,nota2,nota3));
float notamaior=notamax(nota1,nota2,nota3);
float notamenor=notami(nota1,nota2,nota3);
float notamedia;
if(nota1!=notamaior && nota1!=notamenor) {
notamedia=nota1;
}else if(nota2!=notamaior && nota2!=notamenor) {
notamedia=nota2;
}else {
notamedia=nota3;
}
System.out.println("Todavia não é o caso seu coco,sua media com as duas maiores notas que vc vai conseguir na vida é?"+media(notamaior,notamedia));
}
}
Postar um comentário