Preciso criar uma classe chamada Contagem que contenha quatro métodos com o nome “contar” utilizando o conceito da sobrecarga. A assinatura e função de cada método aparecem descritas na tabela conforme
em anexo. Faça também outra classe para testar o método.
Sensacional, é só você criar sua classe e copiar e colar os nomes de métodos que tem na tabela.
amigo, bom dia poderia me mostrar pois não entendi poderia me trazer o trecho do código com o primeiro método contar () ?
Boas, o que tem de fazer é quatro métodos void, com os parâmetros indicados na descrição do problema, ou seja.
public void contar(){
Ciclo aqui dentro e imprime o resultado.
}
public void contar(int fim){
Ciclo aqui dentro e imprimi o resultado.
Ter atenção que tem de usar a variável
do parâmetro.
}
E assim vai…
1 curtida
seria mais ou menos assim ?
public class Contagem {
public static void public static void main(String[] args) {
}
public void contar(){
//Apresenta em tela a contagem dos números de 1 a 10.
}
public void contar(int fim){
//Apresenta em tela a contagem dos números de 1 até o valor
//definido pela variável fim.
}
public void contar(int inicio, int fim){
//Apresenta em tela a contagem dos números com valor inicial
//definido pela variável inicio até o valor definido pela
//variável fim.
}
public void contar(int inicio, int fim, int pausa){
//Apresenta em tela a contagem dos números com valor inicial
//definido pela variável inicio até o valor definido pela
//variável fim. O parâmetro pausa define a pausa (em segundos)
//que deve ser data a cada valor impresso em tela.
}
}
Isso mesmo, só que esse método main você apaga e escreve na outra classe onde você vai testar a classe Contagem.
Inclusive, como você tem várias sobrecargas, você pode fazer com que um método de menos parâmetros delegue a chamada para um método com mais parâmetros, no final você só vai precisar implementar a lógica do método que possui mais parâmetros.
Veja:
public class Contagem {
/**
* Apresenta em tela a contagem dos números de 1 a 10.
*/
public void contar() {
contar(10); // reaproveitando o método 'contar(int fim)'
}
/**
* Apresenta em tela a contagem dos números de 1 até o valor
* definido pela variável fim.
*/
public void contar(int fim) {
contar(1, fim); // reaproveitando o método 'contar(int inicio, int fim)'
}
/**
* Apresenta em tela a contagem dos números com valor inicial
* definido pela variável inicio até o valor definido pela
* variável fim.
*/
public void contar(int inicio, int fim) {
contar(inicio, fim, 0); // reaproveitando o método 'contar(int inicio, int fim, int pausa)'
}
/**
* Apresenta em tela a contagem dos números com valor inicial
* definido pela variável inicio até o valor definido pela
* variável fim. O parâmetro pausa define a pausa (em segundos)
* que deve ser data a cada valor impresso em tela.
*/
public void contar(int inicio, int fim, int pausa) {
// aqui você implementa a lógica
}
}
2 curtidas
Jovem, buguei aqui 
não to conseguindo nem implementar a lógica agora hahahaha travei.
Ué, você vai fazer um laço que vai de inicio até fim, imprimindo o valor do contador e fazendo uma pausa com os segundos informados.
então eu fiz aqui agora, porém não sei onde estou errando agora não executa.
public class Contagem {
public static void contar(){
for(int i = 1; i <= 10; i++){
System.out.println(i);
}
}
public static void contar(int fim){
for(int i = 1; i <= fim; i++){
System.out.println(i);
}
}
public static void contar(int inicio, int fim){
for(int i = inicio; i <= fim; i++){
System.out.println(i);
}
}
public static void contar(int inicio, int fim, int pausa){
for(int i = inicio; i <= fim; i++){
System.out.print(i + " ");
try{
Thread.sleep(pausa*1000);
} catch (InterruptedException ex){
Thread.currentThread().interrupt();
}
}
}
}
Cadê a classe de teste com o método main?
Esse catch está errado, se aconteceu uma InterruptedException porque é que você vai tentar interromper a Thread novamente?
Põe só um ex.printStackTrace() que está ótimo.
Porque você repetiu o for em cada método?
Não viu o exemplo que postei?
O [staroski] está a indicar algo desta forma, implementa e vai chamando o método seguinte.
public class Calcular {
public void contar() {
int contar = 0;
System.out.println("Valores do primeiro método");
while (contar < 10) {
contar++;
System.out.println(contar);
}
contar(10);
}
public void contar(int fim) {
int contador = 0;
System.out.println("Valores do segundo método");
while (contador < fim) {
contador++;
System.out.println(contador);
}
}
public static void main(String[] args) {
Calcular calculo = new Calcular();
calculo.contar();
}
}
PS… Coloquei o metodo main na mesma classe, mas pode separar a classe calcular
Rapazeada, agradeço ae pela força mas acho que java não é minha área não eu nao consigo fazer funcionar, acho q vocês tem que desenhar ou resolver o problema por inteiro. E postar o código para eu ler e intender.
1 curtida
Boas amigo, neste exemplo coloquei todos os métodos independentes, cada um com a sua logico, penso que é melhor para entender.
public class Contagem {
public void contar() {
// variavel contar recebe o valor de 0 //
int contar = 0;
System.out.println("Valores do primeiro método");
// enquanto que a variavel conta seja menor que 10 executa o que está dentro do while
while (contar < 10) {
// uma vez que a variavel contar tem o valor de 0, qd chega a este ponto incremente um a cada vez que passa no while
contar++;
//imprime
System.out.println(contar);
}
}
public void contar(int fim) {
int contador = 0;
System.out.println("Valores do segundo método");
while (contador < fim) {
contador++;
System.out.println(contador);
}
}
public void contar(int inicio, int fim) {
System.out.println("Valores do terceiro método");
while (inicio <= fim) {
System.out.println(inicio);
inicio++;
}
}
public void contar(int inicio, int fim, int pausa) throws InterruptedException {
//throws quem chamar o método tem opção de tratar a exeção //
System.out.println("Valores do quarto método");
// converte milisegundos para segundos //
int segundos = pausa * 1000;
while (inicio <= fim) {
// classe Java que é utilizada para criar e executar tarefas simultaneamente //
//sleep() para pausar a execução atual por um tempo. //
Thread.sleep(segundos);
System.out.println(inicio);
inicio++;
}
}
}
//classe para testar os métodos //
public class testar{
public static void main(String[] args) {
Contagem calculo = new Contagem();
//chama primeiro método //
calculo.contar();
//chama segundo metodo //
calculo.contar(10);
//chama terceiro método
calculo.contar(1, 15);
//chama quarto método //
try {
calculo.contar(1, 10, 2);
} catch (InterruptedException ex) {
//ex é a variavel que vai guardar as exeções do tipo InterruptedException //
System.out.println(ex.getMessage());
//ou//
ex.printStackTrace();
}
}
}vlw irmão muito obrigado.
1 curtida
A ideia da sobrecarga é ter vários métodos com o mesmo nome, porém com assinaturas diferentes (ou seja, com parâmetros diferentes, sejam com tipos diferentes ou até com quantidade diferente). Assim você pode reaproveitar a lógica de um nos outros.
Repare que no seu caso, os métodos têm várias coisas em comum: eles imprimem todos os números de um valor inicial até um valor final, e pode ou não ter uma pausa entre eles. O algoritmo é o mesmo, só mudam os parâmetros.
O que você pode fazer é criar primeiro o método mais “genérico”, o que recebe todos os parâmetros:
public class Contagem {
// recebe o valor inicial, final e o tempo de pausa
public void contar(int inicio, int fim, int pausa) {
long tempoPausa = pausa * 1000;
for (int i = inicio; i <= fim; i++) {
System.out.println(i);
if (tempoPausa > 0) { // se não tem pausa, nem chama o sleep
try {
Thread.sleep(tempoPausa);
} catch (InterruptedException ex) {
// imprime alguma mensagem de erro, não faz nada?
}
}
}
}
}
Ou seja, imprime todos os números no intervalo indicado, e caso o tempo de pausa seja maior que zero, chama o sleep.
Depois, basta reusar o mesmo método para os demais casos. Por exemplo, se o método não recebe nenhhum parâmetro, ele mostra os números de 1 a 10, sem pausas. Ou seja:
public void contar() {
// início=1, fim=10, pausa=0
contar(1, 10, 0);
}
Isso é sobrecarga: temos dois métodos com o mesmo nome (contar), mas com assinaturas diferentes (um não têm parâmetros, outro tem 3). E um pode reaproveitar a lógica do outro, só mudando os valores dos parâmetros.
Com isso, fazer os demais fica fácil. Se ele só recebe o valor final, então o inicial é 1 (e também não tem pausa):
public void contar(int fim) {
contar(1, fim, 0);
}
E se ele recebe o início e fim, executa sem pausas:
public void contar(int inicio, int fim) {
contar(inicio, fim, 0);
}
Isso é basicamente o mesmo que já foi explicado acima, mas enfim… 
Repare que assim você não precisa repetir o mesmo loop em todos os métodos (como sugeriram acima, que também funciona, mas acaba duplicando código à toa).
Ou seja, a classe completa fica assim:
public class Contagem {
public void contar() {
contar(1, 10, 0);
}
public void contar(int fim) {
contar(1, fim, 0);
}
public void contar(int inicio, int fim) {
contar(inicio, fim, 0);
}
public void contar(int inicio, int fim, int pausa) {
long tempoPausa = pausa * 1000;
for (int i = inicio; i <= fim; i++) {
System.out.println(i);
if (tempoPausa > 0) { // se não tem pausa, nem chama o sleep
try {
Thread.sleep(tempoPausa);
} catch (InterruptedException ex) {
// imprime alguma mensagem de erro, não faz nada?
}
}
}
}
}
Testando:
public static void main(String[] args) throws Exception {
Contagem c = new Contagem();
// mostra os números de 1 a 10
c.contar();
// mostra os números de 1 a 5
c.contar(5);
// mostra os números de 15 a 20
c.contar(15, 20);
// mostra os números de 150 a 154, com pausa de 1 segundo
c.contar(150, 154, 1);
}
1 curtida
Não é a cultura deste fórum dar as respostas prontas, porque a ideia é tirar dúvidas pontuais e ajudar no ensino. Mas ajudar no ensino não significa fazer o código, porque se você recebeu um problema com tal enunciado, significa que o professor já te passou conteúdo suficiente para resolver.
Então a cultura aqui é ajudar em questões específicas; não fazer o trabalho todo, porque isso não educa. Programação se aprende fazendo.
Mas já que o @bruno.batista fez isso, então depois pede o pix dele . 
1 curtida