Foros aprenderaprogramar.com
Didáctica y divulgación de la programación

Para el ID único, antes de añadir la nueva persona al ArrayList hay que comprobar si este ya contiene una persona con el mismo ID.
Si ya lo tuviera, pues habría que volver a pedir un nuevo ID al usuario, hasta que finalmente él nos de uno que no exista en el registro.

    public void Registrar(){
        String id, ape, nom, sex;
        int edad;
        double peso;
        Scanner sc = new Scanner(System.in);
        System.out.print("Id: ");
        id = sc.next();
        System.out.print("Nombre: ");
        nom = sc.next();
        System.out.print("Apellidos: ");
        ape = sc.next();
        System.out.print("Sexo: ");
        sex = sc.next();
        System.out.print("Peso: ");
        peso = sc.nextDouble();
        System.out.print("Edad: ");
        edad = sc.nextInt();
        Persona persona = new Persona(id, nom, ape, sex, peso, edad);
        //No añadimos la persona hasta asegurarnos de que su ID es único
        while (ListaPersonas.contains(persona) {
                System.out.print("Ya existe una persona con este ID, proporcione otro: ");
                persona.setId(sc.next());
        }
        ListaPersonas.add(persona);
    }

Si lo del ID no queremos dejarlo en manos del usuario, se puede hacer lo que hicimos con la clase Producto, que sea esta la que vaya generando los ID cada vez que se registraba un producto.

El problema es que has copiado demasiado literalmente ese método de otro ejercicio sobre "deportistas" (recuerda cambiar el texto de los mensajes que se mostrarán en pantalla) y estás usando un método equivocado para obtener el ID del producto.
Ese método getCodigo() no existe en la clase Producto.

      Producto buscado = null;
      for (int i = 0; i < productos.size(); i++)
         if (productos.get(i).getCodigo().equals(codigo))
            buscado = productos.get(i);

Para los productos no estamos usando un "código", si no un identificador "ID"-
Que además es un int, no un String como era el código del deportista.

El método borrar() debería quedar algo como esto:
private static void borrar() {
System.out.println("\n\t--ELIMINAR PRODUCTO--");
System.out.print("ID producto: ");
int id = Integer.parseInt(teclado.nextLine());

Producto buscado = null;
for (int i = 0; i < productos.size(); i++)
if (productos.get(i).getId() == id)
buscado = productos.get(i);

if (buscado == null)
System.out.println("\nNo existe producto con el ID: " + id);
else {
productos.remove(buscado);
System.out.println("\nProducto eliminado");
}
}
Está bien buscar ejemplos de otros ejercicios para aplicar la misma lógica, pero no servirá hacer un simplemente copy-paste. Hay que entender esa lógica para poder adaptarla al ejercicio actual.

También es importante saber interpretar los errores que nos da el compilador.
Se supone que el error te habrá mostrado un mensaje similar a "The method getCodigo() is undefined for the type Producto"

Está claro que eso significa que estamos llamando a un método que no ha sido definido para la clase/tipo Producto. Así que al ver ese error, lo que haremos será revisar la clase Producto y comprobar cuál sería el método equivalente al que tenemos que llamar realmente.

Un saludo.

Hola.
Suponiendo una clase Juego como esta:
public class Juego {

private String nombre;
private String fecha;
private double precio;

public Juego() {
nombre = "";
fecha = "";
precio = 0d;
}

public String getNombre() {
return nombre;
}

public void setNombre(String nombre) {
this.nombre = nombre;
}

public String getFecha() {
return fecha;
}

public void setFecha(String fecha) {
this.fecha = fecha;
}

public double getPrecio() {
return precio;
}

public void setPrecio(double precio) {
this.precio = precio;
}

@Override
public String toString() {
return String.format("Nombre: %s\nFecha: %s\nPrecio: %.2f", nombre, fecha, precio);
}

}
Como nos dicen que solo hay UN JUEGO, y solo uno, en el programa principal puedes declarar un objeto de esa clase, ya sea dentro del método main o como atributo de clase, y trabajar sobre él.

Dejo aquí un ejemplo donde solo he puesto el código para registrar juego, borrar su nombre e imprimir

public class Registro {

private static Juego juego = null;
private static Scanner teclado = new Scanner(System.in);

public static void main(String[] args) {

int opcion = 0;
while (opcion != 8) {
System.out.println("\n[1] -- Registrar Juego");
System.out.println("[2] -- Borrar Nombre");
System.out.println("[3] -- Borrar Fecha");
System.out.println("[5] -- Borrar Precio");
System.out.println("[6] -- Actualizar Nombre y Fecha");
System.out.println("[7] -- Imprimir");
System.out.println("[8] -- SALIR");
System.out.print("Opcion: ");
opcion = Integer.parseInt(teclado.nextLine());

switch(opcion) {
case 1:
System.out.println("\nREGISTRAR JUEGO");
juego = new Juego();
System.out.print("\nIntroduzca nombre: ");
juego.setNombre(teclado.nextLine());
System.out.print("Fecha: ");
juego.setFecha(teclado.nextLine());
System.out.print("Precio: ");
juego.setPrecio(Double.parseDouble(teclado.nextLine()));
break;
case 2:
System.out.println("\nBORRAR NOMBRE");
if (juego == null)
System.out.println("No hay juego registrado");
else {
juego.setNombre("");
System.out.println("Nombre borrado");
}
break;
case 3:
break;
case 4:
break;
case 5:
break;
case 6:
break;
case 7:
System.out.println("\nDATOS DEL JUEGO\n");
if (juego == null)
System.out.println("No hay juego registrado");
else
System.out.println(juego);
break;
case 8:
break;
default:
System.out.println("\n\t\tFIN DE PROGRAMA");

}
}

}

}

Vale, pues olvídate de la clase Pair, no la necesitas.

De hecho, creo que estás haciendo una implementación más complicada de lo que estaría pidiendo el enunciado.

Yo la clase CuentaBancaria la escribiría un poco distinta.
Tu método getDatosCuenta() me parece demasiado complicado al retornar un List de Strings. Si su propósito va a ser simplemente mostrar en pantalla los datos de la cuenta, podemos solucionarlo construyendo un único String con todos esos datos.
Con String.format() se puede hacer de forma sencilla y además hará el redondeo del valor double sin tener que recurrir a otras clases.

El método realizarTransferencia(). Como este método pertenece a la clase CuentaBancaria,es decir, lo vamos a invocar desde un objeto de dicha clase, no es necesario que reciba además dos objetos CuentaBancaria como argumentos entre paréntesis.
Bastaría con recibir uno, que será la cuenta "destino" donde se transferirá el importe. La cuenta "origen", será el propio objeto desde el que vamos a invocar este método.

Por cierto, conviene comprobar si la cuenta origen tiene suficiente saldo para cubrir el importe de la transferencia, a no ser que estemos de acuerdo en que la cuenta pueda tener saldo negativo y estar en deuda con el banco 

Esta sería mi clase CuentaBancaria
import java.util.Random;

public class CuentaBancaria {

private double saldoDeCuenta;
    private String nombreDelTitular;
    private long numeroDeCuenta;
   
    public CuentaBancaria(String nombreDelTitular, double saldoDeCuenta) {
        this.saldoDeCuenta = saldoDeCuenta;
        this.nombreDelTitular = nombreDelTitular;
        Random numAleatorioCuenta = new Random();
        this.numeroDeCuenta = Math.abs(numAleatorioCuenta.nextLong());
    }
   
    public double getSaldo() {
    return saldoDeCuenta;
    }
   
    public String getDatosCuenta() {
    return String.format("CCC: %d\nNombre: %s\nSaldo: %.2f", numeroDeCuenta, nombreDelTitular, saldoDeCuenta);
    }
   
    public void realizarTransferencia(CuentaBancaria otraCuenta, double importe) {
   
    if (importe > saldoDeCuenta)
    System.out.println("Esta cuenta no tiene saldo suficiente para cubrir el importe a transferir");
    else {
    saldoDeCuenta -= importe;
    otraCuenta.saldoDeCuenta += importe;
    }
    }
}
Y ahora, una clase para comprobar que funciona la transferencia de dinero, nos puede servir una tan simple y sencilla como esta:
public class Test {

public static void main(String[] args) {

//Creamos cuentas
CuentaBancaria CCC1 = new CuentaBancaria("Sandra Ramirez", 45000.64);
CuentaBancaria CCC2 = new CuentaBancaria("Antonio Losada", 20000.93);

//Mostramos
System.out.println("Cuentas bancarias:");
System.out.println("\n" + CCC1.getDatosCuenta());
System.out.println("\n" + CCC2.getDatosCuenta());

//Transferencia
System.out.println("\nTransfiriendo un importe de: " + 5000.32);
CCC1.realizarTransferencia(CCC2, 5000.32);

//Mostramos de nuevo
System.out.println("\nCuentas despues de haber hecho transferencia:");
System.out.println("\n" + CCC1.getDatosCuenta());
System.out.println("\n" + CCC2.getDatosCuenta());

}

}
Fíjate en lo que decía antes, para hacer la transferencia, invocamos el método desde la cuenta "origen" y nos basta con pasarle como argumento la cuenta "destino" (y el importe claro)
CCC1.realizarTransferencia(CCC2, 5000.32);Con solo eso, si lo ejecutamos, vemos que todo funciona y básicamente se cumple lo que nos está pidiendo el enunciado:

Cuentas bancarias:

CCC: 7850162117938004654
Nombre: Sandra Ramirez
Saldo: 45000,64

CCC: 3902791561329441160
Nombre: Antonio Losada
Saldo: 20000,93

Transfiriendo un importe de: 5000.32

Cuentas despues de haber hecho transferencia:

CCC: 7850162117938004654
Nombre: Sandra Ramirez
Saldo: 40000,32

CCC: 3902791561329441160
Nombre: Antonio Losada
Saldo: 25001,25

Bien, pues ya lo tenemos.
Sin embargo, ya que parece que no te gustan las cosas tan simples  podemos hacer una versión algo más avanzada.
Ya que intentabas crear "pares" con claves y valores...., podemos hacer un programa con menú para crear tantas cuenta bancarias como queramos.
Estas cuentas las podemos "mapear" utilizando el código de cuenta bancaria como clave para asociarlas.
Y con otra opción de menú, seleccionar una cuenta origen, otra destino y hacer transferencia.

Para ello, primero quiero modificar levemente la clase CuentaBancaria.
Le vamos a añadir un get para obtener el número de cuenta que se genera aleatoriamente, ya que lo vamos a necesitar para usarlo como clave al "mapear" las cuentas.

Y el método para realizar transferencias, lo vamos a hacer boolean, para que retorne false si no puedo hacerse la transferencia (por falta de fondos) o true si todo salió bien.

Marco en negrita los cambios:

public class CuentaBancaria {

   private double saldoDeCuenta;
    private String nombreDelTitular;
    private long numeroDeCuenta;
   
    public CuentaBancaria(String nombreDelTitular, double saldoDeCuenta) {
        this.saldoDeCuenta = saldoDeCuenta;
        this.nombreDelTitular = nombreDelTitular;
        Random numAleatorioCuenta = new Random();
        this.numeroDeCuenta = Math.abs(numAleatorioCuenta.nextLong());
    }
   
    public long getNumeroCuenta() {
       return numeroDeCuenta;
    }
   
    public double getSaldo() {
       return saldoDeCuenta;
    }
   
    public String getDatosCuenta() {
       return String.format("CCC: %d\nNombre: %s\nSaldo: %.2f", numeroDeCuenta, nombreDelTitular, saldoDeCuenta);
    }
   
    public boolean realizarTransferencia(CuentaBancaria otraCuenta, double importe) {
       
       if (importe > saldoDeCuenta) {
          System.out.println("Esta cuenta no tiene saldo suficiente para cubrir el importe a transferir");
          return false;
       }
       else {
          saldoDeCuenta -= importe;
          otraCuenta.saldoDeCuenta += importe;
          return true;
       }
    }
}

Y ahora creamos un nuevo programa principal, donde usaremos un HashMap para mapear las cuentas mediante su código de cuenta como clave.
Y con un menú, el usuario podrá escoger opciones.
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Scanner;

public class Test {

private static HashMap<Long, CuentaBancaria> cuentas = new HashMap<Long, CuentaBancaria>();
private static Scanner teclado = new Scanner(System.in);

public static void main(String[] args) {

int opcion = 0;
while (opcion != 4) {
System.out.println("\n\t\tBANCO ORACLE");
System.out.println("\t\t----- ------\n");
System.out.println("[1] -- Crear una Cuenta Bancaria");
System.out.println("[2] -- Listar todas las Cuentas");
System.out.println("[3] -- Hacer una Transferencia");
System.out.println("[4] -- SALIR");
System.out.print("Elija opcion: ");
opcion = Integer.parseInt(teclado.nextLine());

switch(opcion) {
case 1:
crearCuenta();
break;
case 2:
listarCuentas();
break;
case 3:
hacerTransferencia();
break;
case 4:
System.out.println("\n\t\tFIN DE PROGRAMA");
break;
default:
System.out.println("Opcion equivocada");
}
}

}

private static void crearCuenta() {
System.out.println("\n\tNUEVA CUENTA");
System.out.print("Nombre Titular: ");
String nombre = teclado.nextLine();
System.out.print("Saldo inicial: ");
double saldo = Double.parseDouble(teclado.nextLine());
CuentaBancaria nuevaCCC = new CuentaBancaria(nombre, saldo);
cuentas.put(nuevaCCC.getNumeroCuenta(), nuevaCCC);
}

private static void listarCuentas() {
System.out.println("\nLISTADO DE CUENTAS");
if (cuentas.isEmpty())
System.out.println("No hay cuentas bancarias registradas");
else {
for(Entry<Long, CuentaBancaria> ccc: cuentas.entrySet())
System.out.println("\n" + ccc.getValue().getDatosCuenta() + "\n");
}
}

private static void hacerTransferencia() {
System.out.println("\n\tHACER TRANSFERENCIA");
System.out.print("Num. Cuenta ORIGEN: ");
long cccOrigen = Long.parseLong(teclado.nextLine());
System.out.print("Num. Cuenta DESTINO: ");
long cccDestino = Long.parseLong(teclado.nextLine());
System.out.print("Importe: ");
double importe = Double.parseDouble(teclado.nextLine());

//Buscamos las cuentas
CuentaBancaria origen = cuentas.get(cccOrigen);
CuentaBancaria destino = cuentas.get(cccDestino);

//Comprobamos que existen, y si existen, intentamos transferencia
if (origen == null)
System.out.println("No existe cuenta ORIGEN con nº: " + cccOrigen);
else if (destino == null)
System.out.println("No existe cuenta DESTINO con nº: " + cccDestino);
else if (origen.realizarTransferencia(destino, importe))
System.out.println("Transferencia realizada con exito");

}
}
Si lo ejecutamos, vemos que se pueden crear cuentas, seleccionarlas mediante su código y hacer transferencias entre ellas:

      BANCO ORACLE
      ----- ------

[1] -- Crear una Cuenta Bancaria
[2] -- Listar todas las Cuentas
[3] -- Hacer una Transferencia
[4] -- SALIR
Elija opcion: 1

   NUEVA CUENTA
Nombre Titular: Sara Pelaez
Saldo inicial: 4500.45

      BANCO ORACLE
      ----- ------

[1] -- Crear una Cuenta Bancaria
[2] -- Listar todas las Cuentas
[3] -- Hacer una Transferencia
[4] -- SALIR
Elija opcion: 1

   NUEVA CUENTA
Nombre Titular: Pedro Ramiro
Saldo inicial: 1500.75

      BANCO ORACLE
      ----- ------

[1] -- Crear una Cuenta Bancaria
[2] -- Listar todas las Cuentas
[3] -- Hacer una Transferencia
[4] -- SALIR
Elija opcion: 2

LISTADO DE CUENTAS

CCC: 1790563580212299009
Nombre: Pedro Ramiro
Saldo: 1500,75


CCC: 7698480902857524209
Nombre: Sara Pelaez
Saldo: 4500,45


      BANCO ORACLE
      ----- ------

[1] -- Crear una Cuenta Bancaria
[2] -- Listar todas las Cuentas
[3] -- Hacer una Transferencia
[4] -- SALIR
Elija opcion: 3

   HACER TRANSFERENCIA
Num. Cuenta ORIGEN: 7698480902857524209
Num. Cuenta DESTINO: 1790563580212299009
Importe: 500.45
Transferencia realizada con exito

      BANCO ORACLE
      ----- ------

[1] -- Crear una Cuenta Bancaria
[2] -- Listar todas las Cuentas
[3] -- Hacer una Transferencia
[4] -- SALIR
Elija opcion: 2

LISTADO DE CUENTAS

CCC: 1790563580212299009
Nombre: Pedro Ramiro
Saldo: 2001,20


CCC: 7698480902857524209
Nombre: Sara Pelaez
Saldo: 4000,00


      BANCO ORACLE
      ----- ------

[1] -- Crear una Cuenta Bancaria
[2] -- Listar todas las Cuentas
[3] -- Hacer una Transferencia
[4] -- SALIR
Elija opcion: 4

      FIN DE PROGRAMA

Y ahora sí, ya tenemos un programa un poco más avanzado.
Pregunta lo que no entiendas o pienses que pueda ser incorrecto.

Un saludo.

Sigo sin saber donde/como tienes declarados esos botones.

Hablas de 100 botones.... Si los tienes así declarados, desde el 1 hasta el 100:

private JButton btnDiscos1;
private JButton btnDiscos2;
private JButton btnDiscos3;
private JButton btnDiscos4;
private JButton btnDiscos5;
.....
.....
private JButton btnDiscos100;
Pues ya te digo que mal asunto, es imposible gestionarlo de forma óptima.

En cambio, si los pones en un array como en el ejemplo que yo puse, ya lo tendrías solucionado.
El parámetro "int numeroBoton" que te indica qué archivo imagen hay que escoger del array de imágenes, también te estaría diciendo a cuál botón del array de botones hay que aplicarle esa imagen.

Pero ahí no estás usando ningún ArrayList.
Estás usando un arreglo primitivo:

   public static void main(String[] args) {
      // TODO Esbozo de método generado automáticamente
     
      Scanner read = new Scanner(System.in);

           double []notas;
           int aprobados = 0;
           int reprobados = 0;
           int numNotas;

Un ArrayList para recoger valores double, se declararía de esta manera:
ArrayList<Double> notas = new ArrayList<Double>();
Fíjate que el tipo "Double" lo escribimos en mayúscula. Esto es porque ArrayList no trabaja con tipos primitivos: int, double, float, byte, char...

ArrayList solo trabaja almacenando objetos de clases: Integer, Double, Float, Byte, Character,...

Otra característica del ArrayList es que es dinámico, es decir, no tiene un tamaño fijo como los arreglos primitivos. El ArrayList puede ir creciendo o menguando según insertamos o retiramos objetos.

Así que ni siquiera hace falta preguntar previamente al usuario cuantas notas quiere introducir, podemos ir pidiéndolas y que el usuario decida cuándo quiere terminar.
Esta decisión podemos hacerla preguntando si "quiere continuar (si/no)" o simplificándola aún más mediante alguna condición especial, por ejemplo terminar cuando introduzca un valor negativo (ya que además un valor negativo no serviría como nota para una calificación)

Una vez tenemos las notas insertadas, volvemos a recorrer el ArrayList y por cada nota preguntamos si supera o no la calificación necesaria para aprobar.
Si la supera, contamos un aprobado. Si no, pues contaremos un reprobado.

Terminado este proceso, mostramos los contadores en pantalla.

Si por ejemplo las notas fueran de 0 a 10, siendo necesario un 5 para aprobar, este podría ser el código:
import java.util.ArrayList;
import java.util.Scanner;

public class Notas {

public static void main(String[] args) {

Scanner read = new Scanner(System.in);

ArrayList<Double> notas = new ArrayList<Double>();
int aprobados = 0, reprobados = 0;

//Pedimos notas hasta que introduzcan un valor negativo
double nuevaNota = 0;
while (nuevaNota >= 0) {
System.out.print("Introduzca nueva nota(valor negativo para terminar): ");
nuevaNota = read.nextDouble();
//solo aceptamos la nota si NO es valor negativo
if (nuevaNota >= 0)
notas.add(nuevaNota); //Insertamos en ArrayList
}

//Ya tenemos las notas, recorremos el ArrayList evaluando las notas y contando aprobados/reprobados
//Podemos usar un FOR EACH
for (double nota: notas)
if (nota < 5)
reprobados++;
else
aprobados++;

//Listo, mostramos resultados
System.out.println("\n\nAprobados: " + aprobados);
System.out.println("Reprobados: " + reprobados);
System.out.println("\n\t\tFIN DE PROGRAMA");
read.close();
}

}
Al ejecutarlo, en pantalla vemos que se piden notas hasta que se introduce un valor negativo. Entonces se muestra el conteo de aprobados/reprobados:

Introduzca nueva nota(valor negativo para terminar): 6
Introduzca nueva nota(valor negativo para terminar): 3
Introduzca nueva nota(valor negativo para terminar): 8
Introduzca nueva nota(valor negativo para terminar): 9
Introduzca nueva nota(valor negativo para terminar): 1
Introduzca nueva nota(valor negativo para terminar): 2
Introduzca nueva nota(valor negativo para terminar): 5
Introduzca nueva nota(valor negativo para terminar): 5
Introduzca nueva nota(valor negativo para terminar): -2


Aprobados: 5
Reprobados: 3

      FIN DE PROGRAMA

Cualquier duda, vuelve a preguntar.
Un saludo.

La expresión a construir es compleja, precisamente para practicar a tope este tema.

Cuando una expresión está compuesta de varias "subexpresiones", lo mejor es encerrar estas subexpresiones en sus propios paréntesis. Así nos aseguramos de que se cumplan las prioridades sobre qué partes se han de evaluar primero y además se entiende mejor luego al leerlo a simple vista.

Las destaco con colores, para que aún se vea mejor:

SI -->  Si el diámetro es superior a 1.4 con un grosor inferior a 0.4
o
SI--> si el diámetro es menor o igual a 1.4 pero mayor que 0.8, con un grosor inferior a 0.25

if ( (diametro > 1.4 && grosor < 0.4) || ( (diametro <= 1.4 && diametro > 0.8 ) && grosor < 0.25) )
    alert('El grosor para esta rueda es inferior al recomendado');

Hola.

Veamos:

Operador ++ (anterior): ++a * b == 10
(Ahora el valor de a es: 5)

Ahí se están realizando dos operaciones:
- un incremento(una suma) sobre a
- una multiplicación de a * b.

Si primero hacemos el incremento y luego la multiplicación, tendremos un resultado.
Pero, si primero multiplicamos y el incremento lo hacemos después, el resultado será distinto.

Entonces, cuando se usa "incremento anterior", primero se hace el incremento y luego se multiplica.
Eso es lo que ocurre aquí:

a = 4, b = 2
Operador ++ (anterior): ++a * b == 10
(Ahora el valor de a es: 5)

La a se incrementa en valor 5, y luego se multiplica por b que es 2. Resultado =  10.

En cambio, si se usa el "incremento posterior", entonces primero se hace la multiplicación y el incremento ocurre después.

a = 4, b = 2
Operador ++ (posterior): a++ * b == 8  //¿pq de este resultado??
(Ahora el valor de a es: 5)

Aquí se multiplica la a que vale 4 por b que es dos. Resultado = 8.
Y después, se hace el incremento, por lo que la a pasa a valer 5.
Pero ese 5 no interviene en la multiplicación, porque esta ya terminó.

En ambos casos, la a termina valiendo 5. La diferencia es que en el primer caso se multiplica después de adoptar el valor 5.
Y en el segundo caso, la multiplicación ocurre antes de que adopte valor 5

En los console.log(), ocurre lo mismo:

var a = 2;
console.log(a++); //me da 2
console.log(++a); // me da 4

En la primera línea, la de color azul, se usa el "incremento posterior".
Es decir, ocurra lo que ocurra, lo último será la suma.

Entonces, esa línea azul lo primero que hace es mostrarte el valor de a, que es 2.
Y lo último que hace es el incremento, así que la a pasa a valer 3.
Pero ese 3, tú no lo ves en pantalla, porque cuando el log() mostró el valor de a, aún no se había incrementado.

La siguiente línea, la verde, hace un "incremento anterior", es decir, lo primero que va a ocurrir es la suma. Luego ya pasará lo que tenga que pasar.
Por tanto, la línea verde lo primero que hace es incrementar la a, que valía 3 y ahora pasa a valer 4.
Y tras esto, te muestra en pantalla su valor, que ya es 4.

Espero que ahora haya quedado un poco más claro la diferencia que hay entre estos dos tipos de incrementos (y decrementos).

Saludos.

Hola.
Eso ocurre porque los prompt() te dan cadenas de caracteres:
            var adcon3 = prompt("introduce un numero entero ");
            var adcon4 = prompt("introduce otro numero");
Entonces, si luego con esas variables haces operaciones aritméticas con los operadores de división multiplicación, resta o módulo, dichos operadores trabajan únicamente con valores numéricos.
En ese caso, JS no tiene dudas de que pretendes hacer una operación matemática con ellos, así que él mismo convierte esas cadenas que te han dado los prompt a valores numéricos y hace una operación aritmética.

Sin embargo, el operador de suma aritmética, es el mismo que el de "concatenar" cadenas.
Aquí JS ya no puede deducir cuál es tu intención y lo que hace es "respetar" el tipo de dato original de las variables, que en este caso son cadenas, por eso te está haciendo una concatenación.

Puedes solucionarlo transformando tú mismo las cadenas a números, con la función Number()
            suma = Number(adcon3) + Number(adcon4) ;
            alert('la adiccion es  ' + suma);De este modo, JS ya no tiene dudas de que tu deseo es hacer una suma aritmética

Creo que eso lo genera automáticamente el programa phpMyAdmin cuando por ejemplo le pides que exporte a SQL el código necesario para crear las tablas de una base de datos.