java - JBay Solutions - The Dev Blog

How to Implement a Mechanism like QR code scanning of WhatsApp Web

Rui Pereira — Tue, 20 Sep 2016 09:10:42 GMT

This tutorial came to be due to a question I found on Stackoverflow titled Mechanism behind QR code scanning of whatsapp webapp and the investigation and answer that I gave .

Because the answer was given in real broad strokes, I decided to create a tutorial on how to implement something like what is being used by WhatsApp. This tutorial will cover the theory behind it, the implementation of an Android App to read QR codes and send and receive data to a Server, and also an implementation of the Server side using Play2 Framework. Another implementation using Glassfish 4 and Tyrus will follow at some point if there is interest.

It is assumed some degree of knowledge on Android development for the Android sections, some knowledge of Play2 Framework for the Play2 Framework server side implementation, and obviously Java. I'll try to cover all the basics and specifics, but it will be quite hard to explain everything is 100% detail.

To Start

So, first of all, all source code is available at these two locations:

One is the Web server side bit, which will display a QR Code and allow the auth and also do some chatting, and the other is the Android app that will read QR Codes and also work as a chat client.

These are not particularly pretty, they are a proof of concept and just work. Contributions, forks, etc, are welcome.

What is the plan?

For our small proof of concept, just like with WhatsApp, the chat bit of the Web App will work using WebSockets. When a user opens the URL for the Web App thing ( using http://localhost:9000/ ) the Web page gets a few Javascripts (we are also using JQuery here, just to simplify some of the work we need to be done, and bootstrap so that everything doesn't just look too horrible), some CSSs and then it opens a WebSocket, where it receives immediatly a UUID for it to use to download the QR Code image.

The WebSocket on the browser is listenning for several things, one of which is that UUID for the QR Code retrieval. When the UUID code for the QR Code arrives, the javascript updates the Web Page with that image URL and displays it.

The browser at this point:

has a WebSocket open
has a QR Code displayed on the screen

The server at this point:

Has a WebSocket open with that browser
It knows that the WebSocket is associated with a particular QR Code.

On the Android side of things, the Android App will do most of the communications (like authentication ... which is basically lacking, for simplicity sake, and sending messages to the server) using normal GET requests to the Play2 Application . To receive messages, we will be using Firebase Cloud Messaging, because it saves us time in implementation, because we won't need to keep sockets and whatnot open with the server, and monitor them for disconnects and other problems, and because it is just the best way for this Proof of Concept.

So, unlike the WhatsApp Android App , we require the user to set his username (we make no checks to see if one already exist, or anything like that... feel free to implement this if you like) and sign in. This just stores the Username on the App so that everytime we send a message using the App, it sends the username of the person who wrote that message. This is not at all secure, because it would be easy to impersonate another person, but then again, this is just a Proof of Concept.

Once the User selected a Username on the Android App, the can start chatting away, or can at any moment do the QR Code scanning. Doing the QR Code scanning, the Android App gets the UUID that is embedded on the QR Code and sends a message to the server saying : OK , this UUID that I just scanned, belongs to this Username. The server receives the message, checks the list of QR Code UUIDs that it has, and then uses the WebSocket associated with it to notify the browser of the username it should use, and refresh the interface with the chat windoe and hide the QR Code bit.

At this point both the Android and Web App use GET requests to send messages to the server, and receive new messages either through the WebSocket (in the case of the Web Client) or through Firebase Cloud Messaging (in case of the Android Client).

In both, when a message is received, the interface is updated to show that message and who wrote it.

This is it.

Server and Web Implementation

For the Web/Server implementation we use Play Framework 2.5.6 "Steamy", you can get it at the official Play Framework site , or just get the complete source code of the WhatsApp Clone Play Project Here .

Lets break it down in smaller bits

Generating QR Codes

To generate QR codes we'll use ZXing lib from google version 3.2.1 , which you can get here https://mvnrepository.com/artifact/com.google.zxing/core/3.2.1 . All code made here was base on this Tutorial with some modifications to serve our purpose.

First we add the ZXing dependency to the Play project, by editing the build.sbt file and adding the following line, to the end of it:

libraryDependencies += "com.google.zxing" % "core" % "3.2.1"

We created a class called QRCodeUtil in the package com.jbaysolutions.whatsappclone.util with a single method called generateQRCode that generates a QR Code BufferedImage for a given UUID:

public static BufferedImage generateQRCode(UUID uuid) {

    int size = 250;
    try {

        Map hintMap = new EnumMap(EncodeHintType.class);
        hintMap.put(EncodeHintType.CHARACTER_SET, "UTF-8");
        hintMap.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.L);

        QRCodeWriter qrCodeWriter = new QRCodeWriter();

        BitMatrix byteMatrix = qrCodeWriter.encode(
                uuid.toString(),
                BarcodeFormat.QR_CODE,
                size,
                size,
                hintMap
        );

        int CrunchifyWidth = byteMatrix.getWidth();
        BufferedImage image = new BufferedImage(CrunchifyWidth, CrunchifyWidth,
                BufferedImage.TYPE_INT_RGB);
        image.createGraphics();

        Graphics2D graphics = (Graphics2D) image.getGraphics();
        graphics.setColor(Color.WHITE);
        graphics.fillRect(0, 0, CrunchifyWidth, CrunchifyWidth);
        graphics.setColor(Color.BLACK);

        for (int i = 0; i < CrunchifyWidth; i++) {
            for (int j = 0; j < CrunchifyWidth; j++) {
                if (byteMatrix.get(i, j)) {
                    graphics.fillRect(i, j, 1, 1);
                }
            }
        }

        logger.debug("You have successfully created QR Code.");

        return image;

    } catch (WriterException e) {
        logger.error("Problem generating QR Code" , e);
        return null;
    }
}

On the HomeController we have a method for returning that QR Code to the browser, for a given UUID String:

public Result getQRCode(String inputUUID) throws IOException {

    UUID uuid = UUID.fromString(inputUUID);

    BufferedImage image = QRCodeUtil.generateQRCode(uuid);
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    ImageIO.write(image, "png", baos);
    byte[] bytes = baos.toByteArray();

    ByteArrayInputStream stream = new ByteArrayInputStream(bytes);

    return ok(stream)
            .as("image/png");

}

On the Routes file the Play Project we have the following route for this particular method on the Controller:

GET        /uuid/:uuid                   controllers.HomeController.getQRCode(uuid: String)

That is it. To test it out, just go to a browser on the same machine where you ahve the Play application running and go, for example, to the following URL: http://localhost:9000/uuid/0e2161d7-25e7-4846-84c8-faaa87a81313 . A QR Code should be displayed on the browser. Try it out with any other valid UUID aswell.

Where will this be used?

This QR Code generation code will be used when we implement the WebSocket bit, and on the Browser side, the listenner receives a UUID. When the WebSocket listener receives a specific command with a UUID, it will update the interface with the UUID QR Code image. We'll see more about that in a minute.

WebSockets - The Server Side

A good place to start if the Play Framework documentation on WebSockets , which... is confusing, but still, it give you examples of stuff working. On the next version of Play, a new sort of implementation for WebSockets oin Java is available, and that is why you'll see a lot of uses of the class LegacyWebSocket, which is the old implementation, that will still be made available in the next releases of Play. We'll use that.

On the HomeController we have the following method:

public LegacyWebSocket socket() {

    return new LegacyWebSocket() {
        @Override
        public void onReady(WebSocket.In in, WebSocket.Out out) {

            in.onMessage(new Consumer() {
                @Override
                public void accept(String s) {
                    // Never Used
                }
            });

            in.onClose(new Runnable() {
                @Override
                public void run() {
                    logger.info("WebSocket Disconnected");
                }
            });

            // Now we do some of or logic 
            // 1- We generate a UUID that we'll associate with this WebSocket 
            String uuid = UUID.randomUUID().toString();

            // 2- Now we store the UUID that we just created, in some fashion
            // to associate it with the IN and OUT streams of the Web Socket
            WebSessionsHandler.getInstance().createNewQRSession(
                    uuid,
                    in,out
            );

            // 3- We send the UUID to the browser, through the WebSocket 
            // we just opened with the browser 
            out.write("wsready###" + uuid);

        }
    };

}

Real simple, instead of returning a Result, like we always (almost always) do in the Controllers, we now return a WebSocket ( ok ok , LegacyWebSocket ) to the Browser. In our implementation of the WebSocket we simply create the Socket and make it so that when it is closed, we log that :

in.onClose(new Runnable() {
    @Override
    public void run() {
        logger.info("WebSocket Disconnected");
    }
});

When we receive a message on the Server, through the WebSocket, we do nothing. The reason is : we will not be send messages from the browser to the Server through the WebSocket. For no particular reason, just because we'll use the same method we use for the Android App :

in.onMessage(new Consumer() {
    @Override
    public void accept(String s) {
        // Never Used
    }
});

Then we do some logic that is associated with our WhatsApp Clone thing. First we generate an UUID to associate with the WebSocket on the server side, and later to generate the QR Code on the Browser:

String uuid = UUID.randomUUID().toString();

We then store the IN and OUT "streams" of the WebSocket in association with the UUID :

WebSessionsHandler.getInstance().createNewQRSession(
        uuid,
        in,out
);

Our implementation of WebSessionsHandler isn't particularly nice, but it does the job. We store the In and OUT associated with an UUID, which is just what wew need at this stage.

Then, we use the OUT stream to send the UUID to the browser. We are sending a String that starts with "wsready###" followed by the UUID. This just makes it easier to identify the type of message, and to split the string on the Client side and extract the UUID later:

out.write("wsready###" + uuid);

That is it for the WebSocket code on the Server side. We just need to add a route to the Routes file and give it a test run. The route should look like this:

GET        /ws                           controllers.HomeController.socket()

To test it out, use the following link : http://www.websocket.org/echo.html and use ws://localhost:9000/ws as the test URL. Connect and see the test benchmark receive an UUID!

WebSockets and Interface stuff - The Web Side

Interface Stuff

First things first, on the main.scala.html template, on the Head of the HTML we import JQuery and Bootstrap:

And inside the body, but right at the end:

