Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » NullPointerException en JAVA

Java - NullPointerException en JAVA

Volver
Nuevo Tema
<<>>
 
Vista:
sin imagen de perfil

NullPointerException en JAVA

Publicado por DUMEN (5 intervenciones) el 04/01/2014 19:37:57
Buenas tardes tengo este problema de NullPointerException en JAVA y no sé en qué fallo, a ver si me pudierais echar una mano.

En la clase Montador, en la condición if (rodes.getRoda() >= 2 && xassis.getXassis() >= 1 && manillar.getManillar() >= 1)&#8203;, es donde aparece el error.

Es un ejercicio de "SEMÁFOROS" en el cual consiste en un taller mecánico, en los que hay 3 operarios (Ruedas, Manillar, Chasis) y un montador (Montador). El operario de las ruedas puede tener como mucho 10 ruedas, el operario de los manillares como mucho puede tener 10 manillares, y el operario del chasis puede tener 4.

El montador solo puede montar una motocicleta siempre y cuando disponga de 2 ruedas, 1 manillar y 1 chasis, y se les descontará a cada operario dicha cantidad, para que pueda ir construyendo cuando le toque.

Os pego el código que tengo para cada clase.

-------------------------------------------------- MAIN -----------------------------------------------------------

package taller;
import java.útil.concurrent.Semaphore;
public static void main(String[] args) {
Rodes operari1;
Xassis operari2;
Manillar operari3;
Muntador muntador;
Semaphore mutex, esperar, agafar;
mutex = new Semaphore(1);
esperar = new Semaphore(0);
agafar = new Semaphore(0);
operari1 = new Rodes(mutex, esperar, agafar);
operari2 = new Xassis(mutex, esperar, agafar);
operari3 = new Manillar(mutex, esperar, agafar);
muntador = new Muntador(mutex, esperar, agafar);
operari1.start();
operari2.start();
operari3.start();
muntador.start();
}
}

-------------------------------------------------- RUEDAS ------------------------------------------------------

package taller;
import java.útil.concurrent.Semaphore;

public class Rodes extends Thread {
Semaphore mutex, espera, agafar;
private Semaphore semáforo;
int roda = 0;
int MAXIM = 10;
public Rodes(Semaphore pmutex, Semaphore pespera, Semaphore pagafar) {
this.mutex = pmutex;
this.espera = pespera;
this.agafar = pagafar;
}
public int getRoda() {
return roda;
}
public void setRoda(int rodes) {
this.roda -= rodes;
}
@Override
public void run() {
try {
while (this.roda < MAXIM) {
mutex.acquire();
System.out.println("RODES: construeixo una roda!");
this.roda++;
mutex.release();
Thread.sleep(1000);
if (roda == MAXIM) { //Quan arriba al màxim es manté a l'espera.
System.out.println("RODES: Ja tinc "+MAXIM+" RODES, m'espero...");
espera.acquire();
}
}
System.out.println("Total de Rodes: " + roda);
} catch (InterruptedException e) {
System.out.println("No funciona el fil de Rodes!!!");
}
}
}

-------------------------------------------------- MANILLAR ----------------------------------------------------

package taller;
import java.útil.concurrent.Semaphore;

public class Manillar extends Thread {
Semaphore mutex, espera, agafar;
int MAXIM = 10;
private Semaphore semáforo;
int manillar = 0;
public Manillar(Semaphore pmutex, Semaphore pespera, Semaphore pagafar) {
this.mutex = pmutex;
this.espera = pespera;
this.agafar = pagafar;
}
public int getManillar() {
return manillar;
}
public void setManillar(int manillar) {
this.manillar -= manillar;
}
@Override
public void run() {
try {
while (this.manillar < MAXIM) {
mutex.acquire();
System.out.println("MANILLAR: construeixo un manillar");
this.manillar++;
mutex.release();
Thread.sleep(1500);
if (manillar == MAXIM) { //Quan arriba al màxim es manté a l'espera.
System.out.println("MANILLAR: Ja tinc "+MAXIM+" MANILLAR, m'espero...");
espera.acquire();
}
}
System.out.println("Total de manillars: " + manillar);
} catch (InterruptedException e) {
System.out.println("No funciona el fil de Manillar!!!");
}
}
}

-------------------------------------------------- CHASIS -------------------------------------------------------

