**Cronometro.java**
```java
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class Cronometro extends JFrame {
private JLabel hora;
private JLabel minutos;
private JLabel segundos;
private int segundosContador = 0;
private int minutosContador = 0;
private int horaContador = 0;
public Cronometro() {
setLayout(new FlowLayout());
hora = new JLabel("00:00:00");
minutos = new JLabel("00:00:00");
segundos = new JLabel("00:00:00");
add(hora);
add(minutos);
add(segundos);
Timer timer = new Timer(1000, new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
segundosContador++;
if (segundosContador == 60) {
segundosContador = 0;
minutosContador++;
if (minutosContador == 60) {
minutosContador = 0;
horaContador++;
}
}
hora.setText(String.format("%02d:%02d:%02d", horaContador, minutosContador, segundosContador));
}
});
timer.start();
setSize(300, 100);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
new Cronometro();
}
}
```
Este programa crea una ventana con un cronometro que muestra las horas, minutos y segundos. El cronometro se actualiza cada segundo y muestra el tiempo en formato "HH:MM:SS".
Aquí te dejo un ejemplo de cómo podrías implementar esto en Java:
```java
public class Alumno {
private double[] calificaciones;
public Alumno(double[] calificaciones) {
this.calificaciones = calificaciones;
}
public boolean aprueba() {
double promedio = calcularPromedio();
return promedio >= 3.0;
}
private double calcularPromedio() {
double suma = 0;
for (double calificacion : calificaciones) {
suma += calificacion;
}
return suma / calificaciones.length;
}
public static void main(String[] args) {
// Crear un objeto Alumno con 5 calificaciones
double[] calificaciones = {4.0, 3.5, 4.5, 3.0, 5.0};
Alumno alumno = new Alumno(calificaciones);
// Verificar si aprueba
if (alumno.aprueba()) {
System.out.println("El alumno aprueba.");
} else {
System.out.println("El alumno reprueba.");
}
}
}
```
En este código, creamos una clase `Alumno` con un arreglo de `double` para almacenar las calificaciones. La clase tiene un método `aprueba()` que calcula el promedio de las calificaciones y devuelve `true` si es mayor o igual a 3.0, y `false` en caso contrario.
En el método `calcularPromedio()`, recorremos el arreglo de calificaciones y sumamos cada una de ellas. Luego, dividimos la suma por la cantidad de calificaciones para obtener el promedio.
En el método `main()`, creamos un objeto `Alumno` con 5 calificaciones y llamamos al método `aprueba()` para verificar si aprueba o reprueba.
Recuerda que este código asume que las calificaciones son números enteros entre 0 y 5. Si las calificaciones pueden ser decimales, debes ajustar el código para manejarlas correctamente.
**Suma de vectores pares e impares**
Aquí te presento un algoritmo en Java que crea dos vectores de longitud N, suma los valores en posiciones pares del primer vector con los valores en posiciones impares del segundo vector y imprime el vector suma.
```java
import java.util.Scanner;
public class SumaVectores {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Ingrese la longitud del vector (N): ");
int n = scanner.nextInt();
scanner.close();
// Crear vectores de longitud N
int[] vector1 = new int[n];
int[] vector2 = new int[n];
// Inicializar vectores con valores aleatorios
for (int i = 0; i < n; i++) {
vector1[i] = (int) (Math.random() * 100);
vector2[i] = (int) (Math.random() * 100);
}
// Imprimir vectores
System.out.println("Vector 1: ");
for (int i = 0; i < n; i++) {
System.out.print(vector1[i] + " ");
}
System.out.println();
System.out.println("Vector 2: ");
for (int i = 0; i < n; i++) {
System.out.print(vector2[i] + " ");
}
System.out.println();
// Sumar valores en posiciones pares del primer vector con posiciones impares del segundo vector
int[] suma = new int[n];
for (int i = 0; i < n; i++) {
if (i % 2 == 0) { // Posición par
suma[i] = vector1[i] + vector2[i];
} else { // Posición impar
suma[i] = vector1[i] + vector2[i];
}
}
// Imprimir vector suma
System.out.println("Vector suma: ");
for (int i = 0; i < n; i++) {
System.out.print(suma[i] + " ");
}
System.out.println();
}
}
```
Este algoritmo utiliza un bucle `for` para inicializar los vectores con valores aleatorios entre 0 y 99. Luego, utiliza otro bucle `for` para sumar los valores en posiciones pares del primer vector con los valores en posiciones impares del segundo vector. Finalmente, imprime el vector suma.
Recuerda que este algoritmo asume que la longitud del vector (N) es un número entero positivo. Si la longitud del vector es 0 o negativa, el algoritmo no funcionará correctamente.
**Cronometro.java**
```java
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class Cronometro extends JFrame {
private JLabel hora;
private JLabel minutos;
private JLabel segundos;
private Timer timer;
public Cronometro() {
setLayout(new FlowLayout());
hora = new JLabel("00:00:00");
minutos = new JLabel("00:00:00");
segundos = new JLabel("00:00:00");
add(hora);
add(minutos);
add(segundos);
timer = new Timer(1000, new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
int segundosActual = Integer.parseInt(segundos.getText().split(":")[2]) + 1;
int minutosActual = Integer.parseInt(minutos.getText().split(":")[1]) + segundosActual / 60;
int horaActual = Integer.parseInt(hora.getText().split(":")[0]) + minutosActual / 60;
segundosActual %= 60;
minutosActual %= 60;
horaActual %= 24;
segundos.setText(String.format("%02d", segundosActual));
minutos.setText(String.format("%02d", minutosActual));
hora.setText(String.format("%02d:%02d:%02d", horaActual, minutosActual, segundosActual));
}
});
timer.start();
setSize(300, 100);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
new Cronometro();
}
}
```
Este programa crea una ventana con un cronometro que muestra las horas, minutos y segundos. El cronometro se actualiza cada segundo.
**Explicación**
* Creamos una ventana con un layout de flujo (`FlowLayout`) y agregamos tres etiquetas para mostrar las horas, minutos y segundos.
* Creamos un temporizador (`Timer`) que se ejecuta cada segundo y actualiza el cronometro.
* En el evento de acción del temporizador, calculamos los nuevos valores de segundos, minutos y horas y los actualizamos en las etiquetas correspondientes.
* Utilizamos la función `split` para dividir la cadena de texto de la etiqueta en partes y luego utilizamos la función `parseInt` para convertir las partes en números enteros.
* Utilizamos la función `format` para formatear los números enteros en cadenas de texto con dos dígitos.
**Nota**
* El cronometro se actualiza cada segundo, por lo que el temporizador se ejecuta cada segundo.
* El cronometro se reinicia automáticamente cuando se alcanza el límite de 24 horas.
**Compra de Artículos**
=======================
### Clase Artículo
```java
public class Articulo {
private String nombre;
private double precio;
public Articulo(String nombre, double precio) {
this.nombre = nombre;
this.precio = precio;
}
public String getNombre() {
return nombre;
}
public double getPrecio() {
return precio;
}
public double getPrecioConImpuesto() {
return precio * 1.2;
}
}
```
### Clase Compra
```java
import java.util.ArrayList;
import java.util.List;
public class Compra {
private List<Articulo> articulos;
private double totalEfectivo;
private double totalTarjeta;
public Compra() {
this.articulos = new ArrayList<>();
}
public void agregarArticulo(Articulo articulo) {
articulos.add(articulo);
if (articulos.size() < 6) {
totalEfectivo += articulo.getPrecio();
} else {
totalTarjeta += articulo.getPrecio();
}
}
public void imprimirResumen() {
System.out.println("Artículos:");
for (Articulo articulo : articulos) {
System.out.println(articulo.getNombre() + ": $" + articulo.getPrecio());
System.out.println(articulo.getNombre() + ": $" + articulo.getPrecioConImpuesto());
System.out.println();
}
System.out.println("Total efectivo: $" + totalEfectivo);
System.out.println("Total tarjeta: $" + totalTarjeta);
double impuestoEfectivo = totalEfectivo * 0.2;
double impuestoTarjeta = totalTarjeta * 0.05;
System.out.println("Impuesto efectivo: $" + impuestoEfectivo);
System.out.println("Impuesto tarjeta: $" + impuestoTarjeta);
double totalEfectivoConImpuesto = totalEfectivo + impuestoEfectivo;
double totalTarjetaConImpuesto = totalTarjeta + impuestoTarjeta;
System.out.println("Total efectivo con impuesto: $" + totalEfectivoConImpuesto);
System.out.println("Total tarjeta con impuesto: $" + totalTarjetaConImpuesto);
}
}
```
### Clase Principal
```java
public class Main {
public static void main(String[] args) {
Compra compra = new Compra();
Articulo articulo1 = new Articulo("Artículo 1", 10.0);
Articulo articulo2 = new Articulo("Artículo 2", 20.0);
Articulo articulo3 = new Articulo("Artículo 3", 30.0);
Articulo articulo4 = new Articulo("Artículo 4", 40.0);
Articulo articulo5 = new Articulo("Artículo 5", 50.0);
Articulo articulo6 = new Articulo("Artículo 6", 60.0);
Articulo articulo7 = new Articulo("Artículo 7", 70.0);
compra.agregarArticulo(articulo1);
compra.agregarArticulo(articulo2);
compra.agregarArticulo(articulo3);
compra.agregarArticulo(articulo4);
compra.agregarArticulo(articulo5);
compra.agregarArticulo(articulo6);
compra.agregarArticulo(articulo7);
compra.imprimirResumen();
}
}
```
Este código crea una clase `Articulo` para representar cada artículo, una clase `Compra` para representar la compra y una clase `Main` para crear una instancia de `Compra` y agregar artículos a ella. La clase `Compra` calcula el total de efectivo y tarjeta, y luego imprime el resumen de la compra con y sin impuesto.
**Suma y Media de Números**
```java
public class SumaMedia {
public static void main(String[] args) {
int suma = 0;
int contador = 0;
double media = 0.0;
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.print("Introduce un número (0 para salir): ");
int numero = scanner.nextInt();
if (numero == 0) {
break;
}
suma += numero;
contador++;
}
if (contador > 0) {
media = (double) suma / contador;
System.out.println("La suma de los números es: " + suma);
System.out.println("La media de los números es: " + media);
} else {
System.out.println("No se introdujeron números.");
}
scanner.close();
}
}
```
En este código, creamos un bucle `while` que se ejecuta hasta que se introduce un cero. Dentro del bucle, pedimos un número al usuario y lo sumamos a la variable `suma`. También incrementamos el contador `contador`. Si el usuario introduce un cero, salimos del bucle.
Después del bucle, calculamos la media dividiendo la suma por el contador. Si el contador es cero, significa que no se introdujeron números, por lo que mostramos un mensaje de error.
Finalmente, cerramos el objeto `Scanner` para liberar recursos.
Aquí te dejo un ejemplo de cómo podrías implementar el algoritmo que pides en Java:
```java
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// Creamos un objeto Scanner para leer la entrada del usuario
Scanner scanner = new Scanner(System.in);
// Variable para almacenar la suma de los números
double suma = 0;
// Variable para almacenar la cantidad de números introducidos
int cantidad = 0;
// Variable para almacenar el último número introducido
double ultimoNumero = 0;
// Bucle para leer números hasta que se introduzca un cero
while (ultimoNumero != 0) {
// Pedimos al usuario que introduzca un número
System.out.print("Introduce un número (0 para terminar): ");
ultimoNumero = scanner.nextDouble();
// Si el número no es cero, lo sumamos a la suma y aumentamos la cantidad
if (ultimoNumero != 0) {
suma += ultimoNumero;
cantidad++;
}
}
// Cerramos el objeto Scanner para liberar recursos
scanner.close();
// Calculamos la media de los números introducidos
double media = suma / cantidad;
// Imprimimos la suma y la media de los números introducidos
System.out.println("La suma de los números introducidos es: " + suma);
System.out.println("La media de los números introducidos es: " + media);
}
}
```
Este código utiliza un bucle `while` para leer números hasta que se introduzca un cero. La suma de los números se almacena en la variable `suma`, y la cantidad de números introducidos se almacena en la variable `cantidad`. La media de los números introducidos se calcula dividiendo la suma por la cantidad. Finalmente, se imprimen la suma y la media de los números introducidos.
Recuerda que debes cerrar el objeto `Scanner` después de usarlo para liberar recursos y evitar problemas de memoria.
**Cronometro.java**
```java
import java.util.Timer;
import java.util.TimerTask;
public class Cronometro {
private int horas;
private int minutos;
private int segundos;
private Timer timer;
public Cronometro() {
this.horas = 0;
this.minutos = 0;
this.segundos = 0;
this.timer = new Timer();
}
public void iniciar() {
timer.scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
segundos++;
if (segundos == 60) {
segundos = 0;
minutos++;
if (minutos == 60) {
minutos = 0;
horas++;
}
}
System.out.println(horas + ":" + minutos + ":" + segundos);
}
}, 0, 1000); // 1000ms = 1s
}
public static void main(String[] args) {
Cronometro cronometro = new Cronometro();
cronometro.iniciar();
}
}
```
Este programa crea un cronometro que muestra las horas, minutos y segundos en la consola. El cronometro se inicia automáticamente cuando se ejecuta el programa. El cronometro cuenta en segundos y actualiza la hora, minuto y segundo cada segundo.
**Nota:** El cronometro no se detiene automáticamente cuando se cierra la consola. Si deseas detener el cronometro cuando se cierra la consola, debes agregar un método para detener el cronometro y llamarlo en el método `main` antes de cerrar la consola. Por ejemplo:
```java
public void detener() {
timer.cancel();
}
public static void main(String[] args) {
Cronometro cronometro = new Cronometro();
cronometro.iniciar();
try {
Thread.sleep(10000); // Esperar 10 segundos
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
cronometro.detener();
}
```
Esto detendrá el cronometro después de 10 segundos.
Aquí te dejo un ejemplo de cómo podrías implementar esto en Java:
```java
public class CalculoSalario {
public static void main(String[] args) {
int horasTrabajadas = 45; // cantidad de horas trabajadas
double tarifa = 20.0; // tarifa por hora
double salario = calcularSalario(horasTrabajadas, tarifa);
System.out.println("El salario del trabajador es: $" + salario);
}
/**
* Calcula el salario del trabajador según las horas trabajadas y la tarifa.
*
* @param horasTrabajadas cantidad de horas trabajadas
* @param tarifa tarifa por hora
* @return salario del trabajador
*/
public static double calcularSalario(int horasTrabajadas, double tarifa) {
double salario = 0.0;
// si las horas trabajadas son menores o iguales a 40, se pagan a la tarifa normal
if (horasTrabajadas <= 40) {
salario = horasTrabajadas * tarifa;
}
// si las horas trabajadas son mayores a 40, se pagan a la tarifa normal las primeras 40 horas
// y a la tarifa incrementada las horas extras
else {
salario = 40 * tarifa; // primeras 40 horas
double horasExtras = horasTrabajadas - 40; // horas extras
double tarifaIncrementada = tarifa * 1.5; // tarifa incrementada
salario += horasExtras * tarifaIncrementada; // horas extras a la tarifa incrementada
}
return salario;
}
}
```
En este código, la función `calcularSalario` recibe como parámetros la cantidad de horas trabajadas y la tarifa por hora. Luego, calcula el salario según las reglas establecidas:
* Si las horas trabajadas son menores o iguales a 40, se pagan a la tarifa normal.
* Si las horas trabajadas son mayores a 40, se pagan a la tarifa normal las primeras 40 horas y a la tarifa incrementada las horas extras.
Finalmente, la función devuelve el salario calculado.
En el `main` se muestra un ejemplo de cómo utilizar la función `calcularSalario` con 45 horas trabajadas y una tarifa de $20.00 por hora.
**SepararImparesPares**
Aquí te dejo una solución en Java:
```java
public class SepararImparesPares {
public static void main(String[] args) {
int[] vector = {3, 1, 4, 2, 5, 6, 7, 8, 9};
System.out.println("Vector original:");
imprimirVector(vector);
separarImparesPares(vector);
System.out.println("Vector modificado:");
imprimirVector(vector);
}
public static void separarImparesPares(int[] vector) {
int[] impares = new int[vector.length];
int[] pares = new int[vector.length];
int i = 0, j = 0, k = 0;
for (int num : vector) {
if (num % 2 != 0) {
impares[i] = num;
i++;
} else {
pares[j] = num;
j++;
}
}
int l = 0;
for (int num : impares) {
vector[l] = num;
l++;
}
int m = 0;
for (int num : pares) {
vector[l + m] = num;
m++;
}
}
public static void imprimirVector(int[] vector) {
for (int num : vector) {
System.out.print(num + " ");
}
System.out.println();
}
}
```
En este código, creamos dos arreglos auxiliares `impares` y `pares` para almacenar los números impares y pares del vector original, respectivamente. Luego, recorremos el vector original y copiamos los números impares y pares a sus respectivos arreglos auxiliares. Finalmente, copiamos los números impares al principio del vector original y los números pares al final, conservando su orden relativo.
Aquí te muestro un ejemplo de menú en Java que cumple con las opciones que mencionaste:
```java
import java.util.Scanner;
public class Menu {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int opcion;
do {
System.out.println("Menú");
System.out.println("1. Calcular factorial de un número");
System.out.println("2. Contar números pares e impares en una lista");
System.out.println("3. Verificar si un número es primo");
System.out.println("4. Salir");
System.out.print("Ingrese su opción: ");
opcion = scanner.nextInt();
switch (opcion) {
case 1:
calcularFactorial(scanner);
break;
case 2:
contarParesImpares(scanner);
break;
case 3:
verificarPrimo(scanner);
break;
case 4:
System.out.println("Adiós!");
break;
default:
System.out.println("Opción inválida. Por favor, ingrese una opción válida.");
}
} while (opcion != 4);
}
public static void calcularFactorial(Scanner scanner) {
System.out.print("Ingrese un número para calcular su factorial: ");
int numero = scanner.nextInt();
long factorial = 1;
for (int i = 1; i <= numero; i++) {
factorial *= i;
}
System.out.println("El factorial de " + numero + " es: " + factorial);
}
public static void contarParesImpares(Scanner scanner) {
System.out.print("Ingrese la cantidad de números en la lista: ");
int cantidad = scanner.nextInt();
int[] lista = new int[cantidad];
System.out.println("Ingrese los números de la lista:");
for (int i = 0; i < cantidad; i++) {
lista[i] = scanner.nextInt();
}
int pares = 0;
int impares = 0;
for (int numero : lista) {
if (numero % 2 == 0) {
pares++;
} else {
impares++;
}
}
System.out.println("Números pares: " + pares);
System.out.println("Números impares: " + impares);
}
public static void verificarPrimo(Scanner scanner) {
System.out.print("Ingrese un número para verificar si es primo: ");
int numero = scanner.nextInt();
if (numero <= 1) {
System.out.println(numero + " no es primo.");
} else {
boolean esPrimo = true;
for (int i = 2; i <= Math.sqrt(numero); i++) {
if (numero % i == 0) {
esPrimo = false;
break;
}
}
if (esPrimo) {
System.out.println(numero + " es primo.");
} else {
System.out.println(numero + " no es primo.");
}
}
}
}
```
Este código utiliza un bucle `do-while` para repetir el menú hasta que el usuario elija la opción de salir. Cada opción del menú se maneja mediante un `switch` que llama a la función correspondiente.
Las funciones `calcularFactorial`, `contarParesImpares` y `verificarPrimo` realizan las operaciones solicitadas por cada opción del menú.
Espero que esto te ayude a entender cómo crear un menú en Java. Recuerda que este es un ejemplo básico y puedes agregar más opciones y funcionalidades según tus necesidades.
Aquí te dejo un ejemplo de cómo podrías implementar este algoritmo en Java:
```java
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int suma = 0;
int contador = 0;
double media = 0;
while (true) {
System.out.print("Introduce un número (0 para salir): ");
int numero = scanner.nextInt();
if (numero == 0) {
break;
}
suma += numero;
contador++;
}
if (contador > 0) {
media = (double) suma / contador;
System.out.println("La suma de los números es: " + suma);
System.out.println("La media de los números es: " + media);
} else {
System.out.println("No se introdujeron números.");
}
scanner.close();
}
}
```
Explicación:
* Creamos un objeto `Scanner` para leer la entrada del usuario.
* Inicializamos variables para almacenar la suma, el contador de números y la media.
* Utilizamos un bucle `while` infinito para leer números hasta que el usuario introduzca un 0.
* Dentro del bucle, leemos un número y comprobamos si es 0. Si es así, salimos del bucle.
* Si el número no es 0, lo sumamos a la suma y incrementamos el contador.
* Después del bucle, comprobamos si se introdujeron números. Si sí, calculamos la media y la imprimimos.
* Finalmente, cerramos el objeto `Scanner` para liberar recursos.
Nota: Es importante cerrar el objeto `Scanner` después de usarlo para evitar problemas de recursos.
Aquí te dejo un ejemplo de cómo podrías implementar el programa en Java:
```java
public class MultiplicadorVector {
public static void main(String[] args) {
// Creamos un vector
int[] vector = {1, 2, 3, 4, 5};
// Pedimos al usuario que ingrese un número
System.out.println("Ingrese un número:");
int numero = Integer.parseInt(System.console().readLine());
// Llamamos al método que multiplica el vector por el número
int[] resultado = multiplicarVectorPorNumero(vector, numero);
// Mostramos el resultado
System.out.println("Vector resultante:");
for (int i = 0; i < resultado.length; i++) {
System.out.print(resultado[i] + " ");
}
}
/**
* Multiplica un vector por un número.
*
* @param vector El vector a multiplicar.
* @param numero El número por el que se multiplica el vector.
* @return El vector resultante de la multiplicación.
*/
public static int[] multiplicarVectorPorNumero(int[] vector, int numero) {
// Creamos un nuevo vector con la misma longitud que el original
int[] resultado = new int[vector.length];
// Multiplicamos cada componente del vector por el número
for (int i = 0; i < vector.length; i++) {
resultado[i] = vector[i] * numero;
}
return resultado;
}
}
```
Este programa crea un vector con los números del 1 al 5, pide al usuario que ingrese un número, multiplica cada componente del vector por ese número y muestra el resultado. El método `multiplicarVectorPorNumero` es el que realiza la multiplicación del vector por el número.
**Inverso.java**
```java
import java.util.Scanner;
public class Inverso {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int[] numeros = new int[10];
// Leer números y guardar en el vector
System.out.println("Ingrese 10 números:");
for (int i = 0; i < 10; i++) {
System.out.print("Número " + (i + 1) + ": ");
numeros[i] = scanner.nextInt();
}
// Imprimir números en orden inverso
System.out.println("\nNúmeros en orden inverso:");
for (int i = 9; i >= 0; i--) {
System.out.println(numeros[i]);
}
scanner.close();
}
}
```
**Explicación**
* Creamos un vector de 10 enteros llamado `numeros`.
* Usamos un `Scanner` para leer 10 números del usuario y guardarlos en el vector.
* Luego, imprimimos los números en orden inverso utilizando un bucle `for` que comienza desde el último elemento del vector (índice 9) y se desplaza hacia atrás hasta el primer elemento (índice 0).
**Ejemplo de uso**
1. Compila el programa y ejecútalo.
2. Ingresa 10 números cuando se te solicite.
3. El programa imprimirá los números en orden inverso.
Nota: Asegúrate de que el vector tenga un tamaño suficiente para almacenar los 10 números que se van a leer. En este caso, creamos un vector de 10 enteros (`int[] numeros = new int[10];`).
Aquí te dejo un ejemplo simple de un cronómetro en Java que muestra las horas, minutos y segundos:
```java
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class Cronometro extends JFrame {
private JLabel hora;
private JLabel minuto;
private JLabel segundo;
private int segundos = 0;
private int minutos = 0;
private int horas = 0;
public Cronometro() {
setLayout(new FlowLayout());
hora = new JLabel("00:00:00");
hora.setFont(new Font("Arial", Font.BOLD, 48));
add(hora);
minuto = new JLabel("Minutos: 0");
minuto.setFont(new Font("Arial", Font.BOLD, 24));
add(minuto);
segundo = new JLabel("Segundos: 0");
segundo.setFont(new Font("Arial", Font.BOLD, 24));
add(segundo);
JButton start = new JButton("Iniciar");
start.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
startCronometro();
}
});
add(start);
JButton stop = new JButton("Detener");
stop.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
detenerCronometro();
}
});
add(stop);
JButton reset = new JButton("Reset");
reset.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
resetCronometro();
}
});
add(reset);
setSize(400, 200);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(true);
}
private void startCronometro() {
Timer timer = new Timer(1000, new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
segundos++;
if (segundos == 60) {
segundos = 0;
minutos++;
if (minutos == 60) {
minutos = 0;
horas++;
}
}
hora.setText(String.format("%02d:%02d:%02d", horas, minutos, segundos));
minuto.setText("Minutos: " + minutos);
segundo.setText("Segundos: " + segundos);
}
});
timer.start();
}
private void detenerCronometro() {
Timer timer = (Timer) (new Timer(1000, new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// No hacer nada
}
}));
timer.stop();
}
private void resetCronometro() {
segundos = 0;
minutos = 0;
horas = 0;
hora.setText("00:00:00");
minuto.setText("Minutos: 0");
segundo.setText("Segundos: 0");
}
public static void main(String[] args) {
new Cronometro();
}
}
```
Este programa crea una ventana con un cronómetro que muestra las horas, minutos y segundos. También incluye botones para iniciar, detener y resetear el cronómetro.
**Algoritmo "MayorMenor"**
### Descripción
Este algoritmo permite leer tres valores diferentes y almacenarlos en variables. Luego, imprime el mayor y el menor de los tres valores.
### Código
```java
import java.util.Scanner;
public class MayorMenor {
public static void main(String[] args) {
// Declarar variables
double num1, num2, num3;
// Crear un objeto Scanner para leer la entrada del usuario
Scanner scanner = new Scanner(System.in);
// Pedir los tres números al usuario
System.out.print("Ingrese el primer número: ");
num1 = scanner.nextDouble();
System.out.print("Ingrese el segundo número: ");
num2 = scanner.nextDouble();
System.out.print("Ingrese el tercer número: ");
num3 = scanner.nextDouble();
// Verificar que los números sean diferentes
while (num1 == num2 || num1 == num3 || num2 == num3) {
System.out.println("Los números deben ser diferentes. Por favor, ingrese nuevamente.");
System.out.print("Ingrese el primer número: ");
num1 = scanner.nextDouble();
System.out.print("Ingrese el segundo número: ");
num2 = scanner.nextDouble();
System.out.print("Ingrese el tercer número: ");
num3 = scanner.nextDouble();
}
// Encontrar el mayor y el menor
double mayor = Math.max(Math.max(num1, num2), num3);
double menor = Math.min(Math.min(num1, num2), num3);
// Imprimir el mayor y el menor
System.out.println("El mayor número es: " + mayor);
System.out.println("El menor número es: " + menor);
}
}
```
### Explicación
1. Se declara un objeto `Scanner` para leer la entrada del usuario.
2. Se piden los tres números al usuario y se almacenan en variables.
3. Se verifica que los números sean diferentes. Si no lo son, se pide al usuario que ingrese nuevamente.
4. Se encuentra el mayor y el menor número utilizando la función `Math.max` y `Math.min`.
5. Se imprime el mayor y el menor número.
### Ejemplo de uso
```
Ingrese el primer número: 10
Ingrese el segundo número: 20
Ingrese el tercer número: 30
El mayor número es: 30.0
El menor número es: 10.0
```
Aquí te dejo un ejemplo de cómo crear un cronómetro en Java que muestra las horas, minutos y segundos:
```java
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class Cronometro extends JFrame {
private JLabel hora;
private JLabel minutos;
private JLabel segundos;
private int segundosContador = 0;
private int minutosContador = 0;
private int horaContador = 0;
public Cronometro() {
setLayout(new FlowLayout());
hora = new JLabel("00:00:00");
minutos = new JLabel("00:00:00");
segundos = new JLabel("00:00:00");
add(hora);
add(minutos);
add(segundos);
Timer timer = new Timer(1000, new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
segundosContador++;
if (segundosContador == 60) {
segundosContador = 0;
minutosContador++;
if (minutosContador == 60) {
minutosContador = 0;
horaContador++;
}
}
hora.setText(String.format("%02d:%02d:%02d", horaContador, minutosContador, segundosContador));
}
});
timer.start();
setSize(300, 100);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
new Cronometro();
}
}
```
Este programa crea una ventana con tres etiquetas que muestran las horas, minutos y segundos. Utiliza un Timer para actualizar el valor de las etiquetas cada segundo. El formato de las etiquetas se ajusta automáticamente para mostrar dos dígitos para cada valor.
Aquí te dejo un ejemplo de cómo podrías implementar este algoritmo en Java:
```java
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int suma = 0;
int contador = 0;
double media = 0;
while (true) {
System.out.print("Introduce un número (0 para salir): ");
int numero = scanner.nextInt();
if (numero == 0) {
break;
}
suma += numero;
contador++;
}
if (contador > 0) {
media = (double) suma / contador;
System.out.println("La suma de los números es: " + suma);
System.out.println("La media de los números es: " + media);
} else {
System.out.println("No se introdujeron números.");
}
scanner.close();
}
}
```
Explicación:
* Creamos un objeto `Scanner` para leer la entrada del usuario.
* Inicializamos variables para almacenar la suma, el contador de números y la media.
* Utilizamos un bucle `while` infinito para leer números hasta que el usuario introduzca un 0.
* Dentro del bucle, leemos un número y comprobamos si es 0. Si es así, salimos del bucle.
* Si el número no es 0, lo sumamos a la suma y incrementamos el contador.
* Después del bucle, comprobamos si se introdujeron números. Si sí, calculamos la media y la imprimimos.
* Finalmente, cerramos el objeto `Scanner` para liberar recursos.
Nota: Es importante cerrar el objeto `Scanner` después de usarlo para evitar problemas de recursos.
Aquí te dejo un ejemplo de cómo podrías implementar un programa en Java que encuentre el menor y el mayor elemento de un vector:
```java
public class EncontrarMenorMayor {
public static void main(String[] args) {
int[] vector = {5, 2, 8, 1, 9};
System.out.println("Vector: " + java.util.Arrays.toString(vector));
System.out.println("Menor: " + encontrarMenor(vector));
System.out.println("Mayor: " + encontrarMayor(vector));
}
public static int encontrarMenor(int[] vector) {
int menor = vector[0];
for (int i = 1; i < vector.length; i++) {
if (vector[i] < menor) {
menor = vector[i];
}
}
return menor;
}
public static int encontrarMayor(int[] vector) {
int mayor = vector[0];
for (int i = 1; i < vector.length; i++) {
if (vector[i] > mayor) {
mayor = vector[i];
}
}
return mayor;
}
}
```
En este ejemplo, creamos un método `encontrarMenor` que recorre el vector y encuentra el elemento más pequeño. De manera similar, creamos un método `encontrarMayor` que recorre el vector y encuentra el elemento más grande. Luego, en el método `main`, creamos un vector y llamamos a estos métodos para encontrar el menor y el mayor elemento.
También puedes utilizar la clase `Arrays` de Java para encontrar el menor y el mayor elemento de manera más concisa:
```java
public class EncontrarMenorMayor {
public static void main(String[] args) {
int[] vector = {5, 2, 8, 1, 9};
System.out.println("Vector: " + java.util.Arrays.toString(vector));
System.out.println("Menor: " + encontrarMenor(vector));
System.out.println("Mayor: " + encontrarMayor(vector));
}
public static int encontrarMenor(int[] vector) {
return java.util.Arrays.stream(vector).min().getAsInt();
}
public static int encontrarMayor(int[] vector) {
return java.util.Arrays.stream(vector).max().getAsInt();
}
}
```
En este ejemplo, utilizamos la clase `Arrays` para crear un flujo de elementos del vector y luego llamamos a los métodos `min` y `max` para encontrar el menor y el mayor elemento, respectivamente.
Aquí te dejo un ejemplo de cómo podrías implementar el programa en Java:
```java
public class Multiplicador {
public static void main(String[] args) {
int numero = 5;
int[] vector = {1, 2, 3, 4, 5};
System.out.println("Vector original: ");
imprimirVector(vector);
int[] resultado = multiplicarVector(numero, vector);
System.out.println("\nVector multiplicado por " + numero + ": ");
imprimirVector(resultado);
}
public static int[] multiplicarVector(int numero, int[] vector) {
int[] resultado = new int[vector.length];
for (int i = 0; i < vector.length; i++) {
resultado[i] = vector[i] * numero;
}
return resultado;
}
public static void imprimirVector(int[] vector) {
for (int i = 0; i < vector.length; i++) {
System.out.print(vector[i] + " ");
}
System.out.println();
}
}
```
En este ejemplo, creamos una clase llamada `Multiplicador` con un método `multiplicarVector` que recibe un número y un vector como parámetros, y devuelve un nuevo vector con los elementos multiplicados por el número. El método `imprimirVector` se utiliza para imprimir el contenido de un vector.
En el método `main`, creamos un vector y lo multiplicamos por un número, luego imprimimos el resultado.
Aquí te muestro un ejemplo de cómo podrías implementar el algoritmo en Java:
```java
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Pedir los tres valores al usuario
System.out.println("Ingrese el primer valor:");
double valor1 = scanner.nextDouble();
System.out.println("Ingrese el segundo valor:");
double valor2 = scanner.nextDouble();
System.out.println("Ingrese el tercer valor:");
double valor3 = scanner.nextDouble();
// Verificar si los tres valores son diferentes
if (valor1 == valor2 || valor1 == valor3 || valor2 == valor3) {
System.out.println("Los tres valores deben ser diferentes.");
return;
}
// Encontrar el mayor y el menor valor
double mayor = Math.max(Math.max(valor1, valor2), valor3);
double menor = Math.min(Math.min(valor1, valor2), valor3);
// Imprimir el mayor y el menor valor
System.out.println("El mayor valor es: " + mayor);
System.out.println("El menor valor es: " + menor);
}
}
```
Este algoritmo utiliza un `Scanner` para leer los tres valores del usuario. Luego, verifica si los tres valores son diferentes. Si no lo son, imprime un mensaje de error y termina el programa. Si los valores son diferentes, utiliza `Math.max` y `Math.min` para encontrar el mayor y el menor valor, respectivamente. Finalmente, imprime el mayor y el menor valor.
Recuerda que este algoritmo asume que los valores ingresados por el usuario son números enteros o decimales. Si deseas que el algoritmo sea más robusto, podrías agregar una excepción para manejar el caso en el que el usuario ingrese un valor que no sea un número.
**VectorSumaCuadrada.java**
```java
public class VectorSumaCuadrada {
/**
* Calcula la suma al cuadrado de las componentes de un vector.
*
* @param vector el vector cuyas componentes se van a sumar al cuadrado
* @return la suma al cuadrado de las componentes del vector
*/
public static double sumaCuadrada(double[] vector) {
double suma = 0;
for (double componente : vector) {
suma += componente * componente;
}
return suma;
}
public static void main(String[] args) {
// Ejemplo de uso
double[] vector = {1, 2, 3, 4, 5};
double resultado = sumaCuadrada(vector);
System.out.println("La suma al cuadrado de las componentes del vector es: " + resultado);
}
}
```
Este programa define una clase `VectorSumaCuadrada` con un método estático `sumaCuadrada` que calcula la suma al cuadrado de las componentes de un vector. El método recibe un array de doubles como parámetro y devuelve el resultado como un double.
En el método `main`, se crea un ejemplo de uso donde se define un vector con 5 componentes y se llama al método `sumaCuadrada` para calcular la suma al cuadrado de sus componentes. El resultado se imprime en la consola.
Para compilar y ejecutar este programa, necesitarás tener instalado un entorno de desarrollo Java (como Eclipse o NetBeans) y haber configurado correctamente el proyecto.
Aquí te muestro un ejemplo de cómo podrías implementar este algoritmo en JavaScript:
```javascript
// Función para leer tres valores y almacenarlos en variables
function leerValores() {
let num1 = parseFloat(prompt("Ingrese el primer valor:"));
let num2 = parseFloat(prompt("Ingrese el segundo valor:"));
let num3 = parseFloat(prompt("Ingrese el tercer valor:"));
// Verificar que los tres números sean diferentes
while (num1 === num2 || num1 === num3 || num2 === num3) {
alert("Los tres números deben ser diferentes. Por favor, ingrese nuevamente.");
num1 = parseFloat(prompt("Ingrese el primer valor:"));
num2 = parseFloat(prompt("Ingrese el segundo valor:"));
num3 = parseFloat(prompt("Ingrese el tercer valor:"));
}
// Imprimir el mayor y el menor de los tres números
let mayor = Math.max(num1, num2, num3);
let menor = Math.min(num1, num2, num3);
alert(`El mayor de los tres números es: ${mayor}`);
alert(`El menor de los tres números es: ${menor}`);
}
// Llamar a la función para leer los valores
leerValores();
```
En este código, la función `leerValores()` solicita al usuario que ingrese tres valores y los almacena en las variables `num1`, `num2` y `num3`. Luego, utiliza un bucle `while` para verificar que los tres números sean diferentes. Si no lo son, solicita al usuario que ingrese nuevamente los valores. Finalmente, utiliza las funciones `Math.max()` y `Math.min()` para determinar el mayor y el menor de los tres números, y muestra los resultados en una ventana de alerta.
**Calculadora de Suma y Media**
```java
public class CalculadoraSumaMedia {
public static void main(String[] args) {
calcularSumaMedia();
}
public static void calcularSumaMedia() {
double suma = 0;
int contador = 0;
double numero;
while (true) {
System.out.print("Introduce un número (0 para salir): ");
numero = leerNumero();
if (numero == 0) {
break;
}
suma += numero;
contador++;
}
if (contador > 0) {
System.out.println("La suma de los números es: " + suma);
System.out.println("La media de los números es: " + suma / contador);
} else {
System.out.println("No se introdujeron números.");
}
}
public static double leerNumero() {
Scanner scanner = new Scanner(System.in);
while (true) {
try {
return scanner.nextDouble();
} catch (InputMismatchException e) {
System.out.print("Error: introdujo un valor no numérico. Por favor, inténtelo de nuevo: ");
scanner.next(); // Borrar el valor no numérico
}
}
}
}
```
Este algoritmo utiliza un bucle `while` para pedir números al usuario hasta que se introduzca un cero. La suma y la media de los números introducidos se calculan y se imprimen al final. El método `leerNumero()` se utiliza para leer números del usuario y manejar errores de entrada.
Aquí te dejo un ejemplo de cómo crear un cronómetro en Java que muestra las horas, minutos y segundos. Este programa utiliza la clase `Thread` para crear un hilo que actualiza el cronómetro cada segundo.
```java
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class Cronometro extends JFrame {
private JLabel horaLabel;
private JLabel minutoLabel;
private JLabel segundoLabel;
private int segundos = 0;
private int minutos = 0;
private int horas = 0;
public Cronometro() {
setLayout(new FlowLayout());
horaLabel = new JLabel("00");
horaLabel.setFont(new Font("Arial", Font.BOLD, 24));
add(horaLabel);
minutoLabel = new JLabel("00");
minutoLabel.setFont(new Font("Arial", Font.BOLD, 24));
add(minutoLabel);
segundoLabel = new JLabel("00");
segundoLabel.setFont(new Font("Arial", Font.BOLD, 24));
add(segundoLabel);
JButton startButton = new JButton("Iniciar");
startButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
start();
}
});
add(startButton);
JButton stopButton = new JButton("Detener");
stopButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
stop();
}
});
add(stopButton);
JButton resetButton = new JButton("Reset");
resetButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
reset();
}
});
add(resetButton);
setSize(300, 100);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(true);
}
private void start() {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
try {
Thread.sleep(1000);
segundos++;
if (segundos == 60) {
minutos++;
segundos = 0;
}
if (minutos == 60) {
horas++;
minutos = 0;
}
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
horaLabel.setText(String.format("%02d", horas));
minutoLabel.setText(String.format("%02d", minutos));
segundoLabel.setText(String.format("%02d", segundos));
}
});
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
});
thread.start();
}
private void stop() {
Thread thread = Thread.currentThread();
thread.interrupt();
}
private void reset() {
segundos = 0;
minutos = 0;
horas = 0;
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
horaLabel.setText("00");
minutoLabel.setText("00");
segundoLabel.setText("00");
}
});
}
public static void main(String[] args) {
new Cronometro();
}
}
```
Este programa crea una ventana con un cronómetro que muestra las horas, minutos y segundos. El cronómetro se puede iniciar, detener y resetear mediante botones. El cronómetro actualiza automáticamente cada segundo.
Recuerda que este es un ejemplo básico y puedes personalizarlo según tus necesidades.
Aquí te dejo un ejemplo simple de un cronómetro en Java que muestra las horas, minutos y segundos:
```java
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class Cronometro extends JFrame {
private JLabel hora;
private JLabel minutos;
private JLabel segundos;
private int segundosContador = 0;
private int minutosContador = 0;
private int horaContador = 0;
public Cronometro() {
setLayout(new FlowLayout());
hora = new JLabel("00:00:00");
minutos = new JLabel("00:00:00");
segundos = new JLabel("00:00:00");
add(hora);
add(minutos);
add(segundos);
Timer timer = new Timer(1000, new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
segundosContador++;
if (segundosContador == 60) {
segundosContador = 0;
minutosContador++;
if (minutosContador == 60) {
minutosContador = 0;
horaContador++;
}
}
hora.setText(String.format("%02d:%02d:%02d", horaContador, minutosContador, segundosContador));
}
});
timer.start();
setSize(300, 100);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
new Cronometro();
}
}
```
Este programa crea una ventana con tres etiquetas que muestran las horas, minutos y segundos. Utiliza un Timer para actualizar el valor de las etiquetas cada segundo. El valor de las etiquetas se actualiza de la siguiente manera:
- Si el contador de segundos llega a 60, se resetea a 0 y se incrementa el contador de minutos.
- Si el contador de minutos llega a 60, se resetea a 0 y se incrementa el contador de horas.
El valor de las etiquetas se muestra en formato "HH:MM:SS" con ceros a la izquierda para que siempre tenga dos dígitos.
Aquí te dejo un ejemplo de cómo podrías implementar este programa en Java:
```java
import java.util.Scanner;
public class Primo {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Introduce un número:");
int numero = scanner.nextInt();
if (esPrimo(numero)) {
System.out.println(numero + " es primo.");
} else {
System.out.println(numero + " no es primo.");
}
scanner.close();
}
public static boolean esPrimo(int numero) {
if (numero <= 1) {
return false;
}
int raizCuadrada = (int) Math.sqrt(numero);
for (int i = 2; i <= raizCuadrada; i++) {
if (numero % i == 0) {
return false;
}
}
return true;
}
}
```
Aquí te explico qué hace cada parte del código:
* En la línea `Scanner scanner = new Scanner(System.in);`, creamos un objeto `Scanner` que nos permite leer la entrada del usuario desde la consola.
* En la línea `System.out.println("Introduce un número:");`, imprimimos un mensaje que pide al usuario que introduzca un número.
* En la línea `int numero = scanner.nextInt();`, leemos el número introducido por el usuario y lo almacenamos en la variable `numero`.
* En la función `esPrimo(numero)`, comprobamos si el número es primo. Si el número es menor o igual a 1, no es primo, por lo que devolvemos `false`.
* Calculamos la raíz cuadrada del número y la almacenamos en la variable `raizCuadrada`.
* Luego, recorremos los números del 2 al `raizCuadrada` y comprobamos si el número es divisible por alguno de ellos. Si lo es, no es primo, por lo que devolvemos `false`.
* Si no encontramos ningún divisor, el número es primo, por lo que devolvemos `true`.
* Finalmente, en la línea `scanner.close();`, cerramos el objeto `Scanner` para liberar los recursos.
Espero que esto te ayude a entender cómo funciona el código. ¡Si tienes alguna pregunta, no dudes en preguntar!
Aquí te dejo un ejemplo de código en Java que realiza la operación que mencionas:
```java
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// Creamos un objeto Scanner para leer la entrada del usuario
Scanner scanner = new Scanner(System.in);
// Pedimos al usuario que ingrese los dos números
System.out.println("Ingrese el primer número:");
double num1 = scanner.nextDouble();
System.out.println("Ingrese el segundo número:");
double num2 = scanner.nextDouble();
// Verificamos las condiciones y realizamos la operación correspondiente
if (num1 == num2) {
// Si los números son iguales, los multiplicamos
double resultado = num1 * num2;
System.out.println("Los números son iguales, el resultado de multiplicarlos es: " + resultado);
} else if (num1 > num2) {
// Si el primer número es mayor que el segundo, los restamos
double resultado = num1 - num2;
System.out.println("El primer número es mayor que el segundo, el resultado de restarlos es: " + resultado);
} else {
// Si no, los sumamos
double resultado = num1 + num2;
System.out.println("Los números no son iguales y el primer número no es mayor que el segundo, el resultado de sumarlos es: " + resultado);
}
// Cerramos el objeto Scanner para liberar recursos
scanner.close();
}
}
```
Explicación:
* Creamos un objeto `Scanner` para leer la entrada del usuario.
* Pedimos al usuario que ingrese los dos números.
* Verificamos las condiciones y realizamos la operación correspondiente:
+ Si los números son iguales, los multiplicamos.
+ Si el primer número es mayor que el segundo, los restamos.
+ Si no, los sumamos.
* Imprimimos el resultado de la operación.
* Cerramos el objeto `Scanner` para liberar recursos.
Recuerda que este es un ejemplo básico y puedes personalizarlo según tus necesidades.
**Calculadora de Salario con Horas Extras en Java**
Aquí te muestro un ejemplo de cómo calcular el salario de un trabajador en Java, teniendo en cuenta las horas extras y el aumento de tarifa correspondiente.
### Clase `Trabajador`
```java
public class Trabajador {
private String nombre;
private double tarifaPorHora;
private int horasTrabajadas;
public Trabajador(String nombre, double tarifaPorHora, int horasTrabajadas) {
this.nombre = nombre;
this.tarifaPorHora = tarifaPorHora;
this.horasTrabajadas = horasTrabajadas;
}
public double calcularSalario() {
double salario = 0;
int horasExtras = Math.max(horasTrabajadas - 40, 0);
// Calcular salario por horas normales
salario += (horasTrabajadas - horasExtras) * tarifaPorHora;
// Calcular salario por horas extras
double tarifaPorHoraExtras = tarifaPorHora * 1.5; // Incrementar tarifa en un 50%
salario += horasExtras * tarifaPorHoraExtras;
return salario;
}
public String getNombre() {
return nombre;
}
public double getTarifaPorHora() {
return tarifaPorHora;
}
public int getHorasTrabajadas() {
return horasTrabajadas;
}
}
```
### Clase `Main`
```java
public class Main {
public static void main(String[] args) {
// Crear un trabajador con 50 horas trabajadas y una tarifa de $20 por hora
Trabajador trabajador = new Trabajador("Juan", 20, 50);
// Calcular salario
double salario = trabajador.calcularSalario();
// Mostrar resultados
System.out.println("Nombre: " + trabajador.getNombre());
System.out.println("Tarifa por hora: $" + trabajador.getTarifaPorHora());
System.out.println("Horas trabajadas: " + trabajador.getHorasTrabajadas());
System.out.println("Salario: $" + salario);
}
}
```
### Explicación
1. La clase `Trabajador` tiene tres atributos: `nombre`, `tarifaPorHora` y `horasTrabajadas`.
2. El método `calcularSalario()` calcula el salario del trabajador en función de las horas trabajadas y la tarifa por hora.
3. Si las horas trabajadas son mayores a 40, se calcula el salario por horas extras con una tarifa incrementada en un 50%.
4. En la clase `Main`, se crea un trabajador con 50 horas trabajadas y una tarifa de $20 por hora.
5. Se calcula el salario del trabajador utilizando el método `calcularSalario()` y se muestra en la consola.
Espero que esto te ayude a entender cómo calcular el salario de un trabajador en Java. ¡Si tienes alguna pregunta, no dudes en preguntar!
Aquí te dejo un ejemplo simple de un cronómetro en Java que muestra las horas, minutos y segundos:
```java
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class Cronometro extends JFrame {
private JLabel hora;
private JLabel minuto;
private JLabel segundo;
private int segundos = 0;
private int minutos = 0;
private int horas = 0;
public Cronometro() {
setLayout(new FlowLayout());
hora = new JLabel("00:00:00");
hora.setFont(new Font("Arial", Font.BOLD, 48));
add(hora);
minuto = new JLabel("Minutos: 0");
minuto.setFont(new Font("Arial", Font.BOLD, 24));
add(minuto);
segundo = new JLabel("Segundos: 0");
segundo.setFont(new Font("Arial", Font.BOLD, 24));
add(segundo);
JButton start = new JButton("Iniciar");
start.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
startCronometro();
}
});
add(start);
JButton stop = new JButton("Detener");
stop.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
detenerCronometro();
}
});
add(stop);
JButton reset = new JButton("Reset");
reset.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
resetCronometro();
}
});
add(reset);
setSize(400, 200);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(true);
}
private void startCronometro() {
Timer timer = new Timer(1000, new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
segundos++;
if (segundos == 60) {
segundos = 0;
minutos++;
if (minutos == 60) {
minutos = 0;
horas++;
}
}
hora.setText(String.format("%02d:%02d:%02d", horas, minutos, segundos));
minuto.setText("Minutos: " + minutos);
segundo.setText("Segundos: " + segundos);
}
});
timer.start();
}
private void detenerCronometro() {
Timer timer = (Timer) (new Timer(1000, new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// No hacer nada
}
}));
timer.stop();
}
private void resetCronometro() {
segundos = 0;
minutos = 0;
horas = 0;
hora.setText("00:00:00");
minuto.setText("Minutos: 0");
segundo.setText("Segundos: 0");
}
public static void main(String[] args) {
new Cronometro();
}
}
```
Este programa crea una ventana con un cronómetro que muestra las horas, minutos y segundos. También incluye botones para iniciar, detener y resetear el cronómetro.
**Tienda**
### Descripción
Este programa simula una tienda donde se pueden comprar artículos. Si el número de artículos comprados es menor a 6, se paga en efectivo. En caso contrario, se paga con tarjeta. Los artículos pagados en efectivo tienen un impuesto del 20% sobre el valor original, mientras que los artículos pagados con tarjeta tienen un impuesto del 5% sobre el total pagado.
### Código
```java
import java.util.Scanner;
public class Tienda {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int numArticulos = 0;
double totalEfectivo = 0;
double totalTarjeta = 0;
System.out.println("Bienvenido a la tienda");
while (true) {
System.out.println("¿Desea comprar un artículo? (s/n)");
String respuesta = scanner.nextLine();
if (respuesta.equalsIgnoreCase("n")) {
break;
}
System.out.println("Ingrese el valor del artículo:");
double valorArticulo = scanner.nextDouble();
scanner.nextLine(); // Limpiar el buffer
numArticulos++;
totalEfectivo += valorArticulo;
totalTarjeta += valorArticulo;
System.out.println("Artículo agregado con éxito");
}
if (numArticulos < 6) {
System.out.println("Pagaré en efectivo");
double impuestoEfectivo = totalEfectivo * 0.20;
double totalPagar = totalEfectivo + impuestoEfectivo;
System.out.println("Total a pagar: " + totalPagar);
System.out.println("Valor original: " + totalEfectivo);
System.out.println("Impuesto: " + impuestoEfectivo);
} else {
System.out.println("Pagaré con tarjeta");
double impuestoTarjeta = totalTarjeta * 0.05;
double totalPagar = totalTarjeta + impuestoTarjeta;
System.out.println("Total a pagar: " + totalPagar);
System.out.println("Valor original: " + totalTarjeta);
System.out.println("Impuesto: " + impuestoTarjeta);
}
}
}
```
### Ejemplo de uso
1. Correr el programa.
2. Se mostrará un menú para comprar artículos.
3. Ingrese el valor del artículo cada vez que se le solicite.
4. Cuando desee terminar, ingrese "n".
5. El programa calculará el total a pagar según las reglas establecidas y mostrará los resultados.
Aquí te dejo un ejemplo de cómo podrías implementar el algoritmo que pides en Java:
```java
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// Creamos un objeto Scanner para leer la entrada del usuario
Scanner scanner = new Scanner(System.in);
// Variable para almacenar la suma de los números
double suma = 0;
// Variable para almacenar la cantidad de números introducidos
int cantidad = 0;
// Variable para almacenar el último número introducido
double ultimoNumero = 0;
// Bucle para leer números hasta que se introduzca un cero
while (ultimoNumero != 0) {
// Pedimos al usuario que introduzca un número
System.out.print("Introduce un número (0 para terminar): ");
ultimoNumero = scanner.nextDouble();
// Si el número no es cero, lo sumamos a la suma y aumentamos la cantidad
if (ultimoNumero != 0) {
suma += ultimoNumero;
cantidad++;
}
}
// Cerramos el objeto Scanner para liberar recursos
scanner.close();
// Calculamos la media de los números introducidos
double media = suma / cantidad;
// Imprimimos la suma y la media de los números introducidos
System.out.println("La suma de los números introducidos es: " + suma);
System.out.println("La media de los números introducidos es: " + media);
}
}
```
Este código utiliza un bucle `while` para leer números hasta que se introduzca un cero. La suma de los números se almacena en la variable `suma`, y la cantidad de números introducidos se almacena en la variable `cantidad`. La media de los números introducidos se calcula dividiendo la suma por la cantidad. Finalmente, se imprimen la suma y la media de los números introducidos.
Recuerda que debes cerrar el objeto `Scanner` después de usarlo para liberar recursos y evitar problemas de memoria.
Aquí te dejo un ejemplo simple de un cronómetro en Java utilizando la clase `Thread` para crear un hilo que actualice el tiempo cada segundo.
```java
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class Cronometro extends JFrame {
private JLabel hora;
private JLabel minutos;
private JLabel segundos;
private int segundosContador = 0;
private int minutosContador = 0;
private int horaContador = 0;
public Cronometro() {
setLayout(new FlowLayout());
hora = new JLabel("00:00:00");
minutos = new JLabel("00:00:00");
segundos = new JLabel("00:00:00");
add(hora);
add(minutos);
add(segundos);
Timer timer = new Timer(1000, new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
segundosContador++;
if (segundosContador == 60) {
segundosContador = 0;
minutosContador++;
if (minutosContador == 60) {
minutosContador = 0;
horaContador++;
}
}
hora.setText(String.format("%02d:%02d:%02d", horaContador, minutosContador, segundosContador));
}
});
timer.start();
setSize(300, 100);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args) {
new Cronometro();
}
}
```
Este programa crea una ventana con tres etiquetas que muestran el tiempo en formato "HH:MM:SS". El cronómetro actualiza el tiempo cada segundo utilizando un `Timer`.
Recuerda que para ejecutar este programa, debes tener instalado Java en tu computadora y tener acceso a un entorno de desarrollo como Eclipse o NetBeans.
Si no sabes cómo crear un proyecto en Eclipse o NetBeans, aquí te dejo algunos pasos básicos:
1. Descarga e instala Eclipse o NetBeans.
2. Crea un nuevo proyecto de Java en Eclipse o NetBeans.
3. Copia y pega el código anterior en el archivo `Cronometro.java`.
4. Compila y ejecuta el programa.
Espero que esto te ayude a entender cómo funciona un cronómetro en Java. ¡Si tienes alguna pregunta, no dudes en preguntar!