But that is not all, we also import a Javascript that we will write called whatsappclone.js` :

On this script we will write all of the logic we will describe next.

Also, on the index.scala.html template file we write it like this:

@(title: String)

@main(title) {

    
      WhatsApp Web App Clone Tutorial
    


    
        
            
                
                    

                    
                
            
        
        
            
                
                    
                    
                        
                    
                

            
        
    


    
        
    

}

The important bits to pay attention are :

There is a DIV with id qrcodearea with an img inside. This is where the QR Code will be displayed
There is a DIV with if chatarea . This is the Chat bit. It has a List , where the messages will be displayed, and also an input with id messageInput which is where the user will write messages he wants to send.

Notice that the chatarea div is not being displayed. This is the default startup mode we want: not showing chat area until the user is authenticated with the QR Code.

WebSockets Javascript Stuff

On the main.scala.html file we are importing a javascript called whatsappclone.js, just like we said on the previous section. This is the javascript that contains all the logic. When the javascript is loaded and the document is ready we do a couple of things:

We find the divs that we want to hide and show and assign them to some variables, just for confort.
We initialize the WebSocket
We also add a Listener on the messageInput field, for the return key, and call send message when the return key is pressed while on the input field.

This is the code for that:

$(document).ready(function(){
    console.log("Starting WhatsApp Clone");
    qrcodeareaDiv = $("#qrcodearea");
    chatareaDiv = $("#chatarea");
    chatareaDiv.css('display','none')
    chatList = $("#chatlist");
    initWebSocket();

    $("#messageInput").on('keypress', function (e) {
        if (e.which === 13) {
            sendMessage();
        }
    });

})

The initWebSocket method, that is called on the document ready methods does the following:

function initWebSocket() {

    websocket = new WebSocket("ws://localhost:9000/ws");

    websocket.onopen = function(evt) {
        console.log("WebSocket Opened");
    };

    websocket.onclose = function(evt) {
        console.log("WebSocket Closed");
        websocket = null;
        username = null;
    };

    websocket.onmessage = function(evt) {

        var rawdata = evt.data;

        if (rawdata.startsWith("wsready###")) {

            var qrUuid = rawdata.split("###")[1];
            console.log("UUID for qr received: " + qrUuid);
            $("#qrcode").attr("src", "http://localhost:9000/uuid/" + qrUuid);

        } else if (rawdata.startsWith("authed###")) {

            username = rawdata.split("###")[1];
            console.log("Auth done using mobile for user: " + username);
            qrcodeareaDiv.hide();
            chatareaDiv.css('display','block');

        } else if (rawdata.startsWith("msg###")) {

            var user = rawdata.split("###")[1];
            var msg = rawdata.split("###")[2];
            console.log("message from : " + user + " with data: " + msg + " \n");

            if ( username === user ) {
                // FROM ME
                chatList.append("I said:"+msg+"");
            } else {
                // FROM OTHER PEOPLE
                chatList.append(""+user+" said:"+msg+"");
            }

        } else {
            console.error("Unknown Stuff: " + rawdata) ;
        }

    };


    websocket.onerror = function(evt) { 
        console.error("Error: " + evt) ;
    };

}

So, we open a WebSocket to the url ws://localhost:9000/ws , which is where we are making the socket available:

websocket = new WebSocket("ws://localhost:9000/ws");

Then we say that when the WebSocket is opened, we log some stuff to the javascript console, just for debugging purposes:

websocket.onopen = function(evt) {
    console.log("WebSocket Opened");
};

When the WebSocket is closed, we also print some debugging to the javascript console and we set the WebSocket to null and also a variable called username:

websocket.onclose = function(evt) {
    console.log("WebSocket Closed");
    websocket = null;
    username = null;
};

If there is an error with the WebSocket we also print some debugging to the javascript console:

websocket.onerror = function(evt) { 
    console.error("Error: " + evt) ;
};

Now for the interesting bit, when a message is received on the WebSocket we do a few things:

First we get the message that was sent from the server into a variable:

var rawdata = evt.data;

Then, we try to understand what type of message was sent, and we do that by checking how to message starts. Remember that in the previous section, when a WebSocket was open, the server would send straight away a message with the UUID of the QR code to be displayed. That message starts with wsready followed by ### and the the UUID. So :

if (rawdata.startsWith("wsready###")) {

    var qrUuid = rawdata.split("###")[1];
    console.log("UUID for qr received: " + qrUuid);
    $("#qrcode").attr("src", "http://localhost:9000/uuid/" + qrUuid);

}

What this code does is : when the WebSocket on the browser side receives a message that starts with wsready### , it first splits the message at the ### marker and stores the UUID that comes after the ###:

var qrUuid = rawdata.split("###")[1];

We then log that UUID to the javascript console, just so we can see what is going on, and then, we update an element with id qrcode that exists on the index.scala.html with an url for the QR Code image:

$("#qrcode").attr("src", "http://localhost:9000/uuid/" + qrUuid);

Remember, the url http://localhost:9000/uuid/ was explained in the previous sections, where we show how we generate a QR Code image and how we make it return on a specific route.

The browser and server, if a message starting with wsready### arrives, have a WebSocket open between each other, that specific WebSocket can be identified by an UUID, and the browser is now displaying a QR Code of that UUID.

But that is not all that happens when a message is received on the WebSocket. We are also expecting two other types of messages, which we haven't talked about yeat, but I'll introduce now:

authed### : A message starting with authed### is sent to the WebSocket by the server, once a Mobile user authenticates using the QR Code. This message has the usernameof the user that just authenticated with the Mobile Device, and is used to signal the browser to get ready with the Chat window. so :

1- Store Username:
```
username = rawdata.split("###")[1];
```
2- Hide QR Code bit of the interface, which is not needed anymore, because a user already authenticated with that QR Code:
```
qrcodeareaDiv.hide();
```
3- Display the Chat section of the interface :
```
chatareaDiv.css('display','block');
```
msg###: A message starting with msg### is sent to the WebSocket by the server when some user sends a chat message to the server, be it from a Web Client or a Mobile Client. This message is a two part message with this format : msg###USERNAME###MESSAGE . The first thing we do is split the rawmessage on the ### marks, and extract the username of the person sending the message, and the message itself:
```
var user = rawdata.split("###")[1];
var msg = rawdata.split("###")[2];
```

We then update the Chat interface in one of two ways, depending if the user that sent the message was the same user that is authenticated on the Web Client, or if it was another user:

if ( username === user ) {
    // FROM ME
    chatList.append("I said:"+msg+"");
} else {
    // FROM OTHER PEOPLE
    chatList.append(""+user+" said:"+msg+"");
}

That is it for the WebSocket.

There is also another method, that we have introduced before, when talking about the ready method of the document, with regards to the return key of the messageInputtext field. That is the sendMessage function, which looks like this:

function sendMessage() {
    var message = $("#messageInput").val();

    $.ajax({
        'url': '/session/msg',
        'type': 'GET',
        'data': {
            'user': username,
            'message': message
        },
        'success': function (data) {
            //clear input field value
            $("#messageInput").val("");
        },
        'error' : function (data) {
            alert(data);
        }
    });
}

So, when the Web Client user wants to send a message, he writes it down on the messageInput field, and when he is done, he presses the return key. This method is called, which uses JQuery to send an ajax request to the server, where it send the username of the user sending the message, and the message the user wrote.

Notice that we do no update the Chat sections of the interface. We leave that to the WebSocket. We just send the message to the server, if the server receives it and everything is fine, the server will send the message to every Web Client, through the WebSockets that are open, and the interfaces get refreshed when that message arrives.

This is it for the Web Client side of things.

Send and Receiving Messages - Server Side

The way we went about this is, everytime a client wants to send a message to the Chat, the client must make a GET request to the server with the its Username and Message. The Client shouldn't make any updates to the Chat interface on sending the message. The server receives the message and then goes to all Web Session that are authenticated and to all Mobile Sessions and sends that same message to the clients, using the WebSockets, or the Firebase cloud Messaging, depending on the type of Client. Only then, when the Client receives the message from the server, will it update the Chat interface.

On the Server side, we have the following method on the HomeController :

public Result broadcastMessage(String user, String message) {

    // Send for all WebSessions
    for ( WebSession session : WebSessionsHandler.getInstance().getAllAuthSessions()) {
        try {
            session.getOut().write(
                    "msg###"+user+"###"+message
            );
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // Send for all Mobile Sessions
    for (MobileSession session : MobileSessionsHandler.getInstance().getAllSessions()) {
        FirebaseUtil.sendPushMessage(session.getFirebaseToken(), user + " : " +message);
    }

    return ok();

}

What it does is, first iterate all the WebSessions it has, that are authenticated, and send a message through their WebSocket in the format previously describe while writing the Javascript bit of the WebSocket.

Then it iterates all the MobileSessions and using Firebase Cloud Messaging, send a message to each of the Mobile Devices. For doing this we are using the Pushraven lib , in the following way (FirebaseUtil class) :

 public synchronized static void sendPushMessage(String client_key, String message) {
    raven
            .text(message)
            .to(client_key);
    raven.push();

    raven.clear();
    raven.clearAttributes();
    raven.clearTargets();
}

Please check the official web page for Pushraven for more information on what is going on here.

And this is basically it. Now on to the Android Stuff.

Android Client Implementation

For the Android implementation we have a really simple ìnterface for login in, make the QR Code Scan and do some chatting. It uses Volley for communications with the Chat Server, which we just explained in the previous section, and also uses Firebase Cloud Messaging for receiving new messages from the Server.

It also works a bit different than the WhatsApp app, in that we don't use the phonenumber as the ID for the user, but instead we prompt the user for a Username. We do no validation, nor authentication, because that is not the point of this tutorial.

Lets start!

Interface Bit

For our Android client we just use an Activity with just one interface. That interface is divided in two main sections, one for the Login in, and another for the Chat. The section for the chat also has the QR Code bit. Our activity_main.xml layout looks like this:

We have the signinLayout LinearLayout, which is the section where the user specifies the Username he wants to use:

We have and empty LinearLayout called qrScannerLayout which is where we'll display the Camera bit , when we perform QR Code Scanning. It is empty by default but will be filled when the user selects the QR Code Scanning button:

And then, we have the Chat section bit, which is again another LinearLayout called chatLayout that contains:

Button for QR Code Scanning
ListView for the Chat Messages
EditText for writting Messages to send

One thing to take notice is that the chatLayout has the visibility property as gone, which is the default, because we don't want to show this interface until the user defines its Username. This section looks like this:

On the Activity side it is very simple. For the login bit, the user writes down the Username on the EditTextfield and presses the Login Button, which does nothing except locking the Username EditText field and Login Button, and show the Chat session of the interface, like so:

public void signIn(View view) {
    if (usernameET.getText().toString().isEmpty()) {
        Toast.makeText(this, "Must have username defined", Toast.LENGTH_SHORT).show();
        return ;
    }

    // If a username is defined, then lock interface and update
    usernameET.setEnabled(false);
    signInButton.setEnabled(false);
    chatLayout.setVisibility(View.VISIBLE);
}

But lets now talk about Firebase Cloud Messaging.

Firebase Cloud Messaging Intro and Dependencies

For sending the messages of the Chat from the Server to the Android Clients, we use Firebase Cloud Messaging. Give a read at the Official Site for more information regarding Firebase, but for the purpose of this tutorial you just need to know that it allows sending push messages to Android devices (to and from, and other devices, and browsers and stuff), and that is what we will use it for. We'll use Firebase to send push messages from the Chat server to the Android devices.

So, to start using Firebase, you need to go to the Firebase console at https://console.firebase.google.com and register the app you are creating. For this tutorial, the package to use during registration is : com.jbaysolutions.tutorial.whatsappclone .

Once the app is registered on the Firebase Console, you must download the google-services.json file that is provided and replace it on the App. This is very important, or else it just won't work.

If you are making an app from scratch, then you need to :

Add dependency of com.google.gms:google-services on the build.gradle file on the root of the project ( the one that has the gradle build tools dependency) :

dependencies {
    classpath 'com.android.tools.build:gradle:1.3.0'


   // NOTE: Do not place your application dependencies here; they belong
   // in the individual module build.gradle files


   classpath 'com.google.gms:google-services:3.0.0'


}

Add dependencies of firebase to the build.gradle file that exists at the base of the module:

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
     compile 'com.android.support:appcompat-v7:24.0.0'
     compile 'me.dm7.barcodescanner:zxing:1.8.4'
     compile 'com.google.firebase:firebase-core:9.4.0'
     compile 'com.google.firebase:firebase-messaging:9.4.0'
     compile 'com.android.volley:volley:1.0.0'
}

Add the apply plugin to the end of the of the build.gradle file at the base of the module:
```
apply plugin: 'com.google.gms.google-services'
```
Save the google-services.json you just downloaded from the Firebase Console for this app right next to the build.gradle file at the base of the module.

This is it. You are now ready to use the Firebase Cloud Messaging.

Firebase Android implementation

Most of the code used on the WhatsApp Clone Android App is base on this Tutorial so give it a quick read if you want.

So, when we start the WhatsApp Clone App and the first thing we need to do is send a registration of the Device to the server, with the Firebase token of the device, so that the Server can now contact the Device back at any time. We also need to notify the Server everytime the Firebase token changes.

Remember, the Firebase Token is the one thing that allows the Server to reach the Client Device at any time using push messaging.

Updating Firebase Token

For that we use a service which we define on the Manifest like this :

The code for that Service looks like this :

public class MyFirebaseInstanceIDService extends FirebaseInstanceIdService {

    private static final String TAG = "MyFirebaseIIDService";

    @Override
    public void onTokenRefresh() {

        //Getting registration token
        String refreshedToken = FirebaseInstanceId.getInstance().getToken();

        //Displaying token on logcat
        Log.d(TAG, "Refreshed token: " + refreshedToken);

        try {
            ServerFacade.sendRegistrationToServer(this, refreshedToken);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            Log.e(TAG, e.getMessage(), e);
        }
    }
}

What this does is, everytime the Firebase token for the device changes, the onTokenRefresh method is called, in which we get the token, and then we use the sendRegistrationToServer method of the ServerFacade class to send it to the Server.

The other thing we need to do is do something when a message arives through Firebase.

Handling arriving messages

To handle arriving messages from Firebase we use another service which we have defined on the Manifest like so:

The code for that Service looks like this:

public class MyFirebaseMessagingService extends FirebaseMessagingService {

    private static final String TAG = "MyFirebaseMsgService";

    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        //Displaying data in log
        //It is optional
        Log.d(TAG, "From: " + remoteMessage.getFrom());
        Log.d(TAG, "Notification Message Body: " + remoteMessage.getNotification().getBody());

        //Calling method to generate notification
        //sendNotification(remoteMessage.getNotification().getBody());

        Intent i = new Intent();
        i.setAction("RECEIVEMESSAGE");
        i.putExtra("rawdata", remoteMessage.getNotification().getBody());
        sendBroadcast(i);
    }
}

What this does is, everytime a message is sent to this device, the onMessageReceived method is called. This method retrieves the name of the user who sent the message and the message itself and sends it to the MainActivity through broadcasting. On the Activity we have a BroadcastReceiver implemented and registered to receive these notifications. Lets see that now.

BroadcastReceiver to Receive Messages

On the MainActivity we have a inner class that extends BroadcastReceiver to receive the messages from the MyFirebaseMessagingService . The BroadcastReceiver is implemented like this :

class MessageBroadcastReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        String rawData = intent.getStringExtra("rawdata");
        String user = rawData.split(":")[0].trim();
        String message = rawData.split(":")[1].trim();
        adapter.addMessage(
                user, message,
                (user.trim().equals(usernameET.getText().toString()))
        );
        Log.d("RAWDATA", "Received RawData : " + rawData);
    }
}

What it does is receive messages being sent from the MyFirebaseMessagingService service, extracts the User and Message from the raw message , and updates an Adapter that is set for the ListView of the interface. We'll see more about that in a minute.

For this BroadcastReceiver to actually receive stuff, it needs to be registered on the Activity, which is done like this:

@Override
protected void onResume() {
    super.onResume();
    registerReceiver(mReceiver, new IntentFilter("RECEIVEMESSAGE"));
}

We also unregister is when we have the Activity go on Pause:

@Override
public void onPause() {
    super.onPause();
    if (mScannerView != null) {
        mScannerView.stopCamera(); 
    }
    unregisterReceiver(mReceiver);
}

Now that we have the BroadcastReceiver out of the way, lets look at the ListView and the Adapter.

Chat Message List and Adapter

On the interface layout, we have a ListView called chatLListView which we assign to a variable on the onCreate method, and set an Adapter to it:

chatList = (ListView) findViewById(R.id.chatLListView);
chatList.setAdapter(adapter);

That adapter is an instance of ChatListAdapter which is a BaseAdapter that draws one of two layouts depending on whether the message is from the same user as the user registered on the Android App, or not. The relevant method to take notice is the getView method, that looks like this:

@Override
public View getView(int position, View convertView, ViewGroup parent) {

    View v;
    LayoutInflater vi = LayoutInflater.from(context);

    ChatMessage p = getItem(position);

    if (p.isMe) {
        v = vi.inflate(R.layout.chatlayout_me, null);
    } else {
        v = vi.inflate(R.layout.chatlayout_others, null);
        ((TextView)v.findViewById(R.id.whoTV)).setText(p.user);
    }

    ((TextView)v.findViewById(R.id.messageTV)).setText(p.message);

    return v;
}

The two layouts that exist to render a message are chatlayout_me and chatlayout_others, and they look like this :

chatlayout_me :

chatlayout_others :

They are basically the same, with just a different background color and gravity.

Now for the QR Code Scanning!

QR Code Scanning

The QR Code Scanning was based on this Tutorial , so, again, give it a read if you want to. We are using the ZXing library from google to do the scanning.

The overall idea is : When you press the QR Code Scan button, that is on the activity_main.xml layout file , we initialize a scanning view from the ZXing library and we add it to the qrScannerLayout, which is a LinearLayout we have defined also on the activity_main.xml layout file. This was explained previously. We set the result listener of the scanner to the activity itself (because the MainActivity implements ZXingScannerView.ResultHandler ) and we start the Camera. Like this:

public void performQrScanner(View view) {

    qrScanneLayout.setVisibility(View.VISIBLE);
    mScannerView = new ZXingScannerView(this);   // Programmatically initialize the scanner view

    qrScanneLayout.addView(
            mScannerView
    );

    mScannerView.setResultHandler(this); // Register ourselves as a handler for scan results.
    mScannerView.startCamera();         // Start camera
}

Because our MainActivity implements ZXingScannerView.ResultHandler we have to implement the handleResult method, which we do, just like this:

 public void handleResult(Result rawResult) {
    // Do something with the result here
    Log.e("handler", rawResult.getText()); // Prints scan results
    Log.e("handler", rawResult.getBarcodeFormat().toString()); // Prints the scan format (qrcode)
    // show the scanner result into dialog box.

    mScannerView.stopCamera();

    try {
        ServerFacade.sendRegisterUserToQRCode(
                this,
                usernameET.getText().toString(),
                rawResult.getText()
        );

        qrScanneLayout.removeView(
                mScannerView
        );
        qrScanneLayout.setVisibility(View.GONE);

    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
        Log.e("Main Activity", e.getMessage(), e);
        qrScanneLayout.removeView(
                mScannerView
        );
        qrScanneLayout.setVisibility(View.GONE);
    }

}

On this method we extract the QR Code, which is the UUID provided by the server to the browser through the WebSocket, and we use the ServerFacade class to register the User that is using this device with that UUID. This will trigger the Server to send a command to the Browser that belongs to that UUID notifying that it now belongs to the specific User, and the browser gets it interface updated with the Chat bit.

Now all that we are missing is the ServerFacade class that is used for communication with the Server.

Communication with Server

All communications with the Server are made through the use of a class called ServerFacade. It uses Volley to do all HTTP communications. Check this Tutorial for more information on Volley and how to use it.

There are three methods here:

sendRegistrationToServer : Used to send the deviceId of the android along with the Firebase Token. These are stored on the server for a way for the Server to know how to send message notifications back to the Device.
sendRegisterUserToQRCode : Used to associate a User with the UUID of a QR Code. This is the method that lets the Server know that a WebSocket belongs to a user.
sendMessage : Used to send messages all the registered users .

Give a look at them. There is nothing much to it really.

We have a RequestQueue wrapped in a Singleton, like described on this section of the Tutorial here , which we call RequestQueueSingleton, so all http requests are placed on that queue.

On the ServerFacade, we build the requests using another Singleton called Configuration , which is where we have defined the Chat Server IP and Chat Server Port.

We place the Requests on the queue and that is it.

Configurations that you need to Change

Before you can you this application, you need to go to the Configuration class and modify the IP and Port of the server you are running, so that the App knows where to reach it. And that is it. Compile and deploy it to your mobile phone!

REFERENCES

https://mvnrepository.com/artifact/com.google.zxing/core/3.2.1

http://www.websocket.org/echo.html

https://www.numetriclabz.com/android-qr-code-scanner-using-zxingscanner-library-tutorial/

https://www.simplifiedcoding.net/firebase-cloud-messaging-tutorial-android/

https://www.playframework.com/documentation/2.5.x/JavaWebSockets#handling-websockets

https://blog.openshift.com/how-to-build-java-websocket-applications-using-the-jsr-356-api/

http://crunchify.com/java-simple-qr-code-generator-example/

https://developer.android.com/training/volley/index.html

Understanding Static in Java

Rui Pereira — Tue, 16 Aug 2016 14:35:17 GMT

A very common question from beginners in Java is "What does Static means" or "What is Static in Java". It is actually very simple.

Something that is Static in Java is something that belongs to the Class and not the objects of that Class type, hence it is shared across the instances of that Class type.

To better understand what is meant by that, let us rewind a bit!

When writing a Java program, a programmer writes Classes and creates objects of those Class types, or other Class types that belong to some libs. So, look at this Class:

public class NumberHolder {

    public int number = 5;

}

This Class simply holds a number in a public variable called number. If we wanted to use this class we would need to instantiate this class to create an object, and then use that object to store the value on the variable, just like so :

NumberHolder holder1 = new NumberHolder();
holder1.number = 10;

If we would print the value of the "number" variable inside the holder1 object like so:

System.out.println("Value of holder1 number : " + holder1.number);

we would get:

Value of holder1 number : 10

Now, if we wanted to hold two numbers, we would need to create two objects of type NumberHolder and assign the values to them, like this:

NumberHolder holder1 = new NumberHolder();
holder1.number = 10;

NumberHolder holder2 = new NumberHolder();
holder2.number = 99;

Printing the values of the number variables inside of each of the NumberHolder objects :

System.out.println("Value of holder1 number : " + holder1.number);
System.out.println("Value of holder2 number : " + holder2.number);

Would produce :

Value of holder1 number : 10
Value of holder2 number : 99

So, each of the objects has a variable that belongs to that specific object of class type NumberHolder.

Now in some cases there is a need to have a value that is shared across every instance of a particular class, and to do this, we use Static. Now, bear in mind that making something Static has several implications, that we'll see a bit further down.

Something that is static

So, now we'll create another class that we'll call TotalHolder , which looks somewhat like this:

public class TotalHolder {

    public static int total = 0;

}

Very simple. Now, we'll create two instances of TotalHolder and do some assigning to the total int variable and see what happens:

TotalHolder totalHolder1 = new TotalHolder();
TotalHolder totalHolder2 = new TotalHolder();

totalHolder1.total = 10;
System.out.println("Print total through totalHolder1 : " + totalHolder1.total);

totalHolder2.total = 500;
System.out.println("Print total through totalHolder2 : " + totalHolder2.total);

System.out.println("Print total again through totalHolder1 : " + totalHolder1.total);

If we run this code we get an output like this:

Print total through totalHolder1 : 10
Print total through totalHolder2 : 500
Print total again through totalHolder1 : 500

So, as you can see, the value of the variable total, when being accessed through either of the TotalHolder instances will have the same value..... that is because it is exactly the same variable that is being accessed, not two different variables that share the same value, but the same exact variable! In fact, the static variables (or methods) don't even belong to the Instances of objects, but to the Class itself... and to illustrate that I've made two pictures :

This last image show the example using the NumberHolder objects. As you can see, each instance of the NumberHolder has its own independent "number" variable.

As for the Static example, look at this image:

Because the variable total is static, it does not belong to the Instances of the TotalHolder, but to the class itself. Which means that when accessed, through whatever instance of the object, it will be in fact the Class variable that is being accessed.

But that is not all..... because the static variables (and methods) belong to the Class, we don't really need to have Instances of the objects to access those variables, which means that the previous example code, code be re-written like this:

TotalHolder.total = 10;
System.out.println("Print total through TotalHolder Class : " + TotalHolder.total);

TotalHolder.total = 500;
System.out.println("Print total through     TotalHolder Class : " + TotalHolder.total);

System.out.println("Print total again through TotalHolder Class : " + TotalHolder.total);

Notice that in this example we are not using any Instances, but instead accessing the total variable through the Class... which is completely legal, because the variable belongs to the class.... because it is static.... is it making sense?

But wait !!!!!!! This is not all !!!!! What about methods ?

Methods can also be static, and the same story applies to those methods! Methods that are static belong to the Class, and methods that are not static belong to the instance.... Things might be starting to sound strange, but don't give up on this! It is actually quite simple and I'll try to explain it with examples now.

Static Methods? Why ?

OK, lets recap a bit, cause this really needs to be second nature:

Static variables belong to the Class
Static methods belong to the Class
Static methods and variables can be accessed directly through the Class, instead of Instances.
Non-static methods and variables belong to their Instances, and can only be accessed through those instances

So, to have have a variable that is shared with all Instances of a Class type, we can use a static Variable.

But what about methods? What are the benefits of having Static methods? Are those really needed?

We'll focus on the benefits first!

Because a Static method can be accessed through the Class, there is no need to create an Instance of the class to get access to the methods, which can be very useful with memory management... less instances, less memory used, less GC , less everything! But this is not all. In terms of code style and code reading.... it just makes everything much more readable and easy to understand, if used properly.

One good, and very common use of Static methods, is to create Util classes. Util classes is not an official designation I think, but what I mean by that is a Class that has useful methods (that are usually isolated) to perform certain common tasks, such as for example a Math util class, which could look like this:

public class MathUtil {

    public static double multiply( double par1, double par2) {
        return par1*par2 ;
    }

    public static double divide( double par1, double par2) {
        return par1/par2 ;
    }

    public static double add( double par1, double par2) {
        return par1-par2 ;
    }

    public static double subtract( double par1, double par2) {
        return par1-par2 ;
    }
}

This is obviously a very simple class, but you get the idea! To use this class to make some operations, we would do something like this:

MathUtil.multiply( 20 , 2);
MathUtil.divide( 20 , 2);
MathUtil.add( 10 , 10);
MathUtil.subtract( 2 , 1);

Really easy to read, isn't it? And notice, because we didn't create an Instance of the MathUtil Class, we are actually saving memory! Now imagine that in the ultra massive bank accounting system that you are developing using Java, if these methods were not static, and these operations needed to be done in several places, all the time, you would be creating MathUtil Instances all over the place, you would eventually use a considerable amount of memory, which would also at some point would need to be Garbage Collected..... and not to speak of the object Instantiation times.... you see? Static methods are a solution to these issues. Obviously that in a concurrent environment you would also need to have in mind concurrency considerations, but that is beyond the scope of this tutorial ( Check this Concurrency Tutorial if you are interested ) .

The big rule with Static methods is that, if you are accessing anything outside this method, that something also needs to be Static.

And this makes sence.... lets think about this for a second: If you are calling a Static method, and you know that a static method belongs to a Class and it can be accessed directly through the Class, if that method were to access a non-static variable, which would belong to a specific Instance, the VM wouldn't know which of the instance variables it was refering to, or even worst, if there were no Instances at all created, what would happen?

So, as you can see, having a static method accessing variables or methods outside of the scope of the method is illegal and your code won't compile... because it makes no sense.

And yes... there is more! Lets talk about static blocks!

Static Blocks

You know what a block is, and static block is not very different and looks like this:

public class TotalHolder {

    static {
        total = 0;
    }

    public static int total;

}

Think of static blocks that a Class can have as a Constructor for the Class. What happens is this: When you start you program on the JVM, classes get loaded into memory, this is where the Classes will live, and will be available to create instances, and access static variables and methods.

When a Class is loaded into memory, the JVM will initialize the static variables that exist on the Class, and will execute all the static blocks of the Class, in the order they are presented, always in that order.

Obviously, static block behave like static methods in the sense that they can only access static variables and methods that exist outside of the scope of the block, because.... specially at this time, when the static blocks are being executed, there will be no instances of those classes.

And this is it! We hope this was useful, and leave us any comment you would like to share or any doubts you may still have.

Java Tutorial 7 - Starting Flow Control

Rui Pereira — Fri, 01 Apr 2016 17:01:46 GMT

Introduction

This is where the fun part begins! With the previous tutorials we have and idea of the core building blocks, now we start looking at the implementation of flow control, or logic if you will. The most important statement for implementing logic, in my personal experience is the If statement.

If Statement

Lets jump right into an example! The If statement works like this:

if ( true )
    System.out.println("Evaluation was true");

We have the keywork if followed by a boolean expression that, as the name states, must evaluate to a boolean. In our particular example it will always evaluate to true.

If the expression evaluates to true (which is our example, it always does) , the next statement is executed. If the expression evaluates to false, then next statement is NOT executed , and the execution flow continues after the next statement.

Now lets look at the following modification we made:

if ( false )
    System.out.println("Evaluation was true");
    System.out.println("Evaluation was true, part 2");

The if boolean evaluation is always false now, so the first statement after the if is not executed. But the second print statement will be executed, because the if statement only conditions one statement. If we only wanted to have the two println statements execute if the previous condition was true, then we need to user a block, like so:

if ( false )  {
    System.out.println("Evaluation was true");
    System.out.println("Evaluation was true, part 2");
}

This would make the two println statements execute if the evaluation is true. Because in our previous example it is false, then the two println statement would not be executed.

Until now we have been using a boolean directly to define the behavior of the if statement, which makes this code execute always in the same way and no decision be actually made.

But, like it was said because, we can place any statement inside that if condition as long as it evaluates to a boolean.

Equality Operators

For comparing primitive variables, we have these Equality Operators:

== : Equal to
!= : Not equal to
> : Greater than
>= : Greater than or equal to
< : Less than
<= : Less than or equal to

Look at the following code snippet:

int age = 10;

if ( age < 18 ) {
    System.out.println("Price of ticket : 50" );
}

if ( age == 18 ) {
    System.out.println("Price of ticket : 100" );
}

if ( age > 18 ) {
    System.out.println("Price of ticket : 120" );
}

Very easy to understand, yes?

If the variable age is smaller than ( < ) 18, the code will print : Price of ticket : 50
If the variable age is equal to ( == ) 18, the code will print : Price of ticket : 100
If the variable age is greater than ( > ) 18, the code will print : Price of ticket : 120

Nothing special, but now, lets try something else:

public static void main(String[] args) {

    String value1 = new String("good");
    String value2 = new String("good");

    if (value1 == value2) {
        System.out.println(" They are equal ");
    }

}

When we run this main method, we expected to see the program write They are equal to the console, but it produces nothing. The reason for this is that , like we said before, these operators are only to be used with Primitive Variables, and as we know, String is not a primitive type, it is an Object.

Objects are compared differently, but to fully understand the deal with Object, we must first talk about Reference Variables, which will happen in one or two tutorials. For now, lets focus on primitives and see what can be achieved with If statements .

Equality Operators are to be used with Primitive Variables. Comparing Objects with == might produce unexpected results.

Equality Operators can also be combined with boolean operators to create more complex boolean expressions.

Conditional Operators

These are some the available Conditional Operators:

& - AND
| - OR
&& - Conditional AND
|| - Conditional OR

Lets see them in use and understand the difference between an AND and a Conditional AND . We'll create a class for that purpose, and call it TestOperators. It will look like this:

package tutorial7;

public class TestOperators {

public void compareUsingAnd( int value1 , int value2) {

    if (  value1 >= 10 & value2 < 100 ) {
        System.out.println(" Condition is true ");
    }

}

}

What it means is, if :

value1 >= 10 : value1 variable is Greater or Equal than 10
& : AND
value2 < 100: value2 variable is Less than 100

Then :

System.out.println(" Condition is true ");

Now, on our Starter class, we create an instance of the TestOperators class and call that method like this:

public static void main(String[] args) {

    TestOperators test = new TestOperators();
    test.compareUsingAnd( 10, 50 );

}

When we run the code it produces:

 Condition is true

Lets modify the code on the compareUsingAnd method like this :

package tutorial7;

public class TestOperators {

    public void compareUsingAnd( int value1 , int value2) {

        if (  firstComparison(value1) &   value2 < 100 ) {
            System.out.println(" Condition is true ");
        }

    }

    private boolean firstComparison(int value) {
        if ( value >= 10)
            return true;
        return false;
    }

}

It does exactly the same thing, but instead of doing the two individual comparisons inside the boolean expression, we create one method called firstComparison that performs exactly the same comparison and call that method instead. Lets just look at that method for a second :

private boolean firstComparison(int value) {
System.out.println("- Running firstComparison");

    if ( value >= 10)
        return true;

    return false;
}

From the signature of the method we know :

It is a private method, because it just needs to be accessible from inside the TestOperators class,
it returns a `boolean* value,
it receives an int parameter that we simply call value.