package taller;
import java.útil.concurrent.Semaphore;

public class Xassis extends Thread {
Semaphore mutex, espera, agafar;
private Semaphore semáforo;
int xassis = 0;
int MAXIM=4;
public Xassis(Semaphore pmutex, Semaphore pespera, Semaphore pagafar) {
this.mutex = pmutex;
this.espera = pespera;
this.agafar = pagafar;
}
public int getXassis() {
return xassis;
}
public void setXassis(int xassis) {
this.xassis -= xassis;
}
@Override
public void run() {
try {
while (this.xassis < MAXIM) {
mutex.acquire();
System.out.println("XASSIS: construeixo un xassis");
this.xassis++;
mutex.release();
Thread.sleep(2100);
if (xassis == MAXIM) { //Quan arriba al màxim es manté a l'espera.
System.out.println("XASSIS: Ja tinc "+MAXIM+" xassis, m'espero...");
espera.acquire();
}
}
System.out.println("total de Xassis: " + xassis);
} catch (InterruptedException e) {
System.out.println("No funciona el fil del Xassis!!!");
}
}
}

-------------------------------------------------- MONTADOR -------------------------------------------------

package taller;
import java.útil.concurrent.Semaphore;

public class Muntador extends Thread {
Manillar manillar;
Xassis xassis;
Rodes rodes;
int motos = 0;
Semaphore mutex, espera, agafar;
public Muntador(Semaphore pmutex, Semaphore pespera, Semaphore pagafar) {
this.mutex = pmutex;
this.espera = pespera;
this.agafar = pagafar;
}
@Override
public void run() {
while (true) {
try {
mutex.acquire();
System.out.println("MUNTADOR: comprobant si n'hi ha peces suficients...");
Thread.sleep(800);
if (rodes.getRoda() >= 2 && xassis.getXassis() >= 1 && manillar.getManillar() >= 1) {
System.out.println("MUNTADOR: Puc montar una motocicleta!!");
rodes.setRoda(2); //Resto dues unitats al operari de les rodes.
xassis.setXassis(1); //Resto una unitat al operari del xassis.
manillar.setManillar(1); //Resto una unitat al operari del manillar.
motos++; //Incremento una unitat al contador de motocicletes.
System.out.println("Quantitat de motocicletes montades: " + motos);
espera.release();// Comunicio als operaris que poden continuar fabricant peces.
} else {
System.out.println("No cumpleix els requisits per construir una motocicleta, m'espero una estona.");
mutex.release();
}
mutex.release();
} catch (InterruptedException e) {
System.out.println("No funciona el fil del muntador!!!");
}
}
}
}
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

NullPointerException en JAVA

Publicado por Diego (28 intervenciones) el 05/01/2014 13:38:18
Hola Dumen,

No estoy en casa y no puedo probarlo...

Pero, en el while(true) de la clase Montador, ¿no debería haber la misma condición que en el if, pero en vez de >=2,>=1 y >=1, serían todos >0?

Pruébalo a ver si funciona.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
sin imagen de perfil

NullPointerException en JAVA

Publicado por DUMEN (5 intervenciones) el 05/01/2014 15:42:14
Gracias, pero ya lo he conseguido arreglar, el fallo estaba básicamente en que no lo pasaba en la clase Montador los operarios cuando lo instanciaba en la clase main, por eso me decía el NullPointer, porque creaba una instancia a secas del Montador, os dejo la solución por escrito y en el archivo zip por si alguno le pudiera interesar...

--------MAIN------


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package taller;
 
import java.util.concurrent.Semaphore;
 
public class Taller {
 
    public static void main(String[] args) {
        Rodes operari1;
        Manillar operari2;
        Xassis operari3;
        Muntador muntador;
 
        Semaphore mutex, esperar;
        mutex = new Semaphore(1);
        esperar = new Semaphore(0);
 
 
        operari1 = new Rodes(mutex, esperar);
        operari2 = new Manillar(mutex, esperar);
        operari3 = new Xassis(mutex, esperar);
        muntador = new Muntador(mutex, esperar, operari1, operari2, operari3);
 
 
         operari1.start();
         operari2.start();
         operari3.start();
         muntador.start();
 
    }
}

-----MONTADOR------


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
package taller;
 
import java.util.concurrent.Semaphore;
 
