A Lot of Java in One Simple Tutorial (for Dummies)

To store a value that represents movement, which type of variable from the table above would be best to use? Obviously, it has to be a number: int or double. Since we’ll represent it in whole units, we pick int.

All we need is to declare the variable, but how do you declare it?

To keep things easy, we’ll call the variable velocidad_de_rotacion_del_motor (engine rotation speed) and initialize it to 0. Our Motor class code should end up like this (we’ll look at the words private and public a bit later, in the Visibility level box):

package piezas_internas;

public class Motor {
	private int velocidad_de_rotacion_del_motor = 0;
}

In Eclipse the variable will probably show up underlined in yellow; ignore it. This is a warning –Eclipse labels it as Warning. It’s telling you that you aren’t using that variable, and that’s true: it’s all alone and nobody uses it.

We’ve set the engine’s rotation speed to zero because nothing is moving it; it’s at rest. This variable will hold the state of the engine’s speed before and after the engine runs.

We’re still treating the engine as an empty shell. We need something inside. The piston we talked about earlier would be perfect. What do we know about the piston? We know that to work it needs some gasoline and some oxygen. And that it gives back a force to make the car move, plus carbon dioxide; since we only care about what it gives back to make things work, we’ll ignore the carbon dioxide.

The piston will therefore be a method, which means it will be a part of the engine.

So, some milliliters of gasoline and oxygen go in, and what goes in has to be whole numbers. Also, when the piston works, it will return a force, which will be another integer. How does it do this? Let’s keep going.

Writing the method the way the image above shows is fine, but you always have to write the visibility level in front of the method.

So, we want the piston to be usable only by the Motor. Why would we let anything else, or the driver, touch it? So they can break it?

One thing we left out is the visibility of the first variable we created, velocidad_de_rotacion_del_motor. Since it’s an internal state of the engine, it belongs only to the engine, so it’s private too.

We write our code so that it looks like this:

package piezas_internas;

public class Motor {
    private int velocidad_de_rotacion_del_motor = 0;

    private int un_piston (int mililitros_de_gasolina, int mililitros_de_oxigeno){
        int fuerza_del_piston = 0;
        return fuerza_del_piston;
    }

}

Eclipse will have underlined the method in yellow. It’s telling you that we aren’t using the piston anywhere, and that’s true, right? The engine has the piston inside but doesn’t use it anywhere.

Let’s focus on what’s in the piston’s code:

private int un_piston (int mililitros_de_gasolina, int mililitros_de_oxigeno){
    int fuerza_del_piston = 0;
    return fuerza_del_piston;
}

We’ve written a variable inside the method called fuerza_del_piston (piston force), which will serve something similar to what the variable velocidad_de_rotacion_del_motor does. Careful now! Look at the curly braces that contain what’s inside the method: the variable fuerza_del_piston will only be used inside that method. The variable velocidad_de_rotacion_del_motor, on the other hand, can be used inside this method or in any other in the class (But if it’s private, how is it going to be used? If you’re asking yourself that, you haven’t quite gotten it yet: we’re inside the Motor class, and it’s private for those on the outside. Think of a physical car engine when you open the hood: is the piston accessible to you? No. And the engine’s rotation speed? Yes, but through the transmission belt; when it’s first generated inside the engine, no, because we haven’t reached the engine’s output yet. Private and public may become clearer when we use the engine, which is where you actually see the difference).

Another thing: fuerza_del_piston doesn’t need anything in front of it for visibility, because it’s a local variable, and everything inside a method is private and only for that method. If you hold a piston in your hand, whatever it has inside is not accessible in any way, right? Except by breaking it, but then it stops working, and just like in code, if it’s broken it doesn’t work.

Let’s keep adding logic and behavior to the piston (that is, steps 2 and 3 in the piston’s animated GIF). Let’s assume the following: the piston only withstands less than 30 milliliters of gasoline, otherwise it explodes. The operation will be very simple: the amount of oxygen will be multiplied by the amount of gasoline, and the result is the force. Let’s analyze the two previous sentences:

We’re dealing with a full-blown conditional. The conversion to Java would be:

Since we weren’t going to cause an error in the program when the value is greater than or equal to 30, we’ve chosen to show a symbolic message about the explosion in the Eclipse console.

Our Motor class should end up looking like this:

package piezas_internas;

public class Motor {
    private int velocidad_de_rotacion_del_motor = 0;

    private int un_piston (int mililitros_de_gasolina, int mililitros_de_oxigeno){
        int fuerza_del_piston = 0;

        if (mililitros_de_gasolina<30){
            fuerza_del_piston = mililitros_de_gasolina * mililitros_de_oxigeno;
        }else{
            System.out.println("¡El pistón ha sido demasiado cargado de gasolina y ha explotado!");
        }

        return fuerza_del_piston;
    }

}

This way, if the gasoline is less than 30, we get a piston force, and when the code reaches return, that amount is handed back outside the method to whoever asked for it (for example, if the gasoline is 3 and the oxygen is 5, since gasoline<30 the piston force is 3×5, which is 15).

Now let’s connect the engine’s circuits to the piston. To do that we need to create another method in the class, but this method is special: its visibility is always public, it never returns anything, and it has the same name as the class. This is commonly called a constructor rather than a method, since it runs at the exact moment the class is used for the first time.

In this case we’ll create the constructor with one input for the gasoline (imagine the physical engine with an intake tube for the gasoline); the air is ambient air that comes in through the engine’s vent, and let’s assume that each piston receives 2 milliliters of oxygen. Since the piston returns the force it obtained, and in this case all of it is transmitted to the engine as rotation speed, we get:

public Motor (int mililitros_de_gasolina){
    velocidad_de_rotacion_del_motor = un_piston (mililitros_de_gasolina, 2);
}

We’ll insert the constructor lines so that the code looks like this (as a general rule among developers, the constructor or constructors go before all the methods, but after the global variables):

public class Motor {
    private int velocidad_de_rotacion_del_motor = 0;
    private final int capacidad_maxima_en_mililitros_de_gasolina_para_un_piston = 30;

    public Motor (int mililitros_de_gasolina){
        velocidad_de_rotacion_del_motor = un_piston (mililitros_de_gasolina, 2);
    }

    private int un_piston (int mililitros_de_gasolina, int mililitros_de_oxigeno){
        int fuerza_del_piston = 0;

        if (mililitros_de_gasolina<capacidad_maxima_en_mililitros_de_gasolina_para_un_piston){
            fuerza_del_piston = mililitros_de_gasolina * mililitros_de_oxigeno;
        }else{
            System.out.println("¡El pistón ha sido demasiado cargado de gasolina y ha explotado!");
        }

        return fuerza_del_piston;
    }

}

We have the engine’s state (velocidad_de_rotación_del_motor), we have the engine’s startup (the constructor), and we have the engine’s internal workings (the piston). If we picture the engine, what’s left is the place where the transmission belt attaches, that is, the engine’s output.

As a review we’ll create the data output method; you should already know how to do this from what we explained before. We create a new method, a very simple one: it has no inputs, only the output, which will be the engine’s rotation speed, and since it goes to the transmission belt, it’s public so that other parts (classes) can use it.

public int get_velocidad_de_rotacion_del_motor(){
    return velocidad_de_rotacion_del_motor;
}

As a convention among developers, a method that returns something gets “get” in front of it (it means “give me”), and one that puts some value into the class gets “set”. In this case there’s no “set”, since the class’s constructor takes care of getting the data.

If we add it to the full code, our final Motor class looks like this:

package piezas_internas;

public class Motor {
    private int velocidad_de_rotacion_del_motor = 0;
    private final int capacidad_maxima_en_mililitros_de_gasolina_para_un_piston = 30;

    public Motor (int mililitros_de_gasolina){
        velocidad_de_rotacion_del_motor = un_piston (mililitros_de_gasolina, 2);
    }

    private int un_piston (int mililitros_de_gasolina, int mililitros_de_oxigeno){
        int fuerza_del_piston = 0;

        if (mililitros_de_gasolina<capacidad_maxima_en_mililitros_de_gasolina_para_un_piston){
            fuerza_del_piston = mililitros_de_gasolina * mililitros_de_oxigeno;
        }else{
            System.out.println("¡El pistón ha sido demasiado cargado de gasolina y ha explotado!");
        }

        return fuerza_del_piston;
    }

    public int get_velocidad_de_rotacion_del_motor(){
        return velocidad_de_rotacion_del_motor;
    }

}

Let’s take a moment to analyze what we’ve done in this class:

After all that, we’ve finally built the engine! Let’s save everything so we don’t lose our changes. Now all that’s left is to test this class.

For that, let’s edit the Arranque class. In it we add the program’s start method, main.

package panel_del_conductor;

public class Arranque {

    public static void main(String[] args) {

    }

}

Let’s use the engine at startup. How do we do that? Easy. In the same way that we create a variable declaration, we create one for the engine inside the main class. Remember int X = 5? Well, same thing, but the type won’t be one of the simple ones, but a compound one that we created ourselves: it will be Motor, that is, the Motor class will act as a data type.

Motor mi_motor =

Here we have something called mi_motor (“my engine”), like an X, that only accepts something of type Motor but doesn’t point to anything yet. And what value do we store? Well, an engine that we have to create new, and since our constructor needs the amount of gasoline, we pass it, for example, 20.

Motor mi_motor = new Motor (20);

Here we need to be clear about the difference between Motor, which is the class, and mi_motor, which is the object (without realizing it, we’ve dragged you into the fabulous world of objects in a single programming tutorial). A class is, so to speak, the mold for shaping objects, and an object is an object, pardon the redundancy -it’s white and comes in a bottle, if you catch my drift. Motor is the mold and mi_motor is the object created with the mold. Let’s add this line to the code to see what happens:

package panel_del_conductor;

public class Arranque {

    public static void main(String[] args) {
        Motor mi_motor = new Motor (20);
    }

}

Eclipse complains by underlining the word Motor in red. Don’t worry, we haven’t made a mistake. If we place the cursor over the problem, Eclipse will tell us what we can do. In this case the first option is the ideal one, since we have to tell Java that this Arranque class is going to use another class called Motor. So we click the one that says “Import Motor (piezas_internas)” and it’s solved.

import piezas_internas.Motor;

int velocidad_coche = mi_motor.get_velocidad_de_rotacion_del_motor();

System.out.println("La velocidad del coche es "+velocidad_coche+" km/h");

package panel_del_conductor;

import piezas_internas.Motor;

public class Arranque {

    public static void main(String[] args) {
        Motor mi_motor = new Motor (20);
        int velocidad_coche = mi_motor.get_velocidad_de_rotacion_del_motor();
        System.out.println("La velocidad del coche es "+velocidad_coche+" km/h");
    }

}