First it prints "- Running firstComparison", just so we know the method was called.

Then, if the value provided is Greater or Equal to 10, it returns true and the method finishs (a method finishes after the return statement).

If the value is NOT Greater or Equal to 10, then it does not return true;, so it continues executing, and returns false.

We run our program and it produces:

- Running firstComparison
 Condition is true

So firstComparison evaluated to true, and value2 < 100 also evaluated to true.

Now, as an exercise and because we need it to continue the rest of the tutorial, create a method called secondComparison and do the same thing we did with firstComparison.

The end result should look like this :

package tutorial7;

public class TestOperators {

    public void compareUsingAnd( int value1 , int value2) {

        if (  firstComparison(value1)  &  secondComparision(value2) ) {
            System.out.println(" Condition is true ");
        }

    }

    private boolean firstComparison(int value) {
        System.out.println("- Running firstComparison");

        if ( value >= 10)
            return true;
        return false;
    }

    private boolean secondComparision(int value) {
        System.out.println("- Running secondComparision");

        if ( value < 100)
            return true;
        return false;
    }
}

Running the previous main method will produce:

- Running firstComparison
- Running secondComparision
 Condition is true

With these two methods we can see when the evaluations are made, and it is easier to explain concepts.

Lets modify the main method to call the compareUsingAnd method with values 1 and 50:

public static void main(String[] args) {

    TestOperators test = new TestOperators();
    test.compareUsingAnd( 1, 50 );

}

We compile and run this code and get:

- Running firstComparison
- Running secondComparision

As you can see, this time around there was no "Condition is true" being printed, and the reason is, if you follow the code, method firstComparison evaluates to false even tho secondComparision evaluates to true, and because :

false AND true = false

which is essencially what this mean :

if (  false  &  true ) {
    System.out.println(" Condition is true ");
}

The condition of the if is not meet, and the println statement is not executed.

If you have any doubts why false AND true = false then please check Wikipedia - Truth Tables. It is essential to have an understanding of logic operations of this kind.

Notice that because the first evaluation ( the firstComparison method) evaluates to false! Because we are using an AND, the if condition could never be satisfied, no matter what secondComparision evaluates to.

In an AND boolean operation , both arguments must be true for the result to be true

So :

false AND false = false
true AND false = false
false AND true = false

Only:

true AND true = true

Lets modify the compareUsingAnd method on the TestOperators class to this :

public void compareUsingAnd( int value1 , int value2) {

    if (  firstComparison(value1) && secondComparision(value2) ) {
        System.out.println(" Condition is true ");
    }

}

The only difference was changing & to && , so using Conditional AND instead of AND .

Compiling and running this new version produces the following:

- Running firstComparison

So, as you can see, secondComparision was never called.

This is the difference between AND and Conditional AND . The AND operator ( & ) evaluates both side of the AND before doing the boolean operation . The Conditional AND ( && ) first evaluates the first part , and only if the second part is necessary for the boolean operation, does it ever gets evaluated.

In our last example, because the first part evaluated to false , it is unnecessary to evaluate the second part.

Now, using && is not more or less correct that & . They are different , have different behaviors, and a programmer needs to be aware of this. Most of the time && is used, but there could be particular use-cases that require & instead of && .

OR and Conditional OR work exactly in the same way. OR ( | ) will evaluate both side of the boolean operation before evaluating the OR expression, while the Conditional OR ( || ) evaluates the first side, and only evaluates the second if necessary.

Else

Again, we'll modify the compareUsingAnd method like this :

public void compareUsingAnd( int value1 , int value2) {

    if (  firstComparison(value1) && secondComparision(value2) ) {
        System.out.println(" Condition is true ");
    } else
        System.out.println(" Condition is false ");

    System.out.println(" Finished ");
}

Notice the else keyword. This keyword is used together with If statements, to execute something when the if evaluation is not meet.

Compiling and running this code will produce :

- Running firstComparison
 Condition is false 
 Finished

As like before, only the statement after the else keyword is execute. If the programmer wants to execute more statements in case the evaluation fails, then a block ( { } ) must be used, like this :

    if (  firstComparison(value1) && secondComparision(value2) ) {
        System.out.println(" Condition is true ");
    } else {
        System.out.println(" Condition is false ");
        System.out.println(" Condition is false ");
    }

Which would print the same thing twice..... just to demonstrate the block.

If Statements are binary, the expression evaluates either to true or false and there are only two paths of execution.

To allow for more paths of execution we could chain If Else Statements and create something like this:

    if ( age < 18) {
        System.out.println(" underage ");
    } else {

        if (age < 70) {
            System.out.println(" adult ");
        } else {
            System.out.println(" elder ");
        }

    }

This is completely valid, and commonly done.

Not

Also, there is a wait to invert a boolean. Lets look at the following code :

if ( age < 18) {
    System.out.println(" underage ");
}

This is equivalent to :

if ( ! age >= 18) {
    System.out.println(" underage ");
}

Notice the ! operator, that inverts the result of the age >= 18 expression.

So, if we have age defined like int age = 5 ; , this is how the evaluation would be evaluated :

Replacing we get : if ( ! 5 >= 18 )
5 >= 18 is evaluated first , resulting in false , because 5 is not Getter nor Equal to 18.
we would then have : if ( ! false )
!false is true , because the ! changes the boolean value ( this is what it does )
we have : if ( true )

Is this making sense?

In fact, to demonstrate this better, look at the following code :

boolean value = true;
System.out.println("Value is : " + value);

Executing this would produce :

Value is : true

Now, modifying the code like this :

boolean value = !true;
System.out.println("Value is : " + value);

Would produce :

Value is : false

So, as you can see, the ! operator just inverts the boolean.

There are many many other ways to control the flow of execution of a program, If Statements are one , another is the Switch Statement , which is not used as much as the If Statement but is also important to know.

Switch Statement

The Switch statement works a bit differently from the If Statement. The switch statement also takes an expression, but this expression must evaluate to byte, short, char, int, String.

Lets look at the following example:

int value = 1 ;

switch ( value ) {

    case 1:
        System.out.println("Detected");
        System.out.println("Value is 1");
        break;

}

If we were to execute this code, the result would be :

Detected
Value is 1

So what this does is:

switch ( value) : the switch take the value the expression evaluates to. In this case the expression is just a value that evaluates to int.
The value of the expression gets compared with all the case options available.
Because the evaluation of the expression is 1 and there is a case that matches that case 1: , everything after that is executed until a break; is found.

Very simple!

Look at this modified version of the previous code:

int value = 2 ;

switch (value) {
    case 1:
        System.out.println("Detected");
        System.out.println("Value is 1");
        break;
    case 2:
        System.out.println("Detected");
        System.out.println("Value is 2");
        break;
    case 3:
        System.out.println("Detected");
        System.out.println("Value is 3");
        break;
}

In this example we modified the value the expression evaluates to, and we added a few other cases.

Compiling and executing this will produce :

Detected
Value is 2

There is also a special catch, which is the default case, which can be used to execute in case the expression does not evaluate to any of the other cases :

int value = 5 ;

switch (value) {
    case 1:
        System.out.println("Detected");
        System.out.println("Value is 1");
        break;
    case 2:
        System.out.println("Detected");
        System.out.println("Value is 2");
        break;
    case 3 :
        System.out.println("Detected");
        System.out.println("Value is 3");
        break;
    default:
        System.out.println("Nothing Detected");
        break;
}

Compiling and executing this will produce :

Nothing Detected

Very easy, yes ? But now , just out of curiosity, lets remove all the breaks; from the code. Give a look at this:

int value = 2 ;

switch (value) {

    case 1:
        System.out.println("Detected");
        System.out.println("Value is 1");
        //break;
    case 2:
        System.out.println("Detected");
        System.out.println("Value is 2");
        //break;
    case 3 :
        System.out.println("Detected");
        System.out.println("Value is 3");
        //break;
    default:
        System.out.println("Nothing Detected");
        //break;
}

Executing would produce :

Detected
Value is 2
Detected
Value is 3
Nothing Detected

Because value is now 2, it does not match the first case, but it matches case 2, so it starts executing until it finds the break; statement, which does not exist, so it executes until the end of the Switch statement.

It is very important to remember that, if a case matches, execution will be until a break; is reached, or the Switch body ends.

Wrapping up

So, with this basic knowledge of Flow Control, you are ready to try out a few exercises, just to get some practice in solving some small problems, and getting used to writing code. Check the first exercises section before going for the next Tutorial!

References

Java Tutorial 6 - Arrays

Rui Pereira — Tue, 29 Mar 2016 14:56:28 GMT

Introduction

At this point we have all the knowledge we need to create Classes, methods, variables, instances of Objects, call methods, etc. These are the basic building blocks of any program made in Java.

In the last tutorial we finished with the following phrase:

Wouldn't it be nice to be able to have a list of Person objects stored in someway, instead of having to programmatically define a variable for each of the objects we create?

Well, lets look at Arrays then!

Arrays

For this Tutorial we will create another project with IntelliJ called "BeginnerJava6" , or just another empty folder named "BeginnerJava6" where we'll store our code. Create a package called "tutorial6", and we'll write all our code inside this package.

Lets create a class caller Starter with a main method:

package tutorial6;

public class Starter {
    public static void main(String[] args) {

    }
}

All very simple until now.

Lets talk Arrays

We'll kick it off with an example of an Array:

int[] listOfInts = new int[10];

What is an Array? In Java, the simplest way of describing an array is: a structure that stores values. These structure have a few properties that are very important to understand :

They are of fixed size

So, an array has a fixed size that is defined when the array is created. In our example of listOfInts, it is a structure that can take 10 elements : new int[10]

It is typed

Which means that they store elements of a specific type. This specific type is defined also when the array is created. In our example it stores int values.

It is ordered

This means that the elements have a specific position on the array, and that adding or removing elements, does not change the position or the remaining elements in the array.

These are a few examples of other types of arrays:

float[] listOfFloats = new float[10]; - An array of floats of size 10
double[] listOfDoubles = new double[50]; - An array of doubles of size 50
String[] listOfStrings = new String[9000]; - An array of Strings of size 9000

As you can see, the notation is quite simple! First the programmer defines the type of array it wants to work with, and a name for that array:

int[] listOfInts : This is the declaration part of the statement on our first example

Then the programmer instantiates the array, using the new keyword, like it was an object, but instead of using the ( ) to pass arguments to a constructor, the programmer uses [ ] with the size of the array he need to create :

new int[10] : This is the instantiation part of the statement, where the size of the array is specified

Lets create an array of ints inside the main method of the Starter class:

package tutorial6;

public class Starter {

    public static void main(String[] args) {

        int[] listOfInts = new int[10];

    }

}

A few things to take notice, and recapping from the last tutorials :

the listOfInts variable is of Method Level Scope
because it is of Method Level Scope , it only exist inside that method
and because it is of Method Level Scope it does not have an Access Modifier
inside the main method we create the array variable and instantiate it with a size of 10
it does nothing else

Everything is making sense, yes?

Very easy, give it a compile and run it. If it does absolutely nothing, that means that it is good.

Accessing values of an Array

To access the values inside the array we do : arrayName[ POSITION ] where POSITION is the index of the array we want to access.

The index of an array is an int always starts at 0 and ends at size-1 of the size defined at its instantiation.

Lets modify the main method of the Starter class to print all the elements of the array we are creating:

public static void main(String[] args) {

    int[] listOfInts = new int[10];

    System.out.println("Value at index 0 : " + listOfInts[0] );
    System.out.println("Value at index 1 : " + listOfInts[1] );
    System.out.println("Value at index 2 : " + listOfInts[2] );
    System.out.println("Value at index 3 : " + listOfInts[3] );
    System.out.println("Value at index 4 : " + listOfInts[4] );
    System.out.println("Value at index 5 : " + listOfInts[5] );
    System.out.println("Value at index 6 : " + listOfInts[6] );
    System.out.println("Value at index 7 : " + listOfInts[7] );
    System.out.println("Value at index 8 : " + listOfInts[8] );
    System.out.println("Value at index 9 : " + listOfInts[9] );

}

Compile and run it. The result should be something like this:

Value at index 0 : 0
Value at index 1 : 0
Value at index 2 : 0
Value at index 3 : 0
Value at index 4 : 0
Value at index 5 : 0
Value at index 6 : 0
Value at index 7 : 0
Value at index 8 : 0
Value at index 9 : 0

Notice that all elements of the array are filled with 0s, this is an important detail to know about arrays, they are initialized with with default values of the type of array they are, hence:

int[] ints = new int[10] : all elements will be 0
double[] doubles = new doubles[10] : all elements will be 0.0

If the array was an array of objects, then the default value of each element would be null, which is to mean that the position is empty and has no object. We'll see more about what null means when looking at Reference Variables. Some examples :

User[] users = new Users[10] : all elements will be null
String[] strings = new String[10] : all elements will be null

Give it a try and see the results yourself.

Now we can read the elements in the array positions, but what about setting those values?

Setting values of elements

To set the value of a particular element of an array we use the same notation as before: arrayName[ POSITION ] where POSITION is the index of the array we want to access, and then we assign the value using the = operator, like so:

listOfInts[5] = 1000;

This last statement will assign the value of 1000 to the element on the 6st position! Yes, 6st position, remember that the index starts at 0, and 0 is the first position of the array.

As an exercise, modify the main method to first assign values to all elements of the array and then print them out.

The end result should be something like this:

public static void main(String[] args) {

    int[] listOfInts = new int[10];

    listOfInts[0] = 199;
    listOfInts[1] = 9349;
    listOfInts[2] = 9229;
    listOfInts[3] = 11243;
    listOfInts[4] = 952;
    listOfInts[5] = 13;
    listOfInts[6] = 422;
    listOfInts[7] = 4239;
    listOfInts[8] = 527;
    listOfInts[9] = 874;


    System.out.println("Value at index 0 : " + listOfInts[0] );
    System.out.println("Value at index 1 : " + listOfInts[1] );
    System.out.println("Value at index 2 : " + listOfInts[2] );
    System.out.println("Value at index 3 : " + listOfInts[3] );
    System.out.println("Value at index 4 : " + listOfInts[4] );
    System.out.println("Value at index 5 : " + listOfInts[5] );
    System.out.println("Value at index 6 : " + listOfInts[6] );
    System.out.println("Value at index 7 : " + listOfInts[7] );
    System.out.println("Value at index 8 : " + listOfInts[8] );
    System.out.println("Value at index 9 : " + listOfInts[9] );

}

And running this last example will produce:

Value at index 0 : 199
Value at index 1 : 9349
Value at index 2 : 9229
Value at index 3 : 11243
Value at index 4 : 952
Value at index 5 : 13
Value at index 6 : 422
Value at index 7 : 4239
Value at index 8 : 527
Value at index 9 : 874

There is another way to set the values of an array, which is to assign the values when initializing the array.

Initing with values

In some cases, when we create an array we already know what values we want to place in it, and in those cases it makes a lot more sense to just set those values during instantiation, instead of instantiating an array with a specific size and then writing some more code to insert the values in their correct positions.

This is done in the following way:

int[] listOfInts = new int[]{ 111,222,333,444,555,666,777,888,999,1000 };

This small example will create an array of ints called listOfInts, with a size of 10although it is not specified directly, and with the following ints 111,222,333,444,555,666,777,888,999,1000 in their ordered position.

Notice that by using this notation :

The size of the array is specified indirectly , it is the size of parameters provided.
The order of the values will be the corresponding index, starting with 0

As an exercise, modify the main method to assign values during instantiation of the array, and print those values out.

The end main method should look something like this:

public static void main(String[] args) {

    int[] listOfInts = new int[]{ 111,222,333,444,555,666,777,888,999,1000 };

    System.out.println("Value at index 0 : " + listOfInts[0] );
    System.out.println("Value at index 1 : " + listOfInts[1] );
    System.out.println("Value at index 2 : " + listOfInts[2] );
    System.out.println("Value at index 3 : " + listOfInts[3] );
    System.out.println("Value at index 4 : " + listOfInts[4] );
    System.out.println("Value at index 5 : " + listOfInts[5] );
    System.out.println("Value at index 6 : " + listOfInts[6] );
    System.out.println("Value at index 7 : " + listOfInts[7] );
    System.out.println("Value at index 8 : " + listOfInts[8] );
    System.out.println("Value at index 9 : " + listOfInts[9] );

}