public class Muntador extends Thread {
 
    Manillar manillar;
    Xassis xassis;
    Rodes rodes;
    int motos = 0;
    Semaphore mutex, espera;
 
    public Muntador(Semaphore pmutex, Semaphore pespera, Rodes operari1, Manillar operari2, Xassis operari3) {
        this.mutex = pmutex;
        this.espera = pespera;
        this.rodes = operari1;
        this.manillar = operari2;
        this.xassis = operari3;
    }
 
    @Override
    public void run() {
        while (true) {
            try {
                mutex.acquire();
 
                if (rodes.getRoda() >= 2 && xassis.getXassis() >= 1 && manillar.getManillar() >= 1) {
 
                    rodes.setRoda(2); //Resto dues unitats al operari de les rodes.

                    xassis.setXassis(1); //Resto una unitat al operari del xassis.

                    manillar.setManillar(1); //Resto una unitat al operari del manillar.

                    motos++; //Incremento una unitat al contador de motocicletes.

                    System.out.println("\nMUNTADOR: Puc montar una motocicleta Nº: " + motos
                            + "\n  Ara tinc rodes ----->" + rodes.getRoda()
                            + "\n  Ara tinc manillrs ----->" + manillar.getManillar()
                            + "\n  Ara tinc xassis ----->" + xassis.getXassis() + "\n");
                    Thread.sleep(3000);
                } else {
                    System.out.println("\nMUNTADOR: No tinc material suficient, m'espero una estona..."
                            + "\n  Hi ha rodes ----->" + rodes.getRoda()
                            + "\n  Hi ha manillars ----->" + manillar.getManillar()
                            + "\n  Hi ha xassis ----->" + xassis.getXassis() + "\n");
                    espera.release(); //Desperto als treballadors que hi hagin dormint.

                    mutex.release(); //allibero el recurs.

                    Thread.sleep(5000);
                }
                mutex.release();
            } catch (InterruptedException e) {
                System.out.println("No funciona el fil del muntador!!!");
            }
        }
    }
}

-----RUEDAS-----


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package taller;
 
import java.util.concurrent.Semaphore;
 
public class Rodes extends Thread {
 
    Semaphore mutex, espera, agafar;
    int roda = 0;
    int MAXIM = 10;
 
    public Rodes(Semaphore pmutex, Semaphore pespera) {
        this.mutex = pmutex;
        this.espera = pespera;
 
    }
 
    public int getRoda() {
        return roda;
    }
 
    public void setRoda(int rodes) {
        this.roda -= rodes;
    }
 
    @Override
    public void run() {
 
        try {
 
            while (this.roda < MAXIM) {
                mutex.acquire();
 
                System.out.println("RODES: construeixo una roda!");
                this.roda++;
                if (roda == MAXIM) { //Quan arriba al màxim es manté a l'espera.

                    System.out.println("RODES: Ja tinc " + MAXIM + " RODES, m'espero...");
                    espera.acquire();
                }
                mutex.release();
                Thread.sleep(1000);
            }
            System.out.println("Total de Rodes: " + roda);
 
        } catch (InterruptedException e) {
            System.out.println("No funciona el fil de Rodes!!!");
        }
    }
}

-----MANILLAR-------


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package taller;
 
import java.util.concurrent.Semaphore;
 
public class Manillar extends Thread {
 
    Semaphore mutex, espera, agafar;
    int MAXIM = 10;
    int manillar = 0;
 
    public Manillar(Semaphore pmutex, Semaphore pespera) {
        this.mutex = pmutex;
        this.espera = pespera;
 
    }
 
    public int getManillar() {
        return manillar;
    }
 
    public void setManillar(int manillar) {
        this.manillar -= manillar;
    }
 
    @Override
    public void run() {
        try {
            while (this.manillar < MAXIM) {
                mutex.acquire();
 
                System.out.println("MANILLAR: construeixo un manillar");
                this.manillar++;
                if (manillar == MAXIM) { //Quan arriba al màxim es manté a l'espera.

                    System.out.println("MANILLAR: Ja tinc " + MAXIM + " MANILLAR, m'espero...");
                    espera.acquire();
                }
                mutex.release();
                Thread.sleep(2000);
            }
            System.out.println("Total de manillars: " + manillar);
 
        } catch (InterruptedException e) {
            System.out.println("No funciona el fil de Manillar!!!");
 
        }
    }
}

