1.Utilizar arreglos para realizar cálculos básicos y manejar posibles errores. Instrucciones: Solicita al usuario que ingrese un tamaño para un arreglo (debe ser mayor que 0). o Si el tamaño es inválido (negativo o cero), lanza una excepción personalizada TamañoInvalidoException. 2.Llena el arreglo con números aleatorios entre 1 y 100. 3. Implementa métodos para: o Calcular el promedio de los números en el arreglo. o Encontrar el número mayor y menor. o Contar cuántos números son múltiplos de 5. 4. Muestra los resultados, manejando excepciones para evitar errores en caso de que el tamaño sea incorrecto o el arreglo esté vacío. Agrega una excepción personalizada. Rubrica: 1.Demuestra entendimiento del problema, identificando claramente los entradas, salidas y restricciones. .

A continuación, te proporciono una solución en Java que cumple con las instrucciones dadas.

### TamañoInvalidoException.java
```java
public class TamañoInvalidoException extends Exception {
    public TamañoInvalidoException(String mensaje) {
        super(mensaje);
    }
}
```

### ArregloCalculos.java
```java
import java.util.Random;
import java.util.Scanner;

public class ArregloCalculos {
    private static final int MINIMO = 1;
    private static final int MAXIMO = 100;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int tamaño;

        // Solicitar tamaño al usuario y manejar excepciones
        while (true) {
            try {
                System.out.print("Ingrese el tamaño del arreglo (mayor que 0): ");
                tamaño = scanner.nextInt();
                if (tamaño <= 0) {
                    throw new TamañoInvalidoException("El tamaño debe ser mayor que 0.");
                }
                break;
            } catch (TamañoInvalidoException e) {
                System.out.println(e.getMessage());
            } catch (Exception e) {
                System.out.println("Error al leer el tamaño. Por favor, ingrese un número entero.");
                scanner.next(); // Limpiar el buffer
            }
        }

        // Llenar arreglo con números aleatorios
        int[] arreglo = new int[tamaño];
        Random random = new Random();
        for (int i = 0; i < tamaño; i++) {
            arreglo[i] = random.nextInt(MAXIMO - MINIMO + 1) + MINIMO;
        }

        // Mostrar arreglo
        System.out.println("Arreglo:");
        for (int i = 0; i < tamaño; i++) {
            System.out.print(arreglo[i] + " ");
        }
        System.out.println();

        // Calcular promedio
        double promedio = calcularPromedio(arreglo);
        System.out.println("Promedio: " + promedio);

        // Encontrar número mayor y menor
        int mayor = encontrarMayor(arreglo);
        int menor = encontrarMenor(arreglo);
        System.out.println("Número mayor: " + mayor);
        System.out.println("Número menor: " + menor);

        // Contar múltiplos de 5
        int multiplosDe5 = contarMultiplosDe5(arreglo);
        System.out.println("Número de múltiplos de 5: " + multiplosDe5);
    }

    private static double calcularPromedio(int[] arreglo) {
        if (arreglo.length == 0) {
            throw new ArregloVacioException("El arreglo está vacío.");
        }
        int suma = 0;
        for (int numero : arreglo) {
            suma += numero;
        }
        return (double) suma / arreglo.length;
    }

    private static int encontrarMayor(int[] arreglo) {
        if (arreglo.length == 0) {
            throw new ArregloVacioException("El arreglo está vacío.");
        }
        int mayor = arreglo[0];
        for (int numero : arreglo) {
            if (numero > mayor) {
                mayor = numero;
            }
        }
        return mayor;
    }

    private static int encontrarMenor(int[] arreglo) {
        if (arreglo.length == 0) {
            throw new ArregloVacioException("El arreglo está vacío.");
        }
        int menor = arreglo[0];
        for (int numero : arreglo) {
            if (numero < menor) {
                menor = numero;
            }
        }
        return menor;
    }

    private static int contarMultiplosDe5(int[] arreglo) {
        if (arreglo.length == 0) {
            throw new ArregloVacioException("El arreglo está vacío.");
        }
        int multiplos = 0;
        for (int numero : arreglo) {
            if (numero % 5 == 0) {
                multiplos++;
            }
        }
        return multiplos;
    }
}

class ArregloVacioException extends Exception {
    public ArregloVacioException(String mensaje) {
        super(mensaje);
    }
}
```

### Explicación

La solución consta de dos clases: `TamañoInvalidoException` y `ArregloCalculos`. La primera clase define una excepción personalizada para manejar el caso en que el usuario ingrese un tamaño inválido. La segunda clase contiene el código principal que solicita el tamaño del arreglo, llena el arreglo con números aleatorios, calcula el promedio, encuentra el número mayor y menor, y cuenta los múltiplos de 5.

La clase `ArregloCalculos` utiliza un bucle `while` para solicitar el tamaño del arreglo al usuario y manejar excepciones en caso de que el tamaño sea inválido. Luego, llena el arreglo con números aleatorios entre 1 y 100.

Los métodos `calcularPromedio`, `encontrarMayor`, `encontrarMenor` y `contarMultiplosDe5` se utilizan para realizar los cálculos correspondientes. Estos métodos manejan excepciones en caso de que el arreglo esté vacío.

Finalmente, la solución muestra los resultados en la consola.

### Ejemplo de uso

Al ejecutar la solución, se mostrará la siguiente salida:
```
Ingrese el tamaño del arreglo (mayor que 0): 10
Arreglo:
34 13 67 82 11 45 98 23 56 79
Promedio: 48.2
Número mayor: 98
Número menor: 11
Número de múltiplos de 5: 2
```
Nota que el tamaño del arreglo y los números aleatorios generados serán diferentes en cada ejecución.