Executing this last main method will produce:

Value at index 0 : 111
Value at index 1 : 222
Value at index 2 : 333
Value at index 3 : 444
Value at index 4 : 555
Value at index 5 : 666
Value at index 6 : 777
Value at index 7 : 888
Value at index 8 : 999
Value at index 9 : 1000

What is the size of this array?

Another really important detail of working with arrays, is getting the size of an array. In our examples thus far we created the arrays, we know the sizes, we know what they contain, but this might not always be the case.

To get the size of an array we access the length public int variable that exists on all arrays, because arrays are objects (remember, if a variable is not of a primitive type, it is an object) :

listOfInts.length;

As an exercise, modify the main method we have been working with, and after printing all the values print also the size of the array.

The end result could look like this:

public static void main(String[] args) {

    int[] listOfInts = new int[]{ 111,222,333,444,555,666,777,888,999,1000 };

    System.out.println("Value at index 0 : " + listOfInts[0] );
    System.out.println("Value at index 1 : " + listOfInts[1] );
    System.out.println("Value at index 2 : " + listOfInts[2] );
    System.out.println("Value at index 3 : " + listOfInts[3] );
    System.out.println("Value at index 4 : " + listOfInts[4] );
    System.out.println("Value at index 5 : " + listOfInts[5] );
    System.out.println("Value at index 6 : " + listOfInts[6] );
    System.out.println("Value at index 7 : " + listOfInts[7] );
    System.out.println("Value at index 8 : " + listOfInts[8] );
    System.out.println("Value at index 9 : " + listOfInts[9] );

    int size = listOfInts.length;
    System.out.println("Size of array is : " + size);

}

Notice that in this bit of code, this particular section :

int size = listOfInts.length;
System.out.println("Size of array is : " + size);

Could be rewritten as:

System.out.println("Size of array is : " + listOfInts.length);

Which would avoid creating another variable and assigning a value to that variable.

If you have been trying these exercises, and writing code as you are learning it, you probably already tried to access an element of an array using an index that is larger than the size of the array itself. If you did, then you got an error. Lets look at that now.

Accessing using invalid index

Like it was said in the beginning of this tutorial, an array has a fixed size, and it's index goes from 0 to size-1, so what happens when we use an index that is smaller than 0 or bigger than size-1?

Lets modify the main method to try it out:

public static void main(String[] args) {

    int[] listOfInts = new int[10];
    System.out.println("Value at index 0 : " + listOfInts[-1] );

}

Compiling this code will produce no errors.

Running the compiled code will generate an exception:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: -1
    at tutorial6.Starter.main(Starter.java:7)

The same is true for trying to set a value with an invalid index:

int[] listOfInts = new int[10];
listOfInts[20] = 1000;

This will also produce an exception:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 20
at tutorial6.Starter.main(Starter.java:7)

One way to avoid these exceptions, of type ArrayIndexOutOfBoundsException, if to verify before if the index we are about to use is smaller or equal to the size of the array, and also larger than 0. We'll see how to do that on the next tutorial.

If you feel ready, the next Tutorial : Tutorial 6 - Flow Control

References

Java 8 API Specification

Java Tutorial 5 - Packages and Access Modifiers

Rui Pereira — Tue, 29 Mar 2016 14:55:18 GMT

Introduction

In this tutorial we'll finally look at Packages to organize our code, and also at Access Modifiers that will allow us to restrict access to parts of our Classes.

By this point you show have an understanding of how to create a new Class, create new objects of a class type, create variables and know that there are primitive types. If you don't, the please check the Tutorial 3 - Variables and Tutorial 4 - Classes, Constructors and Methods .

So, if you have IntelliJ Community Edition installed and would like to use it, just open it up and Create a New Project, of Java type, and select no other libraries nor Frameworks. Call it "BeginnerJava5". If you are using a text editor, just create a new Folder somewhere on your disc and call it "BeginnerJava5".

We'll develop a very rudimentary system that creates and stores data on Persons, much like we did on the previous tutorial. We'll do it from scratch, and now learn about Packages in Java.

Lets start with creating a class called Starter, so using IntelliJ on the left tree find the "src" folder, right click in it and select "new" -> "Java Class" . If you are using a the text editor, create a file called "Starter.java" on the root of the folder you previously created.

public class Starter {
}

This is our Starter class. Lets create a main method and make it print out something:

public class Starter {

    public static void main(String[] args) {
        System.out.println("Starting program");
    }

}

Compile it and run it. If you are using IntelliJ simply press Ctrl+Shift-F10.

Everything should be fine to this point.

Now we'll go and implement the User class, but before we do, lets think a little about how we want to organize our Classes. For a project so small as this one it wouldn't be a problem to have all Classes in the same place, but imagine for a project that will have tens or hundreds or thousands of Classes? Having a large project with all its classes in the same place would be a nightmare to manage, and work with.

There is the concept of Packages in Java, which allows the programmers to organize their classes in a tree like fashion.

Packages

Every project in Java should have its package, the exception being that the project will never ever be used again in any sort of productive way. Lets call this a rule.

Because we are programming a Person management system, and because we want to do it right, well create a package for this project. We'll call it tutorials.personmanagement .

There is a naming convention as to what the package name of a software or library should be and what rules should be follow:

Package names are in all lowercase
If the project is developed by a company, organization, or person that has an internet domain, the reverse of the domain is used to start the name of the package.

For example, if this was a project developed by JBay Solutions and this project is a Printing Money Software, then because JBay Solutions has the domain jbaysolutions.com the package could be called for example:

com.jbaysolutions.printingmoney
com.jbaysolutions.printmoneysoftware
com.jbaysolutions.lib.printingmoney

There is a bit of freedom to choose the name of the package, but its goal is to avoid conflicts! By following these rules, it is very unlikely that you'll find conflicts of Classes with the same name, inside packages with the same name, in different libraries.

So, our package is going to be called tutorials.personmanagement.

If you are using IntelliJ just right-click on the "src" folder on the Project tree on the right, and select "new" -> "Package" . Just type in : tutorials.personmanagement .

If you are using the text editor, then just go to the folder of the project, and create a folder named "tutorials" and then inside that folder create another folder called "personmanagement" .

So now we have the Package for the project, we'll start with the creation of the Person class, inside the tutorials.personmanagement package . Just go ahead and create the Person class, with no methods and no variables.

If you use IntelliJ it should look like this:

package tutorials.personmanagement;

public class Person {
}

If you created the Class in a normal Text Editor, then you are probably missing the first line:

package tutorials.personmanagement;

Because this Person class "belongs" to a package, not only must the file be created inside that specific folder, the first statement of that Class must be the definition of the package it belongs to.

This would also be correct, because the Comments and Blank lines obviously don't count as statements:

// This is a comment

/*
 This is also a comment 
*/

package tutorials.personmanagement;

public class Person {
}

For our software, a Person will have the following attributes:

A Name - String
An Age - int
A Salary - double

Lets implement this class then, with the Getter and Setter methods for all the properties, and also create 2 constructors, one that takes all 3 parameters and one that takes just the Name and Age, because under aged people will not have a salary.

We should end up with a class somewhat like this :

package tutorials.personmanagement;

public class Person {

    String name;
    int age;
    double salary;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

Notice that in this class we have two constructors. This is valid, because the constructors have different signatures.

Likewise we could have several methods with the exact same name, as long as input paramenters part of the signature is different. This is called method overloading , or in our particular case here, constructor overloading.

Overloading

Lets think about this "Overloading" thing for a second.

We have two Constructors like this:

public Person(String name, int age, double salary)
public Person(String name, int age)

Why is this allowed? The simple reason is : you call them in different ways!

Because you call them in different ways, the JVM, when it is executing, will know exactly which constructor to use based on the input you provide.

As an example, imagine you will be creating a Person object with the following code:

Person person = new Person( "Rui", 35 );

The JVM knows that you are trying to call a constructor that takes as input a String and an int in this particular order. It will then look at the class Person and see if there is a Constructor that matches this. It finds it and uses it:

public Person(String name, int age)

It will not be able to use the other Constructor :

public Person(String name, int age, double salary)

Likewise, if we try to create a Person object with the following code:

Person person = new Person( "Rui", 35 , 1000.0 );

It will only be able to use the second constructor.

Overloading works exactly in the same way for methods.

Also, if we look at one of the constructor, we will notice that the names of the parameters provided are exactly the same as the names of the Class level variables:

String name;
int age;
double salary;

public Person(String name, int age) {
    this.name = name;
    this.age = age;
}

These are effectively two different variables, one that has a Class Level Scope, and one that has a Method Level Scope (check the previous Tutorial to understand more about variables scope Here) .

This is legal, because they are defined in different scopes.

But now, because we can access two variables with the same name from inside the method (or constructor in our case), there has to be a way to unequivocally specify which variable we are referring to, hence the use of the keyword this .

this Keyword

From inside a method, the keyword this is used to reference the Object the method belong to. In this particular case, inside the constructor, the this.name specifies unequivocally that we are referring to the String name variable defined outside the method.

If we have this Constructor instead:

String name;
int age;
double salary;

public Person(String name, int age) {
    name = name;
    age = age;
}

Because we are not using the this keyword, then we will be referring to the String name variable that is passed as argument, and therefore we would not be affecting any of the Class Level variables that exist on the class.

Notice also that on the Setter methods of the class, we also use the same name for the input argument as we use for the Class variables, and therefore we need to use the this keyword:

public void setName(String name) {
    this.name = name;
}

Also, keep in mind that the following method would be valid and would accomplish the same result as the previous method:

public void setName(String newName) {
    this.name = newName;
}

In this particular case the use of the this keyword is redundant, because there is no ambiguity as to which variables we are referring to, but it is legal and correct non the less.

Lets continue with the code.

Continuing

On our Starter class, which does not have a package, we only have the main method, which is at this point printing a String. Lets modify the main method to now create an object o type Person:

public class Starter {

    public static void main(String[] args) {
        System.out.println("Starting program");        
        Person person = new Person("Rui", 35);
    }

}

If you are using IntelliJ or any other IDE, the source code should be showing some errors. This is because the Starter doesn't know what Person is, nor where it is. We must import the Class to let Starter know that when we refer to Person we are talking about a specific class:

import tutorials.personmanagement.Person;

public class Starter {

    public static void main(String[] args) {
        System.out.println("Starting program");

        Person person = new Person("Rui", 35);
    }

}

As you can see, in the first line of this class, we added an import statement:

import tutorials.personmanagement.Person;

This is how it works: If a programmer is writing some code in a Class that uses other Classes, then, if the other Classes are not in the same exact Package, the programmer needs to import either the specific class, or everything inside the Package of the other classes:

import tutorials.personmanagement.Person; : Importing specific class
import tutorials.personmanagement.* ; : Importing every class inside this package

Usually a programmer will import only the Class that is needed, unless there are several Classes inside a package that are going to all be needed, and in that case, the programmer imports all the Classes inside a Package using the * notation.

Why is this important?

Imagine for a second that you are developing a big project that has a visual component that draws Squares on the screen, and a computational side that calculates areas of Squares. You will possibily have two classes called Square on two different packages :

com.project.render.Square
com.project.area.Square

When writting the code, depending of which part the programmer is now coding, he will need to import a different Square class. This gets even more tricky when a project uses libraries that were developed by a 3rd party, and you don't know all the names of all the classes that exist inside that 3rd party library.

The import statements are always placed between the Package statement and the beginning of the class

Like this:

package com.project;

import com.project.render.Square;

public class Example {
    [ETC ETC ETC]
}

If the specific class you will need to import stuff into does not belong to a Package, then the import statements should be the first statements of the file. (Obviously not counting the comments)

Compile and run what you have until now, and see if the import works ( Ctrl+Shift+F10 or Shift+F10 on IntelliJ) .

Calling methods from anywhere

In the previous part of this tutorial we created a Person class, and a Starter class where we create an instance of Person with some values. Lets now modify the Person object that was created and change the value of the name variable for that object, and lets also modify the Person class to add a method for printing the values of the variables. We'll start with the method of the Person class:

public void printData() {
    System.out.println("Value for name is : " + name);
    System.out.println("Value for age is : " + age);
    System.out.println("Value for salary is : " + salary);
}

Very simple, like we did on the previous tutorials.

Now, lets modify the main method on the Starter class, to modify the name property of the object and also print out the values of the object afterwards:

public static void main(String[] args) {
    System.out.println("Starting program");

    Person person = new Person("Rui", 35);
    person.setName("Super Rui");
    person.printData();
}

Compiling and running it we get :

Starting program
Value for name is : Super Rui
Value for age is : 35
Value for salary is : 0.0

The first thing to notice here is that the Constructor used for creating the Person object was the Constructor that only takes in String name and int age , and therefore salary was never ever set! But when we print, the value of salary is 0.0.

This is because, for Class Level Scope primitive typed variables (yes... all these names we have just learned), when not assigned, they take their default value, which for a double is 0.0.

The second thing to notice is that the change of the name was done through a Setter method, which is correct, but is not enforced here, which is bad. We'll see how to enforce that in a minute with Access Modifiers.

For our example of a Person Management System, we want that every time that a Person is created or properties are modified on a Person object, the Software shows some Logs. To do this, we will implement a method on the Person class that prints a provided message. We'll call that method logToConsole and we define it like this :

public void logToConsole(String message) {
    System.out.println("PERSON LOG - " + message);
}

So, every time this method is called with a message, it will writen to the console with a PERSON LOG - prefix.

Now, we'll modify every Setter method on the Person class to call this method before changing the value of a variable. We'll also modify the Constructors to call this method when they are called.

The final *Person class should look something like this now:

package tutorials.personmanagement;

public class Person {

    String name;
    int age;
    double salary;

    public Person(String name, int age) {
        logToConsole("Creating Person with name: " + name + " age: " + age);

        this.name = name;
        this.age = age;
    }

    public Person(String name, int age, double salary) {
        logToConsole("Creating Person with name: " + name + " age: " + age + " salary: " +salary);

        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public void logToConsole(String message) {
        System.out.println("PERSON LOG - " + message);
    }

    public void printData() {
        System.out.println("Value for name is : " + name);
        System.out.println("Value for age is : " + age);
        System.out.println("Value for salary is : " + salary);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        logToConsole("name modified to: " + name );

        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        logToConsole("age modified to: " + age);

        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        logToConsole("salary modified to: " + salary );

        this.salary = salary;
    }
}

Looking, for example, at the setName method we have:

public void setName(String name) {
    logToConsole("name modified to: " + name );

    this.name = name;
}

Which mean that before assigning the provided name value to the class variable name , we call the method logToConsole and print the value out.

Compiling the project now and running it will return something like this:

Starting program
PERSON LOG - Creating Person with name: Rui age: 35
PERSON LOG - name modified to: Super Rui
Value for name is : Super Rui
Value for age is : 35
Value for salary is : 0.0

Notice that we have 2 LOGs on the output. The first which corresponds to the Constructor , which should the values used on the creation of the Person object, and the second one which if for the call of the setName method.

Lets say now that we are very sneaky and lets try to call the logToConsole method from the main method in this way :

public static void main(String[] args) {
    System.out.println("Starting program");

    Person person = new Person("Rui", 35);
    person.setName("Super Rui");

    person.logToConsole("name modified to: MEGA MEGA RUI");

    person.printData();
}

When we compile and run it we get:

Starting program
PERSON LOG - Creating Person with name: Rui age: 35
PERSON LOG - name modified to: Super Rui
PERSON LOG - name modified to: MEGA MEGA RUI
Value for name is : Super Rui
Value for age is : 35
Value for salary is : 0.0

We now have 3 LOGs on the output, we have the third LOG saying that the name was modified to "MEGA MEGA RUI" but when we call the printData method, we see that the value for name is still "Super Rui". We understand why, because we called the logToConsole function, which simply prints things to the console, and not the setName Setter Method which also prints things (through the use of logToConsole) but also modifies the value of the name variable. We know this, but other users, that might be looking at the LOGs will not get this, and will wonder why the name was not modified.

The reason why this can happen is because everyone can call logToConsole.

Problems can even be worst, for example, with the salary variable. Imagine that the Setter method for Salary has some other code that calculates Taxes, and other things that are related to money. It would be a very big security issue if a programmer would modify the value of the salary of a person directly without using the Setter method, or print LOGs saying that the salary was modified, but nothing was actually changed on the Person object in question.

Enter the Access Modifiers.

Access Modifiers

Since the first tutorial of this series, every method and class we created started with the public keyword. This is the Access Modifier of the Class or Method, which in all our examples was public, which is the least restrictive Access Modifier that there is.

There are in total 4 Access Modifiers:

public
protected
no modifier (package-protected)
private

Public

A method that is public is a method that can be called from anywhere in the code. You can call it from inside the same class, from a different class in the same package, from a different class on a different package, etc. The same goes for Class Level Scope variables, you can access these variables from anywhere.

Private

A method that is private is a method can can only be called from the same Class where it is declared. The same goes for Class Level Scope variables, these can only be accessed from inside the same Class where they are declared.

Package-Protected

The package-protected is a modifier which does not have a specific name, but is usually referred to as the Package-Protected access modifier, or Package Level access modifier, which is when a method or a variable have no Access Modifier defined. An example is :

public class Person {

    String name;  // <-- Package-Protected Access Modifier
    int age;  // <-- Package-Protected Access Modifier
    double salary;  // <-- Package-Protected Access Modifier

}

These three Class Level Scope variables have the Package-protected access modifier , because they don't have an Access Modifier defined.

What this means is that these variables can be accessed directly only from the Class they are declared in, or from other Class that belong to the same package.

Protected

The protected Access Modifier is almost the same as the Package Access Modifier ( or "no modifier" ) , which means that the method or variable can be accessed from Classes that belong to the same package, but also from Subclasses even if they are in other packages. What is a Subclass? Well get back to this in a few tutorials, but it is nothing to worry about.

All these Access Modifiers can be applied Methods and Class Level Scope Variables.

As for Classes, they can only be "public" or "Package level" . Private and protected make no sense to Classes, and therefore cannot be used.

Using Access Modifiers

Looking at our Person Class, we see that we have 3 variables that are package-protected:

String name;
int age;
double salary;

It makes no sense to have them as Package-Protected because they are only meaningful to the Object they belong to. Also, because they have Getter and Setter methods, it makes no sense to allow them to be accessed and modified from outside of this Class. We should make them private, like so:

public class Person {

    private String name;
    private int age;
    private double salary;

What about the methods? The Getter and Setter methods, because we want to be able to access them from other classes, even outside of the package this class belongs to, we leave them as public.

What about the logToConsole method? Because we only want this method to be called from inside the Person class, and avoid other developers ruining the LOGs we produce, we'll make the method private :

private void logToConsole(String message) {
    System.out.println("PERSON LOG - " + message);
}

Making this change to the logToConsole method will make calling it from the main method at Starter illegal and will generate an error if we try to Compile. Try it and see for yourself (really, try it) .

Lets now remove the call to logToConsole method from the main method (or comment it out), and give it a compile and run.

public static void main(String[] args) {
    System.out.println("Starting program");

    Person person = new Person("Rui", 35);
    person.setName("Super Rui");

    //person.logToConsole("name modified to: MEGA MEGA RUI");  

    person.printData();
}

What about Constructors?

Constructors are like methods and therefore can have any Access Modifier, even the "private" modifier. You'll see examples of it later on.

What about Method Level Scope Variables?

Method Level Scope Variables don't have an Access Modifier, because they are only accessible from inside the specific method they are created in. Also, it wouldn't make any sense to have them have an Access Modifier because they only exist during the execution of the method they belong to, and after the method execution they stop existing.

Many objects

As an exercise, lets now modify the main method to make it create 2 objects of type Person , using the two different Constructors we have, and then print the data on both the objects using the printData method.

If should look something like this :

public static void main(String[] args) {
    System.out.println("Starting program");

    Person person = new Person("Rui", 35);
    person.setName("Super Rui");

    Person person2 = new Person("Miguel", 90, 500.0);

    person.printData();
    person2.printData();
}

Compile and run it. The result should look like:

Starting program
PERSON LOG - Creating Person with name: Rui age: 35
PERSON LOG - name modified to: Super Rui
PERSON LOG - Creating Person with name: Miguel age: 90 salary: 500.0
Value for name is : Super Rui
Value for age is : 35
Value for salary is : 0.0
Value for name is : Miguel
Value for age is : 90
Value for salary is : 500.0

Wouldn't it be nice to be able to have a list of Person objects stored in someway, instead of having to programmatically define a variable for each of the objects we create? Yes , and we'll look into of doing it in the next tutorial.

Java Tutorial 4 - Classes, Constructors and Methods

Rui Pereira — Tue, 29 Mar 2016 14:54:38 GMT

Introduction

In the previous tutorials we dabbed into Primitive variables, did a few operations with them, nothing special or exciting.

In this tutorial however, we'll now look at Objects and Reference Variables, and we'll start with understanding the Scope of variables.

Variables Scope

In our previous examples, the ones shown in the previous tutorial, all our variables were defined and used inside a method. What this means is that those variables are only available inside that method, they are created and erased and recreated with each time that method is executed.

Look at the next Class:

public class Scope {

    int classVariable = 1;

    public void methodNumber1() {

        int methodVariable1 = 2 ;

    }

    public void methodNumber2() {

        int methodVariable2 = 3 ;

    }
}

There are a total of 3 variables defined in this Class.

classVariable: This variable can be accessed from anywhere inside the Class and it can be accessed from inside any of the methods inside that Class. Just as a side note, this is called a variable with Class Level Scope.
methodVariable1 and methodVariable2 : These variables can be accessed only from inside the methods they are defined in. In fact, they don't exist outside of the execution of their method, and therefore, methodNumber2 cannot access (read, write... print) methodVariable1, because that variable is only defined inside methodNumber1. This is called having Method Level Scope.

The names Class Level Scope and Method Level Scope are not really important to know, but what they imply is. methodVariable1 and methodVariable2 exist only inside their respective methods. They could even have the exact same name, it wouldn't matter, they don't exist outside of the methods.

Code indentation (writing code in an organized way, like we have been doing so far) really helps a lot to understand the scope of variables.

Classes and Objects

To explain the concept of Objects and Classes, we'll implement a very rudimentary system that creates and stores Users and some attributes of each of the Users, and then prints out a listing of this information, formatted in some particular way.

Because we know we will be storing Users, and those users have attributes, we know that the best way to organize this information would be to have a "template" for what a user should have. We'll start with the creation of a User class.

Create a new file called User.java inside an empty folder that will be used for this tutorial, and write the code for the class:

public class User {

}

This Class, as it is, will store absolutely nothing, and it has no methods defined, so in practice it will do nothing.

Lets say that our Users will all have a name and an age:

public class User {

    String name;
    int age;

}

So this class can now be used to store two pieces of data :

a name, of type String
an age, of type int

But let us discuss it a bit further.

As we saw in the previous tutorial, and int is a primitive type that uses 32bits. It can be a number that goes as high as 2^31-1, so it is very unlikely (if not biologically impossible) that someone will ever be that age. We could actually use a byte to store the age of the User, it would save memory (if that is a concern) .

We'll choose to continue using an int, for no particular reason.

We also have a variable named name of type String. String is a very particular type, it is not a primitive (it is in a way a collection of chars) but can be declared like a primitive, and also some operators work on it ( like the + operator, when we concatenate Strings). We'll talk about String in a second.

Another difference from what we have been doing so far, is that there is no main method on this class. This means that you cannot execute this class, and therefore the main method must exist in another class, if the project is to be executed.

Without closing the User.java file, create another file, right next to the User.java file, and call it "LessonExecution3.java" . This will be the Class that starts the program, and will make use of the User class. Create the LessonExecution3 class and create a main method in it. It should look like this:

public class LessonExecution3 {

    public static void main(String[] args) {

    }

}

Now, lets create a User and store it, we'll specify the name and the age of the user, and then, we will print that data:

public static void main(String[] args) {
    User user = new User();
    user.name = "Rui";
    user.age = 35;

    System.out.println( "User Name: " + user.name );
    System.out.println( "User Age: " + user.age );
}

Compile and run both files like this:

javac User.java LessonExecution3.java
java  LessonExecution3

The output should be something like:

User Name: Rui
User Age: 35

Lets look at the inside of the main method we have just created inside the LessonExecution3 class.

We start with the statement:

User user = new User();

We know that User is a class, and therefore what we are doing here is creating a variable of that Type, and assigning a newly created Object of that type to the variable:

User user : creating a variable of type User
new User() : creating an Object of type User
User user = new User() : Assigning the object to the variable.

When creating an object, the notation is always new Object , with emphasis on the word new .

So. after we create and assign an Object of type User to the variable named user, we access the variables inside that object using the . (dot) notation:

user.name = "Rui";
user.age = 35;

Notice that when we access the variables inside the newly created object, we use name of the variable of the object, and the name of the variable inside that object. Looking at user.name we can break it down like this:

user : the name of the variable , not the name of the Class!
name : the name of the variable inside that particular object!

Remember, we don't do something like User.name because User is the name of the Class, and the Class, like we said before is just a template for objects to be created.

After we access the variables to assign them values, we perform the System.out.println() statements, where we access the variables inside the particular Object and print those values out.

This works, but lets make it better!

Creating Methods

Now, the printing of data of the User object is being done on the main method, which is not very wise if one wants to print the contents of several User objects, because it would mean that there would have to be as many System.out.println as twice the number of User objects created.

A method that prints this same data could be easily created. Lets do it.

Go to the User class source code file, and modify it to look like this :

public class User {

    String name;
    int age;

    public void printData() {
        System.out.println( "User Name: " + name );
        System.out.println( "User Age: " + age );
    }

}

In this updated version of the User class, we have now a method called printData that :

returns nothing : void
receives nothing : ()
performs some System.out.println() statements inside.

Notice that when we do the printing inside this method, we access the variables directly, without using the dot notation. This is because :

the scope of those variables makes them accessible from that method
Also, the variable User user does not exist on this class, it is only accessible from the LessonExecution3 class, inside the main method.

Now the main method of LessonExecution3 must be modified to call the method printData instead of having the two System.out.println statements. We do it like this:

public class LessonExecution3 {

    public static void main(String[] args) {
        User user = new User();
        user.name = "Rui";
        user.age = 35;

        user.printData();  // <------------
    }

}

On this new version, the System.out.println statements were removed, and replaced by the user.printData() statement, which has inside some other System.out.println statements. We call the method by using the variable of the object we want to access, and using the dot notation specify the method we want to execute. In this particular case, because printData receives no arguments, we place the ( ) with nothing inside the brackets.

Setter Methods

But we can improve this code a lot still. When we declare the user variable and instantiate it, we then access the variables inside that object to assign values to them. This is actually a bad practice.

Instead of accessing the variables directly, we should be using methods to both set values of these variables and to get the values of these variables.

We'll now implement a method to set the variable name. We call methods that specifically set values for variables Setter Methods, and a modified version of the User class with a setter method for the name variable can be seen next:

public class User {

    String name;
    int age;

    public void printData() {
        System.out.println( "User Name: " + name );
        System.out.println( "User Age: " + age );
    }

    /*
    Setter method for the name variable
    */
    public void setName(String newname) {
        name = newname ;
    }

}

There is now a method with the signature like public void setName(String newname), which means:

the method receives only one argument, which we call newname
the method return nothing : void

Then, inside the method, we set the Class Variable name with the value of the received variable newname , like this : name = newname ; . Simple yes?

But having this Setter method does not stop programmers from accessing the variable name directly and modifying it! It is just another way to modify the Class variable.

There is a way to make it impossible for a user to access the variable directly, which the use of Access Modifiers, and we'll see about it on the next Tutorial.

Now lets modify the main method inside LessonExecution3 to use the setter method for name instead of accessing it directly:

public static void main(String[] args) {
    User user = new User();
    user.setName( "Rui" );   //   <-------- Using setter method for name
    user.age = 35;    //  <-------- Accessing age variable directly

    user.printData();
}

Because the setName method requires a String parameter as input, the method is called with the value to be assigned to that parameter inside the () brackets, like this: ( "value" ) .

If, for example, the required parameter was a number, of type int , then calling the method and providing a String as argument would make the program not compile.

Now, do exactly the same thing to the variable age . Create a setter method and modify the main method to call the setter method for age instead of accessing it directly.

The resulting User class should look something like this :

public class User {

    String name;
    int age;

    public void printData() {
        System.out.println( "User Name: " + name );
        System.out.println( "User Age: " + age );
    }

    /*
      Setter method for the name variable
    */
    public void setName(String newname) {
        name = newname ;
    }

    /*
      Setter method for the age variable
    */
    public void setAge(int newage) {
        age = newage ;
    }

}

Notice that we have started putting comments before the methods, explaining what they will be doing.

And then the main method should look like this:

public static void main(String[] args) {
    User user = new User();
    user.setName( "Rui" );
    user.setAge( 35 );

    user.printData();
}

Now that we already made 3 methods, including two that are setter methods, it makes sense to create also the getter methods for those variables!

Getter Methods

Getter methods are just what their name say, they are methods to get values of specific variables.

For example, from looking to our class User to get the values of both name and age variable a programmer would need to access them directly. This is not desired, accessing variables from other classes directly is a bad practice, and therefore we need a way to access the values of those variables.

Accessing variables from other classes directly is a bad practice

To create a getter method for the variable name, we need to write a method whose signature should look like this: public String getName() , which means:

the method returns one String : String
the method does not require any parameters ; ( )

Now the question is, how does one make a method return a value? Simple, we use the return keyword :

/*
  Getter method for the Name variable
*/
public String getName() {
    return name;
}

So, if somewhere on our code, from outside of the User class, we would like to get the value of name of a particular object, we can now instead use this getter method. Lets exemplify using our main method inside of LessonExecution3 :

public static void main(String[] args) {
    User user = new User();
    user.setName( "Rui" );
    user.setAge( 35 );

    user.printData();

    // ---- Testing the getter method ----
    String valueFromObject = user.getName();
    System.out.println("Testing getter method : "  + valueFromObject );
}

Modify your classes accordingly, compile and give it a run. The output should look something like :

User Name: Rui
User Age: 35
Testing getter method : Rui

Now, as an exercise implement a getter method for the age variable, that returns an int and test the getter method on the main method, like we did before.

The resulting User class should look like this:

public class User {

    String name;
    int age;

    public void printData() {
        System.out.println( "User Name: " + name );
        System.out.println( "User Age: " + age );
    }

    /*
      Setter method for the name variable
    */
    public void setName(String newname) {
        name = newname ;
    }

    /*
     Getter method for the name variable
    */
    public String getName() {
        return name;
    }

    /*
      Setter method for the age variable
    */
    public void setAge(int newage) {
        age = newage ;
    }

    /*
    Getter method for the age variable
    */
    public int getAge() {
        return age;
    }

}

And the resulting LessonExecution3 class should look like this:

public class LessonExecution3 {

    public static void main(String[] args) {
        User user = new User();
        user.setName( "Rui" );
        user.setAge( 35 );

        user.printData();

        String valueFromObject = user.getName();
        System.out.println("Testing getter name method : "  + valueFromObject );

        int ageFromObject = user.getAge();
        System.out.println("Testing getter age method : "  + ageFromObject );

    }

}

But we can still make it better!

If we look at the previous code, to create a User object with complete information (with name and age) we must do it in 3 different statements!

If we accept that a User must always have a name and age , then this code will not do it, because we are not forcing these to be defined at creation, which means that if someone creates a User object and then forgets to call the setters for name and age, the User object would not have these variables defined.

For this, there is a special kind of method, which is called a Constructor that can only be called at the creation of the object.

Constructor

A Constructor is a method that does not return anything, and has the exact same name as the Class and is called during instantiation of the new Object.

Each class must have at least one Constructor, but if none is provided, one is created automatically, called the default constructor, which takes 0 parameters and does absolutely nothing.

In the previous version of the code, the User class has no constructor, which mean that one is created automatically (behind the scenes), which is equivalent to this :

public class User {

    /*
     The Default Constructor
    */
    public User() {

    }

    String name;
    int age;

    [ ETC ETC ETC ] 
}

And when in the main method we were doing:

User user = new User();

the new User() is actually saying : create a new object of type User, using the "no arguments" Constructor.

As you can see, the constructor :

public User() {

}

Has no return type defined, because it is a constructor
Has the same name as the Class

A class can have multiple Constructors, as long as they have different signatures, which in this particular case means that each different Constructor must have different types of parameters that they take as input (or the number of parameters vary). For example, having these constructors all on the same class would be acceptable:

public User()
public User(String newname)
public User(String newname, int age)
public User(int age, String newname)

Having a class with all these constructors would be illegal:

public User()
public User(String firstname)
public User(String surname)

Because the last two Constructors are identical.

So, recapping, if no Constructor is defined, then one is automatically created, that takes no arguments, and does absolutely nothing. And if one Constructor is specified, then the automatic "no arguments" constructor is not created.

Getting back to our code, because we decided that there would make no sense to have User objects without name and age, we'll create a Constructor that must receive both these parameters, and we delete the "no arguments" Constructor if there is one:

public class User {

    String name;
    int age;

    public User(String newname, int newage) {
        name = newname;
        age = newage;
    }

    [ETC ETC ETC]

}

At this point we have a User class that has only one constructor, and that constructor must take 2 arguments, the newname String and the newage int.

If you tried to compile now you would get an error like this :

LessonExecution3.java:4: error: constructor User in class User cannot be applied to given types;
        User user = new User();
                    ^
  required: String,int
  found: no arguments
  reason: actual and formal argument lists differ in length
  1 error

This happens because we are creating the user object using a constructor that does not exist! Remember, before we had no Constructor defined, and because of that one automatic one was created. Now there is one, and because there is only one, we must use that constructor!

We must now modify the main method to make use of that constructor:

public static void main(String[] args) {
    User user = new User("Rui" , 35);
    user.setName( "Rui" );
    user.setAge( 35 );

    user.printData();

    String valueFromObject = user.getName();
    System.out.println("Testing getter name method : "  + valueFromObject );

    int ageFromObject = user.getAge();
    System.out.println("Testing getter age method : "  + ageFromObject );

}

Notice that now we are creating the object using new User("Rui" , 35); , which tells us that we are using the Constructor that takes one String and one int, in that particular order.

Afterwards we have :

user.setName( "Rui" );
user.setAge( 35 );

This is unnecessary, because the values are already being set in the Constructor. Lets remove that, and we end up with :

public static void main(String[] args) {
    User user = new User("Rui" , 35);

    user.printData();

    String valueFromObject = user.getName();
    System.out.println("Testing getter name method : "  + valueFromObject );

    int ageFromObject = user.getAge();
    System.out.println("Testing getter age method : "  + ageFromObject );

}

Compile everything now and run it, to verify that the values are being set correctly:

User Name: Rui
User Age: 35
Testing getter name method : Rui
Testing getter age method : 35

Exercise

As an exercise, create another constructor on the User class, that takes an int and a String, is this new order and create another object of type User in a variable called user2 , using the new Constructor, and call the printData method on that object!

The code for the User class should end up looking like this:

public class User {

    String name;
    int age;

    public User(String newname, int newage) {
        name = newname;
        age = newage;
    }

    public User(int newage, String newname) {
        name = newname;
        age = newage;
    }

    public void printData() {
        System.out.println( "User Name: " + name );
        System.out.println( "User Age: " + age );
    }

    [ETC ETC ETC]

}

And the code for the LessonExecution3 should look something like this:

public class LessonExecution3 {

    public static void main(String[] args) {
        User user = new User("Rui" , 35);

        user.printData();

        User user2 = new User(99, "Old Man");

        user2.printData();

        String valueFromObject = user.getName();
        System.out.println("Testing getter name method : "  + valueFromObject );

        int ageFromObject = user.getAge();
        System.out.println("Testing getter age method : "  + ageFromObject );

    }

}

At this point you should know how to implement methods and constructors , create new classes , and create instances of those classes (creating new Objects of the class type). All of this speaks to the absolute basic mechanics of Object-Oriented programming.

There are a few more considerations to know about methods, that you might have figured out already, but we'll put it in writing.

What else about Methods?

A method can have both input and output at the same time. Look at this valid method, which is totally unrelated to the code we have been producing:

public int sumTwoNumbers(int number1 , int number2) {
    return number1 + number2 ;
}

This method is completely acceptable, and valid. It receives two ints and returns the sum of those ints .

Variables that are declared inside the method cannot be accessed outside of that method:

public void  testFunction ( ) {
    int specialNumber;   // <--- Declared
    specialNumber = 20 ;  // <--- Assigned

    specialNumber = specialNumber + 10 ; 

    System.out.println("Value now is : "  + specialNumber); // <-- will print 30

    // HERE 
}

In the previous example, each time the method testFunction is executed, a variable is created called specialNumber, and just before the method finishes, this variable stops existing. Remember, those variables only exist inside the method!

Now, if the declaration is outside of the method, in the Class:

int specialNumber;   // <--- Declared

public void  testFunction ( ) {

    specialNumber = 20 ; 
    specialNumber = specialNumber + 10 ; 

    System.out.println("Value now is : "  + specialNumber); // <-- will print 30

}

in this case, the variable specialNumber will exist for each object , and can be accessed from any method on that Class.

And that is it for this tutorial! In the next tutorial we will look into Packages and Access Modifiers, like the keyword public that we have been using.

Lets go, next Tutorial: Tutorial 5 - Packages and Access Modifiers

Java Tutorial 3 - Variables - First Look

Rui Pereira — Tue, 29 Mar 2016 14:52:49 GMT

Introduction

On the previous tutorial we made a really simple program, with just one Class and one Method. There was no data stored, no calculations done, etc.

In this tutorial we will look into storing data and doing something with that data. We'll talk about variables, primitives and Objects, and we'll make a really simple calculator to add 2 numbers! Yes, exciting!

My first Variable

First, we open our favorite text editor and create a new class called Lesson2 with an empty main method. If you have been following the tutorials, try and do it by yourself, or just simply copy the following code onto the editor and save the file as Lesson2.java (remember, java is Case Sensitive).

public class Lesson2 {
    public static void main(String[] args) {

    }
}

You can now compile it and run it. It should give you no errors and print absolutely nothing.

Make the main method now print the "Hello World" phrase, like it was done on the previous tutorial, and we should end up with something like this:

public class Lesson2 {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

Compile and run it again. It should be printing "Hello World"! Remember, every time you modify the Source Code you must compile the code again, and only then will you be able to run it with the new changes.

Lets modify this code now to have a variable and have that code print the value of the variable:

public class Lesson2 {

    public static void main(String[] args) {
        int firstVariable = 5;
        System.out.println("Value is: " + firstVariable);
    }

}

The first change you notice is the int firstVariable = 5; . This is a variable named firstVariable , it is of type int (integer) and has a value of 5.

This is how you declare a variable in Java: You explicitly define the Type of the variable and give it a name. Optionally you can also define a value, like we did there, but this is not mandatory.

The second change is the print that we are now doing: System.out.println("Value is: " + firstVariable); . The program will now print "Value is: " and concatenate the value of the firstValue using the operator +.

Compile and run it. It should have printed : Value is: 5

So, the first variable, which is named firstVariable is of type int (which stands for integer), but what is an int and what other types are there?

Primitive Variables

int is what is called a Primitive type and there are 7 other primitive types. Here is a complete list, with a very simple description of what they are:

short : a type of whole number, that can go from -32768 to 32767. (it is 16bit signed)
int : a type of whole number, that can go from -2^31 to (2^31)-1. (it is 32bit signed)
long : a type of whole number, that can go from -2^63 to (2^63)-1. (it is 64bit signed)
float : a type of floating point number, therefore can have decimals (it is 32bit single precision)
double : a type of floating point number, therefore can have decimals (it is 64bit double precision)
boolean : a type that only allows 2 values : true or false.
char : a single character (16 bit)
byte : a type of whole number, that can go from -128 to 127. (it is 8bit signed)

Before you get too nervous about all this jibber jabber, lets start by saying that only about 3 or 4 of these are used really regularly and these are : int, long, double and boolean . That is not to mean that you don't need to know about the other ones, you do, and you will use some of them, but for learning purposes we'll focus on these 4 for now.

What is a Primitive Variable? There are two types of Variables, those that are of a Primitive type (therefore of one of these 8 types) or those that are Reference Variable. We'll see Reference Variables later, lets write some code first!

Lets modify the Lesson2 class and create variables for these types:

public static void main(String[] args) {
    short shortVariable = 1;
    System.out.println("shortVariable is: " + shortVariable);

    int intVariable = 2;
    System.out.println("intVariable is: " + intVariable);

    long longVariable = 3;
    System.out.println("longVariable is: " + longVariable);

    float floatVariable = 4.1f;
    System.out.println("floatVariable is: " + floatVariable);

    double doubleVariable = 5.1;
    System.out.println("doubleVariable is: " + doubleVariable);

    boolean booleanVariable = true;
    System.out.println("booleanVariable is: " + booleanVariable);

    char charVariable = 'x';
    System.out.println("charVariable is: " + charVariable);    

    byte byteVariable = 8;    
    System.out.println("byteVariable is: " + byteVariable);    
}

Now compile and run it. You should be getting an output like:

shortVariable is: 1
intVariable is: 2
longVariable is: 3
floatVariable is: 4.1
doubleVariable is: 5.1
booleanVariable is: true
charVariable is: x
byteVariable is: 8

Notice the notation used to define these variables:

float floatVariable = 4.1f ;

We placed an "f" after the number. When you define a value of a float typed variable, you must write the letter "f" after the number, to let the compiler know (when you decide to compile the code) that you understand that you are using a small floating-point type, and therefore know that you will not have a lot of precision on that number.

boolean booleanVariable = true ;

When defining a value for a boolean typed variable, there are only 2 choices: true or false .

char charVariable = 'x' ;

When defining a value for a char typed variable, the character must be enclosed inside ' and only one character. Char is a bit special, it is 16 bits, exactly the same as the short type... and are interchangeable. We'll get a chance to see it later.

Now that we have a basic knowledge of the primitive variable types, lets do some operations on those.

Some Operator Action and Strings!

Now that we know how to define and assign values to primitive variables, lets modify the code again, and have only two variables of type int defined inside the main method. We'll call them number1 and number2 and will assign them the values 50 and 2. Try doing it yourself!

It should end up looking like this:

public static void main(String[] args) {

    // Variable of type int called number1 and number2
    int number1 = 50;
    int number2 = 2;

}

If you compile and run it now, it should produce no output. Also, notice that now we have a comment on the source code, before the definition of the variables. This is one of the two ways of writing comments, by placing // everything thing written to the right of this will be considered a comment and ignored by the compiler.

Lets now create another variable, named sumOfNumbers, which will contain the sum of number1 and number2, and lets print the result to the console:

public static void main(String[] args) {

    // Variables of type int called number1 and number2
    int number1 = 50;
    int number2 = 2;

    int sumOfNumbers = number1 + number2;

    System.out.println( sumOfNumbers );

}

Compile it and give it a run. It should have printed the result : 52

There are many other operators, like - for subtraction, / for division, * for multiplication, % for modulus. There are also Compound Operators and Equality Operator, which we'll see very soon.

Experiment with those operators to see what happens, create a few more variables with the result of these operators applied to variables number1 and number2 and print those values out. Check the following code:

public static void main(String[] args) {

    // Variables of type int called number1 and number2
    int number1 = 50;
    int number2 = 2;

    int sumOfNumbers = number1 + number2;
    System.out.println( "Sum: " + sumOfNumbers );

    int subtractionOfNumbers = number1 - number2;
    System.out.println( "Subtraction: " + subtractionOfNumbers );

    int divisionOfNumbers = number1 / number2;
    System.out.println( "Division: " +divisionOfNumbers );

    /*
        For the Multiplication, we'll do something different
    */

    int multiplicationOfNumbers;
    multiplicationOfNumbers = number1 * number2;
    System.out.println( "Multiplication: " + multiplicationOfNumbers );

}

Compile and run!

In this piece of code we can see a few new things:

We have a new type of comment : /* comment */ . This type of comment can span several lines, it begins with /* and ends with */ . Everything in between those is ignored by the compiler
We create an int typed variable called multiplicationOfNumbers but we do not assign any value to it. Then, on the next statement, we assign the value with the result of the multiplication of number1 and number2.
We modified every "print" statement, to now print a String (like "Multiplication: ") with the value of specific variables.

Notice that we have been using the + operator since the beginning of the tutorials to concatenate a String ( something inside " ) and values of primitive variables. Keep in mind that the Add operator, when applied to primitives calculates the addition of the values of the two variables. When applied to one or more Strings, it performs concatenation.

On the next Tutorial we'll talk about Constructors and Methods.

When you feel ready: Tutorial 4 - Classes, Constructors and Methods

Java Tutorial 2 - Hello World

Rui Pereira — Tue, 29 Mar 2016 14:51:55 GMT

Introduction

To start this great journey, we'll use the typical "Hello World" program. Yes, it is not very exciting, not very motivational, but before we start running we must learn how to walk.

At this point you should have the JDK installed, and a text editor available. If you have no idea what a JDK is, then you should go and check the previous tutorial: Tutorial 1 - Introduction (The Absolute Basics)

Open your favorite (or available) text editor and lets start!

Hello World

Just for this example, we'll use a normal text editor instead of IntelliJ. This is just to show you how you compile java code. In the next tutorials we'll start making use of IntelliJ Community Edition, which makes it a lot simpler to compile and run your projects. But don't skip this bit, you should really know how to compile and run your code by hand!

Grab the text editor, start a new file and copy this bit of code into it:

public class Lesson1{
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

After you copied this, create an empty folder, which we will be using for this particular tutorial, and save the file with the name Lesson1.java. Java is a case sensitive language, so copy the code exactly the wait it was presented before and save the file with that precise name. We'll get more into that, don't worry.

There should now be a Folder on your system, with just one file named Lesson1.java .

Remember: Java is a case sensitive language

Open a command prompt if you are in windows (type cmd.exe in the "Run" option on the Windows Start Button) , or a Shell if you are in a Unix based system and go to that Folder.

JAVA and JAVAC

To compile the Lesson1 program we are making, which simply prints "Hello World", we must first compile it! To compile we use the Java Compiler (JAVAC).

On the command prompt or shell, inside the folder where the Lesson1.java file exists, type in:

javac

If a sea of text just flashed by, then the JDK is correctly installed and you can proceed to the next step. If on the other hand there was an error message like : javac: command not found , then the JDK is not correctly installed and you should check the previous tutorial before proceeding.

On the command prompt or shell, type in:

javac Lesson1.java

If everything went right, you should now have exactly 2 files inside that folder:

Lesson1.java - The source code
Lesson1.class - The Compiled Java Bytecode

Now in that same command prompt or shell, type in:

java Lesson1

It should print out "Hello World"! Congratulations, this is your first program in Java! It doesn't do much, but it is a start! Lets look at the source code and understand what it all means.

Looking at the Code

As it was said in the previous tutorial, Java is a Object Oriented (OO) language, and that means that our program is structured in Objects that may or may not have data inside, and may or may not have code inside.

A Class

When a programmer writes a file like this:

public class Lesson1{

}

The programmer is in fact creating a Class , which you can think of as a Template for Objects, with the name Lesson1.

Because our "Hello World" program is really small, it only has one Class, but if it was more complex it could have many many many more Classes.

From that code public class Lesson1 , we know that we are creating a Class named Lesson1, and that Class is Public. We'll forget about the Public bit for now, but we'll get back to it once we look at Access Modifiers in the Tutorial 5 - Packages and Access Modifiers .

A Method

Then, inside the Lesson1 class (which is the bit between { and }, we have:

public static void main(String[] args) {

}

This is a Method, and it is called "main". We'll break it down:

public : like in the class, it will be talked about in the next tutorial
static : we'll also forget about this for the moment, we'll get back to it in a few tutorials
void : this means that the method does not return anything.
main : the name of the method we are creating
(String[] args) : the arguments the method receives, in this case it is an Array of Strings, called args.

This part of the method public static void main(String[] args) is called the Signature of the method. Obviously all methods will have a signature, where:

the name of the method is specified,
the arguments it receives are specified,
what it returns is specified

This method, named "main", with a signature as described before, is a very important method! It is the method that the JVM (Java Virtual Machine) will grab and execute, and therefore this is where a program starts its execution.

Notice that the class named Lesson1 starts with a capital letter. Now notice that the main method start with a lowercase letter. This was not something random that just happened to be this way, it was on purpose. Although there is no technical reason why this is so, it is a convention, and every Java programmer knows this and will do it this way. We will adhere to it :

Names of classes start with Capital letters

Names of methods start with Lower case letters

Names of variables start with Lower case letters (except for some exceptions well see later)

Inside the method we find:

System.out.println("Hello World");

In simple terms it is a Statement that prints a line with "Hello World" to the console (or command prompt, or shell) .

In sightly more complex term (which you don't need to completely understand now, and will be explained later on) we are calling a method called println that exists inside a variable called out , that exists inside a System object. We know this because of the naming conventions, and it will all make a lot more sense really soon.

So, what do we know up to this point?

A Class is a template for Objects
A Class name always starts with a Capital Level
A Method has a signature that defines the input and output
A Method is named with a starting lowercase letter
A Class is compiled using the Java Compiler javac
A Compiled program is run using the Java Virtual Machine: java

Next we'll talk about variables and just a little bit more OO theory. We are about to start the good stuff!

Exercises

To get a bit more practice, consider doing the following exercise:

Create a class named Exercise1 that prints "My First Exercise" when it is executed.

Next tutorial: Tutorial 3 - Variables

Java Tutorial 1 - Introduction - The absolute basics

Rui Pereira — Tue, 29 Mar 2016 14:50:52 GMT

Introduction

Java is not a difficult language to learn, even if you are a complete beginner. There are a few concept however that we must get out of the way in order to get started.

In this tutorial we will cover the absolute basics of Java and programming in general, so if you already know what Java is, what a development kit is, you have a JDK installed and ready to run, then go ahead and Skip to the next tutorial.

What is Java?

Java is two things: it is both an Object-Oriented Programming language and a Platform.

Object-Oriented Programming (OO) Language .

When writing code, or programming, a programmer writes that code using a specific syntax and grammar that he and other programmers understand called the Programming Language. In the particular case of Java, it is an Object-Oriented programming language, which means that it is based around the notion of Objects that may have data inside and also may contain code instructions (like methods).

Object-Oriented programming is one of several programming paradigms, but there are others, like Functional Programming (like Lisp and Haskell) , Logic Programming (like Prolog), etc. It is simply a set of concepts and rules on how to structure an idea or problem.

So, when we say that Java is an Object Oriented Programming Language, we are just expressing the way that code is structured, and what is the expected behavior of that code. This will be covered more indepth in the next tutorials of this series, while writing some code and getting some hands-on experience.

But Java is also a Platform,

Platform

When someone makes a program in Java, for it to be executable it needs to be compiled. Compiling code is basically translating the human readable source code, which is the writing the programmer does, into a "format" that the computer can make sense of. This is called compiling to Native code, and it has the following particularities:

Code compiled natively is usually faster, at least at startup
Code compiled natively is architecture and OS specific (must be compiled independently for each OS : windows, Linux, etc)
Code compiled natively do require an interpreter.

Java in particular (and some other languages as well) is an interpreted programming language, which means that the Java Source code is compiled into intermediate "format", and then for it is run, the computer must have an interpreter. In Java this is called Compiling to Java bytecode, and has the following particularities:

Java Bytecode requires an interpreter to be installed ( Java must be installed on the running machine)
Java Bytecode is not architecture or OS specific. It can run in any arch. or Os that has an interpreter

So, when we talk about Java there is this distinction, it is a programming language, but also a Platform (or runtime environment).

Development Kit

To start programming in Java, the first thing that a programmer needs is the Java Development Kit (also known as JDK) and to run a program made in Java, a user needs the Java Runtime Environment (also known as JRE).

The JDK has the compiler, and all utilities needed to transform Java Source Code into Java Bytecode, and also brings a JRE inside so the developer can run the application he is coding. As a developer you'll only need to install the JDK on your computer.

The JRE has the interpreter, that is called the Java Virtual Machine (or JVM for short). We'll talk more about the particularities of the JVM as we move along.

So, to get the JDK you can go to the Oracle JDK 8 Download Page . We are looking for the Java SE Development Kit 8u73 . Download the version for your platform and follow all the steps to install it.

Once the JDK is installer, you'll need an editor to write the Source Code for the projects you'll be programming.

IDE

Any text editor will do, you can code Java using the Windows Notepad, or linux Vi if you want. But sometimes it is helpful to have an editor that can verify straight away the syntax you are using to program, and warn you of any errors you might have made. It is also useful to have a text editor that writes some boilerplate code that you don't want to be writing all the time, and that allows for the code to be compiled automatically from inside the editor, to save time and for convenience. These are called Integrated Development Environments, or IDEs for short.

There are many many IDEs for Java, like NetBeans, Eclipse, etc etc etc.

For the first tutorials there is no need for a fancy IDE. We could use a simple text editor and everything would be fine.

Some recommended text editors are :

But don't get lost in the choice of text editor. It really makes no difference, you can do it with Notepad.

After the first beginner tutorials, the IDE that will be used is IntelliJ Community Edition . Any other can be used, but the examples will be made using IntelliJ. There is a Community Edition of IntelliJ that is free, and that is the one that will be used on the tutorials.

Next Steps

Before the next tutorial you should:

install the specified JDK.
install a text editor , an IDE (or decide to use notepad or something for now)

Once you are ready, next tutorial: Tutorial 2 - Hello World

Adding Image to PDF file using Java and IText

Gustavo Santos — Tue, 27 Oct 2015 15:49:00 GMT

To add an image to an already existing PDF file is a relatively simple task, using iText.

On this example, we will add a smile image to the bottom of the PDF first page.

We start by loading the PDF we want to modify, and getting the reference for the first page:

    PdfReader reader = new PdfReader(srcPdf);
    PdfStamper stamper = new PdfStamper(reader, new FileOutputStream(destPdf));
    PdfContentByte content = stamper.getOverContent(1);

srcPdf is a String with the full path to the existing PDF file, while destPdf is the full path where the modified PDF file will be created.

Then, we load the image (imagePath is the full path for the imagem file):

Image image = Image.getInstance(imagePath);

// scale the image to 50px height
image.scaleAbsoluteHeight(50);
image.scaleAbsoluteWidth((image.getWidth() * 50) / image.getHeight());

Since the image dimensions are large, it's scaled to 50 pixels height before we add it to the PDF.

We then set the page coordinates where we want it. Be aware that the 0 value for the Y axis is the bottom of the page, not the top:

image.setAbsolutePosition(70, 140);

All we need to do now is add it to the page reference and close the stamper:

content.addImage(image);

stamper.close();

That's it!

The sample project with all the code, example PDF and image is available at github, here

Reading and converting XML files to Excel in Java

Gustavo Santos — Fri, 16 Oct 2015 14:43:45 GMT

Today we're going to show how to read a XML file and convert it's entries to lines on an excel file.

The XML file is located at https://github.com/jbaysolutions/xml-to-excel/blob/master/Publication1.xml?raw=true.

The XML file's main nodes are "Substances", each one has a few properties "Name", "entry_force", "directive" and a list of "Product". We're going to create an excel row for each Product. Each row will also have the Product parent Substance details.

Below is a sample of the XML structure:




    09/07/2015 13:45


    Garlic extract (++)
    01/09/2008
    Reg. (EC) No 839/2008
    
        FRUITS, FRESH or FROZEN; TREE NUTS
        0100000
        
        01/09/2008
    
    
        Oranges (Bergamots, Bitter oranges/sour oranges, Blood oranges, Cara caras, Chinottos,
            Trifoliate oranges, Other hybrids of Citrus sinensis, not elsewhere mentioned,)
        
        0110020
        
        01/09/2008
    
    
        Lemons (Buddha's hands/Buddha's fingers, Citrons,)
        0110030
        
        01/09/2008
    
    
        Limes (Indian sweet limes/Palestine sweet limes, Kaffir limes, Sweet limes/mosambis, Tahiti
            limes,)
        
        0110040
        
        01/09/2008
    


(...)

As usual, we use Apache POI, to create the excel file.

You can get the sample project used in this post at GitHub.

Downloading the file

We start by downloading the file from it's original URL location:

File xmlFile = File.createTempFile("substances", "tmp");
String xmlFileUrl = "http://ec.europa.eu/food/plant/pesticides/eu-pesticides-database/public/?event=Execute.DownLoadXML&id=1";
URL url = new URL(xmlFileUrl);
System.out.println("downloading file from " + xmlFileUrl + " ...");
FileUtils.copyURLToFile(url, xmlFile);
System.out.println("downloading finished, parsing...");

Preparing the Excel file

To create the Excel file where we're writing, we start by creating a new workbook, an empty sheet and writing the first line with the column headers:

workbook = new XSSFWorkbook();

CellStyle style = workbook.createCellStyle();
Font boldFont = workbook.createFont();
boldFont.setBold(true);
style.setFont(boldFont);
style.setAlignment(CellStyle.ALIGN_CENTER);

Sheet sheet = workbook.createSheet();
rowNum = 0;
Row row = sheet.createRow(rowNum++);
Cell cell = row.createCell(SUBSTANCE_NAME_COLUMN);
cell.setCellValue("Substance name");
cell.setCellStyle(style);

cell = row.createCell(SUBSTANCE_ENTRY_FORCE_COLUMN);
cell.setCellValue("Substance entry_force");
cell.setCellStyle(style);

cell = row.createCell(SUBSTANCE_DIRECTIVE_COLUMN);
cell.setCellValue("Substance directive");
cell.setCellStyle(style);

cell = row.createCell(PRODUCT_NAME_COLUMN);
cell.setCellValue("Product name");
cell.setCellStyle(style);

cell = row.createCell(PRODUCT_CODE_COLUMN);
cell.setCellValue("Product code");
cell.setCellStyle(style);

cell = row.createCell(PRODUCT_MRL_COLUMN);
cell.setCellValue("MRL");
cell.setCellStyle(style);

cell = row.createCell(APPLICATION_DATE_COLUMN);
cell.setCellValue("Application Date");
cell.setCellStyle(style);

Parsing

For this sample, the XML file is parsed using DOM.

We get the reference to the excel file sheet:

Sheet sheet = workbook.getSheetAt(0);

We start by loading the XML document using DOM and getting the Substances node list:

DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
Document doc = dBuilder.parse(xmlFile);

NodeList nList = doc.getElementsByTagName("Substances");

Then we iterate through the Substances list and get the Substance properties:

for (int i = 0; i < nList.getLength(); i++) {
    System.out.println("Processing element " + (i+1) + "/" + nList.getLength());
    Node node = nList.item(i);
    if (node.getNodeType() == Node.ELEMENT_NODE) {
        Element element = (Element) node;
        String substanceName = element.getElementsByTagName("Name").item(0).getTextContent();
        String entryForce = element.getElementsByTagName("entry_force").item(0).getTextContent();
        String directive = element.getElementsByTagName("directive").item(0).getTextContent();

        NodeList prods = element.getElementsByTagName("Product");

When we get to the Product element, we get it as a NodeList and iterate it to get it's details:

for (int j = 0; j < prods.getLength(); j++) {
    Node prod = prods.item(j);
    if (prod.getNodeType() == Node.ELEMENT_NODE) {
        Element product = (Element) prod;
        String prodName = product.getElementsByTagName("Product_name").item(0).getTextContent();
        String prodCode = product.getElementsByTagName("Product_code").item(0).getTextContent();
        String lmr = product.getElementsByTagName("MRL").item(0).getTextContent();
        String applicationDate = product.getElementsByTagName("ApplicationDate").item(0).getTextContent();

Now that we have all the details we want to write on the excel file, we create a row with all the details:

Row row = sheet.createRow(rowNum++);
Cell cell = row.createCell(SUBSTANCE_NAME_COLUMN);
cell.setCellValue(substanceName);

cell = row.createCell(SUBSTANCE_ENTRY_FORCE_COLUMN);
cell.setCellValue(entryForce);

cell = row.createCell(SUBSTANCE_DIRECTIVE_COLUMN);
cell.setCellValue(directive);

cell = row.createCell(PRODUCT_NAME_COLUMN);
cell.setCellValue(prodName);

cell = row.createCell(PRODUCT_CODE_COLUMN);
cell.setCellValue(prodCode);

cell = row.createCell(PRODUCT_MRL_COLUMN);
cell.setCellValue(lmr);

cell = row.createCell(APPLICATION_DATE_COLUMN);
cell.setCellValue(applicationDate);

When all the elements are written, we write the excel to the filesystem:

FileOutputStream fileOut = new FileOutputStream("C:/Temp/Excel-Out.xlsx");
workbook.write(fileOut);
workbook.close();
fileOut.close();

Finally, we delete the downloaded XML file:

if (xmlFile.exists()) {
    System.out.println("delete file-> " + xmlFile.getAbsolutePath());
    if (!xmlFile.delete()) {
        System.out.println("file '" + xmlFile.getAbsolutePath() + "' was not deleted!");
    }
}

Conclusion

The sample project used in this post at GitHub has a main class XmlToExcelConverter to download, parse the file and create the excel file.

Feel free to copy and adapt the code to read other XML files!
Hope it helped anyone having the same issues as us!

References

DOM

DOM Tutorial

Apache POI

Starting new Activity in Android

Rui Pereira — Mon, 12 Oct 2015 14:22:23 GMT

From an Activity

To start a new Activity from another Activity:

Intent intent = new Intent(this, OtherActivity.class);
startActivity(intent);

From a Service

Intent intent = new Intent(this, OtherActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);

From somewhere else

To start an Activity from another class that does not extend Context or does not extend a class that allows access to a Context, a context must be retrieved in some way.

Either by passing it to the method being called:

public void startNewActivity(Context context) {
    Intent intent = new Intent(this, OtherActivity.class);
    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    context.startActivity(intent);
}

Or by using the Application Context, if the class that extends Application (if there is one) makes it available directy of by using an helper class.

Example of Aplication and AppState Helper Class

Following a set of classes to help with making the Application Context available to all classes of the project.

The Application class for the project:

package com.example.mytestapp;

import android.app.Application;
public class MyTestApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        MyTestAppState.setApplicationContext(this);
    }
}

The AppState class for the project:

package com.example.mytestapp;

import android.content.Context;
import android.util.Log;

public class MyTestAppState {

    private static final String TAG = "MyTestAppState";
    private static Context sContext;

    private static MyTestAppState INSTANCE;

    public static MyTestAppState getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new MyTestAppState();
        }
        return INSTANCE;
    }

    private MyTestAppState() {
        if (sContext == null) {
            throw new IllegalStateException("MyTestAppState inited before app context set");
        }
        Log.v(TAG, "MyTestAppState inited");
    }

    public Context getContext() {
        return sContext;
    }

    public static void setApplicationContext(Context context) {
        if (sContext != null) {
        Log.w(TAG, "setApplicationContext called twice! old=" + sContext + " new=" + context);
        }
        sContext = context.getApplicationContext();
    }
}

Using the Application Context

Intent intent = new Intent(this, OtherActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
MyTestAppState.getInstance().getContext().startActivity(intent);

What is Intent.FLAGACTIVITYNEW_TASK

According to the Android Development API documents, when this Flag is set, the new ACtivity will become the start of a new task on the History Stack.

Reading and parsing Excel Spreadsheet XML files with Java

Gustavo Santos — Wed, 04 Mar 2015 17:29:31 GMT

On one of our projects, we were asked to implement a process that updates a database with values from an Excel file on a daily basis. The file is located at https://github.com/jbaysolutions/excel-xml-reader/raw/master/ActiveSubstance.xls. The problem with this file is its format. It's an Excel spreadsheet XML.

Usually we parse excel files using Apache POI, but it has no support for Excel spreadsheet XML. The solution was to create our own parser.

For this specific case, we will cover the process of obtaining the substance name (column A), ADI value (column P) and ARfD value (column S).

You can get the sample project used in this post at GitHub.

Downloading the file

This class was to be used by a timer that runs once a day. Starts by downloading the file:

File file = File.createTempFile("substances", "tmp");

String excelFileUrl = "http://ec.europa.eu/sanco_pesticides/public/?event=activesubstance.exportList";
URL url = new URL(excelFileUrl);
System.out.println("downloading file from " + excelFileUrl + " ...");
FileUtils.copyURLToFile(url, file);
System.out.println("downloading finished, parsing...");

Parsing

Since the file format is XML, it can be parsed using SAX.

Since this file has only one sheet, we are keeping the parser simple, so we will only need to find the sheet rows and cells. We declare a class to represent the row:

class XmlRow {
    ArrayList cellList = new ArrayList<>();

    @Override
    public String toString() {
        return cellList.toString();
    }
}

And a SAX handler to load the rows and cell ("Data" in the XML) contents:

class SAXHandler extends DefaultHandler {

    List xmlRowList = new ArrayList<>();
    XmlRow xmlRow = null;
    String content = null;

    @Override
    //Triggered when the start of tag is found.
    public void startElement(String uri, String localName, String qName, Attributes attributes)
            throws SAXException {
        switch (qName) {
            //Create a new Row object when the start tag is found
            case "Row":
                xmlRow = new XmlRow();
                break;
        }
    }

    @Override
    public void endElement(String uri, String localName,
                           String qName) throws SAXException {
        switch (qName) {
            case "Row":
                xmlRowList.add(xmlRow);
                break;
            case "Data":
                xmlRow.cellList.add(content);
                break;
        }
    }

    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        content = String.copyValueOf(ch, start, length).trim();
    }
}

Once the file is downloaded, it's loaded to a string to be supplied to the SAX Parser:

String fileContent = IOUtils.toString(new FileInputStream(file));

SAXParserFactory parserFactor = SAXParserFactory.newInstance();
SAXParser parser = parserFactor.newSAXParser();
SAXHandler handler = new SAXHandler();

ByteArrayInputStream bis = new ByteArrayInputStream(fileContent.getBytes());

parser.parse(bis, handler);

When we try and run this the first time, and exception occurs:

Exception in thread "main" org.xml.sax.SAXParseException; lineNumber: 2; columnNumber: 14; The processing instruction target matching "[xX][mM][lL]" is not allowed.

This happens because some blank space or other visible content exists before the declaration. For this file, we have to remove the first 2 lines, so it can be parsed:


removeLineFromFile(file.getAbsolutePath(), 1, 2);

String fileContent = IOUtils.toString(new FileInputStream(file));

SAXParserFactory parserFactor = SAXParserFactory.newInstance();
SAXParser parser = parserFactor.newSAXParser();
SAXHandler handler = new SAXHandler();

ByteArrayInputStream bis = new ByteArrayInputStream(fileContent.getBytes());

parser.parse(bis, handler);

The removeLineFromFile() method can be found on the sample project source.

When we try to parse it again, another exception is thrown:

Exception in thread "main" org.xml.sax.SAXParseException; lineNumber: 1313; columnNumber: 70; The entity "nbsp" was referenced, but not declared.

This happens because the entity isn't one of XML's predefined entities. To fix it, we have to prepend this to the file before parsing it:

]>

The ´ entity was also found on the file, so we added it as well.

There was also the text "JECFA&ECCO" somewhere in a cell which would cause the parser to throw another exception.

The code now looks like this:

removeLineFromFile(file.getAbsolutePath(), 1, 2);

String fileContent = IOUtils.toString(new FileInputStream(file));
fileContent = fileContent.replaceAll("&ECCO", "&ECCO");
fileContent = "\n" +
        " \n" +
        " \n" +
        "]>" + fileContent;


SAXParserFactory parserFactor = SAXParserFactory.newInstance();
SAXParser parser = parserFactor.newSAXParser();
SAXHandler handler = new SAXHandler();

ByteArrayInputStream bis = new ByteArrayInputStream(fileContent.getBytes());

parser.parse(bis, handler);

We now have a row list, where each row has a cell list. We are going to use this to get our values:

//Parsing the substances list obtained from XML
int count = 0;
for (XmlRow subsRow : handler.xmlRowList) {
    if (subsRow.cellList.size() > 19) {
        String substance = subsRow.cellList.get(0);
        if (substance.equals("Substance")) {
            continue;
        }

        count++;
        String adi = subsRow.cellList.get(15); // column P
        String arfd = subsRow.cellList.get(18); // column S

        System.out.println("Substance name='" + substance + "', ADI='" + adi + "', ARfD='" + arfd + "'");
    }
}

In this example we only care for the substance rows, so we ignore any row that has less than 19 cells. On our project class we use these values to update a DB table, but for simplicity here we are only printing them.

If our goal was to create a regular Excel file, we could change the code to:

Workbook workbook = new HSSFWorkbook();
Sheet sheet = workbook.createSheet();

//Converts all rows to POI rows 
int rowCount = 0;
for (XmlRow subsRow : handler.xmlRowList) {
    Row row = sheet.createRow(rowCount);
    int cellCount = 0;
    for (String cellValue : subsRow.cellList) {
        Cell cell = row.createCell(cellCount);
        cell.setCellValue(cellValue);
        cellCount++;
    }
    rowCount++;
}

String fileOutPath = "/tmp/fileOut.xls";
FileOutputStream fout = new FileOutputStream(fileOutPath);
workbook.write(fout);
workbook.close();
fout.close();

As you can see, it can be easily modified depending on the purpose!

Finally, we delete the downloaded file:

if (file.exists()) {
    System.out.println("delete file-> " + file.getAbsolutePath());
    if (!file.delete()) {
        System.out.println("file '" + file.getAbsolutePath() + "' was not deleted!");
    }
}
//System.out.println(result);
System.out.println("getAndParseFile finished, processed " + count + " substances!");

Conclusion

For the purpose of reading data from an Excel spreadsheet XML file, it's relatively simple to do it.

The sample project used in this post at GitHub has two main classes. ExcelXmlReader to download, parse the file and print the values to the console and the ExcelXmlConverter class, to download, parse the file and converts it to OOXML file format.

The code can be modified to read multiple sheets or even the styles if necessary. It just wasn't needed for our use case.

Hope it helped anyone having the same issues as us!

References

Excel spreadsheet XML

SAX

Apache POI

JPA 2 Tutorial - Queries with JPQL

Rui Pereira — Thu, 16 Oct 2014 13:17:09 GMT

If you are following the tutorials here you must be dying to do some queries using JPA. So, before we go any further into other aspects of JPA, lets query the model! For this task, instead of using SQL we will be using the Java Persistence Query Language or also known as JPQL. Exciting, yes?

Sample Project

About the sample project provided: it is a Maven project, we do not require an App Server at this point and the database used is a MySQL database. Check the JPA2 Tutorials page for links of recommended software.

You can get the project at GitHub.

What is and Why use JPQL?

Before going into what is JPQL, lets talk about SQL. SQL is a query language used for managing data in a relational database. It an ANSI and ISO standard, but if you try running a medium to high complexity SQL query in two different relational databases from two different vendors, you are in for a big surprise. Why is that? Because some vendors create specific dialects of the SQL language.

Now imagine for a second you have a big application that you just developed and deployed, which is using a specific relational database, and for some reason you decide to migrate your data to another relational database from a different vendor. Well, if you wrote your queries in SQL, you are well advised to go and double check all of your queries for correctness against the new dialect.

JPQL to the rescue. JPQL is a query language, much like SQL (syntax wise and all that), but instead of querying over a relational database, it queries over the persistent schema of entities and relationships (which is almost the same thing, but not quite!). What this means is that, if the relational model of the new database is still represented by the schema of entities and relationships you have on your project, then your JPQL queries will be portable and will work as expected. Emphasys on Portability.

Select Statements

For our tutorial we'll use the model created for the One-To-Many Tutorial but we will extend it a bit more:

You can get the MySQL Workbench file for this from the model folder of the sample project. Along with the Workbench file there is a SQL script that creates the model and adds a few entries to it so we can test our queries:

INSERT INTO `jpa2tut-queries`.`company` (`name`, `address`, `created_year`) VALUES ('JBay Solutions', 'Somewhere in Portugal', 2009);
INSERT INTO `jpa2tut-queries`.`company` (`name`, `address`, `created_year`) VALUES ('JetBrains', 'Somewhere in Prague', 2000);
INSERT INTO `jpa2tut-queries`.`company` (`name`, `address`, `created_year`) VALUES ('Google', 'Somewhere in the US', 1998);
INSERT INTO `jpa2tut-queries`.`company` (`name`, `address`, `created_year`) VALUES ('Yahoo', 'Somewhere in the US',1994);
INSERT INTO `jpa2tut-queries`.`company` (`name`, `address`, `created_year`) VALUES ('MySQL', 'Somewhere in an Oracle Office', 1995);

Also, check the src/main/java folder of the project in order to check the Entity Objects we have. An understanding of these objects is core to understanding the JPQL code we will write next.

A Simple Select

As you can see from the previous SQL bits, we have a few entries on the company table. Lets query for the list of those entries:

SELECT c FROM CompanyEntity AS c

At this point you should be going like: Wait a second please... I understand this language!. Like said before, JPQL is very much like the regular SQL, except that we perform queries on the persistent schema of entities and relationships.

Lets run this in Java. Check the files inside the src/test/java folder of the sample project. You should be looking for the QueryTesting.java file at the method testSimpleQuery:

Query query = em.createQuery("SELECT c FROM CompanyEntity AS c");
for ( CompanyEntity ce : (List)query.getResultList()) {
    System.out.println(" -> Company : " + ce.getName() );
}

We give it a run:

[...]
[EL Info]: connection: 2014-10-14 16:41:13.476 --ServerSession(1563886825)--file:/home/rui/projects/jpa2tut-queries/target/test-classes/_jpa2tut-test login successful
 -> Company : JBay Solutions
 -> Company : JetBrains
 -> Company : Google
 -> Company : Yahoo
 -> Company : MySQL

Simple, yes? We create a Query Object with the JPQL query and we call em.getResultList(); . We cast the result to List , because we know that getResultList() returns a List (it does) and we also know that the query we created returns objects of CompanyEntity type.

We can also restrict the number of results being returned from the Query, by modifying the JPQL query used. Imagine we want to return all the companies that are called "JBay Solutions":

SELECT c FROM CompanyEntity AS c WHERE c.name='JBay Solutions'

And the code being (testSimpleQueryWhere method) :

Query query = em.createQuery("SELECT c FROM CompanyEntity AS c WHERE c.name='JBay Solutions'");
for ( CompanyEntity ce : (List)query.getResultList()) {
    System.out.println(" -> Company : " + ce.getName() );
}

Give it a quick spin:

[EL Info]: connection: 2014-10-14 16:54:56.972--ServerSession(1861307614)--file:/home/rui/projects/jpa2tut-queries/target/test-classes/_jpa2tut-test login successful
 -> Company : JBay Solutions

Process finished with exit code 0

At this point one should be able to make pretty simple, but very useful queries, but some issues stand out:

We must be constantly casting the results
All our queries until now allow no input

Enter TypedQuery

In JPA2 a new type of Query object was introduced. The TypedQuery, which allows us to make a Query that is Typed. That is it, TypedQuery extends Query, allowing one to define straight away what is to be returned and avoid continuously Casting every single result.

Looking at our previous examples, we can modify them to use TypedQuery instead of Query by using an overloaded createQuery method from the EntityManager that also takes as a parameter the Type of the query result:

TypedQuery query = em.createQuery("SELECT c FROM CompanyEntity AS c", CompanyEntity.class);

TypedQuery query = em.createQuery("SELECT c FROM CompanyEntity AS c WHERE c.name='JBay Solutions'", CompanyEntity.class);

to perform the iteration now we do:

for (CompanyEntity ce : query.getResultList()) {
    System.out.println(" -> Company : " + ce.getName());
}

No casting, no nothing. For the complete code check both testSimpleTypedQuery and testSimpleTypedQueryWhere methods of the QueryTesting.java file on the test sources.

We still have the no input issue to work on.

Passing Input to the Queries

In a way, some examples we shown before could be easily modified in a way to allow inputs to be passed onto them. Check this out:

String inputName = "JBay Solutions"; 
TypedQuery query = em.createQuery("SELECT c FROM CompanyEntity AS c WHERE c.name='" + inputName + "'", CompanyEntity.class);

Can you spot the problem with this? Well, simple, if you want to perform this query several times with different inputs, then you need to continuously re-create a new Query object. Not counting the performance impact it will have, it also leads to the JPQL not being readable at all. Imagine a query like the one presented but with several conditional expressions on the WHERE clause. What a nightmare.

To avoid these situations we have in JPQL:

Named Parameters
Positional Paramenters

Constructing a Query with any of these types of dynamic parameters allows a Query to be reused (and therefore avoid constant instantiation of Query objects) and makes the JPQL query much more readable.

Named Parameters

Lets look at the following example (from testSimpleTypedQueryWhereInputNamed method):

em.createQuery("SELECT c FROM CompanyEntity AS c WHERE c.name=:nameParam", CompanyEntity.class);
query.setParameter("nameParam", "JBay Solutions");

So, a named parameter is a parameter that is called out by name. It is defined using the :< param_name > notation:

They are defined using the ":" prefix
They are Case Sensitive
$ and _ chars are allowed,
? is not allowed.
They can be used more than once on the Query string
They must be SET to something on execution
There is a list of reserved identifiers that cannot be used. Some of these reserved identifiers are : SELECT , WHERE, GROUP, TRUE, and many more, but you get the gist. These reserved identifiers are case insensitive, and non can be used as a named parameter.

The named parameters are then set on the Query using the setParameter method of the Query instance:

query.setParameter("nameParam", "JBay Solutions");
for (CompanyEntity ce : query.getResultList()) {
    System.out.println(" -> Company : " + ce.getName());
}
query.setParameter("nameParam", "Google");
for (CompanyEntity ce : query.getResultList()) {
    System.out.println(" -> Company : " + ce.getName());
}

What happens if you don't set one of the parameters? You get an IllegalStateException:

[...]
[EL Info]: connection: 2014-10-14 18:30:02.302--ServerSession(822392390)--file:/home/rui/projects/jpa2tut-queries/target/test-classes/_jpa2tut-test login successful

java.lang.IllegalStateException: Query argument nameParam not found in the list of parameters provided during query execution.
    at org.eclipse.persistence.internal.jpa.QueryImpl.processParameters(QueryImpl.java:498)
    [...]

Positional Parameter

Lets look at the following example (from testSimpleTypedQueryWhereInputNumbered method):

em.createQuery("SELECT c FROM CompanyEntity AS c WHERE c.name=?1", CompanyEntity.class);
query.setParameter(1, "JBay Solutions");

A positional parameter is defined using the ?< int > notation:

The parameters are numbered starting with 1
Positional parameter can appear more than once in the Query string.
The order by which they are set is irrelevant

So:

query.setParameter(1, "JBay Solutions");
query.setParameter(2, "Google");

will return the same as:

query.setParameter(2, "Google");
query.setParameter(1, "JBay Solutions");

Using Multiple Entities

Right, making JPQL queries that take into account several Entities is the next logical step. For that, take into account the following SQL script (that is part of the create-and-populate.sql file of the sample project):

INSERT INTO `jpa2tut-queries`.`employee` (`name`, `address`, `idcompany`, `birthday`) VALUES ('Rui Pereira', 'Lisbon',1 , '1981-06-27' );
INSERT INTO `jpa2tut-queries`.`employee` (`name`, `address`, `idcompany`, `birthday`) VALUES ('Gustavo Santo', 'Peniche',1, '1979-12-19');
INSERT INTO `jpa2tut-queries`.`employee` (`name`, `address`, `idcompany`, `birthday`) VALUES ('Maxim Shafirov', 'St.Petersburg, Russia',2, '1970-06-01');
INSERT INTO `jpa2tut-queries`.`employee` (`name`, `address`, `idcompany`, `birthday`) VALUES ('Valentin Kipiatkov', 'St.Petersburg, Russia',2, '1975-06-01');
[... many more entries]

This simply adds a few Employees to the previously created Companies. Now we have JBay Solutions with two employees and JetBrains with also two employees, and the remaining companies with also two employess (check file for the remaining entries).

Lets create a JPQL query that returns the employees of a particular company:

TypedQuery query =
    em.createQuery("SELECT employee FROM CompanyEntity AS company, EmployeeEntity as employee " +
    "WHERE company.name=:name " +
    "AND employee.company = company", EmployeeEntity.class);

Pretty simple, yes?

On the FROM clause we define two Entities with two Identifiers
we make use of a named parameter
we make use of the AND logical operator

Remember we said that JPQL perform queries on the persistent schema of entities and relationships. EmployeeEntity has a ManyToOne Relationship defined to CompanyEntity, and therefore we can use that relationship in our JPQL queries. The relationship is defined like this:

@ManyToOne
@JoinColumn(name = "idcompany", referencedColumnName = "idcompany")
private CompanyEntity company;

Therefore when we in JPQL do something like employee.company = SOMETHING, we call employee.company a Path Expression, and the result for this case should be pretty obvious, because the relationship maps to only one other Entity. We'll talk a bit more about Path Expressions in a bit.

Lets give a run at testMultipleEntities1 method on the QueryTesting.java, which runs this query like this:

query.setParameter("name", "JBay Solutions");
for (EmployeeEntity client : query.getResultList()) {
    System.out.println(" -> Q1 : " + client.getName());
}

query.setParameter("name", "JetBrains");
for (EmployeeEntity client : query.getResultList()) {
    System.out.println(" -> Q2 : " + client.getName());
}

And check the results:

[EL Info]: connection: 2014-10-14 20:58:59.383--ServerSession(1268465323)--file:/home/rui/projects/jpa2tut-queries/target/test-classes/_jpa2tut-test login successful
 -> Q1 : Rui Pereira
 -> Q1 : Gustavo Santo
 -> Q2 : Maxim Shafirov
 -> Q2 : Valentin Kipiatkov

Perfect!

Now, on the other side of the relationship, we'll have a OneToMany Relationship, like this:

@OneToMany(mappedBy = "company")
private Collection employeeCollection;

And using that collection there on a JPQL query is also possible, but not as shown before. When we write something like this AND employee.company = company , the employee.company part as we said before is called a Path Expression, and one of the rules of Path Expressions is that it cannot be created from another Path Expression that evaluates to a collection. Lost you all there? In order words, check this next example.

Take this bit of code FROM EmployeeEntity as employee , we could create these Path Expressions :

employee.name : Evaluates to a String
employee.id : Evaluates to an int
employee.address : Evaluates to a String
employee.company : Evaluates to a Company object
employee.company.id : Evaluates to an int
employee.company.name : Evaluates to a String
employee.company.address : Evaluates to a String
employee.company.employeeCollection : Evaluates to a Collection

So you see, we created Path Expressions from other path expression in the way that employee.company.id is created from the employee.company Path Expression.

Since we have that rule of not being able to create from Path Expressions that evaluate to Collections, we can't do the following :

employee.company.employeeCollection.id : Illegal
employee.company.employeeCollection.name : Illegal
employee.company.employeeCollection.address : Illegal
employee.company.employeeCollection.company : Illegal

But Path Expressions that evaluate to Collections can be very useful in other ways. Lets give it another try at writting a JPQL query that makes use of this to achieve that same goal as the previous one:

TypedQuery query =
    em.createQuery("SELECT employee FROM CompanyEntity AS company, EmployeeEntity as employee " +
    "WHERE company.name=:name " +
    "AND employee MEMBER OF company.employeeCollection ", EmployeeEntity.class);

See what we did there?

we made use of the MEMBER OF comparison operator
and we have a working knowledge of what is a Path Expression

There are a few more rules regarding Path Expressions, but a working knowledge is quite enough. If you feel you must know these right now, please check the JPA 2 Final Spec, which can be found at the bottom of this post in the References section.

About the MEMBER OF comparison operator, there are quite a few comparison operators, like BETWEEN, IN , EMPTY, EXISTS, LIKE, IS NULL and your well known = , >, <, <>, <=, and >= .

The MEMBER OF operator

The MEMBER OF operator is used to match or NOT the existence of something in a Collection. An example if we may :

employee MEMBER OF company.employeeCollection

The employee section is a path expression that evaluates to an entity. It could evaluate to a simple value (like for example employee.id does) or an object (like employee.company), these are allowed.

The company.employeeCollection section is a path expression that will evaluate to a Collection of Employees. That is it.

To match the inexistence of something inside a Collection, we can use the NOT MEMBER OF, like this:

employee NOT MEMBER OF company.employeeCollection

The NOT is a constant in the remaing comparison operators, like we will see next.

The BETWEEN operator

Lets shift our focus now to the Company table and CompanyEntity bean. There is a field there that stores the year the Company was created. It is mapped as an Integer and cannot be Null.

For our next task we will write a JPQL query that will return the Companies that were created in 1995 or after and in 2005 or before:

em.createQuery("SELECT company FROM CompanyEntity AS company " +
"WHERE company.createdYear >= 1995 " +
"AND company.createdYear <= 2005<="" b=""> ", CompanyEntity.class);

Easy, yes? But we could use the BETWEEN operator in the following way:

"WHERE company.createdYear BETWEEN 1995 AND 2005 "

Which will return the exact same result.
Expanding on what we already know, we could actually just replace both the MIN and MAX arguments of the BETWEEN operator with named parameters and allow for them to be defined dynamically:

query = em.createQuery("SELECT company FROM CompanyEntity AS company"+
"WHERE company.createdYear BETWEEN :minimum AND :maximum ", CompanyEntity.class);
query.setParameter("minimum", 1995);
query.setParameter("maximum", 2000);

But BETWEEN can be used with other types of parameters, like Dates. Lets write a JPQL query that returns now all the Employees of any company that were born between 1979-01-01 and today:

TypedQuery query =
    em.createQuery("SELECT employee FROM EmployeeEntity AS employee"+
    "WHERE employee.birthday BETWEEN :minimum AND :maximum ", EmployeeEntity.class);
query.setParameter("minimum", "1979-01-01");
query.setParameter("maximum", new Date());

To get the exclusion of those dates, you use the NOT :

"WHERE employee.birthday NOT BETWEEN :minimum AND :maximum ", EmployeeEntity.class);

Moving on.

The LIKE operator

We know how to compare Strings, we have the regular = and <> comparison operators. Lets try them out in writing a JPQL query that returns all the companies that are named Google:

SELECT company FROM CompanyEntity AS company WHERE  company.name = 'Google'

But what about if on our database, that company was named "google" and not "Google"? Well, that query would fail, that's what.

And what if we want to return all the Companies that have "oo" (two 'o's) in their name? Well then we have to write a pattern and check which entries match that pattern.

For that we use the LIKE operator.

The LIKE works like this : on the left hand side you place a String or a path expression that evaluates to a String. On the right hand side you place a String that has a pattern to be matched.

So, if we do:

WHERE  company.name LIKE 'google'

We would get a match for companies named:

google
Google
GOOGLE
GoOgLe

In order words: 5 letter words that have the same letters in that order, but are case insensitive.

Lets write a JPQL that matches all Companies with "oo" in their name, no matter where in their name:

WHERE company.name LIKE '%oo%'

Here we go. Now we will match :

Google
Yahoo
oo.org
Boo

The % character is a wildcard character that matches any sequence of characters, including an emply one. The other wildcard charater we have is the underscore _ which matches exactly one character.

So, if we were to write:

WHERE company.name LIKE '%oo_'

We would only match companies named like this:

Gooa
Goob
oox
ooy
yahooa

Why? Because the _ wildcard must match exactly 1 character, whatever character it is, but it must be 1!

As with the precious operator, if we want to get all the company names that don't match that pattern, we use the NOT :

WHERE  company.name NOT LIKE '%oo%'

And we get pretty much any company whose name doesn't have exactly two 'o's together.

The EMPTY operator

The EMPTY operator simply evaluates if Collection expressed by a path expression is empty, or NOT EMPTY.

Lets write a JPQL query that returns all the companies that have no employees:

SELECT company FROM CompanyEntity AS company WHERE company.employeeCollection IS EMPTY

The company.employeeCollection poins to a Collection of Employees. If we run this query against our test database, we get no returns, because all the companies on our DB have employees. So instead lets have a query that returns all the companies that have employees:

SELECT company FROM CompanyEntity AS company WHERE company.employeeCollection IS NOT EMPTY

And now if we run that query we get returned all the Companies in our test DB.

The NULL operator

Not that any of the operators are difficult to understand, but NULL is by far the easiest one. IS NULL is used to test if a give path expression or parameter is a NULL value , or NOT.

For completeness' sake lets write a JPQL query that returns all Employees that have their address NULL:

SELECT employee FROM EmployeeEntity AS employee WHERE  employee.address IS NULL

And now, a query that returns all the Employees that don't have their address NULL:

SELECT employee FROM EmployeeEntity AS employee WHERE  employee.address IS NOT NULL

In case you are wondering, a path expression that evaluates to a Collection cannot be NULL. It can however be EMPTY or NOT EMPTY. So, if you try something like this:

SELECT company FROM CompanyEntity AS company WHERE  company.employeeCollection IS NULL

Well... that just isn't going to work.

But there is more!

What about Subqueries? Any more comparision operators? And Update and Delete statements? What about the Criteria API?

We'll take a break here, because this post is getting big and we'll continue on the next post! We'll update this one with a link as soon as the next post comes out.

References

JPA 2 Final Spec

JPA 2 Tutorial – Many To Many with Self

Rui Pereira — Thu, 06 Jun 2013 15:40:42 GMT

We have just covered the subject of Many-To-Many relationships, which is a fun topic for the hole family! Now there are some particular cases on the Many-to-many front which are not particularly hard, but can lead to a bit of confusion. One of those particular cases is the M2M with same table.

A reader asked : "How would one create manyToMany relationship with the same entity. Entity user can have friends (user), and can be friend to other users. With note that junction table has to have some additional columns besides user keys. How can that be achieved?" (Thanks Felix for the feedback and question!)

So, to start of let us be clear that to follow this Tutorial you should :

Have a basic understanding of JPA2 , enough to create a few entities etc
Know how to create a Many to many relationship between two related Entities

If you have been following the Tutorials till now, then you can go right ahead and start this one. If you haven't been following but know the stuff that is fine as well. If you want to go and check them out : JPA2 Tutorials .

You'll need EclipseLink, JUnit and MySQL, so if you are missing any of these this is the time to go and get them:

Source Code for all of this can be found at Sourceforge

Lets get started

In the previous tutorial we have discussed about the* Join Table*, which is a table that has one only purpose, which is to allow the creation of a many to many relationship between two tables. This is not entirely correct, as it was pointed out by simply reading the question that was posed. The two tables can in fact be the same table, and in that case the Join Table is mapping a many to many relationship between elements of the same type. The following diagram exemplifies:

Let us start by creating a database with these two tables. The SQL should look something like this :

 CREATE TABLE IF NOT EXISTS `jpatutorial3u1`.`person` (
  `idperson` INT NOT NULL AUTO_INCREMENT ,
  `name` VARCHAR(45) NOT NULL ,
  `phonenumber` VARCHAR(45) NULL ,
  PRIMARY KEY (`idperson`) )
 ENGINE = InnoDB;
 CREATE TABLE IF NOT EXISTS `jpatutorial3u1`.`business` (
  `seller` INT NOT NULL ,
  `buyer` INT NOT NULL ,
  PRIMARY KEY (`seller`, `buyer`) ,
  INDEX `fk_person_has_person_person1_idx` (`buyer` ASC) ,
  INDEX `fk_person_has_person_person_idx` (`seller` ASC) ,
  CONSTRAINT `fk_person_has_person_person`
  FOREIGN KEY (`seller` )
  REFERENCES `jpatutorial3u1`.`person` (`idperson` )
  ON DELETE NO ACTION
  ON UPDATE NO ACTION,
  CONSTRAINT `fk_person_has_person_person1`
  FOREIGN KEY (`buyer` )
  REFERENCES `jpatutorial3u1`.`person` (`idperson` )
  ON DELETE NO ACTION
  ON UPDATE NO ACTION)
 ENGINE = InnoDB;

As for the Entity Bean, let us create one Entity called PersonEntity, and add the existing columns to it, just the columns for now. The main bits of the PersonEntity class should look somewhat like this:

@Entity
@Table(name = "person", catalog = "jpatutorial3u1", schema = "")
public class PersonEntity implements Serializable {
 private static final long serialVersionUID = 1L;
 @Id
 @GeneratedValue(strategy = GenerationType.IDENTITY)
 @Column(name = "idperson", nullable = false)
 private Integer idperson;

 @Basic(optional = false)
 @Column(name = "name", nullable = false, length = 45)
 private String name;

 @Basic(optional = true)
 @Column(name = "phonenumber", length = 45)
 private String phonenumber;

Create now the Getters and Setters for these fields. While we are at it, lets go and take a look at the Test Packages folder and check the MemSelfTest JUnit class. For those not following the source code, the relevant bit is :

@Test
public void testMemSelf(){
        // Start a transaction
        em.getTransaction().begin();
        // ------------
       PersonEntity c = new PersonEntity();
        c.setName("Rui");
        em.persist(c);
        em.flush();

        Object result = em.find(PersonEntity.class, c.getIdperson());
        assertEquals(c, result);

        em.remove(c);
        em.flush();

        // Commit the Transaction
        em.getTransaction().commit();
}

It doesn't really do much except for creating a Person, searching for it, and removing it.... just to make sure everything is working fine and we can proceed.

The basic stuff is now done, lets move on to the mapping of the relationship

Who Sold To Who?

Lets start with editing the PersonEntity class by adding the following bit:

 @JoinTable(name = "business", joinColumns = {
 @JoinColumn(name = "seller", referencedColumnName = "idperson", nullable = false)}, inverseJoinColumns = {
 @JoinColumn(name = "buyer", referencedColumnName = "idperson", nullable = false)})
 @ManyToMany
 private CollectionsoldToCollection;

and, as per usual, add the Setters and Getters for soldToCollection.

If you are a bit lost right now with the notation used and the way it was used, then you should probably give a read to JPA 2 Tutorial – Relationships – Many To Many , but I'll recap a bit here.

The @JoinTable annoration is used on the Owning Entity side of the relationship, which is in fact the PersonEntity class (both the owning and the inverse to be honest, but it will depend on the context it is being used). The Join Table is specify as "friend" , which is the name of the Join Table and then we do the JoinColumns bit, in which we specify the Fields used to map the relationship. Please do give a read at JPA 2 Tutorial – Relationships – Many To Many if nothing seems to make sense at this point!

Let us modify the M2mSelfTest JUnit class now. First let us create another few users :

PersonEntity c = new PersonEntity();
c.setName("Rui");
PersonEntity f1 = new PersonEntity();
f1.setName("Felix");
PersonEntity f2 = new PersonEntity();
f2.setName("Gusy");
em.persist(c);
em.persist(f1);
em.persist(f2);
em.flush();

Now we got a few PersonEntity objects to play about with. After the assertEquals that we have created previously, add the following bit as well:

    assertEquals(c.getSoldToCollection().size(),0);
    c.getSolfToCollection().add(f1);
    em.merge(c);
    em.flush();
    assertEquals(c.getSoldToCollection().size(),1);
    System.out.println(c.getName() + " sold stuff to :");
    for (PersonEntity tempP : c.getSoldToCollection() )
          System.out.println(" - " + tempP.getName() );

and to finish it off , lets delete every object we have created and clean the DB :

em.remove(c);
em.remove(f1);
em.remove(f2);
em.flush();
// Commit the Transaction
em.getTransaction().commit();

Run it and, if it was done right, everything should have work fine:

    
    [EL Info]: 2013-06-06 16:07:42.49--ServerSession(805125680)--EclipseLink, version: Eclipse Persistence Services - 2.3.2.v20111125-r10461
    [EL Info]: 2013-06-06 16:07:42.753--ServerSession(805125680)--file:/home/rui/projects/syshex-code/JPATutorial3.1/trunk/build/classes/_JPATutorial3.1PU login successful
    Rui sold stuff to :
     - Felix

But you know what would be really cool too? For a us to know who he Bought stuff from, yeah?

Who did He Bought From?

First, lets modify the PersonEntity again and add the following:

    
    @ManyToMany(mappedBy = "soldToCollection")
    private Collection boughtFromCollection;

Feeling a bit lost? Check out JPA 2 Tutorial – Relationships – Many To Many where it is explained everything about @ManyToMany and the mappedBy property.

Go ahead and create the Setter and Getter for this new collection, and afterward , lets go to the MemSelfTest JUnit test and modify like so:

    
    System.out.println(c.getName() + " sold stuff to :");
    for (PersonEntity tempP : c.getSoldToCollection() )
         System.out.println(" - " + tempP.getName() );

    System.out.println(c.getName() + " Bought stuff from :");
    for (PersonEntity tempP : c.getBoughtFromCollection())
         System.out.println(" - " + tempP.getName() );

    em.refresh(f1);

    System.out.println(f1.getName() + " sold stuff to :");
    for (PersonEntity tempP : f1.getSoldToCollection() )
        System.out.println(" - " + tempP.getName() );

    System.out.println(f1.getName() + " Bought stuff from :");
    for (PersonEntity tempP : f1.getBoughtFromCollection())
         System.out.println(" - " + tempP.getName() );

Lets run it !

[EL Info]: 2013-06-06 16:18:04.464--ServerSession(745084087)--EclipseLink, version: Eclipse Persistence Services - 2.3.2.v20111125-r10461
[EL Info]: 2013-06-06 16:18:04.73--ServerSession(745084087)--file:/home/rui/projects/syshex-code/JPATutorial3.1/trunk/build/classes/_JPATutorial3.1PU login successful
Rui sold stuff to :
- Felix
Rui Bought stuff from :
Felix sold stuff to :
Felix Bought stuff from :
- Rui

Wicked stuff really.

But, what if.... we need to store some information regarding the relationship?

Storing Info about Relationship

Well, then we would have something like this :

selfnot_really" title="">

Now, as it was said in the last Tutorial :

The table that you see serving as a connection between the Company table and the Client table is what is called a “Join Table” , and its sole purpose in life is to keep track of the relations that exist between Company and Client Entities.

And storing information regarding Money in it will make it have* more the a "sole" purpose. Not that it is wrong to do this, if you need to have information regarding the relationship, but since it has information, it should be an Entity. It could be called *BusinessEntity, in which money , seller and buyer are in fact information that regard the Business.

In looking at this Business table and an Entity and not as a simple JoinTable, we can deduce that there are One-To-Many relationships to be used instead of the* Many-To-Many*.

So, wrapping it up, in this situation you should see this in a totally different light than a M2M

Hope his helped, and as per usual, leave a comment if you find errors, problems, or for a kind word. And again, thanks for checking out our blog.

Also, check the next tutorial on this series: JPA 2 Tutorial - Queries with JPQL