-------CHASIS-------


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
package taller;
 
import java.util.concurrent.Semaphore;
 
public class Xassis extends Thread {
 
    Semaphore mutex, espera, agafar;
    int xassis = 0;
    int MAXIM = 4;
 
    public Xassis(Semaphore pmutex, Semaphore pespera) {
        this.mutex = pmutex;
        this.espera = pespera;
    }
 
    public int getXassis() {
        return xassis;
    }
 
    public void setXassis(int xassis) {
        this.xassis -= xassis;
    }
 
    @Override
    public void run() {
        try {
            while (this.xassis < MAXIM) {
                mutex.acquire();
 
                System.out.println("XASSIS: construeixo un xassis");
                this.xassis++;
                if (xassis == MAXIM) { //Quan arriba al màxim es manté a l'espera.

                    System.out.println("XASSIS: Ja tinc " + MAXIM + " xassis, m'espero...");
                    espera.acquire();
                }
                mutex.release();
                Thread.sleep(3000);
            }
            System.out.println("total de Xassis: " + xassis);
 
        } catch (InterruptedException e) {
            System.out.println("No funciona el fil del Xassis!!!");
        }
    }
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de gonzalo mosquera
Val: 35
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

NullPointerException en JAVA

Publicado por gonzalo mosquera (22 intervenciones) el 07/01/2014 06:21:26
¡feliz 2014! ¿Me hace el favor de mostrar los comentarios del código en español o explicármelo?
Gracias.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
sin imagen de perfil

NullPointerException en JAVA

Publicado por DUMEN (5 intervenciones) el 09/01/2014 10:54:46
No era muy complicado la traducción de los comentarios, pero igualmente te los he traducido.
Dime lo que no entiendes en concreto y intentaré explicártelo.

--------MAIN------

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package taller;
 
import java.util.concurrent.Semaphore;
 
public class Taller {
 
public static void main(String[] args) {
Rodes operari1;
Manillar operari2;
Xassis operari3;
Muntador muntador;
 
Semaphore mutex, esperar;
mutex = new Semaphore(1);
esperar = new Semaphore(0);
 
 
operari1 = new Rodes(mutex, esperar);
operari2 = new Manillar(mutex, esperar);
operari3 = new Xassis(mutex, esperar);
muntador = new Muntador(mutex, esperar, operari1, operari2, operari3);
 
 
operari1.start();
operari2.start();
operari3.start();
muntador.start();
 
}
}

-----MONTADOR------

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
package taller;
 
import java.util.concurrent.Semaphore;
 
public class Muntador extends Thread {
 
Manillar manillar;
Xassis xassis;
Rodes rodes;
int motos = 0;
Semaphore mutex, espera;
 
public Muntador(Semaphore pmutex, Semaphore pespera, Rodes operari1, Manillar operari2, Xassis operari3) {
this.mutex = pmutex;
this.espera = pespera;
this.rodes = operari1;
this.manillar = operari2;
this.xassis = operari3;
}
 
@Override
public void run() {
while (true) {
try {
mutex.acquire();
 
if (rodes.getRoda() >= 2 && xassis.getXassis() >= 1 && manillar.getManillar() >= 1) {
 
rodes.setRoda(2); //Resto dos unidades al operario de las ruedas.

xassis.setXassis(1); //Resto una unidad al operario del chasis.

manillar.setManillar(1); //Resto una unidad al operario del manillar.

motos++; //Incremento una unidad al contador de motocicletas.

System.out.println("\nMONTADOR: Puedo montar una motocicleta Nº: " + motos
+ "\n Ara tinc rodes ----->" + rodes.getRoda()
+ "\n Ara tinc manillrs ----->" + manillar.getManillar()
+ "\n Ara tinc xassis ----->" + xassis.getXassis() + "\n");
Thread.sleep(3000);
} else {
System.out.println("\nMONTADOR: No tengo material suficiente, me espero un rato..."
+ "\n Hay ruedas ----->" + rodes.getRoda()
+ "\n Hay manillares ----->" + manillar.getManillar()
+ "\n Hay chasis ----->" + xassis.getXassis() + "\n");
espera.release(); //Despierto a los trabajadores que estén durmiendo.

mutex.release(); //Libero el recurso.

Thread.sleep(5000);
}
mutex.release();
} catch (InterruptedException e) {
System.out.println("No funciona el hilo del montador!!!");
}
}
}
}

-----RUEDAS-----

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package taller;
 
import java.util.concurrent.Semaphore;
 
public class Rodes extends Thread {
 
Semaphore mutex, espera, agafar;
int roda = 0;
int MAXIM = 10;
 
public Rodes(Semaphore pmutex, Semaphore pespera) {
this.mutex = pmutex;
this.espera = pespera;
 
}
 
public int getRoda() {
return roda;
}
 
public void setRoda(int rodes) {
this.roda -= rodes;
}
 
@Override
public void run() {
 
try {
 
while (this.roda < MAXIM) {
mutex.acquire();
 
System.out.println("RUEDAS: construyo una rueda!");
this.roda++;
if (roda == MAXIM) { //Cuando llega al máximo se mantiene a la espera.

System.out.println("RUEDAS: Ya tengo " + MAXIM + " RODES, me espero...");
espera.acquire();
}
mutex.release();
Thread.sleep(1000);
}
System.out.println("Total de Ruedas: " + roda);
 
} catch (InterruptedException e) {
System.out.println("No funciona el hilo de Ruedas!!!");
}
}
}

-----MANILLAR-------

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package taller;
 
import java.util.concurrent.Semaphore;
 
public class Manillar extends Thread {
 
Semaphore mutex, espera, agafar;
int MAXIM = 10;
int manillar = 0;
 
public Manillar(Semaphore pmutex, Semaphore pespera) {
this.mutex = pmutex;
this.espera = pespera;
 
}
 
public int getManillar() {
return manillar;
}
 
public void setManillar(int manillar) {
this.manillar -= manillar;
}
 
@Override
public void run() {
try {
while (this.manillar < MAXIM) {
mutex.acquire();
 
System.out.println("MANILLAR: construyo un manillar");
this.manillar++;
if (manillar == MAXIM) { //Cuando llega al máximo se mantiene a la espera.

System.out.println("MANILLAR: Ya tengo " + MAXIM + " MANILLAR, me espero...");
espera.acquire();
}
mutex.release();
Thread.sleep(2000);
}
System.out.println("Total de manillares: " + manillar);
 
} catch (InterruptedException e) {
System.out.println("No funciona el hilo de Manillar!!!");
 
}
}
}

-------CHASIS-------

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
package taller;
 
import java.util.concurrent.Semaphore;
 
public class Xassis extends Thread {
 
Semaphore mutex, espera, agafar;
int xassis = 0;
int MAXIM = 4;
 
public Xassis(Semaphore pmutex, Semaphore pespera) {
this.mutex = pmutex;
this.espera = pespera;
}
 
public int getXassis() {
return xassis;
}
 
public void setXassis(int xassis) {
this.xassis -= xassis;
}
 
@Override
public void run() {
try {
while (this.xassis < MAXIM) {
mutex.acquire();
 
System.out.println("CHASIS: construeixo un xassis");
this.xassis++;
if (xassis == MAXIM) { //Cuando llega al máximo se mantiene a la espera.

System.out.println("CHASIS: Ya tengo " + MAXIM + " chasis, me espero...");
espera.acquire();
}
mutex.release();
Thread.sleep(3000);
}
System.out.println("total de chasis: " + xassis);
 
} catch (InterruptedException e) {
System.out.println("No funciona el hilo del chasis!!!");
}
}
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de gonzalo mosquera
Val: 35
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

NullPointerException en JAVA

Publicado por gonzalo mosquera (22 intervenciones) el 13/01/2014 04:32:01
Hola Dumen, gracias por los comentarios, me aclaran mucho el código.
La duda que tengo es en MAXIM, ¿A que se refiere como el máximo?
Gracias.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
sin imagen de perfil

NullPointerException en JAVA

Publicado por DUMEN (5 intervenciones) el 13/01/2014 08:23:42
Se trara de una constante tipo int, y la defino como atrivi así, porque si te fijas, en el código, siempre que se puedo no hay que poner números que pueden variar al cabo del tiempo, por eso defines una constante tipo int y si alguna vez lo has de cambiar, solo lo has de hacer en un sitio, de lo contrario deberias de ir buscando en cada método donde esta ese numerito para cambiarlo.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar