Java for serious and fun

Can I Count The Ways? Let me...

2007-08-14T08:28:00.000-07:00

I lost my lunch writing this, so in recompense, I decided to play some games online. There were so many options. “Like the Mahjong game?” Smiled. “I speak of it all the time, right?” “Okay which now?” “Won't tell. Since you can be Harry Porter, how soon will Oz be at your doorstep?” “What's the game, Cyp?”
But before you play, the code is long, your fingers have need some getting used to the typing.Nice day.


/*
 *I JUST TRIED DOING A LITTLE BINARY OPERATORS
 *HERE AFTER HAVING A LOOK AT SOME OLD CALC
 *MACHINE. HOPY YOU LIKE IT.
 */

package overall;

import java.io.*;
import java.util.*;
import java.lang.*;

public class Postfix {    
    static List stackList = new ArrayList();
    static List operatorList = new ArrayList(); //ignore generics.
    //the index counts to tail lof list
    static int listCounter = -1;   
    
    protected static void checkInput(String keyedIn){
        //check for exit character once and for all
        if (keyedIn.equals("@")){
            System.exit(0);
        }
        //not ready to exit?
        //make sure first number is a number        
        if (listCounter == -1){ //nothing in list at all
            try{
                //see if we can parse the keyed in figure to int
                int received = Integer.parseInt(keyedIn);
                //insert first number into the list
                stackList.add(received);
                //increase the counter
                ++listCounter;
                System.out.println("Key in an operator, please.");
            }
            catch(NumberFormatException e){
                System.err.println("First number must be a number. Thanks.");
            }
        }
        //where the keyedin number is not the first number i.e something in stack
        //we expect an operator for next number
        //check if an operator is already waiting for an operand
        int opCheck = operatorList.size();
        if (opCheck == 0) {
            //no operator waiting! if operand replace it with previous.
                try{
                    int checking = Integer.parseInt(keyedIn);
                    //replace first number and count is still 0
                    stackList.remove(0);
                    stackList.add(checking);
                }
                //if operator, what was expected
                catch(NumberFormatException e){
                    //send to operator then
                    doOperation(keyedIn);                    
                }
        }
        //operator waiting, waiting for a number.
        //number expected
        if(opCheck > 0){
            try{
                int checked = Integer.parseInt(keyedIn);
                //if number add to list and increase count
                stackList.add(checked);
                ++listCounter;
                compResult();
            }
            //if not number ask for number
            catch(NumberFormatException e){
                System.out.println("Input a valid number please.");
            }
        }        
    }
    
    protected static void doOperation(String ourOperator){
        //whenever any character is assumed operator, check for
        //validity of operator
        if (ourOperator.equals("/") || ourOperator.equals("*") || ourOperator.equals("%")
                || ourOperator.equals("-") || ourOperator.equals("+")){
            //perform required operation. operator valid
            char calc = ourOperator.charAt(0);
            //do calculation now
            doCalculate(calc);
        }
        else {
            //ask for valid operator
            System.out.println("Key in a valid operator please.");
        }
    }
    
    protected static void doCalculate(final char theOperator){
        //store in operator list
        operatorList.add(theOperator);        
        //if only one operand in list, wait for next input
        //lock on stack size
        int contains = stackList.size();
        if (contains == 1){
            //lock on the size
            System.out.println("Insert next number for operation.");                   
        }
        else if(contains == 2){
            compResult();
        }
    }
    
    public static void compResult(){
        //get the last two elements in the stack list
        //get the head of the operator list
        //do the binary operation
        //output the result
        //get stack list tail
        int stackTail = stackList.remove(listCounter);
        --listCounter;
        int tailAfterLast = stackList.remove(listCounter);
        --listCounter;
        //get operator list head
        Object opHead = operatorList.remove(0);
        System.out.print(tailAfterLast + " " + opHead + " "+stackTail + " is = ");
        //do the binary operation
        //check what operator we're using first though
        if (opHead.equals('+')){
            tailAfterLast += stackTail;
            System.out.println(tailAfterLast);
            //keep the result in head of operand list
            stackList.add(tailAfterLast);
            ++listCounter;
        }
        else if (opHead.equals('-')){
            tailAfterLast -= stackTail;
            System.out.println(tailAfterLast);
            //keep the result in head of operand list
            stackList.add(tailAfterLast);
            ++listCounter;
        }
        else if (opHead.equals('%')){
            tailAfterLast %= stackTail;
            System.out.println(tailAfterLast);
            //keep the result in head of operand list
            stackList.add(tailAfterLast);
            ++listCounter;
        }
        else if (opHead.equals('*')){
            tailAfterLast *= stackTail;
            System.out.println(tailAfterLast);
            //keep the result in head of operand list
            stackList.add(tailAfterLast);
            ++listCounter;
        }
        else if (opHead.equals('/')){
            tailAfterLast /= stackTail;
            System.out.println(tailAfterLast);
            //keep the result in head of operand list
            stackList.add(tailAfterLast);
            ++listCounter;
        }        
        else {
            System.out.println("We're going nowhere.");
        }
    }

    public static void main(String[] args) throws IOException{        
        BufferedReader bufR = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Enter any character. First character must be a number");
        System.out.println("Enter @ to end the program.");
        boolean keepOn = true;
        //keep getting input until single @ entered or end of operation
        while (keepOn){
            //get the input from keyboard
            String dInserted = bufR.readLine();
            //check whether it is an operator, operand or @ sign
            checkInput(dInserted);            
        }
    }    
}

What Angle Does Three Make?

2007-08-14T08:04:00.000-07:00

Am sure you guessed the answer, a triangle. Take three edges and join them by their edges, what you get is a triangle. Measure the angle if you can. We're following up on our staircase faces to build a triangle. You just have to think in alternation. How? Twist the stairs 180 degrees to the left, leave the first one remaining and voila!, you have a triangle. That's what three makes. Now four? A Mahjong game; read my lips, there is even a Mahjong messenger online. Officially. But if you go for poker...


/*
 *TRY DOING A DIAMOND AFTER THIS CODE
 *  :-)
 */
package overall;

public class AtTriangle {
    
    public static void main(String[] args){
        //@ character unicode representation as char
        char c = '\u0040';
        //declaring our array
        char[][] atTriangleArray;
        //we now allocate only the rows
        atTriangleArray = new char[6][];
        //next the columns are allocated
        for (int i=0; i<atTriangleArray.length; i++){
            //for the six rows there are eleven columns
            atTriangleArray[i] = new char[11];
            //if this is the first column assign at to the 
            //6th column
            switch(i){
                case 0: atTriangleArray[i][5] =c; break;
                case 1: atTriangleArray[i][4] =c; 
                        atTriangleArray[i][5] =c;
                        atTriangleArray[i][6] =c;
                        break;
                case 2: atTriangleArray[i][3] =c;
                        atTriangleArray[i][4] =c;
                        atTriangleArray[i][5] =c;
                        atTriangleArray[i][6] =c;
                        atTriangleArray[i][7] =c;
                        break;
                case 3: atTriangleArray[i][2] =c;
                        atTriangleArray[i][3] =c;
                        atTriangleArray[i][4] =c;
                        atTriangleArray[i][5] =c;
                        atTriangleArray[i][6] =c;
                        atTriangleArray[i][7] =c;
                        atTriangleArray[i][8] =c;
                        break;
                case 4: atTriangleArray[i][1] =c;
                        atTriangleArray[i][2] =c;
                        atTriangleArray[i][3] =c;
                        atTriangleArray[i][4] =c;
                        atTriangleArray[i][5] =c;
                        atTriangleArray[i][6] =c;
                        atTriangleArray[i][7] =c;
                        atTriangleArray[i][8] =c;
                        atTriangleArray[i][9] =c;
                        break;
                case 5: atTriangleArray[i][0] =c;
                        atTriangleArray[i][1] =c;
                        atTriangleArray[i][2] =c;
                        atTriangleArray[i][3] =c;
                        atTriangleArray[i][4] =c;
                        atTriangleArray[i][5] =c;
                        atTriangleArray[i][6] =c;
                        atTriangleArray[i][7] =c;
                        atTriangleArray[i][8] =c;
                        atTriangleArray[i][9] =c;
                        atTriangleArray[i][10] = c;
                        break;
                default : break;
            }            
        }
        for(int i=0; i<atTriangleArray.length;i++){
                for(int j=0; j<atTriangleArray[i].length; j++){
                    System.out.print(atTriangleArray[i][j]);
                }
                System.out.println();
            }
    }
}

Life is easy when you're on rails, especially when you are three: you, your girl beside you and your dog. I'd take a vacation to anywhere i'd call home. Now if you mind my talking about a home, I've been watching the prices of some real estate here. I can tell you without blinking that they are SPECIAL OFFERS and for you.

AM FEELILNG LIKE WOW!

2007-08-14T07:42:00.000-07:00

Just finished watching the TV and a commercial was ringing in my head: Move On Up! I really didn't understand if they were to move me up or if my savings account was to move them up, so I wrote a code for steps and ladders which if you take the initiative, you're surely going on up.


 /* 
 *we're building a staircase based on java's native handling
 *of multidimensional arrays, as arrays of arrays
 *
 */
package overall;

public class TFaces {
        
    public static void main(String[] args){
        char c = '\u0040';
        char[][] atArray;
        //declare the 2-dim array first with only the rows
        //columns for each row are unallocated
        atArray = new char[5][];
    
        //now allocate columns for rows
        for(int i=0; i<atArray.length; i++){
            //each row has one step greater than 
            //its preceding one
            atArray[i]= new char[i+2];
        }
        //initialise and print out the array
        for(int i=0; i<atArray.length; i++){
            for(int j=0; j<atArray[i].length; j++){
                atArray[i][j] = c;
                System.out.print(atArray[i][j]);                
            }
            System.out.println();
        }
    }    
}

If you can, pick as many images as you can find and put them faces on the staircases. You'll love the wow! effect. Picasa just popped out on my desktop. With picasa, you can make your computer images all searchable. Searchable. You don't need to think: where was that picture of I and Micheal taken in 1996 at Mimmy's matriculation? Nope. Picasa has it; straight in ya face!

Never Multi-thread Your System Clock 4

2007-08-14T07:34:00.000-07:00

MAYBE THE FINAL SOLUTION

Threads. Threads. Threads. Do you need a real nice and cool loan for a house from your best bank? Have to check your credit score first, right? Well, for this you just have to do no checking. A trip to Hawaii or to New Zealand or to Malaysia or anywhere in the world. Anywhere in the world. Is it for free? Yes, but for your time. How? Right from the labs of google comes, Google Maps. It's just absolutely wonderful. I fell in love with google maps from the word go. Go anywhere. Let's see. Why not try the city of London?
Yeah, the final solution. Back from that travel, you can use just one thread and get as much time in any time zone that you so desire. The code below diverts off the piggy-backing threads class on these aspects: I removed the constructors for time zone threads and used a single thread in the run method. Then formatted the time instance in a single method, zoned(). Therefore, within this method, I can and you can create as many time zone instances as you like.


package overall;

import java.text.DateFormat;
import java.util.Date;
import java.util.SimpleTimeZone;

public class SingleThread implements Runnable {
    
    public void run() {
        //the limit on time
        final long LIMIT = 1000*60*5;
        //guard on time spent doing this shit
        long timeSpent = 0;
        //present time guard
        Date dater = new Date();
        //we'll catch an exception on this computation
        try{
            while(timeSpent < LIMIT){
                //call the time formatter 
                zoned();
                //sleep three second
                Thread.sleep(1000*3);
                //update the system time
                Date now = new Date();
                //compute time difference between start and now
                timeSpent = now.getTime() - dater.getTime();
            }
        }
        //catch any exception please
        catch(Exception e){
            e.printStackTrace();
        }
    }
    
    protected void zoned(){
        //an hour of time
        long oneHour = 1000*60*60;
        //get the date formatter
        DateFormat formatter = DateFormat.getTimeInstance();
        //declare the time zone. set initially to utc
        SimpleTimeZone simp = new SimpleTimeZone((int)oneHour*0, "UTC");
        //set the timezone of our dates to utc
        formatter.setTimeZone(simp);
        //print out the utc time at this moment in time
        System.out.println("Time in UTC (London) is: "+ formatter.format(new Date()));
        //set the time zone to hawaii time
        simp.setID("HST");
        simp.setRawOffset((int)oneHour*10);
        formatter.setTimeZone(simp);
        System.out.println("Time in HST (Hawaii) is: "+formatter.format(new Date()));
        //set time zone new zealand time
        simp.setID("NST"); //new zealand standard time
        simp.setRawOffset(-(int)oneHour*12);
        formatter.setTimeZone(simp);
        System.out.println("Time in NST (Fiji) is: "+formatter.format(new Date()));
    }
    
    public static void main(String[] args){
        //declare an instance of our time
        SingleThread instar = new SingleThread();
        //call its thread
        Thread t = new Thread(instar);
        //start the thread
        t.start();
    }
}

When I was young, we piggy-backed to get into the movie theater. This is how: A buys the ticket for the film, enters theater, the innocent one, wraps ticket on his pen, runs to the first floor of the building and throws it to B. Yeah, the ticket's already marked but the film house has a toilet that is at the outside. If B has a good tongue and can give and take shit, B can enter and so can C, and so can D, and so... The timing just has to be right. Piggy-backing and fond memories...!

Never Multi-Thread Your System Clock 3

2007-07-28T11:40:00.000-07:00

A FAIR ENOUGH IMPLEMENTAION.

Am sure you did read the first blog on this topic? Let me remind you a point from it: any number of men can pass through a door which is supposed to allow only one man at any time if they can all piggyback into the door, provided the height of the door is sufficient to take as much piggybackers.
I can implement piggybacking for this time zone problem by creating three separate threads for each time zone, such that the first thread calls the second and the second calls the third. You can create any number of time zone references this mind. Like the Mahjong game, you can even create four. But caution! Sshhh... read to the end first. This thread calling is best done with ThreadGroups. A ThreadGroup makes it possible that where one thread gets interrupted or a parent thread gets interrupted, all the threads die together.
Now for the code. For a challenge, write a third thread that is declared in the second thread or the Hawaii standard time thread in the code below.


import java.lang.*;
import java.util.*;
import java.text.*;

public class FairEnough implements Runnable {
    String dZone = "Local";
    //every thread exists in a group such that 
    //they all die together
    ThreadGroup dGroup = new ThreadGroup("myGroup");
    //the time zones am going to use, simp for UTC and 
    //zHst for Hawaii Standard Time.
    SimpleTimeZone simp = null;
    SimpleTimeZone zHst = null;
    //computing this long now prevents future recursive 
    //computing
    long oneHour = 1000*60*60;
    
    /** Creates a new instance of FairEnough */
    public FairEnough(String zoner) {
        //if string is utc, run utc else if hst run hst
        if (zoner == "UTC"){
            this.dZone = zoner;
            //set the time zone to utc
            simp = new SimpleTimeZone((int)oneHour*0, dZone);
            //create the utc thread in a a thread group and start it
            Thread utc = new Thread(dGroup, this);
            //start our thread
            utc.start();
            //utc  object now calls the hst object
            FairEnough second = new FairEnough("HST");            
        }else{
            //this here is constructor code for hst object
            this.dZone = "HST";
            zHst = new SimpleTimeZone((int)oneHour*10, dZone);
            //create hst thread
            Thread hst = new Thread(dGroup, this);
            hst.start();
        }
    }
    
    //the run method defines the thread itself. 
    public void run() {
        //LIMIT means i don't want this thread to run for
        //more than five minutes
        long LIMIT = 1000*60*5;
        //this is the guard on five minutes limit
        long timeSpent = 0;
        //this is the guard on timer, reference to the
        //instance in time when run started, +/- nanoseconds
        Date dater = new Date();
        //our thread could be interrupted, so let's put
        //it in a try
        try{
            while(timeSpent < LIMIT ){
                //create date formatter formatting only time
                DateFormat formatter = DateFormat.getTimeInstance();
                //specify time zone to use
                if(this.dZone == "UTC"){
                    formatter.setTimeZone(simp);
                }else if(this.dZone == "HST"){
                    formatter.setTimeZone(zHst);
                }       
                //print out our time
                System.out.println(this.dZone +" time is "+formatter.format(new Date()));
                //sleep 3 seconds
                Thread.sleep(1000*3);
                //update system time
                Date now = new Date();
                //compute the time spent doing this stuff
                timeSpent = now.getTime() - dater.getTime();
            }
        }
        catch(Exception e){
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args){
        //specify time zone to start with. if utc or hst.
        //use upper case please!!Mine!!
        FairEnough fair = new FairEnough("UTC");
    }   
}

Caution: I ran the code above on a 1.2 Ghz Pentium III Intel and was my puter humming all the time. Not to worry, he's just complaining to deaf ears. That goes to show you that this is not a very good candidate for implementing this concept, just a solution just made it. If you're really that bold, try getting driver magic if you're experimenting with clocks and threads first.
In my magic bag is a simple, affordable solution that you'll make use of and your puter wouldn't realise you came into its machine space. Ready for the last and final blog on this topic? I sure am.

Never Multi-thread Your System Clock 2

2007-07-28T07:29:00.000-07:00

HOW NOT TO GO ABOUT IT.

A little on threading. A thread is like a process that is running inside another process. Imagine the wheels of your car running when the car starts. But never imagine the beautiful baby on the left could ever be yours. Now, in Java programming, when a thread wants to access or reference a variable, it has to acquire the lock on the object or variable, which we'll refer to here as its monitor. And no two threads can acquire the same lock on a monitor. Rather, if a thread wants the lock on a monitor and another thread has it, it has to wait for that owner thread to release the lock first.

Our clock has to be in three time zones, one in the New Zealand Standard time, another in Universal Time and the other in Hawaii Standard Time. It looks simple to just create separate threads, taking from our example in the first blog for this title. No, creating three threads for the three time zones will not necessarily run. There are issues to consider.

Issue of monitor locking. If we have say three threads, thread A, B and C and A starts executing first. Other threads have to wait for it but they have already been called to start. There is no way we should expect B and C to return the same time as A. Clocking is dynamic and time never waits for any man. The error reporting chain gets propagated indefinitely as B gets the baton and as C acquires a subsequent lock.

Issue of thread sleeping. It would seem some solution to ask A to sleep and pass the baton to B and then to C and then to receive the baton or lock later. That was what we would all assume the normal should be. But this is no solution at all because if thread A enters a sleep state, are we sure it will ever recover from one? Will it not sleep forever? Let's say, A starts sleeping, to sleep for 1 second. B begins to run and then enters a sleep that lasts for also one second. Are we not to assume that A and B will ask for the lock at the same instance? Even if they have to sleep for any second at all! Both threads will have to eventually fight for the lock. We are setting the stage for a fight on the system time or our monitor. If B wins, A ends up fighting with C. Will A win? As in life and in threading, no thread can fight for long. One would give up and throw an interrupted exception and stop executing. So, why not put a usage clause on our thread. Imagine that! We'd rather never have to implement a thread in the first place.

But we'll never give up here. There's a solution for our threading problem. I found on the bottle to your right a natural solution to a throat problem, and it's the New Zealand way. That was while googling on New Zealand. In a new way, I'll demonstrate two ways this problem can be solved.

NEVER MULTI-THREAD YOUR SYSTEM CLOCK

2007-07-26T04:00:00.000-07:00

THE BREEZE SECTION.

If three men have to pass through a door that can take only one, how many men can pass through at any one time?

“Hey, you? ”

“One.”

“Why one?”

That's the question, why only one? Can't they piggyback through the door, like the one in front having another on his back and another on his back and another ad infinitum, provided the height of the door can accommodate as many? Well, convention and dynamism are two ends of the same stick. The longer one stays it becomes the other.

Now before we enter the door of seriosity, I'll like to unwind with a cup of Chinese tea. I like the ginseng blend. Which do you prefer? Choose yours.

I had this question thrown to me recently: How can one implement three threads such that they reference the same time while preventing deadlock and other issues known with threads.

What would you answer? As they always say, KISS. Keep it simple, stupid. So I decided to write a simple class that displays just one time, just one thread, my system time converted to UTC time. Foremost on my mind was what the thread was going to do: simple, just update my system time, convert it to Universal Time and format it in a simple human-readable format.


import java.text.DateFormat;
import java.util.*;
import java.lang.*;

public class Availables implements Runnable {
    
    DateFormat firstFormatter; 
    
    public void run() {
        //get my present instance
        Date date = new Date();
        //an a simple utc time zone converter
        SimpleTimeZone utcZone = new SimpleTimeZone(0, "UTC");
        //i don't want this timer to run just five minutes
        final long LIMIT = 1000*60*5;
        //then i'll set a time guard on our time
        long timeSpent = 0;
        //while the thread is running, i expect to receive an 
        //interrupted exception. maybe from my puter
        try{
            //what next? until five minutes runs out
            while(timeSpent < LIMIT){
                //set the time zone for our time
                firstFormatter = DateFormat.getTimeInstance();
                firstFormatter.setTimeZone(utcZone);
                //print out what the present time is
                System.out.println(firstFormatter.format(new Date()));
                //ask the thread to sleep for 3s seconds, to
                //simulate a real timer
                Thread.sleep(1000*3);
                //update our thread, compute the elapsed time
                Date now = new Date();
                timeSpent = now.getTime()- date.getTime();
            }
        }
        catch(InterruptedException e){
            e.printStackTrace();
        }
        //little checker. unecessary, but you never can tell
        if (Thread.interrupted()){System.out.println("Finished.");}
    }
    
    public static void main(String[] args){
        Availables newbie = new Availables();
        Thread tre = new Thread(newbie);
        tre.start();
    }
}

Now, how about the other threads that had to show different time zones, say Hawaii standard time or New Zealand Standard Time? And to talk of Hawaii, if you had to choose between a special Home in Florida and a week in Hawaii, which would it be. I saw this lovely house, and my, did i fall in love with it. Would you still go to Hawaii?

DOES A PICTURE SAY A THOUSAND WORDS 3?

2007-07-23T06:35:00.000-07:00

I won't bore you any longer with steps to take, you already know them. After the First and Second blog on this topic, this here is the last and am sure you'll appreciate coming here. The javax.imageio package provides a custom decoder (what I thought the CharsetDecoder class would do for me!) through the ImageIO class.

This here is the code. Before Coding, have you played some high performance games lately?


  package examples;
  
  import javax.imageio.*;
  import java.awt.image.*;
  import java.io.*;
  
  public class Byter {
   
   BufferedImage buffer;
   File f;
   
   protected void doThis(){
    try{
     //grab the file in a file reference, handle exception also
     f = new File("amelipassport.jpg");
     //use a static method read of ImageIO to buffer file
     buffer = ImageIO.read(f);
     //test buffer. You'll get two results, the ColorModel and Raster
     //try and see
     System.out.println(buffer.toString());
    }
    catch(IOException e){
     e.printStackTrace();
     System.err.println("File not found");
    }
    finally{
     //finally call the raster for character rep. 
     //of the pixels in each cell. int returned by getRGB is 8 bits
     for (int i=0; i<314;i++){
      for(int j=0; j<274; j++){
       System.out.print(buffer.getRGB(j,i)+",");
      }
      System.out.println();
     }
    }
   }
  
   public static void main(String[] args){
    Byter by = new Byter();
    by.doThis();
   }
   
  }

little challenge: send the output of Sysout to a “.txt” file and you'll see the table arrangement of the character representation of the colors you saw in the picture above.

A picture doesn't say a thousand words, you'll never understand them unless you know the language it was speaking in.

When the code ran, what I read from the output was that the picture has two components, a ColorModel and a Raster of image data. The results i got for the young beautiful dark african in the picture above is: This image is one of 8 bits in RGB colors, in windows style BGR color model with Red, Green and Blue of 3 bytes. There is no alpha value in the picture because this is false. The picture is set to 100% transparency and has a width of 274 pixels with a height of 314 pixels.
Try your hands on any picture of your choice and try reading what was said.

But for sure, appreciate colors, appreciate beauty and appreciate the picture even if the language seems difficult for you to understand.

DOES A PICTURE SAY A THOUSAND WORDS 2?

2007-07-23T06:16:00.000-07:00

Faced with the task of decoding that picture of a young african girl, I said to myself, small fry. It'll be handled in a breeze. After I finished writing the first blog of this series, I went outside to the fresh air, drank some water and popped some gums into my mouth. How long should this take me? An hour, two, or three at most. Trust me, this is work just for a Gothamite.

First course of action : I'd grab the image files through a Bufferedinputstream, decode the files using the default charset decoder and maybe a decoder also of the utf-8 charset and then write the decoded data out through a BufferedWriter. That should do it. I'd get a character representation of the image data. So, I set out coding and this is what i wrote.

Standards are what we'll be living by in our codes, like engineering standards, Web standards...etc


  package examples;
  
  import java.io.*;
  import java.nio.BufferOverflowException;
  import java.nio.ByteBuffer;
  import java.nio.CharBuffer;
  import java.nio.charset.*;
  
  public class Tunes {
   
   CharBuffer charBuf;
   ByteBuffer byteBuf;
   BufferedInputStream bin = null; 
   //writer wasn't called. i used Sysout to look ahead.
   BufferedWriter bufWriter;
   String strChar;
   //default character set for my machine is windows-1252.
   //tried default and also utf-8
   Charset cs = Charset.defaultCharset(); 
   byte[] toUse;
   public void doFinal() throws FileNotFoundException,IOException {
    try{
     //create a buffered file inputstream
     bin = new BufferedInputStream(new FileInputStream("amelipassport.jpg"));
     //we want to use the default character encoding 
     //and the default byte buffer size
     //we'll use a file writer on a file output stream'
     bufWriter = new BufferedWriter (new FileWriter("writeout.txt"));
     int c;  // check on int returned by file read
     //provided there are data in the file, 
     //keep reading your file and writing to output until 
     //you get to end of file
     toUse = new byte[bin.available()];
     while ((c =bin.read(toUse)) != -1){
      byteBuf = ByteBuffer.wrap(toUse); //i have a byte buffer now
      charBuf = byteBuf.asCharBuffer();
     }            
    }
    finally{
      //call the charset decoder reset method
      Tunes newTunes = new Tunes();
      //i used a helper class, HelpDecode 
      Tunes.HelpDecode helpDecode = newTunes.new HelpDecode();
      //follow api instructions to letter. first reset(), decode(), 
      //final decode(), then flush()
      helpDecode.reset();
      CoderResult coder = helpDecode.decode(byteBuf, charBuf,true); 
      //never used the buffer writer since i had to lookahead on
      //what my machine was supposed to do
      //decode returned malformed
      //input byte sequence not legal for this character set, 
      //even on utf-8
      System.out.println(coder.toString());  
      coder = helpDecode.flush(charBuf);
      System.out.println(coder.toString());
      System.out.println(charBuf.toString());
      //close all your two streams if any is still open
      if (bin != null) {bin.close();}     
    }
   }
   
   //helper class HelpDecode extends CharsetDecoder
   private class HelpDecode extends CharsetDecoder{
    protected HelpDecode(){
     //let max and avg charsperbyte be similar
     super(cs, 255.0f, 255.0f);
    }
    
    protected CoderResult decodeLoop(ByteBuffer in, CharBuffer out) {
     //used underflow as a check on result
     return CoderResult.UNDERFLOW;
    }
    
   }
   public static void main(String[] args) 
                     throws FileNotFoundException, IOException  {
    Tunes nTunes = new Tunes();
    nTunes.doFinal();
   }   
  }

From the code above you should realise that I can't decode the image file that way. It's not possible. I took a step from the code and asked myself: “what erroneous presumptions do I have about decoding this file?”

One, the “.jpg” file can be referenced by a File object.
Two, image files should be binary data.

The decoding process just can't do what I want it to do and by the way, my decoder class that was supposed to inherit from CharsetDecoder doesn't inherit any method that reads bytes and decodes them straight to char values, just as I expected.

Bad day. There goes my lunch. There must be a way.

Yes there is. I found one late at night. The java.awt.image package and the javax.imageio packages have just what I wanted. They can even decode images. Great. I had to write the third and definitive piece just for you.

DOES A PICTURE REALLY SAY A THOUSAND WORDS?

2007-07-20T03:52:00.000-07:00

I took a look at a picture, a picture of a young beautiful dark african lady on my laptop and decided, what if i see how the computer translates this simple picture into text. What would the computer say about this lady? I had to go about it.

I delved into the Java API and was told, just read the image binary file, buffer the input stream and then write it out in another buffered output stream. Pronto. I checked the java tutorials and was told the same story. Just do that and you'll be fine. So i tried it and am giving you the result.
If you love chinese games, you really might be interested in Mahjong. There is also one for PocketPCs.


 package examples;
  
 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.*;
  
 public class Google {
  BufferedInputStream bin;
  BufferedOutputStream bout;
   
  public void doingThis() throws FileNotFoundException, IOException{
   try{
    //create the input stream
    bin = new BufferedInputStream(new      
                                     FileInputStream("amelipassport.jpg"));
    //create the output stream
    bout = new BufferedOutputStream(new 
                                     FileOutputStream("pix2words.txt"));
    //now there's this int type that i'll use to read the 
                                //bytes coming from the buffered input stream
    int c;
    //we'll keep reading the stream and writing to output
    //until we each end of file, eof
    while((c = bin.read()) != -1){
     bout.write(c);
    }
   
   }
   finally{
    //at the end of everything, close all streams
    if (bin != null){ bin.close();}
    if (bout != null) {bout.close();}
   }
  }
   
  //now this is the class loader
  public static void main(String[] args) throws FileNotFoundException, IOException{
   Google blogger = new Google();
   blogger.doingThis(); 
  }
  
 }

I had the honor of asking the unholy question: What would the computer say? Now these are a few lines of my result.

ÿØÿþ WANG2ÿà JFIF  x x  ÿÛ C  
  (1#%(:3=<9387@H\N@DWE78PmQW_bghg>Mqypdx\egcÿÛ C//cB8BccccccccccccccccccccccccccccccccccccccccccccccccccÿÀ :! ÿÄ               ÿÄ µ   } !1AQa"q2‘¡#B±ÁRÑð$3br‚
  %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyzƒ„…†‡&circ
;‰Š’“”•–—˜™š¢£
¤¥¦§¨©ª²³´µ¶·¸
¹ºÂÃÄÅÆÇÈÉÊÒÓ
ÔÕÖ×ØÙÚáâ&atild

I really don't know what the computer said. I can see WANG2 and then after...Gibber-gibber-gabber-dash? Or something like that?There must be a way to understand this gibber language. Yes, there is, i have to decode the gibberish stuff. Going back to ask the API.“Hey, API, you told me some half truth. Now, wise man, how do i translate this gibber?”

I've already written a solution. It's a breeze away.

And for those who cannot do without being mobile, here's something you might like, Mundu for Mobiles.

EXPLORING TWO BOOLEAN OPERATORS

2007-07-17T04:08:00.000-07:00

Two operators that are quite similar in functionality but for which a developer has to be conscious of bugs creeping into his code are the boolean logical inclusive or, | and conditional-or, ||, operators.

The operands for both operators should be of type boolean or the boolean wrapper, Boolean. One difference between both of them is that the conditional-or || operator evaluates its operands differently and in a subtle fashion than its counterpart, the boolean logical inclusive-or | operator.

Let's illustrate this with a truth table.

table illustrating both boolean operators
T	F	Result: Logical inclusive-or \| operator	Result: conditional-or operator \|\|
T	T	T	T. Ignores right operand and proceeds to next expression.
T	F	T	T. ignores right operand; proceeds to next expression
F	T	T	T. evaluates right operand which is true where left operand if false and proceeds to next expression.
F	F	F	F. evaluates right operand which is false where left operand is false. Proceeds to next expression.

This is the difference between both operators: although they give the same result for truth or falsity, operand evaluation is different. From the table, realize that where the left operand is false for a conditional-or operand, the right operand is then evaluated, else where the left operand is true, the right operand is ignored.

So what's the consequence of this effect?

Let's take a simple question: which of the options below is not robust enough to throw a null pointer exception?

Option A: if ( (myArray != null) | (num == myArray.length()) );
Option B: if ( (myArray != null) || (num == myArray.length()) );
Option C: if ( (myArray == null) | (num == myArray.length()) );
Option D: if ( (myArray == null) || (num == myArray.length()) );

Answers:

Option A: if left operand is true and right operand is true or false, the if-statement evaluates to true and the expression after the if statement is next evaluated. If left operand is false, the if-statement will always throw a null pointer exception.

Option B: if left operand is true, execution jumps to the expression following the if statement, else a null pointer exception is immediately thrown.

Option C: if left operand is true, a null pointer exception is immediately thrown because the right operand would never be evaluated. If left operand is false, if statement evaluates to true if the right operand is true, false otherwise.

Option D: if left operand is true, execution immediately jumps to the statement following the if-statement. If left operand is false, right operand is then evaluated. If right operand is true or false, no null pointer exception will ever be executed.

So which option will never throw a null pointer? You guessed right, option D.

Generating Random Numbers

2007-07-16T04:35:00.000-07:00

Quest: a trivial exercise in generating random integers that one can class as either zero, even or odd between zero (inclusive) and eleven exclusive. After these integers, nine in all, are generated, classification is done and the result of the number of zeros, evens and odds in the total numbers generated is then printed to the screen.

Find: i”ll use an instance of a RandGenerator class to reach the above goal. Importing the class Random from the package, java.util, the following fields are declared by our RandGenerator class:


  import java.util.*;
  
  public class RandGenerator {
        //the array to hold the numbers generated
        private int[] boxArray = new int[9];
        //declaring an instance of our random number class
        private Random rand;
        //counters for the integers generated
        private int oddCount=0, evenCount=0, zeroCount=0;

we'll make use of two methods, a generator() that uses the Random class to generate nine integers from between zero (0) and ten (10) and then inserting the integers into an array.


        //method that generates random numbers as int values
        private void generator(){
             rand = new Random();
             //this for loop generates 9 consecutive random numbers
             for (int i =0; i<9; i++){
                  //get a random number between 0 and 11 exclusive
                  //and store in an array of ints
                  boxArray[i] = rand.nextInt(11);
             }
        }

Another method, probing(), accesses the array for its int values, maps each int trivially to either a zero, even or odd class and increases the count for each class so mapped. Note that the mapping is assumed. Finally, this class prints out the numeric value of the numbers generated for each of zero, even or odd classes from accessing the array.


        //method that evaluates the numeric count of the integers
       //generated randomly according to a zero, even and odd class
       private void probing(){
             //starting from the first to the last element in the array find out 
            //what integer was generated
            for (int i=0; i‹boxArray.length; i++){
                 int take = boxArray[i];
                 //if integer generated is zero, increase zero count
                 if (take == 0) {
                   zeroCount++;
                 }
                 //if even integer generated, increase even count
                 //by one
                 else if (take % 2 == 0){
                    evenCount++;
                 }
                 //otherwise odd integer generated, increase count
                 else {
                   oddCount++;
                 }
            }
   //print out the result of the count values
   System.out.println("Number of odd values"+ 
                    "generated were "+ oddCount+" .");
   System.out.println("Number of even values"+ 
                    "generated were "+evenCount+" .");
   System.out.println("The zeros generated were" +
                    zeroCount+" in number.");
  }

Finally, you can run this code by instantiating the class and just calling the two methods.


  public static void main(String[] args){
            RandGenerator random = new RandGenerator();
            random.generator();
            random.probing();
  }

Thinking of another quest for next blog. Promise it'll be great

my pix

2007-06-11T11:35:00.000-07:00

GRAPHICS DEBUGGING.

2007-06-09T09:56:00.000-07:00

GRAPHICS DEBUGGING.

Debugging graphics involves the ability to observe every painting operation as it occur during the rendering of a component and all of its children. Intended for problem finding with rendering, layout and container hierarchies. i.e everything display related.

When graphics debugging is enabled, the graphics object used in painting is an instance of DebugGraphics class which extends the Graphics class. JComponent and every swing component support graphics debugging which can be turned on or off with Jcomponent's setDebugGraphicsOption( ) method. This methods takes an int parameter that details the debug options. This parameter determines how the component should display the information:

if :
1.DebugGraphics.LOG_OPTION – a text message is printed.
2.DebugGraphics.FLASH_OPTION - The display flashes several times.
3.DebugGraphics.BUFFERED_OPTION - It creates an external window that displays the operations performed on this view's offscreen buffer.
4.DebugGraphics.NON_OPTION - Debug disabled.
5.If 0 no change is issued to the debugging option.

Note that these values can be bitwise OR'd into the current value.

Let's explore the options one after the other:

1.DebugGraphices.FLASH_OPTION.

Each paint operation flashes a specified number of times, in a specified flash color, with a specified flash interval.

You set this values with the following methods from the DebugGraphcics static methods :

setFlashTime(int flashTime)
setFlashCount (int flashCount)
setFlashColor (Color flashColor)

to see the flashing as it occurs you must disable buffering like this:

RepaintManager.currentManager(null).setDoubleBuffereingEnabled(false).

After this every component's doubleBuffered properyty will henceforth be ignored.

I loved the flashing at first instance and have been flashing my computer since.

So let me drop a code for that. See how the buttons changed color.

package tests;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import javax.swing.event.*;

public class Property extends JPanel{

//declaring an instance
static Color dColor = new Color(0, 255, 100, 125);

//the dimension
static Dimension dim = new Dimension(400, 400);

static JButton jButton1 = new JButton(" ");
static JTextArea jText;

/** Creates a new instance of Property */
public Property() {
jButton1 = new JButton("click me");
add(jButton1);

//we'll use the instance as foreground.
jButton1.setBackground(dColor);
}

private static void dButton(){
JFrame.setDefaultLookAndFeelDecorated(true);
JFrame frame = new JFrame("Property");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Property nProp = new Property();

//buffering and opaque value for painting and updating
nProp.setOpaque(true);
nProp.setDoubleBuffered(true);

//graphics debugging
nProp.setDebugGraphicsOptions(DebugGraphics.FLASH_OPTION);
DebugGraphics.setFlashColor(Color.red);
DebugGraphics.setFlashCount(5);
DebugGraphics.setFlashTime(10);
RepaintManager.currentManager(null).setDoubleBufferingEnabled(false);

//set max, min and preferred sizes
nProp.setMaximumSize(dim);
nProp.setMinimumSize(dim);
nProp.setPreferredSize(dim);

frame.setContentPane(nProp);

//let the above size stay 4ever
frame.setResizable(false);

frame.pack();
frame.setVisible(true);
}

public static void simplyText(String txt){
jText.append(txt+"\n");

}

public void paintComponent(Graphics g){
super.paintComponent(g);

//counter
int c = 0;

//for use below
int w=0;
int h=0;
int d=0;

//get damaged region
Rectangle r = g.getClipBounds();
int clipx = r.x;
int clipy = r.y;
int clipw = r.width;
int cliph = r.height;

//fill only damaged region
g.setColor(Color.white);
g.fillRect(clipx, clipy, clipw, cliph);

//filled yellow circle only if bounding region is damaged
if (clipx <= 240 && clipy <= 240){
g.setColor(Color.yellow);
g.fillOval(0, 0, 240, 240);
c++;
}

//filled magenta cirlce if bounding region has been damaged
if (clipx + clipw>=160 && clipx<=400 && clipy+cliph>=160 && clipy<=400){
g.setColor(Color.magenta);
g.fillOval(160, 160, 240, 240);
c++;
}

}
public static void main(String[] args){
javax.swing.SwingUtilities.invokeLater(new Runnable(){
public void run(){
dButton();
}
});
}
}

2.DebugGraphics.LOG_OPTION: each paint operation is messaged as they occur and by default are directed to standard output i.e System.out. Note that these output can be redirected with DebugGraphic's static setLogStream() method which method takes a PrintStream instance as a parameter.

we can also instance any string into the log using the debuggraphics static logStream () method.
3.DebugGraphics.BUFFERED_OPTION . This pops up a frame that gives offscreen rendering. Double-buffering must be enabbled.
4.DebugGraphics.NONE_OPTION. Basically shuts down graphics debugging by nullifying the settings.

Caveats in graphics debugging.

You'll notice that the button color changed from the default to brown due to its being blended with the flash color, red. Yeah, that's a caveat in graphics debugging.
1. Where the UI delegate of the component is null. If a component's UI delegate is null, graphics debugging will not work. The best way to go around this is if you declared a class without a UI delegate so as to define a trivial (empty) UI delegate.

2. DebugGraphics does not properly clean up after itself. A flash results in painting over of the color of the components and it does not get erased. This presents a problem because transparent rendering now becomes alpha blended with the flash color. You can hide the flash color though by giving its color an alpha value of invisible, i.e 0 or 0.0. we can sidestep this blending by making the flash time and flashcount to wait long enough between operations.

To implement the above we can rewrite the above code adding the below:

package tests;

import javax.swing.plaf.ComponentUI;
import javax.swing.*;

public class EmptyUI extends ComponentUI {

private static final EmptyUI sharedInstance = new EmptyUI();

public static ComponentUI createUI(JComponent c){
return sharedInstance;
}
}

then to the Property class we add this code as the first line in its constructor:

super.setUI(EmptyUI.createUI(this));

DEALING WITH GRAPHICS AND TEXT

2007-06-08T10:38:00.000-07:00

DEALING WITH GRAPHICS AND TEXT

first of all know that every component owns its own graphics context, which context is defined in the Graphics class of java.awt package and has the following properties:

1.the component object on which to draw
2.a translation origin for rendering and clipping coordinates
3.the current clip
4.the current color
5.the current font
6.the current logical pixel operation function (XOR or paint)
7.the current XOR alternation color

although in AWT to paint we typically override component's paint() method, to do rendering we use the update() method for implementing our own double buffering and background filling before calling paint(), but in swing, if any component wants to take charge of its rendering, it should override the paintComponent() method and not the paint() method and should always begin the paintComponent() method with a call to super.paintComponent() thereby it acts as its own lightweight canvas.

Note before: the above is useful for simple custom components but for normal swing component, since the UI delegate is in charge of rendering, never attempt it.

Inside the paintComponent() method, we have access to the component's graphics object or its graphics context used for painting shapes and drawing lines and text. Check the graphics class for useful methods.

Some code that illustrates the above.

package tests;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import javax.swing.event.*;

public class Property extends JPanel{

//declaring an instance
static Color dColor = new Color(0, 255, 100, 125);
static Color mainRed = new Color(255, 0, 0, 150);
static Color mainGreen = new Color(0, 255, 0, 150);
static Color mainBlue = new Color (0, 0, 255, 150);

static Font mainBIFont = new Font("Monospace", Font.BOLD| Font.ITALIC, 36);
static Font mainPFont = new Font("SansSerif", Font.PLAIN, 12);
static Font mainBFont = new Font("Serif", Font.BOLD, 24);

//the dimension
static Dimension dim = new Dimension(400, 400);

static JButton jButton1 = new JButton(" ");
static JTextArea jText;

/** Creates a new instance of Property */
public Property() {
jButton1 = new JButton("click me");
add(jButton1);

//we'll use the instance as foreground.
jButton1.setBackground(dColor);
}

private static void dButton(){
JFrame.setDefaultLookAndFeelDecorated(true);
JFrame frame = new JFrame("Property");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Property nProp = new Property();

//buffering and opaque value for painting and updating
nProp.setOpaque(true);
nProp.setDoubleBuffered(true);

//set max, min and preferred sizes
nProp.setMaximumSize(dim);
nProp.setMinimumSize(dim);
nProp.setPreferredSize(dim);

frame.setContentPane(nProp);

//let the above size stay 4ever
frame.setResizable(false);

frame.pack();
frame.setVisible(true);
}

public static void simplyText(String txt){
jText.append(txt+"\n");

}

public void paintComponent(Graphics g){
super.paintComponent(g);

//fill entire component white
g.setColor(Color.white);
g.fillRect(0, 0, getWidth(), getHeight());

//fills yellow circle
g.setColor(Color.yellow);
g.fillOval(0, 0, 240, 240);

//filled magenta circle
g.setColor(Color.magenta);
g.fillOval(160, 160, 240, 240);

g.setColor(Color.black);

//text is bold, italic, 36-point, "Nigeria"
g.setFont(mainBIFont);
FontMetrics fm = g.getFontMetrics();
int w = fm.stringWidth("NIGERIA");
int h = fm.getAscent();
g.drawString("NIGERIA", 120-(w/2), 120+(h/4));

//plain, 12-point, "go"
g.setFont(mainPFont);
fm = g.getFontMetrics();
w = fm.stringWidth("go");
h = fm.getAscent();
g.drawString("go", 200-(w/2), 200+(h/4));

//bold, 24-point, "SURVIVE"
g.setFont(mainBFont);
fm = g.getFontMetrics();
w = fm.stringWidth("GO");
h = fm.getAscent();
g.drawString("SURVIVE", 280-(w/2), 280+(h/4));

}
public static void main(String[] args){
javax.swing.SwingUtilities.invokeLater(new Runnable(){
public void run(){
dButton();
}
});
}
}

If you run the above code, it'll display: “NIGERIA go SURVIVE” in bright colors that illustrates the power of the rendering and painting properties of every graphics context for swing component. Worthy of note though is that not the totality of the area of a component is painted but for the sake of efficiency there are some so-called “dirtied” areas or damaged areas which are defined as the bounds of the clipping area which are not painted. You can get a Rectangle object showing this by calling getClipBounds() method of the Graphics class.

COLORS IN SWING

2007-06-08T06:30:00.000-07:00

COLORS IN SWING

the color class encapsulates colors in the default sRGB color space or colors in the arbitrary color spaces identified by a ColorSpace class. Every color has an implicit alpha value of 1.0 or an explicit one provided in the constructor, which alpha values denote the color's transparency and 1.0 means totally transparent if denoted with a float range or 255 if an int range. Also alpha values of 0 or 0.0 means completely transparent color. Note that color classes do not pre-multiply alpha values.

Information on the sRGB color space is defined by the World Wide Web consortium
the overloaded constructors for color take a colorspace parameter, float or int values. Check this out in the api.

Like the font accessor methods, getXX() methods are specified for the color class but in modifying any color instance, one is usually expected to create a new one. By specifying an alpha value, we can use a color instance on a component's background to make it transparent. Note that when setting the foreground of a component the look and feel may ignore the color specified.

Our button and textareas colored with Color.

package tests;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import javax.swing.event.*;

public class Property extends JPanel{

//declaring an instance
static Color dColor = new Color(0, 255, 100, 125);

static JButton jButton1 = new JButton(" ");
static JTextArea jText;
/** Creates a new instance of Property */
public Property() {
jButton1 = new JButton("click me");
add(jButton1);

//we'll use the instance as foreground.
jButton1.setBackground(dColor);

jText = new JTextArea(" ", 10, 20);
add(jText);
GraphicsEnvironment genv = GraphicsEnvironment.getLocalGraphicsEnvironment();
String[] fontNames = genv.getAvailableFontFamilyNames();
for (int i=0; i simplyText(fontNames[i]);
}
}

private static void dButton(){
JFrame.setDefaultLookAndFeelDecorated(true);
JFrame frame = new JFrame("Property");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Property nProp = new Property();
nProp.setOpaque(true);

//and also use it here too
nProp.setBackground(dColor);

frame.setContentPane(nProp);
frame.pack();
frame.setVisible(true);
}

public static void simplyText(String txt){
jText.append(txt+"\n");

}
public static void main(String[] args){
javax.swing.SwingUtilities.invokeLater(new Runnable(){
public void run(){
dButton();
}
});
}
}

keywords: color, swing, colorspace, alpha value, sRGB, GraphicsEnvironment

FONTS

2007-06-08T04:20:00.000-07:00

FONTS

to work with fonts, two classes are worth noting, the GraphicsEnvironment and Font classes which are both in the java.awt package.

GraphicsEnvironment: this class describes a collection of GraphicsDevices and font objects that are available to a java application on a particular platform and note that the resources might be local or remote. GraphicsDevices might be screens, printers or image buffers. Each GraphicsDevice has a number of Graphicsconfiguration objects associated with it that specifies configuration usage for different GraphicsDevices.

Font: this represents a class for rendring text in a visible way. A font provides information needed to map sequence of characters to sequence of glyphs and to render a sequence of glyphs as Graphics on component classes.

we can retrieve font related properties from a local or remote machine using the GraphicsEnvironment and font classes working together.

Here is a code that demonstrates the fonts available on my windows xp machine:

package tests;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import javax.swing.event.*;

public class Property extends JPanel{

static JButton jButton1 = new JButton(" ");
static JTextArea jText;
/** Creates a new instance of Property */
public Property() {
jButton1 = new JButton("click me");
add(jButton1);
jText = new JTextArea(" ", 10, 20);
add(jText);
GraphicsEnvironment genv = GraphicsEnvironment.getLocalGraphicsEnvironment();
String[] fontNames = genv.getAvailableFontFamilyNames();
for (int i=0; i simplyText(fontNames[i]);
}
}

private static void dButton(){
JFrame.setDefaultLookAndFeelDecorated(true);
JFrame frame = new JFrame("Property");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Property nProp = new Property();
nProp.setOpaque(true);
frame.setContentPane(nProp);
frame.pack();
frame.setVisible(true);
}

public static void simplyText(String txt){
jText.append(txt+"\n");

}
public static void main(String[] args){
javax.swing.SwingUtilities.invokeLater(new Runnable(){
public void run(){
dButton();
}
});
}
}

Although we can use the classic getXX() accessor methods for font objects note that to set them we have to derive fonts using an overloaded deriveFont() method.

USING TIMERS WITH SWING.

2007-06-08T04:19:00.000-07:00

USING TIMERS WITH SWING.

A timer instance can be considered as a unique thread that fires one or more action events at specified intervals. The timer class for use in GUI contexts in java is defined in the javax.swing.Timer class.

Let's write a code for creating a Timer class.

package tests;
import javax.swing.*;
import java.awt.event.*;
import javax.swing.event.*;

public class Property extends JPanel{

static JButton jButton1 = new JButton(" ");
static JTextArea jText;
/** Creates a new instance of Property */
public Property() {
jButton1 = new JButton("click me");
add(jButton1);
jText = new JTextArea("welcome", 2, 50);
add(jText);

//start the timer
int delay = 10000; // 3 sec. delay initially and between firing

//the action listener that processes the timer event
ActionListener al = new ActionListener(){
public void actionPerformed(ActionEvent ae){
simplyText("Don't forget me.");
}
};

//create an instance of a timer with delay and action listener
//then start timer thread
Timer tim = new Timer (delay, al);
tim.start();
}

private static void dButton(){
JFrame.setDefaultLookAndFeelDecorated(true);
JFrame frame = new JFrame("Property");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Property nProp = new Property();
nProp.setOpaque(true);
frame.setContentPane(nProp);
frame.pack();
frame.setVisible(true);
}

public static void simplyText(String txt){
jText.setText(txt);

}
public static void main(String[] args){
javax.swing.SwingUtilities.invokeLater(new Runnable(){
public void run(){
dButton();
}
});
}
}

THE EVENT DISPATCHING THREAD

2007-06-08T03:56:00.000-07:00

THE EVENT DISPATCHING THREAD

Listeners, as we've mentioned before, process every event and every event is in an event-dispatching thread. In the api, a FIFO queue of events is associated with this thread, an EventQueue instance, that is the system events queue and defined in the java.awt.EventQueue class. This queue is filled in a serial fashion, FIFO-like. As events are executed, this is done serially too, whether the event is a component property update or repainting .

Please ensure that all your events are within this thread and none should be dispatched outside this event dispatching thread. Also ensure that event handling code and painting codes will be executed quickly, i.e keep them simple. Otherwise, one event that takes up time could block the whole queue and your application gets frozen or locked up.

I have written a code here that makes use of the event dispatching threads on two listeners that listen for the same type of event, a mouse click.

package tests;

import java.awt.event.*;

public class FirstListener extends MouseAdapter {

public void mouseClicked(MouseEvent e){
//after this listener processes event, remove from queue
//and just add the second to make sure we did not remove
//it earlier also
Property.simplyText("the first listener at attention.");
Property.jButton1.removeMouseListener(this);
Property.jButton1.addMouseListener(new SecondListener());
}

}

import java.awt.event.*;

public class SecondListener extends MouseAdapter {

public void mouseClicked(MouseEvent e){
//after this listener processes event, remove from queue
//and just add the second to make sure we did not remove
//it earlier also
Property.simplyText("the second listener at attention.");
Property.jButton1.removeMouseListener(this);
Property.jButton1.addMouseListener(new FirstListener());
}
}

import javax.swing.*;
import java.awt.event.*;
import javax.swing.event.*;

public class Property extends JPanel{

EventListenerList listenerList = new EventListenerList();
FirstListener fl = new FirstListener();
SecondListener sl = new SecondListener();
MouseEvent me;

static JButton jButton1 = new JButton(" ");
static JTextArea jText;
/** Creates a new instance of Property */
public Property() {
jButton1 = new JButton("click me");
add(jButton1);

//here are the two listeners added to the event dispatching
//queue
jButton1.addMouseListener(fl);
jButton1.addMouseListener(sl);

jText = new JTextArea("welcome", 5, 50);
add(jText);
}

private static void dButton(){
JFrame.setDefaultLookAndFeelDecorated(true);
JFrame frame = new JFrame("Property");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Property nProp = new Property();
nProp.setOpaque(true);
frame.setContentPane(nProp);
frame.pack();
frame.setVisible(true);
}

public static void simplyText(String txt){
jText.setText(txt);

}
public static void main(String[] args){
javax.swing.SwingUtilities.invokeLater(new Runnable(){
public void run(){
dButton();
}
});
}
}

EVENT LISTENER LIST.

2007-06-08T03:50:00.000-07:00

EVENT LISTENER LIST.

The EventListenerList class is defined in the javax,swing.event package. An EventListernerList is an array of XXEvent/XXListener pairs. JComponent and each of its descendants use an EventListenerList to maintain their listeners. All default models also maintain listeners and an EventListenerList.

On adding a listener to a swing component or model, the associated event's Class instance (used to identify event type) is added to its EventListenerList array followed by the listener itself.
Since these pairs are stored in an array rather than a mutable collection, a new array is created on each addition or removal using the System.arrayCopy() methods.

When events are received, the list is walked through and events are sent to each listener with a matching type. Because the array is ordered in an XXEvent, XXListener, YYEvent, YYListener fashion, a listener corresponding to a given event type is always next in the array. This gives for very efficient event-dispatching routines.

For thread safety, the methods for adding and removing listeners from an event listener synchronises access to the array when it is manipulated.

In JComponent, the EventListenerList is a protected field called listenerList so that all subclasses inherit it and most listeners are managed through listenerList.

Here is a code where the class itself handles the event and is the sole occupant of the component's event listener list.

import javax.swing.*;
import java.awt.event.*;
import javax.swing.event.*;
import java.lang.*;

public class Property extends JPanel implements ActionListener{

JButton jButton1 = new JButton(" ");
JTextField jText;
/** Creates a new instance of Property */
public Property() {
jButton1 = new JButton("click me");
add(jButton1);

//this object is its own action listener
jButton1.addActionListener(this);

jText = new JTextField("welcome", 50);
add(jText);

}

private static void dButton(){
JFrame.setDefaultLookAndFeelDecorated(true);
JFrame frame = new JFrame("Property");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Property nProp = new Property();
nProp.setOpaque(true);
frame.setContentPane(nProp);
frame.pack();
frame.setVisible(true);
}

public void actionPerformed(ActionEvent e){
//get the action listeners associated with this object, here one
ActionListener[] al = jButton1.getActionListeners();

jText.setText("the "+al[0].getClass().toString()+" is the action listener " +
"in the list");
}

public static void main(String[] args){
javax.swing.SwingUtilities.invokeLater(new Runnable(){
public void run(){
dButton();
}
});
}
}

EVENT HANDLING AND DISPATCHING.

2007-06-08T03:43:00.000-07:00

EVENT HANDLING AND DISPATCHING.

Pressing a key or mouse button generates events. The type of events that swing components can generate whether in java.awt.event or javax.swing.event packages are of different types. Some event types are component specific.

Each event type is represented by an object that identifies the source of the event and other additional information about what specific kind of event it is and information about the state of the source before and after the event was generated. Sources of events are most commonly components or models but also different kinds of objects can generate events.

To receive notification of events, we need to register listeners with the target object . A listener is an implementation of any of the XXListener classes (where XX is an event type) defined in the java.awt.event, java.beans and javax.swing.event packages. There is at least one method defined in each interface that takes a corresponding XXEvent as parameter. Any class supporting XXEvents notification generally implements the XXListener interface and have support for registering those listeners through addXXListener methods and unregistering those listeners through removeXXLister methods. Most event targets allow any number of listeners to be registered with them. Also any listener instance can be registered to receive events for any number of event source. Usually classes that support XXEvents() provide protected fireXX() methods used for constructing event objects and sending them to the event handlers for processing.

The code below was repeated from an earlier one but with comments that emphasis some aspects of events handling.

import javax.swing.*;
import java.awt.event.*;

//implementing listeners that processes this event type
public class Property extends JPanel implements ActionListener{

JButton jButton1 = new JButton(" ");
JTextField jText;
/** Creates a new instance of Property */
public Property() {
jButton1 = new JButton("button1");
add(jButton1);

//registering instances of this class to receive this events
jButton1.addActionListener(this);
jText = new JTextField("welcome", 20);
add(jText);

}

private static void dButton(){
JFrame.setDefaultLookAndFeelDecorated(true);
JFrame frame = new JFrame("Property");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Property nProp = new Property();
nProp.setOpaque(true);
frame.setContentPane(nProp);
frame.pack();
frame.setVisible(true);
}

public void actionPerformed(ActionEvent e){
//event handler with associated object as parameter
jText.setText(jButton1.getMaximumSize().toString());
}

public static void main(String[] args){
javax.swing.SwingUtilities.invokeLater(new Runnable(){
public void run(){
dButton();
}
});
}
}

JCOMPONENT SIZING AND POSITIONING METHODS.

2007-06-06T06:05:00.000-07:00

JCOMPONENT SIZING AND POSITIONING METHODS.

Since JComponent extends java.awt.container, it inherits the sizing and positioning functionality of the AWT (for those familiar with AWT).

To manage a component's preferred, minimum and maximum size, the following methods are used:

the setters: setPreferred size(), setMinimumSize(), setMaximumsize().
The getters: getPreferredSize(), getMinimumSize(), getMaximumSize().

All these methods return a Dimension instance. Note that the size of components in a container is layout manager specific (the layout manager is the class responsible for laying out the components of a a container. ) The layout manager might ignore or respect sizing commands.

To assign a component both a size and a position with its parent container, we use JComponent's setBounds() method. The method takes a rectangle parameter or 4 int parameters that represent the x-coordinate, y-coordinate, width and height. Note that layout managers always have the first crack at component sizing, so setBounds() might be ignored in some cases. Use setBounds though if your component has no layout manager.

You can query a component's size using its getHeight() and getWidth() methods.

Also we can set a component's position within its container using the setLocation(int x, int y) method.

JComponent also maintains an alignment. Horizontal and vertical alignment can be specified by float values between 0.0 and 1.0. 0.5 means center, close to 0.0 means left or top and closer to 1.0 means right or bottom. The JComponent methods are : setAlignmentX(float f), setAlignmentY(float f).

JCOMPONENT PROPERTIES.

2007-06-06T06:01:00.000-07:00

JCOMPONENT PROPERTIES.

All swing components conform to the javabeans specification. The javabeans specification will be discussed later. Among the five features a javabean is expected to support are a set of properties and associated accessor methods for them.

Property: a property is a global variable. Accessor methods, if any, of a property are of the setPropertyName(), getPropertyName(), or isPropertyName() methods.

a. Simple, bound and constrained properties.

A simple property is a property that has no event firing associated with a change in its value.

A bound property is a property from which a property change event is/are fired after it changes state. We can register propertyChangeListeners to listen for propertyChangeEvents through JComponent's addPropertyChangeListener method.

Constrained porperty is a property for which propertyChangeEvents are fired before a change in state occurs. We can register vetoableChangeListeners to listen for propertyChangeEvents through JComponent's addVetoableChangeListener method. A change can be vetoed in the event handling code of a vetoableChangeListener by throwing a propertyVetoException. Only one swing class has constrained properties, the JInternalFrame class.

PropertyChangeEvents carry three pieces of information: name of the property, old value and new values. Beans can use an instance of propertyChangeSuppport to manage the dispatching of propertyChangeEvents corresponding to each bound property to each registered listener. Also, an instance of vetoabableChangeSupport can be used to manage the sending of all propertyChangeEvents corresponding to each constrained property. There is a class in swing, swingPropertyChangeSupport in the javax.swing.events package that extends the propertyChangeSupport class and provides more efficient methods.

Code for a class that demonstrates bound properties.

import javax.swing.*;
import java.awt.event.*;

public class Property extends JPanel implements ActionListener{

JButton jButton1 = new JButton(" ");
JTextField jText;
/** Creates a new instance of Property */
public Property() {
jButton1 = new JButton("button1");
add(jButton1);
jButton1.addActionListener(this);
jText = new JTextField("welcome", 20);
add(jText);

}

private static void dButton(){
JFrame.setDefaultLookAndFeelDecorated(true);
JFrame frame = new JFrame("Property");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Property nProp = new Property();
nProp.setOpaque(true);
frame.setContentPane(nProp);
frame.pack();
frame.setVisible(true);
}

public void actionPerformed(ActionEvent e){
jText.setText(jButton1.getText());
}

public static void main(String[] args){
javax.swing.SwingUtilities.invokeLater(new Runnable(){
public void run(){
dButton();
}
});
}
}

b. Change properties.

Change properties carry information about the source of a change. We use changeListeners to listen for changeEvents that get fired when these properties change state. ChangeEvents carry only one information, the source of the event.

c. client property
this property is implemented on a list such that for every propertyChange associated with a propertyChangeEvent, a list of propertyChangeListeners sought to notify all listeners for that event that a change has occurred.

Properties of swing components will be discussed in the course of these discussion.

HOW SWING IMPLEMENTS MVC.

2007-06-06T05:57:00.000-07:00

HOW SWING IMPLEMENTS MVC.

Swing packages each component's view and controller into an object called a user interface (UI) delegate, that is why, while reading the online java tutorial you'll be told that swing's architecture is not really MVC but a model-delegate. Model-delegate communication is indirect, like the MVC conception therefore one UI delegate can be associated with more than one model.

The base class of all UI delegates is in the swing pluggable look and feel architecture, i.e javax.swing.plaf.ComponentUI or in brief, ComponentUI class.

Important methods of the ComponentUI class although this class is not invoked directly are:
a. createUI. This method is a static public method and it returns a ComponentUI while accepting a JComponent as its parameter. The method returns an instance of the UI delegate for the specified component. Each subclass of this class must provide a static createUI method.
b. installUI. This method configures the specified component appropriate for the look and feel. Invoked when the ComponentUI instance is being installed as the UI delegate on the specified component. This method completely configures the component for the look and feel.

Read up the above method and others in the api. UI delegate and their use in swing components will be discussed in forthcoming discussions.

In swing, there are sets of UI delegates which contains ComponentUI implementation of most swing components, and each of the sets is called a look and feel or a pluggable look and feel (PLAF). From the api, you'll realize that there are four pluggable look and feel packages, basic, metal, multiplexing and synth. Basic is the set from which every component implements

MVC ARCHITECTURE:

2007-06-06T05:54:00.000-07:00

MVC ARCHITECTURE:

Model view controller, (MVC), is a user interface design decomposition that breaks down components into three parts: a model, a view and a controller.

In this three-way separation model, a mode l is responsible for maintaining all aspects of the component state e.g whether a button was pressed or unpressed, the character data of a text component, the opacity value of a window. A model communicates indirectly with the view and the controller i.e this communication is carried out without the model knowing its view or controller.

The view is the visual representation of the component's model or what is called the “look”. One noticeable example is the font of a character on a button or color of a label. The view receives indirect messages from the model and direct messages from the controller and is responsible for keeping its on-screen representation updated.

The controller is responsible for event management or the reaction of the component to events such as input devices such as the keyboard or mouse. The controller is the “feel” of the component, determining component actions. The controller receives direct messages from the view, and indirect messages from the model.

Let's illustrate the MVC concept: imagine a button with the state unpressed. On the model, this is the state and the view shows a button that is unpressed, idle. If a user clicks on the button, an event received by the controller, the controller translates this as a press or the button sends a direct message to the view, the view now looks “pressed” and send a message to the model to change its state to press = true.

Advantages of the MVC architecture:
1.we can customize the “look”(view) and “feel”(controller) of a component without affect the model.
2.We can customize specific parts of a component without affecting the model.
3.We can customize and replace a component's data model.

If you check the api there are various interfaces for the swing components that implement models and you will find references to the models that are implemented. In the course of the following weeks we will also be implementing this models in our classes for the swing components.

Z-ORDER IN SWING.

2007-06-06T05:53:00.001-07:00

Z-ORDER IN SWING.

According to the api, swing components are lightweight. On the other hand AWT components are heavyweight. The difference between the two terms is z-order i.e the notion of depth or layering.

A heavyweight component occupies its own z-order layer while all lightweight components are contained inside heavyweight components and maintain their own layering scheme as defined by swing. If a heavyweight container is placed inside another heavyweight container, it will, by definition, overlap all lightweights in that container. Therefore, avoid using both heavyweight and lightweight components in the same container wherever possible. Although they can both be mixed one has to be careful while doing so.

Note though that:
1.you should not place heavyweight components inside lightweight containers that commonly support overlapping children.
2.If using popup menus in a container holding a heavyweight component, force that popup to be heavyweight. On the other hand, swing has much functionality that makes the use of AWT heavyweight components really less useful.

One useful reason why swing is preferred over AWT is due to its platform independence. On the other hand there are swing container classes like JApplet, JDialog, JFrame and JWindow which are direct AWT class subclasses that are platform dependent.

SWING PACKAGE DESCRIPTION:

2007-06-06T05:50:00.000-07:00

SWING PACKAGE DESCRIPTION:

Swing components range from the very simple, e.g. JLabel, to the very complex, e.g JTable, JTree. Almost all swing components are derived from a single parent called JComponent which extends the AWT Container class. You now see why swing is called a layer on top of AWT. Top-level containers though like JFrame, JDialogue and JApplet do not inherit from JComponent but rather serve as places where any class that inherits from JComponent can paint itself. We'll explain swing components and the containment hierarchy later.

Am sure you must have realised that every class in swing that compares to an AWT equivalent is prefixed with 'J', this is because all the names have already been taken.

INTRODUCTION TO SWING.

2007-06-06T05:44:00.000-07:00

INTRODUCTION TO SWING. (I had to diverge from the JLS to swing because i fell in love with it.)

Each user of an application want to use a software that not only is pleasing to the eyes but which usage is simple to discover. Back in the day, before user interfaces became so glorified, computers were horrible mammoths reserved for just scientists. Today, a youth in a garage can devise glorious graphical functionalities on the internet using ajax and flex and likewise make an application speak with user interfaces, one of them being the java user interface which is not left out in the conference.

Before the swing revolution, the designers of the java language created a set of classes called the abstract window toolkit (AWT) used for creating user interfaces, painting graphics and rendering images on computer screens and other devices. But the AWT had platform compatibility problems that make it frustrating and not up to par with its competition in the user interface space. So back to the drawing board went the designers and they came out with swing, a set of revolutionary user interfaces that along with the java component reusability feature of beans is comparable to the visual modeling capabilities of VB.

Swing is incorporated into the java foundation class or JFC which comprises of AWT, Swing, Accessibility, Java 2D, and Drag and Drop.

Swing is built on top of AWT and the naming of its classes follows the AWT. These two libraries are one the two important libraries any java programmer will never do without.

The swing classes are in the javax.swing package of the api and according to the api, this package provides a set of lightweight components that to the maximum degree possible, work on all platforms.

SNIPPET, java.lang.Math

2007-04-13T03:24:00.000-07:00

SNIPPET, java.lang.Math

Sometimes it is necessary to take time off from the usual and play with the application programming interface. We’ll be using some of the functionalities here when we start real time coding.

package transkawa;

class MathAPI {
static double container = 2.0098765d;
public static void main(String[] args){
System.out.println("Base log to e is: "+Math.E);
System.out.println("PI is "+Math.PI+" in double
primitive.");

//the absolute value of PI is
System.out.println("PI in absolute values
is:"+Math.abs(Math.PI));
System.out.println("log e in abs value is:
"+Math.abs(Math.E));
System.out.println("Absolute value of our container
"+Math.abs(container));

//the smallest double value that is greater than or equal
//to the double value of container and equal to an integer
System.out.println("The ceiling value of container is:
"+Math.ceil(container));
System.out.println("While the floor is:
"+Math.floor(container));

//raising the floor by 2
System.out.println("Let's raise the floor of container to
2: "+Math.pow(Math.floor(container), 2));

//the cosine assuming container is an angle
System.out.println("The cosine of container is:
"+Math.cos(container));

//we can test for mathematical greater than
System.out.println("The greater of PI and log e is:
"+Math.max(Math.PI, Math.E));

//a random number generator also exists for Math class
//you get random numbers all the time:)
System.out.println("What u see is what u get:
"+Math.random());

//let's do a narrowing primitive conversion on container
System.out.println("double to long gives:
"+Math.round(container));

//a little square root pleae
System.out.println("square root of 2.0098756 is:
"+Math.sqrt(container));

System.out.println(Math.ulp(container));
}

}

SNIPPET, java.lang.StringBuilder

2007-04-13T03:13:00.001-07:00

SNIPPET, java.lang.StringBuilder

This class defines a mutable sequence of characters. It was created as a drop-in replacement for StringBuffer class in places where the StringBuffer would be used for single threaded actions.

The principal operations in a StringBuilder are the append and insert methods which are overloaded and accept data of any type. A given datum is effectively converted to a string and the characters of that string inserted or appended to the StringBuilder where the append method add these characters at the end of the builder and the insert method at a specified point.

Here is a simple class, BuilderExample, that is based on the principles of the StringBuilder class.

package transkawa;

class BuilderExample {
static StringBuilder stringchain = new StringBuilder("A");
static final String initialchain = stringchain.toString();
String spaces = " ";
static String current="Current string chain: ";

//to append strings in this class, first attach a space
//then attach the string. Append always at the last position
void appendString(String str){
stringchain.append(spaces);
stringchain.append(str);
}

//this method appends a char without spaces
void appendChar(char ch){
stringchain.append(ch);
}

//insertString at any position before the last string in chain
void insertString(String str, String insertbefore){
int theindex = stringchain.indexOf(insertbefore);
stringchain.insert(theindex, str);
theindex += str.length();
stringchain.insert(theindex, spaces);
}

//properties method
int propMethod(char ch){
int resultvar = 0;
for (int i=0; i if(stringchain.charAt(i) == ch ){
resultvar +=1;
}
}
return resultvar;
}

public static void main(String[] args) {
//an instance of our class
BuilderExample build = new BuilderExample();

//on instantiating the string contains only "A"
System.out.println("Initial chain is "+initialchain);

//we're appending the string "Teaching" to the chain
build.appendString("Teaching");
System.out.println(current+BuilderExample.stringchain);

//we'll insert a string at a chosen position
build.insertString("Tremendous", "Teaching");
System.out.println(current+BuilderExample.stringchain);

//let's add "Tool" after "Teaching"
build.appendString("Tool");
System.out.println(current+BuilderExample.stringchain);

//suppose we made a mistake, we didn't insert '!' in "Tool"
build.appendChar('!');
System.out.println(current+BuilderExample.stringchain);

//if we want to know the properties of the string built
System.out.print("There are "+(build.propMethod(' ')+1)+"
words");
System.out.println(" and
+BuilderExample.stringchain.length()+" characters in the chain");
}
}

Enjoy!

SNIPPET, java.lang.StringBuilder

2007-04-13T03:13:00.000-07:00

INTERFACES(4)

2007-04-13T03:12:00.000-07:00

INTERFACES(4)

ANNOTATIONS
Annotations provide data about a program that is not part of the program itself. They have no direct effect on the operation of the code they annotate.

Annotations have a number of uses, among which are:
1. they provide information for compilers and can be used to detect or suppress warnings.
2. can be used for compiler-time and deployment-time processing. Software tools can process annotations to generate code, XML files and so forth.
3. for runtime processing. Some annotations are available for examination at runtime.

Note that annotations may be used as modifiers in any declaration, whether package, class, interface, field, method, parameter, constructor or local variable.

package examples;

public @interface Author {
String name();
String date();}

//annotation as modifier for class MyClass
//annotations *must* contain an element-value pair for
//every element of the corresponding annotation type
@Author (
name="nnaemeka david",
date="10/04/2007"
)
public class MyClass {}

annotations may also be used on enum constants.

A compile time error is more than one annotation is specified for a declaration.

There are 3 kinds of annotations:
1. normal annotations – these are fully general annotations
2. marker annotations – these are shorthand annotations
3. single-element annotations - these are shorthand annotations

Normal annotations: normal annotations are used to annotate program elements.

Notation: @TypeName (ElementValuePairsopt)

Where ElementValuePairs are notated as: Identifier = ElementValue

And ElementValue is either:
a. a conditional expression
b. an annotation
c. an element value array initialiser which is notated as {ElementValueopt,opt}

example:
public @interface Author {
String name(); //return type of this method defines the element type
//of the element-value pair
}

//here, TypeName is Author; identifier is name, Element
//value conforms to the return type for method name in
//Author annotation, which is String.
@Author(name="nnaemeka david")
public class MyClass {}

the element type T of the element-value pair is commensurate with an element value V if and only if one of the following conditions is true:
1. T is an array type E[] and either
a. V is an ElementValueArrayInitialiser and each ElementValue initialized in V is commensurate with E, or
b. V is an element value that is commensurate with T

2. The type of V is assignment compatible with T and therefore
a. If T is a primitive type or String, V is a constant expression
b. V is not null
c. If T is Class, or an invocation of Class, and V is a class literal
d. If T is an enum type and V is an enum constant.
Element types must always be commensurate with element values.
Little example:

package examples;

public @interface Author {
int[] number();
}

public @interface Author {
int[] number();
}

An annotation on an annotation type declaration is called a meta-annotation.

import java.lang.annotation.*; //these type on demand import necessary
//to use @Document annotation

//a meta-annotation
@Documented
public @interface Author {
int[] number();
}

Marker annotations: marker annotations notated as: @TypeName
are simply shorthands for the normal annotation, @TypeName().

package examples;

import java.lang.annotation.*;

@Documented
public @interface Author {}

//marker annotation
@Author()
public class MyClass {}

Simple-element annotation: this is a shorthand designed for use with single-element annotation types. Note that by convention, single-element annotation types have a single method, value.

The notation for single-element annotation is: @TypeName(ElementValue) which is the shorthand for the normal annotation: @TypeName(value = ElementValue).

package examples;

import java.lang.annotation.*;

@Documented
public @interface Author {
String value();
}

//single-element annotation
@Author("david")
public class MyClass {}

there are lots of examples in section §9.7 that illustrates this three types of annotations.

INTERFACES(3)

2007-04-13T03:10:00.000-07:00

INTERFACES(3)

ANNOTATION TYPES
An annotation type declaration is a special type of interface declaration using the at sign @ along with the keyword interface.

Notation:
InterfaceModifiersopt @interface Identifier AnnotationTypeBody

AnnotationTypeBody: {AnnotationTypeElementDeclarationopt}

Where the annotation type element declarations can be one or many and notated as either one or many of:
AbstractMethodModifiersopt Type Identifier() DefaultValueopt;
ConstantDeclaration
ClassDeclaration
InterfaceDeclaration
EnumDeclaration
AnnotationTypeDeclaration
;

The default values are notated thus: default ElementValue

By virtue of its context free syntax, the following restrictions are imposed on annotation type declarations:
1. annotation type declarations cannot be generic
2. no extends clause is permitted (annotation types (denoted with the sign @) implicitly extend annotation.Annotation.)
3. methods cannot have any parameter
4. methods cannot have any type parameter.
5. method declarations cannot have a throws clause.

Take note: unless explicitly modified, all the rules applying to ordinary interface declarations apply to annotation type declarations.

The identifier in an annotation type declaration specifies the annotation type name and it cannot be the same simple name as any of its enclosing classes or interfaces.

If an annotation a on an annotation type declaration corresponds to an annotation type T, and T has a (meta-)annotation m that corresponds to annotation.Target, then m must have an element whose value is annotation.ElementType.ANNOTATION_TYPE or annotation.ElementType.TYPE or a compile time error occurs.

The direct superinterface of an annotation type is always annotation.Annotation.

The return type of a method declared in an annotation type is either:
1. one of the primitive types
2. String
3. Class and any invocation of Class
4. an enum type
5. an annotation type
6. an array of any of the types above,
otherwise a compile time error occurs.

If any method declaration in an annotation type has a signature that is override-equivalent to that of any public or protected method declared in the class Object or in the interface annotation.Annotation, then a compile time error occurs.

Each method declaration in an annotation type declaration defines an element of the annotation type. Annotation types can have zero or more elements which are only those defined by the methods it explicitly declares.

A compile time error for an annotation of type T to contain an element of type T, either directly or indirectly.

An annotation type element may have a default value specified. This is done by following the empty parameter list with the keyword default and then the default value of the element.

An ElementValue is used to specify a default value and must be correctly typed otherwise a compile time error. An ElementValue is always FP-strict.

(see jls for example. No need to duplicate it here. )

By convention, value is the name of the sole element in a single-element annotation type.

Predefined annotation types:
Target: this predefined annotation type is used in meta-annotations to indicate that the kind of program element an annotation type is applicable to.

Target has one element of, annotation.ElementType[]

The meta-annotation below indicates that the declared type is itself a meta-annotation type. It can only be used on annotation type declarations.

@Target (ElementType.ANNOTATION_TYPE)
public @interface MetaAnnotationtype { ... }

the meta-annotation below indicates that the declared type is intended solely for use as a member type in complex annotation type declarations. It cannot be used to annotate anything directly.

@Target ({})
public @interface MemberType { ... }

note: a single ElementType cannot appear more than once in a Target annotation.

Retention: indicates if annotations may be present only in the source code or in the binary form of a class or interface. The annotation type, annotation.Retention is used to choose between the above two.

If an annotation a corresponds to type T and T has a meta-annotation m that corresponds to annotation.Retention, then
- if m has an element whose value is annotation.RetentionPolicy.SOURCE, then a java compiler must ensure that a is not present in the binary representation of the class and interface in which it appears.
- If m has an element with value annotation.RetentionPolicy.CLASS , or annotation.RetentionPolicy.RUNTIME, then a java compiler must ensure that a is represented in the binary representation of the class or interface in which a appears, unless m annotates a local variable declaration, then it won’t be retained in the binary representation.

Inherited: this indicates that annotations on this class are automatically inherited.

Override: this annotation is useful for early detection of programmers mistaking an overload for an override for a method.

If a method declaration is annoted with the annotation @override, but this method does not in fact override any method declared in a superclass, a compile time error will occur.

SuppressWarnings: used to indicate that the named compiler warnings should be suppressed in the annotated element (and in all program elements contained in the annotated element). It contains a single element that is an array of String.

INTERFACES(2)

2007-04-13T03:09:00.000-07:00

INTERFACES(2)

INTERFACE MEMBERS:
The members of an interface are:
1. those members declared in the interface
2. members inherited from direct superinterfaces
3. where there is no direct superinterface, then the interface implicitly declares a public abstract member m with signature s return type r and throws clause t corresponding to each public instance method m with signature s return type r and throws clause t declared in Object unless an explicit declaration of a method with the same signature, return type and compatible throws clause exists. If m is declared to be final in Object and the interface explicitly declares me, then a compile time error results.

It is a compile time error if the interface declares a method with a signature that is override-equivalent to a public method of Object, but has a different return type or incompatible throws clause.

Except for those fields, classes and interfaces that is hides and methods it overrides, an interface inherits members of an interface it extends.

FIELD (CONSTANT) DECLARATION:
Constant declaration:

ConstantModifiersopt Type VariableDeclarators;

Where constant modifiers are one of:
Annotation public static final

Note: every field declaration in the body of an interface is implicitly public static final. Redundant modifier specification is allowed.

If an annotation a on a field declaration corresponds to an annotation type T, and T has a (meta-)annotation m that corresponds to annotation.Target, then m must have an element whose value is annotation.ElementType.FIELD, or a compile time error occurs.

A same name field in an interface with its superinterface hides the field of the superinterface provided they are accessible and the field exists.

Although an interface can inherit two fields with the same name, referencing this fields using their simple names will result in compile time error due to ambiguous referencing.

If inheritance of a field can be done through several paths, inheritance is considered to be just once and the field’s simple name can be used to referenced it.

Initialisation of fields in interfaces:
Every field in the body of an interface must have an initialization expression, which need not be a constant expression. When the interface is initialized, the variable initialiser is evaluated and the assignment performed exactly once.

Note:
1. initialization expression for an interface field cannot contain a reference by simple name, a. to itself; or b. to another field whose declaration occurs textually later in the same interface.
2. the keywords this or super cannot occur in the initialization expression for a field of an interface unless this occurrence is within the body of an anonymous class.

(the jls contains some straight-to-the-point examples for the above, at section §9.3)

ABSTRACT METHOD DECLARATION:
Notation:
AbstractMethodModifiersopt TypeParametersopt ResultType MethodDeclarator Throwsopt

Abstract method modifiers can be one of the following:
Annotation public abstract

Modifier appearance redundancy is not allowed.

Every method declaration in an interface body is implicitly abstract, so its body is always represented by a semicolon, ;, and not a block.

Every method declaration in the body of an interface is implicitly public.

Abstract methods cannot be static and vice versa, so member interface methods can never be static.

Annotation rules also apply to interface methods i.e if an annotation a on a method declaration corresponds to an annotation type T, and T has a (meta-)annotation m that corresponds to annotation.Target, then m must have an element whose value is annotation.ElementType.METHOD, or a compile time error occurs.

These are known compile time errors:
1. for an interface to declare two methods with override-equivalent signatures, whether implicitly or explicitly. However, an interface may inherit several methods with such signatures.
2. interface methods must not be declared final although implementing classes can declare its implementation as final
3. interface methods may be generic.

Inheritance and overriding.
If an interface I has an instance method m1 and interface J has an instance method m2, m1 overrides m2 if and only if the following are true:
- I is a subinterface of J
- The signature of m1 is a subsignature of the signature of m2.

Note that overriding and hiding implies return type substitutability along with subtyping on the overriding type which can issue an unchecked warning.

A method declaration does not have a throws clause that conflicts with that of any method it overrides, otherwise, compile time error occurs.

If a type declaration T has a member method m1 and another method m2 exists, declared in T or a supertype of T, a compile time error occurs if all if all the following holds:
1. m1 and m2 have same name
2. m2 is accessible from T
3. the signature of m1 is not a subsignature of the signature of m2
4. m1 or some method m1 overrides (directly or indirectly) has the same erasure as m2 or some method m2 overrides (directly or indirectly.)

notes:
a. methods are overridden on a signature-by-signature basis.
b. All methods not overridden by an interface in the supertype are automatically inherited.
c. An interface can inherit several methods with override-equivalent signatures, however, one of the inherited methods must be return-type substitutable for any other inherited method, otherwise a compile time error occurs.
d. A method can be inherited from several paths, inheritance is considered as being only once.

Overloading: overloading of interface member methods similar to as detailed for class methods overloading.

MEMBER TYPE DECLARATIONS
Interfaces may contain member type declarations; a member type declaration in an interface is implicitly static and public.

A member type C enclosed in an interface N has a fully qualified name N.C.

Member type hiding can occur between an interfaces and its superinterface.

An interface will inherit all non-private accessible non-hidden member types of its superinterface.

An interface can inherit 2 or more type declarations with the same name, but on referencing them with their simple names, ambiguity results.

If the same type declaration is inherited with different paths by an interface, then inheritance is assumed to be but once.

INTERFACES

2007-04-13T03:08:00.000-07:00

INTERFACES

An interface declaration introduces new reference types whose members are classes, interfaces, constants and abstract methods. Being without implementation, unrelated classes can implement interfaces by providing a definition for its abstract methods.

There are two kinds of interfaces, normal interfaces and annotation types, and they both can either be top level interfaces or nested interfaces (i.e with their declaration in the body of another class or interface).

Interface Declarations
An interface declaration specifies a new named reference type. There are two kinds of interface declarations:
NormalInterfaceDeclaration
AnnotationTypeDeclaration
A normal interface declaration is notated thus:
InterfaceModifiersopt interface Identifier TypeParameteropt ExtendsInterfacesopt InterfaceBody

Annotation type declarations will be broached later.

The identifier in an interface declaration denotes the name of the interface which name should not be the same as an enclosing class or interface otherwise, a compile time error will result.

Interface Modifiers
The interface declaration may include interface modifiers which may be one of:
public protected private abstract static strictfp

not all modifiers are applicable to all interfaces. Protected and private are applicable only to member interfaces within a directly enclosing class declaration; static applies only to member interfaces; the same modifier should not appear more than once in the same interface declaration.

If an annotation a for an interface declaration corresponds to an annotation type T, and T has a (meta-)annotation m such that m corresponds to annotation.Target, then m must have an element whose value is annotation.ElementType.TYPE, otherwise a compile time error results.

Note that every interface is implicitly abstract, but the use of this modifier is obsolete; a strictfp interface declaration is to make all double and float expressions in the interface be explicitly FP-strict, including nested types declared in the interface.

Generic interfaces and type parameters
Generic interfaces are interfaces which declare one or more type variables which are known as the type parameters of the interface and delimited by angle brackets, ‘<’ and ‘>’. A generic interface declaration defines a set of types, one for each possible invocation of the type parameter section. All type parameters share the same interface at runtime.

The scope of an interface’s type parameter is the entire declaration of the interface including the type parameter section itself. Therefore, type parameters can appear as part of their own bounds, or as bounds of other type parameters declared in the same section.

Never refer to the type parameter of an interface anywhere in a member field or member type of an interface.

Superinterfaces and subinterfaces:
If the extends clause is provided, then the interface being declared extends each of the other named interfaces and therefore inherits the member types, methods and constants of each of the other named interfaces, called the direct superinterfaces of the interface being declared.

If a class implements the declared interface, it is also considered to implement all the interfaces this interface extends.

Notation: extends InterfaceType(s)

Note that interface types can be generic and must be accessible.

An interface I directly depends on a type T if T is mentioned in the extends clause of I either as a superinterface or as a qualifier within a superinterface name.

An interface I depends on a reference type T if any of the following conditions hold:
1. I directly depends on T
2. I directly depends on a class C that depends on T
3. I directly depends on an interface J that depends on T (using this definition recursively.)
An interface cannot directly depend on itself.

While every class is an extension of the Object class, there is no interface such that all interfaces implicitly extends it.

The suerinterface relationship is a transitive closure of the direct superinterface relationship. An interface K is a superinterface of interface I if either of the following is true:
1. K is a direct superinterface of I
2. an interface J exists such that K is an interface of J, and J is a superinterface of I, applying this definition recursively.
Where K is a superinterface of J then J is said to be a subinterface of K.

Interface Body and member declarations: the body of an interface may declare members of the interface where the members are either:
1. a constant declaration
2. an abstract method declaration
3. a class declaration
4. an interface declaration.
The scope of the declaration of a member m declared in or inherited by an interface type I is the entire body of I, including any nested type declarations.

Access to interface member names: all interface members are implicitly public and access to them is allowed if the interface is also declared public or protected.

CLASSES(8)

2007-04-13T03:07:00.001-07:00

CLASSES(8)

ENUMS
The notation form for enum type is:
ClassModifiersopt enum Identifier Interfacesopt EnumBody

Where Enum body is:
{ EnumConstantsopt,opt EnumBodyDeclarationsopt }

The body of an enum type may contain enum constants which defines instances of the enum type.

Notes:
1. never explicitly instantiate an enum type
2. enum constants can never be cloned due the the clone method of Enum
3. the special treatment of the serialization mechanism ensures that duplicate instances are never created as a result of deserialisation.
4. reflective instantiation of enum types is prohibited.
Notes 1-4 above ensures that only an enum constant can define instances of enum types.

Enum constants thus have the following notation:
Annotations Identifier Argumentsopt ClassBodyopt
Where Arguments: (ArgumentListopt)

Also the optional enum body declaration is declared thus: ;ClassBodyDeclarationsopt

An enum constant when preceded by annotation modifiers, say a, corresponding to an annotation type T, and T has a (meta-)annotation m such that the m corresponds to annotation.Target, then m must have an element whose value is annotation.ElementType.FIELD, or a compile time error results.

An enum constant may be followed by arguments and these arguments are passed to the constructor of the enum type when the constant is created during class initialization. If the arguments are omitted, an empty argument list is assumed. If the enum type has no constructor declarations, a parameterless default constructor is provided (matching the implicit empty argument list) and the default constructor is private.

The optional class body of an enum constant implicitly defines an anonymous class declaration that extends the enclosing enum type. The class body is governed by the usual anonymous class rules, in particular, it cannot contain constructors.

Compile time error scenarios, brief:
1. a compile time error if an enum type is declared abstract
2. an enum type, E, cannot have abstract methods unless E has one or more enum constants and all these enum constants have class bodies that provide concrete implementations of the abstract method.
3. the class body of an enum constant cannot declare an abstract method.

An enum type is implicitly final unless it contains an enum constant that has a class body, but does not have to be explicitly so defined otherwise compile time error.

Nested enum types are implicitly static and one can explicitly declare them thus.

Any constructor or member declaration declared with an enum declaration applies to the enum type exactly as if they had been present in the class body of a normal class declaration unless explicitly stated otherwise.

The direct superclass of an enum type named E is Enum. in addition to members inherited from Enum, for each declared enum constant n the enum type has an implicitly declared public static final field named n of type E. these fields are considered to be declared in the same order as the corresponding enum constant and initialized to the corresponding enum constant. Each such field is also considered annotated by the same annotations as the corresponding enum constants. The enum constant is said to be created when the corresponding field is initialized.

The following implicitly declared static method exists for any enum type:
public static E[] values(); //this returns an array containing the constants of the enum
type in the order declared.

public static E valueOf(String name); //returns the enum constant with the specified
name

read the specific examples in the jls!

CLASSES(7)

2007-04-13T03:06:00.001-07:00

CLASSES(7)

MEMBER TYPE DECLARATIONS
Member classes or member interfaces are nested classes or interfaces. The name of a member type hides any and all accessible declarations of member types with the same name in superclasses and superinterfaces.

If there exists a declaration of a member type in scope before the declaration of another member type with the same name, then these other member type declaration will shadow the earlier one.

If a member class or interface with simple name C is directly enclosed in another class declaration with fully qualified name N, then N.C is the fully qualified name of the member class or interface.

INSTANCE INITIALISERS
An instance initialiser declared in a class is executed when an instance of the class is created.

A named class’ instance initialiser should not throw any exceptions unless the following conditions hold: a. that exception or its supertype must be explicitly declared in the throws clause of the constructor, b. the class must have at least one explicitly declared constructor.

An anonymous class’ instance initialiser can throw any number of exceptions.

An instance initiliser must complete normally.

There must be no return statement in an instance initialiser.

Try to declare instance variables used in instance initialiser before usage even though these instance variable declarations are in scope.

Instance initialisers can refer to the current object this, to any variable that is in scope and can use the keyword super.

STATIC INITIALISERS
Any static initialisers declared in a class are executed when the class is initialized, and together with any field initialisers for class variables, may be used to initialize the class variables of the class.

Notation for static initialisers is: static Block

Static initialisers and class variable initialisers are executed in textual order. Declaration after usage of class variables is discouraged even though the variables may be in scope.

No return statement must appear inside the block of a static initialiser.

The keywords this, super or any type variable declared outside the initialiser are not allowed and produce compile time errors.

CONSTRUCTOR DECLARATIONS
a constructor is used in the creation of an object that is an instance of a class.

Notation:
ConstructorModifiersopt ConstructorDeclarator Throwsopt ConstructorBody

Where the Constructor Declarator is notated thus:
TypeParametersopt SimpleTypeName (FormalParameterListopt)

The simple name of the constructor declarator must be the simple name of the class in which the constructor is declared, otherwise compile time error. Except for the simple name requirement, the constructor looks like a method declaration without any return type.

Very simple example of a constructor:

class Loader {
int x, y;
Loader(){}
}
Constructors are invoked by:
1. class instance creation expressions.
2. conversions and concatenations caused by the string concatenation operator, +.
3. explicit constructor invocations from other constructors.

Access to constructors is governed by access modifiers.

Constructor declarations are not members. They are not inherited and therefore cannot be overridden or hidden.

The formal parameters and formal type parameters of constructors are identical in structure and behaviour to those of a method.

It is a compile time error to declare two constructors whose signatures are override-equivalent or have the same erasure types in a class.

Constructor Modifiers: the choice of constructor modifiers are either one of public, protected or private, and a single one can never be declared twice nor can more than one of the choice above be chosen. If a normal class has a constructor without an access modifier, then the default is chosen. An enum type has default access modifier of private and cannot ever be declared public or protected.

If an annotation a on a constructor corresponds to an annotation type T and T has a meta-annotation m such that m corresponds to annotation.Target, then m must have an element whose value is annotation.ElementType.CONSTRUCTOR, otherwise a compile time error results.

Unlike methods, a constructor cannot be:
a. abstract, because it would not be implemented
b. final, because it is never inherited.
c. Static, because since a constructor is invoked with respect to an object, it makes no sense to declare it static.
d. Synchronized, because it would lock the object under construction, making it unavailable to other threads until all constructors for the object have finished their work.
e. Native, a design decision in java to ensure proper superclass constructor invocations.
f. Strictfp, a design decision to ensure that unlike in method modifiers, the class determines the fp-strictness of the results of the constructor.

Generic constructors: whether or not the class a constructor is in is generic or not, a constructor can be declared generic. A generic constructor must declare one or more type variables known as the formal type parameters of the constructor which form is identical to the type parameter list of a generic class or interface.

The scope of a constructor’s type parameter is the entire declaration itself, including the type parameter section. Type parameters can therefore appear as part of their own bounds or as bounds of other type parameters in the same section.

On invoking a generic constructor, you need not provide the type parameters explicitly, and when not provided, they are inferred.

Constructor throws: identical to that of a method.

The type of a constructor: consists of its signature and exception types given its throws clause.

Constructor body: the first statement of a constructor body may be the explicit invocation of another constructor of the same class or of the direct superclass.

{ExplicitConstructorInvocationopt BlockStatementsopt}

A constructor using this should not directly or indirectly invoke itself, otherwise a compile time error results.

If the constructor is a constructor for an enum type, it is a compile time error for it to invoke the superclass constructor explicitly.

If a constructor does not begin with a. an explicit constructor invocation, b. and the constructor being declared is not part of the primordial class of Object, then the compiler assumes the constructor begins with “super();”, an invocation of the constructor of its direct superclass that takes no arguments.

Except for possible explicit constructor invocations, the body of a constructor is similar to that of a method.

See examples in §8.8.7 of the jls.

Explicit constructor invocations: notations are of this form
1. alternate constructor invocations, beginning with this are used to invoke an alternate constructor for the class and may be prefaced with explicit type arguments.
nonWildTypeopt this(ArgumentListopt);

2. Superclass constructor invocations are either, a. unqualified, or b. qualified.
a. unqualified superclass constructor invocations, begin with super and may be prefaced with explicit type arguments.
nonWildTypeopt super(ArgumentListopt);
b.
Primary.nonWildTypeopt super(ArgumentListopt);

Where nonWildTypes are notated as where the list of reference types are one or many.

package examples;

public class A {
A(){
System.out.println("I am your super man.");
}
}

public class C extends A {
String color;
C(){
this("white"); //call alternate constructor
}

//the alternate constructor
C(String givencolor){
this.color = givencolor;
}
}

class Loader {

public static void main(String[] args) {
//create an instance without arguments and it'll give
//us white.
C newc = new C();
System.out.println("without arguments default color is
"+newc.color);

//creating one with argument, alternate to customise color
C customc = new C("red");
System.out.println("we've chosen to use the color
"+customc.color);

//not that an implicit call to the super is done each
//time the the subclass constructor is invoked.
}
}

Constructor overloading: constructor overloading similar to method overloading.

Default constructor: if a class contains no default constructor, then one is automatically provided that takes no parameters.

If class is Object, then the constructor an empty body, else the default takes no parameters and simply invokes the superclass constructor with no arguments.

A default constructor has no throws clause.

In an enum type, the default constructor is implicitly private. The default constructor is implicitly given the access modifier that is specified for the class!

Preventing instantiation of a class:

A class can prevent code outside of the class declaration from creating instances of the class by:
1. declaring at least one constructor.
2. preventing the creation of an implicit constructor.
3. declaring all constructors to be private.

A public class can likewise prevent the creation of instances outside the package by:
1. declaring at least one constructor
2. preventing the creation of a default constructor with public access.
3. declaring no constructor that is public.

CLASSES(6)

2007-04-13T03:04:00.000-07:00

CLASSES(6)

Method throws: a throws clause is used to declare any checked exceptions that can result from the execution of a method or constructor.

The notation is: throws ExceptionTypeList
Where ExceptionTypeList can be one or more and the types are either a class type or a type variable.

Note:
1. the type of exception mentioned in a throws clause must be a subtype of Throwable.
2. any checked exception that will be encountered in the body of a method or constructor must be mentioned in a throws clause in the declaration of the method or constructor.
3. if a throws clause does not contain that exception type, then the compiler will fail to handle the exception and this will result in a compile time error.

Two exceptions that are not checked because declaring their every occurrence would be inconvenient are:
a. exceptions that are represented by subclasses of the class Error.
b. Exceptions that are represented by subclasses of the class, RuntimeException.

if a method declaration n in a class or interface B overrides or hides a method declaration m in A where A is a superclass or superinterface of B. if n has a throws clause that mentions any checked exception types, then m must have a throws clause, and for every checked exception type listed in the throws clause of n, that same exception class or one of its supertypes must exist in the erasure of the throws clause of m; otherwise a compile time error will result.

If there exists a throws clause in n such that no throws clause in an unerased m is a supertype of this throws clause, then an unchecked warning must be issued.

Method body: a method body is a block of code that implements the method, or simply a semicolon indicating the lack of an implementation. Note that the body of a method must be a semicolon, ;, if and only if the method is declared abstract or native.

If an implementation is to be provided for a method declared void, but the implementation requires no executable code, the method body should be written as a block that contains no executable code, {}.

A method declared void must not contain a return statement in its code, a method declared with a return type must have a return statement in its body that returns a value of type return type.

A method that specifies a return type could in some cases not return anything.

Inheritance, overriding, hiding: a class C can inherit from its direct superclasses and superinterfaces (a) all non-private methods (whether abstract or not) of the superclass and superinterface that are public, protected or the default (i.e package-private), (b) in the same package as C, and (c) are neither overridden nor hidden by a declaration in the class.

Overriding (by instance methods): the example below illustrates this.
Note:
1. an instance method does not override a static method.

package examples;

public class A {
void m1(int enter){
System.out.println("A enters with "+enter);
}
}

//C is a subclass of A
public class C extends A{

//both methods have the same signatures, zero parameters
void m1(int enter){
System.out.println("C enters with with "+enter);
}

//to access the overridden method, we use super
void overridden(int enter){
super.m1(enter);
}
}

class Loader {

public static void main(String[] args) {
//let's show overriding of instance methods
C thec = new C();
thec.m1(35);

//the printout will show that C.m1 overrides A.m1
//although C inherits A.m1

//to access the overridden method, let's call the
//method that uses super
thec.overridden(56);
}
}

Hiding (by class methods):
Note:
1. a static method does not hide an instance method otherwise a compile time error.

package examples;

public class A {
static void m1(int enter){
System.out.println("A enters with "+enter);
}
}

public class C extends A{
static void m1(int enter){
System.out.println("C enters with "+enter);
}

//accessing the static method, m1 of A
void overridden(int enter){
super.m1(enter);
}
}

class Loader {

public static void main(String[] args) {
//m1 of A is overridden
C.m1(30);

//we can access A.m1 though these ways
//a. using the qualified name
A.m1(60);

//b. calling the super through method overridden
C thec = new C();
thec.overridden(60);
}
}

Requirements in Overriding and Hiding: 2 requirements are:
1. return type substitutability for the overriding method on the overridden
2. the throws clause should be a subtype of the throws in the overridden method.
3. the access modifier on an overriding or hiding method must provide at least as much access as the overridden method, d4
a. if the overridden method is declared public, then the overriding method must be declared public otherwise a compile time error
b. if the overridden method is declared protected, then the overriding method must be declared protected or public.
c. If the overridden method has default access (package-private), then the overriding method cannot be private.

Overloading: overloading occurs when two methods of a class (whether both are declared, or both are inherited, or one is declared and the other inherited) have the same name but signatures that are not override equivalent.
Note that overriding on methods occurs on a signature-by-signature basis

CLASSES(5)

2007-04-13T03:02:00.000-07:00

CLASSES(5)

Method Signature: two methods have the same signature if they have the same name and argument types. Two methods M and N may be said to have the same argument types if the following conditions hold:
- if they have the same number of formal parameters (possibly zero)
- if they have the same number of type parameters (possibly zero)
- if the formal parameters of M are and of N are if it is possible to replace each Bi in N with the As in M and you get a formal parameter list equal to that in M,
then, M and N have the same signatures.

The signature of a method m1 could be said to be the subsignature of a method m2 if either:
- m2 has the same signature as m1
- the signature of m1 is the same as the erasure of the signature of m2.
Note on subsignatures: this feature was incorporated into the java programming language to express a relationship between two signatures although not identical but one can override the other, a good example is allowing a method without generic types to override one with generic types.

it is a compile time error to declare two methods with override-equivalent signatures where override-equivalent signatures operate on two methods m1 and m2 if m1 is a subsignature of m2 or m2 is a subsignature of m1.

Method Modifiers: the method modifiers are:

public protected private abstract static final synchronized native strictfp

notes:
1. the same modifier cannot appear more than once for a method and public protected private have exclusive usage on each other.
2. if a method declaration contains the keyword abstract it cannot contain any of private static final native strictfp or synchronized.
3. if a keyword native is contained in a declaration it cannot contain strictfp any longer.
4. if there is an annotation a on a method declaration that corresponds to an annotation type T, and T has a meta-annotation m such that m corresponds to annotation.Target, then m has an element with value annotation.ElementType.METHOD, or a compile time error results.
5. the other specified above for method modifiers is customary but not a must.

Abstract methods: the abstract modifier introduces a method as a class member, providing its signature, return type and throws clause but providing no implementation for the method. Abstract methods must appear within abstract classes otherwise a compile time error results. An Enum declaration though can contain an abstract method. If an abstract class is to be subclassed, then that subclass must provide an implementation for its abstract methods, otherwise, a compile time error results.

A private method cannot be declared abstract because a private method cannot be implemented from outside the class.

It is an error for a static method to be declared abstract because invocation of such a method through its qualified name will return a compile time error.

It is a compile time error for a final method to be declared abstract because final methods will never allow a subclass to implement this method or any other method because the implementation is finished and perfect.

An abstract class can override another abstract class by providing an abstract method declaration, giving a facility for detailed specification or loosened specification to be attached to that method.

An instance method that is not abstract can be overridden by an abstract method.

Static methods: a method that is declared static is called a class method. A static method cannot be declared abstract. A static method is invoked with reference to the class and not to any particular object. Use of the keywords this or super in referencing a class method will result in compile time error.

On the other hand, a method that is not declared static is called an instance method and is invoked with respect to a particular object, which is the object which the keywords this or super refer to during execution of the method.

Final methods: a method is declared final to prevent subclass overriding or hiding of the method, attempting to do so results in compile time error. A private method and all methods declared within a final class all behave as if they are final because they cannot be overridden.

A final method can never be declared abstract.

Note that final methods on invocation are inlined by the optimizer or machine code generator.

Native methods: a method that is native is implemented in platform-dependent code, typically written in another programming language, typically C, C++, FORTRAN or Assembly language. The body of a native method is given as a semicolon only, indicating that the implementation is omitted, in place of the method’s body or block.

See §8.4.3.4 of the jls for an example.

Strictfp methods: the effect of strictfp modifier in methods is to make sure that all float or double expressions within the method body are FP-strict.

Synchronized methods: a synchronized method acquires a monitor of an object or class before it executes. If the method is a class (static) method, the monitor associated with the Class object for the method’s class is used, else if an instance method, the monitor associated with the this object is used.

Generic methods: a method is generic if it declares one or more type variables, these being the formal type parameters of the method. The form of the formal type parameter list is identical to that of a class or interface.

The scope of a method’s type parameter is the entire declaration of the method, including the type parameter section. Hence, type parameters can appear as part of their own bounds, or as bounds of other type parameters declared in the same section.

Type parameters for methods are almost always inferred on invocation of the method, so they need not be explicitly provided.

Method return type: the return type of a method states whether the method doesn’t return a value, declared as void, or the type of value a method returns, if it returns a value.

Notion of return type substitutability: two methods are return type substitutable is the following conditions hold for both methods return types:
1. if one of the return types is a primitive type, then the second return type is identical to the first.

//return types for both methods identical
int myMethod(){}

int yourMethod(){}

2. if one of the return types is a reference type, then the other is substitutable to the first if it is a subtype of the earlier or can be converted to a subtype of the earlier by an unchecked conversion.

//where Lagos class was declared to extend Nigeria
//these two methods are return type substitutable
Nigeria myMethod(){}

Lagos yourMethod(){}

3. if the erasure of one of the return types is equal to the raw type of the other.
4. if one is void, then the other is void.

(to be continued)

CLASSES(4)

2007-04-13T03:01:00.000-07:00

CLASSES(4)

Initialization of fields: a field declaration with a variable initialiser has the semantics of an assignment to the declared variable and,
- if the declaration is for a class variable (i.e not a static field), then the variable initialiser is evaluated and exactly a single-time assignment performed, when the class is initialized. If the evaluation of a variable initialiser for a static field of a named class(or an interface) can complete abruptly with a checked exception, then this is a compile-time error.
- If the declaration is for an instance variable, (i.e a field that is not static,), then the variable initialiser is evaluated and the assignment performed each time an instance of the class is created. If an instance variable initialiser of a named class can throw a checked exception, then there is a compile time error, otherwise that exception or one of its supertypes is explicitly declared in the throws clause of each constructor of its class and the class has at least one explicitly declared constructor.
An instance variable initialiser in an anonymous class can throw any exception.

Initialization of class variables:
a. any reference to the simple name of an instance variable will result in an error in a class variable initialization expression..
b. use of the keyword this or super in a class variable initialization expression will result in an error.
c. Class variables declared final and initialized with compile time constants will always be initialized first, whether in classes or interfaces.
d. A restriction is placed on using a class variable before its textual declaration, whether or not the class variable is in scope.

Initialization of instance variables:
a. initialization expressions for instance variables may refer to the simple names of class variables.
b. The expression may use the keyword this and super .
c. Restrictions exist on the use of an instance variable before its textual declaration.

Restrictions on the use of fields during initialization:
The declaration of a member of a class needs to appear textually before usage only if the member is an instance (respectively static) field of a class that directly encloses it and the following conditions hold:
a. the usage occurs in an instance variable initialiser(respectively static) of the enclosing class or in an instance initialiser (respectively static) of the enclosing class.
b. The usage is not on the leftmost side of an assignment
c. The usage is via a simple name
d. This class is the innermost class enclosing the usage.

Note: take usage to refer to the main method’s class and you’ll understand why following the rule that you should try to textually declare before usage can really save you some grief. If usage was within same class as instance variable, then static modifiers for the variable would be a must requirement.

METHOD DECLARATIONS:
A method declares executable code that can be invoked, passing a fixed number of values as arguments.

The formal notation for method declaration is: MethodHeader MethodBody

We’ll treat MethodHeader first.

The MethodHeader consists of :
MethodModifiersopt TypeParametersopt ResultType MethodDeclarator Throwsopt

The MethodModifiers, TypeParameters and Throws sections will be discussed shortly. The ResultType signifies the type of value that the method returns and this could be void, that means, it doesn’t return any value, or a recognized type.

The MethodDeclarator has the following notation: identifier (FormalParameterListopt)
The identifier is used in a name to refer to a method.

Try to avoid using same names for methods, classes, fields, member classes or interfaces even if they do not result in compile time errors.

Using two methods with the same signatures (name, number of parameters and types of parameters), will result in a compile time error.

Formal Parameters: the formal parameters of a method or constructor, if any, are specified by a list of comma-separated parameter specifiers.

The parameter specifiers have the notation:
VariableModifiers Type VariableDeclaratorId

Taking them one by one, the VariableModifiers are one or both of final and an annotation. The type specifies the allowed type of the arguments for the method and the VariableDeclaratorId could be an identifier or an array of the specified type. The specification here is for a fixed arity parameter or a case where the number of parameters that are allowed are known, finite and specified as to number. Where the number of allowed formal parameters are not specified, the method is said to have a variable arity parameter of the form methodname(Type… id ) where id is either a simple name or an array of the specified type.
A compile time error occurs if two methods or constructors possess the same formal parameters when they have the same identifier or names.

If an annotation a on a formal parameter corresponds to an annotation type T, and T has a (meta-)annotation, m such that m corresponds to annotation.Target, then m must have an element whose value is element.ElementType.PARAMETER, otherwise a compile time error is issued.

When the parameter of a method is declared final, it is a compile time error to attempt to assign the parameter within the body of the method.

Note that on invocation of a method or constructor, the arguments passed to the method initialize newly created parameter variables each of the Type mentioned in the formal parameter of the method and passed as their simple names before usage in the method body. Note that the identifier mentioned as a parameter in the method declaration may be used to refer to the formal parameter in the body of the method.

Never declare parameter names in local variables of a method or as exception parameters of catch clauses in a try statement of the method or parameter. However, if a method contains a nested class declaration, the parameters of the method may be shadowed inside the nested class. Note though that the nested class should be a local class or an anonymous class.

Never use a qualified name to refer to a formal parameter, only simple names.

If a parameter contains a parameter of type float the value of the float should be in the float value set, and if in the extended-exponent value set this should map well to the float value set otherwise a compile time error results. Same goes for parameters of type double.

But where an actual argument expression corresponding to a parameter variable is not FP-strict, during evaluation of the actual argument expression, intermediate values from the extended-exponent-value set can be used, but prior to being passed to the parameter variable par value, these values have to be mapped to the corresponding value set by method invocation conversion.

An example that illustrates other features pertaining this topic:

package examples;

public class MyMethod {
String terms;

//this method returns no value and has fixed arity parameters,
//which are 1 in number.
void simpleMethod(final String builder){
//we'll refer to the arguments passed with the name
//builder and because of final, it can not be assigned
System.out.println("What was passed was a String,
"+builder);
}

//this method has variable arity parameters, which is considered
//to define a String[]. so am querying the length here.
void variablearity(String... somestrings){
System.out.println(somestrings.length+" parameters were
passed.");
}

//this method has no parameters, empty pair therefore in
//parentheses
String noparam(){
return terms;
}
}

class Loader {

public static void main(String[] args) {
MyMethod thema = new MyMethod();

//new variable initiallized on invocation of simpleMethod
//with type String
thema.simpleMethod("foobar");

//on invocations of a variable arity method, you can define
//how much parameters to pass yourself
thema.variablearity("oh boy", "terrific!", "humdrum");
System.out.print("later ");
thema.variablearity("naughty", "ohlolo", "tellme",
"finale");
}
}

(to be continued)

CLASSES(3)

2007-04-13T03:00:00.000-07:00

CLASSES(3)

Superinterface: the optional implements clause in a class declaration introduces the names of interfaces that are direct superinterfaces of the class being declared.

Notation: interfaces:
implements InterfaceTypeList
where InterfaceTypeList may be one or many and are denoted by a TypeParameter specification which might be generic i.e TypeDeclSpecific TypeArgumentsopt

Given a class that could possibly be generic (C, n≥0, c≠Object),the direct superinterfaces of that class type are the types given in the implements clause of the declaration of C where C is a generic class declaration i.e (C, n>0), given a parameterized class type C where each T, denoted Ti, for 1≤i≤n, is a type, the direct superinterface of these parameterized class type are all types in the form I where I is a direct superinterface of C and theta is the substitution [F1 := T1, …, Fn := Tn].

Note:
1. each interface must name an accessible interface type
2. if type name is followed by type arguments, it must be invoked as-is, i.e as declared.
3. type arguments can never be wildcard if 2 is true.
4. an interface can not occur in an implements clause more than once.

An interface I is a superinterface of class type C if any of the following is true:
- I is a direct superinterface
- C has some direct superinterface J for which I is a superinterface.
- I is a direct superinterface of the direct superclass of C

(see jls for a simple, beautiful illustration in the section §8.1.5)

A class may not at the same time be a subtype of two interface types which are different invocations of the same generic interface (because they have similar erasures), or an invocation of a generic interface and a raw type naming that same generic interface.

class B implements I //erasure is /I/
class C extends B implements I //erasure /I/, similar to above

therefore, C cannot implement a type erasure twice.

Class body and Member declarations: a class body may contain declaration of members of a class, that is, fields, methods, nested class and interface declarations. A class body may also contain instance initialisers, static initializers, and constructor declarations.

The scope of member declarations in any class, whether explicitly declared or inherited, is the entire body of the class.

On shadowing, see the “Names, scope of a declaration” blog.

CLASS MEMBERS:
The members of a class type are all one of the following:
- members inherited from its direct superclass, except for class Object, which has no direct superclass.
- Members inherited from any direct superinterface.
- Members declared in the class body.

If a member is declared private, it cannot be inherited by subclasses of that class, but where declared as protected or public, other packages other than the one in which it is declared can inherit it.

The types of members of a class are denoted as:
a. for a field, its type
b. for a method, an ordered 3-tuple consisting of:
a. argument types: a list of the types of the arguments to the member method.
b. Return type: a return type of the method member
c. Throws clause: exception types declared in the throws clause of the method member.
Note: constructors, static initialisers and instance initialisers are not members and therefore are not inherited.

(there are fine examples in the jls at section §8.2 that well illustrate this concept.)

FIELD DECLARATORS: the variables of a class type are introduced by field declarations. Field declaration is of the notation:
FieldModifiersopt Type VariableDeclarators ;
Variable declarations can be one or many and are indicated by a variable identifier that could be a simple or qualified name or a name that is an array type. If a field is initialized on being declared, then it is done so with an expression or an appropriate array initialiser.

package examples;

public class AnyClassWithVariable {
//myfirstvar, mysecondvariable, simple named variables
//am sure you can do qualified names easily!!!
int myfirstvar;
float mysecondvar = 0.006453f; //initialised and declared

//an array variable stringer, not initialised
String[] stringer = new String[3];

//another that is initialised
int[] twoshort = {3, 5, 7};
}

Note:
1. a compile time error is reported if the body of a class declaration declares 2 fields with the same name, but methods, types and fields may have the same name since they are used in different context and disambiguated by different lookup.
2. Hiding fields: a field declared in a subclass with the same name as another in a superclass will hide the field in the superclass or superinterface. Hiding here corresponds to resolution mechanism for field name conflicts. In hiding, the 2 fields may have different type.
3. Shadowing fields: declarations of any accessible field in enclosing classes or interfaces, and any local variable, formal method parameter and exception handler parameter with the same names as that field will result in shadowing.
An illustration:

package examples;

public class AnyClassWithVariable {
//myfirstvar, mysecondvariable, simple named variables
//am sure you can do qualified names easily!!!
int myfirstvar;
float mysecondvar = 0.006453f; //initialised and declared

//an array variable stringer, not initialised
String[] stringer = new String[3];

//another that is initialised
int[] twoshort = {3, 5, 7};

//shadowing of mysecondvar, reflected in main of Loader
void shadowMethod(){
float mysecondvar = 0.098765f;
System.out.println(mysecondvar); //sure to shadow
}
}

public class ClassAndVariable extends AnyClassWithVariable {
int myfirstvar = 400;
}

class Loader {

public static void main(String[] args) {
AnyClassWithVariable tester = new AnyClassWithVariable();

//mysecondvar in scope of class declaration
System.out.println("global mysecondvar is:
"+tester.mysecondvar);

//here shadowed in shadowMethod
System.out.print("global mysecondvar is shadowed by
method's mysecondvar: ");
tester.shadowMethod();

//to start to show hiding, we instantiate the subclass
ClassAndVariable test2 = new ClassAndVariable();

//which myfirstvar int field will test2 give us
System.out.println("Of the two myfristvar fields, test2
gives: "+test2.myfirstvar);
System.out.println("which is hiding the uninitialised one,
AnyClassWithVariable.myfristvar.");

//to get this field, use the qualified name within the
//method scope
}
}

Field modifiers: field modifiers are one of the following:

public protected private static final transient volatile

the appearance of a field modifier must be distinct although ordering is not defined, the above order is customary in java programming.

If an annotation a corresponds to an annotation type T, then T has a (meta-)annotation m that corresponds to annotation.Target, then m must have an element whose value is annotation.ElementType.FIELD, or a compile-time error results.

Static fields: if a field is declared static, there exists exactly one incarnation of the field, no matter how many instances (or zero) of the class that may eventually be instantiated. A static field is sometimes called a class variable and is instantiated on class initialization.

A field not declared static (or called a non-static field) is called an instance variable. An instance variable has distinct incarnations for every instance of a class.
(see the example in §8.3.1.1 for class and instance variable distinction. Well explained. )

Final fields: class and instance variables can be declared final.

It is a compile time error if a blank final (a final variable whose declaration lacks an initializer) class variable is not definitely assigned by a static initialiser of the class in which it is declared.

A blank final instance variable must be definitely assigned at the end of every constructor of the class in which it is declared, otherwise, a compile time error results.

Transient fields: variables declared transient will never be part of the persistent state of an object, such that the system service does not save this variable in persistent storage.

Volatile fields: when a variable is accessed by more than one thread with at least one write operation on the variable followed by any number of reads, the java programming language gives the programmer the facility of locking the variable to ensure consistent and reliable updating of the variable. The modifier volatile supplements this locking making sure that the java memory model gives all threads a consistent value for this variable.

(to be continued)

CLASSES(2)

2007-04-13T02:58:00.000-07:00

CLASSES(2)

Inner classes and enclosing instances: any class within another class is said to be nested, but a nested class that is not implicitly or explicitly declared static is said to be an inner class.
Examples illustrating rules on inner classes:

package examples;

class ByTheWay {
static int x = 4;
}

class MyOuter {

//nested class declared static
static class NotInnerClass{

//nested non-inner class can declare static members
//freely
static void trialMethod(){}

}

//nested class, not declared static, d4 inner class
//extending ByTheWay makes Inner inherit a static member, note
class InnerClass extends ByTheWay {

//if inner classes are to declare static members, they
//must be constants
static final String candeclare = "declared";

}

//nested member, interface, implicitly static
interface ImplicitStaticMember{

}

}

And here’s another example that deals with enclosing instances and static contexts.

package examples;

class AnotherExample {
String name="david";
//this inner class, MyInner, occurs in a static context
//due to static oldmethod. therefore it's lexically enclosing
//block that of oldmethod and it has no lexically enclosing
//class
static void oldmethod(){
final int m = 6;
class MyInner {
int y = m; //to use m in MyInner, declare it final
}
}

//inner class without a static context and the immediately
//lexically enclosing class of Without in AnotherExample
class Without {
String name="micheal";
}
}

class Loader {

public static void main(String[] args) {
//since the immediately enclosin instance of Without is
//AnotherExample, reflected in the instance creation
//constructor invocation for any object of type, Without.
//the name field exists for both classes
//creator attaches to its local field in scope
//i.e no naming conflict in same variable for inner and
//its enclosing variable
AnotherExample.Without creator = new AnotherExample().new
Without();
System.out.println("creator knows its name which is:
"+creator.name);

//AnotherExample is the 0th lexically enclosing instance
//of itself, i.e associated only with itself.
AnotherExample myself = new AnotherExample();
System.out.println("Associated with myself, i am:
"+myself.name);

}
}

Superclasses and Subclasses: the optional extends clause in a normal class declaration specifies the direct superclass of the current class.

Notation: super:
extends ClassType
a class is said to be a direct subclass of its direct superclass where the direct superclass is the class from whose implementation the implementation of the subclass is derived.

The direct superclass of an enum type E is Enum.

The extends clause must not appear in the definition of the class Object, because Object is a primordial class and has no direct superclass.

Given a class declaration which could possibly be or not be generic, i.e (C, n>0, c≠Object), the direct superclass of the class type is the type given in the extends clause when C is declared else Object becomes the direct superclass.

If C is a generic class declaration (C,n>0), given a parameterized class type C where for each T, i.e Ti, 1≤i≤n, T is a type, the direct superclass is D, where D is the direct superclass of C and theta is the substitution [F1 := T1, …, Fn := Tn].

Notes:
1. the class type must be an accessible, existing class type.
2. the class type must allow subclassing i.e should never be declared final
3. the class type must never name the class Enum or any of its invocations
4. you should always invoke parameterized types correctly, as declared and never invoke a wildcard type variable.

A subclass relationship is a transitive closure of the direct subclass relationship i.e if class A is a subclass of class C, then either of the following is true:
- A is direct subclass of C
- There exists a B such that A is a subclass of B and B is a subclass of C, applying this definition recursively.

A class C directly depends on a type T if T is mentioned as an extends or implements clause of C either as a superclass or superinterface, or as a qualifier of a superclass or superinterface name.

A class C depends on a reference type T if any of the following are true:
- C directly depends on T
- C directly depends on an interface I that depends on T
- C directly depends on a class D that depends on T.
Note: a class cannot depend on itself.

(to be continued)

CLASSES

2007-04-13T02:57:00.000-07:00

CLASSES
Class declarations define new reference types and describe their implementation. This chapter dwells on members of a class, class semantics as well as meanings of access modifiers applied to classes and members of classes.

Class declarations: a class declaration defines new reference types. A class declaration can be either a normal class declaration or an enum declaration.
The notation for a normal class declaration is as below:
ClassModifiersopt class identifier TypeParametersopt Superopt Interfacesopt ClassBody

A class declaration is introduced by the keyword class which can be preceded by an optional access modifier. The identifier in a class declaration specifies the name of a class. We’ve discussed names and meaning of names in an earlier blog. If a class declaration has TypeParameters specified, which is optional, then it is a generic class and in a class declaration, only one optional superclass can exist while any number of interfaces, also optional, can be implemented. The ClassBody is enclosed in opening ‘{‘ and closing ‘}’ wherein the codes for class behaviour and storage spaces are defined.

Class Modifiers: more than one class modifier can be specified for a class. The modifiers that can be attached to class declarations are:

public (applied only to top level classes and member classes. )
protected (applies only to member classes)
private (applies only to member classes)
abstract
static (applies to member classes)
final
strictfp

please note that a compile time error will occur if the same modifier appears more than once in a class declaration. If an annotation on a class declaration, a, corresponds to an annotation type, T and T has a (meta-)annotation m such that m corresponds to annotation.Target, then m must have an element whose value is annotation.ElementType.TYPE or a compile time error occurs.

Abstract classes: an abstract class is a class that is considered incomplete. Note that only a class declared abstract is allowed to have abstract methods, otherwise, a compile time error occurs.

Enum types (in a later blog, please) must not be declared abstract, otherwise, a compile time error occurs. An Enum type is only allowed to declare a method as abstract if it has one or more enum constants with class bodies that provide concrete implementation of the abstract method.

A class C can have abstract methods from any of the 3 ways:
- if C explicitly declares an abstract method (remember, from what we discussed, to do this C has to be abstract itself.)
- if any of C’s superclasses have an abstract method and C neither declares nor inherits a method that implements this method.
- a direct superinterface of C declares or inherits a method (interface are necessarily abstract; to be discussed later) and C neither declares nor inherits the method that implements it.

The example in the jls will be restated here, not for redundancy’s sake but to clarify some points explained therein.

package examples;

//Point is declared abstract because it contains
//an abstract method, alert()
abstract class Point {
int x=1, y=1;
void move(int dx, int dy){
x += dx;
y += dy;
alert();
}
abstract void alert();
}

//ColoredPoint must be declared abstract since it
//inherits alert() from Point and doesn't implement it
abstract class ColoredPoint extends Point {
int color;
}

//SimplePoint although subclass of Point is not abstract
//because it implements alert()
class SimplePoint extends Point{
void alert(){
System.out.print("X is now: "+this.x+". ");
System.out.println("Y is now: "+this.y);
}
}

class Loader {

public static void main(String[] args) {
Point p = new SimplePoint();

//field initialisers and methods of Point can
//now be invoked. try it and see.
p.move(2, 2);
}
}

A class is declared abstract with the intent that subclasses can be created to complete the implementation but where one wants to create a class that needs not be instantiated, a better way to do this is to declare the class’ constructor as private, never invoke the constructor, declare it without arguments and declare no other constructor.
Final classes: a final class is a class whose definition is complete and no subclasses are desired or required for it.
Note:
1. a final class can be a superclass of another class
2. a class declared final can never be overridden because it doesn’t have subclasses
3. a class declared final can never be declared abstract

strictfp classes: the effect of modifying a class with the strictfp modifier is to make all float or double expressions within the class declaration to be explicitly FP-strict i.e strictly within the floating-point value set.

Generic Class and Type Parameters: a class is generic if it declares one or more type variables. These type variables are known as the type parameters of the class.
The type parameter section follows the class name and its delimited by angle brackets, ‘<’ and ‘>’. Note that the type parameters are sectioned in the type and their definition is within the generic class declaration. They share the same class at run-time.

Note:
1. generic classes do not throw exceptions i.e they can never be direct or indirect subclasses of the class Throwable.
2. the scope of a class’ type parameter is the entire declaration of the class including the type parameters section itself. Therefore, type parameters can appear as parts of their own bounds, and as bounds of other type parameters declared in the same section.
3. parameterized class declarations can be nested inside other declarations.

I tried to write a little example to this effect.

package examples;

public class Nigeria {
String name, gmt;
}

public class Ghana {
String name, gmt;
}

public class Africa {
//note: the field declaration for this class will be
//within the scope of the type variables
String name, gmt;
Africa(String countryname, String countrygmt){
this.name = countryname; //type has fields in scope
this.gmt = countrygmt;
}
}

class Loader {

public static void main(String[] args) {
Africa naija = new Africa("Nigeria",
"+1");
Africa kwama = new Africa("Ghana", "0");

//the sections in our generic class share same run-time
//class.
boolean b = naija.getClass()== kwama.getClass();
System.out.println(b);

//let's create a nigerian object
Nigeria mortar = new Nigeria();

//type variable Nigeria not same as class type Nigeria,note
System.out.println("Is type variable same as class type?
"+mortar.equals(naija));

//but class type can reference type variable
mortar.name = naija.name;
System.out.println("Mortar took a name which is: "
+mortar.name);

//we're certain now that we have the right name
System.out.println("In a section of africa there is a
country called: "+naija.name);
}
}

(to be continued)

PACKAGES (3)

2007-04-13T02:54:00.001-07:00

PACKAGES (3)

TOP LEVEL TYPE DECLARATIONS:
Top level type declarations declare a top level class type or a top level interface type.

Accessibility: the default accessibility (package-private) applies to this declaration, but if the declaration is public, access is granted to the type by codes from other packages.

Scope: the scope of this declaration is all type declarations in the package in which the top level type is declared.

For instance, where the package has name P and the type is named T, therefore , the fully qualified name is P.T, otherwise the fully qualified name is T, i.e where the type is in an unnamed package.

Note:
1. a restriction can always be enforced by a host system that if a type is not associated with a type name plus an extension (.java or .jav) and either:
a. the type is referred to by code in other compilation units of the package in which the type is declared
b. or the type is declared public (quite sure this’ your piece of cake!)
is true, then the host system should return a compile time error. So, there must be at most one such type per compilation unit.

In a database storage, this restriction might not be imposed.

2. a compile time error occurs if the name of a top level type appears as the name of any other top level class or interface type declared in the same package.

3. also, if (2) is also declared as a type by a single-type-import declaration in the compilation unit containing the type declaration, a compile time error occurs.
Please, see the examples in §7.6 of the jls; they are very instructive and I don’t want to create a redundancy.

UNIQUE PACKAGE NAMES:
Unique package names are essentially necessary when a package is not for local or casual usage but to be widely distributed for easy and automatic installation and cataloguing of packages.

Suggestions of usage:
1. unique package names are usually formed form internet domain names of the organization one belongs to. Example: if your internet domain is mydomain.com, these are usually used to derive unique package names. You reverse this name, component by component to obtain, com.mydomain and use this as a prefix for your package names. Usally, a convention is developed within organizations on how to administer package names using this domain name as base.

Where the internet domain name is not a valid package name for your case you can do the following:
a. where the domain name contains a hyphen or any other special character not allowed in an identifier, convert it into an underscore _ .
b. if any resulting package name components are keywords, then append an underscore to them.
c. If any of the resulting package name components start with a digit, or any other character not allowed as an initial character of an identifier, have an underscore prefixed to the component.

2. the first component of unique package names is always written in all lower-case ASCII letters and should be a top level domain name (currently com, edu, mil, net and org) or one of the English two-letter codes identifying countries as specified in ISO standard 3166, 1981.
com.mydomain.myjavafiles.me
edu.myschool.myschoolfiles._us

3. the name of a package is not meant to imply where the package is stored within the internet. The suggested convention above merely a convenience to piggyback a package naming convention on top of an existing, widely known unique name registry instead of having to create a separate registry for package names.

PACKAGES(2)

2007-04-13T02:48:00.000-07:00

PACKAGES(2)

IMPORT DECLARATIONS:
An import declaration allows a static member (in another type) or a named type (in another package) to be referred to by a simple name that consists of a single identifier. The appropriate word, import, is used in the declaration.
There are four types of import declarations:
1. single-type-import declaration (imports a single named type by mentioning its canonical name.)
2. type-import-on-demand declaration (imports all the accessible types of a named type as needed.)
3. single-static-import declaration (imports all accessible static members with a given name from a type, by giving its canonical name.)
4. static-import-on-demand declaration (imports all accessible static members of a named type as needed.)

the scope of any type imported is all the class and interface type declaration in the compilation unit in which the import declaration appears. It does not include, in its scope:
1. the package statement
2. other import declarations in the current compilation unit
3. other compilation units in the same package.

Single-type-import declaration: a single-type-import declaration imports a single type by giving its canonical name, making it available under a simple name in the class and interface declaration in the compilation unit in which the single-type-import declaration appears.

Denoted in this : import TypeName ;
Given a single-type-import declaration, d, the type imported, n, in a compilation unit, c, of package , p, shadows:
- any top level same-named type, d, in another compilation unit of p throughout c.
- any type with same name, n, imported by a type-import-on-demand declaration in c throughout c.
- any type with same name, n, imported by a static-import-on-demand declaration in c throughout c.

Type-import-on-demand declaration: a type import-on-demand declaration allows all accessible types declared in the type or package named by a canonical name to be imported as needed.

Denoted as: import PackageOrTypeName.* ;

Note:
1. the type or package must be accessible or a compile time error is the result.
2. when redundancy in importing is encountered, i.e where 2 or more type import-on-demand declaration names the same type or package, the effect is as if that type were imported only once.
3. if a type-import-on demand declaration and a static-import-on-demand declaration both import the same type in a compilation unit, the effect is as if the static member type of that type were imported only once.
4. a type import on demand declaration will never shadow any other declaration.
Considering a type imported as: import java.util.* ; into the class or interface type of this compilation unit,
5. a simple name Vector refers to a type Vector in java.util.Vector, provided Vector is a. not shadowed, b. obscured in its scope.
6. a single-type-import declaration with simple name Vector might shadow, java.util.Vector; an explicit declaration of a type Vector in the class or interface might shadow java.util.Vector; a nested class or interface with simple name Vector might also shadow it.
7. declaration of a field, parameter or local variable named Vector might obscure java.util.Vector.

Single static import declaration: a single-static-import declaration imports all accessible static members with a given simple name from a type.

Denoted as: import static TypeName.identifier;

The TypeName must be the canonical name of a class or interface type which exists and is accessible, otherwise a compile time error is the result.

The identifier must name at least one existing static member of the named type which is accessible, otherwise a compile time error occurs.
Note:

1. a static member, n, whether field or method name imported this way will shadow every other static-import-on-demand member n whether field or method with the same signature as the single static member.

2. any static type with the same name n imported by a static-import-on-demand declaration is also shadowed i.e
o any static type with same name n imported by static-import-on-demand declaration throughout the compilation unit.
o Any top level type named n declared in another compilation unit throughout the compilation unit
o Any type named n imported in a type import on demand declaration in the compilation unit throughout the compilation unit.

3. redundancy is allowed.

4. if the simple name of a member and a type imported by a single-static-import declaration and a single-type-import declaration respectively, a compile time error occurs.

5. if a single-static-import declaration imports a type n and the compilation unit explicitly declares same type n, a compile time error results.

Static import on demand declaration: a static-import-on-demand declaration allows all accessible type members declared in the type named by a canonical name to be imported as needed.

Denoted as: import static TypeName.* ;
Note:

1. the type used for importing must exist.

2. redundancy is allowed, either in types or members.

3. if a compilation unit contains a static-import-on-demand declaration and a type-import-on-demand declaration that name the same type, the effect is as if the static member types of that type were imported only once.

Automatic imports: all the public type names declared in the predefined package, java.lang are automatically imported.

PACKAGES

2007-04-13T02:43:00.000-07:00

PACKAGES

Programs are organized as set of packages, with each package having its own set of names for types, which will help prevent name conflicts. We know by now that if a type is top level and declared public it is generally accessible outside the package. The sections below discusses other features of packages.

Package Members: package members are:
1. subpackages
2. all top level class types
3. top level interface types
where 2 and 3 are declared in all the compilation units of the package.
Note:
a. if a package P has a subpackage Q, then the fully qualified name of the subpackage is P.Q
b. a package may not contain 2 members of the same name or a compile-time error results.
c. The hierarchical naming structure for packages is intended for convenience in related-packages organization but has no significance except to prevent package members from being same name.

Host support for packages:

Each host determines how packages, compilation units and subpackages are created and started, and which compilation units are observed in a particular compilation.

Compilation unit observability in turn determines which packages are observable and which packages are in scope.

Packages may be stored in a local file system or use a distributed file system or some form of database to store source and/or binary code.

Storing packages in a file system: imagine that a directory is used to store the packages that are used for a project, then each immediate subdirectory of the directory would represents a top level package i.e one whose fully qualified name consists of a single simple name.

e.g subdirectories might be java or com or one you created yourself, like api_package. The directory java might contain, amongst others, the subdirectories applet, awt, io, lang or util. these subdirectories then correspond to the packages java.applet; java.awt; java.io; java.lang; java.util which are defined as part of the java API.

Inside the util directory, we might get the following files:
BitSet.java, BitSet.class where the .java files contain the source code and the .class files contain the binary compiled files for a compilation unit that defines the class or interface.

So if we had something like: java.util.BitSet, then the directory structure in same a Windows file system will be java\util\BitSet i.e each package is said to have a top level directory where it is the subdirectory.

If a package name component or class name contains characters outside the allowed ranges (usually ASCII) of an Operating System’s directory naming scheme, the character outside the range can be escaped using the @ character followed by four hexadecimal digits giving the numeric value of the character, similar to the \uxxxx escape we earlier encountered in Unicode escaping.

Supposing we have a package name like this: children.activities.craft.papierM\u00e2ch\u00e9

which in Unicode will give us:
children.activities.craft.papierMâché

and this might be mapped to the directory name:
children\activities\craft\papierM@00e2ch@00e9 in Windows.

Note: if the @ character is not a valid character in a file name for some given host file system, then some other character that is not identifier-valid could be used instead.

Storing packages in a database:

When a host system stores programs, their compilation units and subpackages in a database, such a database must relax some restrictions on compilation units as found in file-based implementation, but provision should exist so that such a program can be exported to file-based implementation.

COMPILATION UNITS

A compilation unit is the goal symbol for the syntactic grammar of java. Note here that type dependence can be created amongst different compilation units i.e where a type contains another type as its member and that other type contains this type as its member.

A compilation unit consists of three parts, each of which is optional:

1. a package declaration, giving the fully qualified name of the package to which the compilation unit belongs. If there is no package declaration, then the package is an unnamed package.

2. import declaration that allows simple names use of types, given other packages and static members of types to be referred.

3. top level type declarations of class and interface types.

A host system determines which compilation units are observable but all compilation units of the package java and its subpackages java.lang and java.io must always be observable. The observability of a compilation unit affects the observability of the package.

Named Packages: a named package is one with a package declaration. A package declaration is defined thus:
Annotationsopt package PackageName ;

The keyword package may optionally be preceded by annotation modifiers. If an annotation a on a package declaration corresponds to an annotation type T, T has a (meta)annotation m that corresponds to annotation.Target, then m must have an element whose value is annotation.ElementType.PACKAGE, otherwise a compile time error occurs.

The PackageName in a package declaration must be the fully qualified name of the package.

Package annotations: annotations may be used on package declaration with the restriction that at most one annotated package declaration is permitted for a given package.

Unnamed Packages: a compilation unit where there is not package declaration is unnamed. Unnamed packages do not have subpackages.

Observability of a package: a package is observable if and only if either:
- a compilation unit containing a declaration of the package is observable.
- A subpackage of the package is observable.

Scope of a package declaration: provided that a package declaration is observable, the scope is all observable compilation units. Subpackage declarations are never in scope. Package declarations never shadow other declarations.

2007-04-10T04:01:00.000-07:00

NAMES(4)

Meaning of PackageNames:

if package name a simple name. then it denotes a package that exists at compile time otherwise error.
if a qualified name, Q.id, then Q is a package that has id as a member package of Q, i.e a subpackage, that exists at compile time otherwise a compile time error results.

Meaning of PackageOrTypeNames:

if a simple name. then it denotes a TypeName if the name Q occurs in the scope of a type named Q, else a PackageName.
let qualified name be Q.id. if member id of a type or package exists, then a TypeName, otherwise, a PackageName.

Meaning of TypeNames:

if simple name. if name consists of a single identifier, then the identifier must exist in the scope of exactly one visible declaration of a type with this name, or a compile time error occurs. The meaning of a type is a type.
if qualified name of the form Q.id. if id names exactly one type that is a member of the type or package denoted by Q, then the qualified type name denotes that type. A compile time error occurs if id does not name a member type within Q, or is not accessible in Q or id occurs more than once in Q, then compile time error occurs.

Meaning of ExpressionNames:

1. simple name or single identifier. There must be exactly one visible declaration denoting either a field, parameter or local variable in scope at the point at which the identifier occurs.

If declaration declares a final field, the name’s meaning is its value, otherwise meaning of the expression name is the variable declared by the declaration.

If the field is an instance variable, the expression name must appear within the declaration of an instance method, constructor, instance initializer or instance variable initializer. If within a static method, static initializer or initializer for a static variable, then a compile time error occurs.

2. qualified, of form Q.id. in this situation, the expression name, Q.id has already been classified as package, type or expression name.

- if Q is a package name, then a compile time error occurs.

- if Q a type name naming a class type, then

- there must be exactly one accessible member that is the field id otherwise a compile time error occurs.

- otherwise if the single accessible member is not a class variable (i.e declared stastic) then a compile time error occurs.

- otherwise if the class variable is declared final, then Q.id denotes the value of the class variable. The type of the expression Q.id is the declared type of the class variable after capture conversion. Note that Q.id should not appear in a context that requires a variable.

- otherwise, Q.id denotes the class variable. The type of the expression Q.id being the declared type of the class variable after capture conversion. This clause also covers the enum constants since these always have a corresponding final class variable.

- if Q is a type name that names an interface type

- there must be exactly one accessible member of the interface type, the field named id.

- otherwise Q.id denotes the value of the field. The declared type being the type of the field after capture conversion. If Q.id appears in a context that requires a variable and not a value, then a compile time error ensures.

- if Q is an expression name, let T be the type of the expression Q:

- T must be a reference type

- there must be exactly one accessible member of the type T named id.

- otherwise if this field is any of the following:

- a field of an interface type, or

- a final field of a class type (either a class or an instance variable)

- the final field length of an array type

Then Q.id denotes the value of the field. The declared type being the type after capture conversion. If the context requires a variable, a compile time error.

- otherwise Q.id is a variable, id, (class or instance variable). The type of the expression Q.id is the type of the field member after capture conversion.

MEANINGS OF METHOD NAMES

A method name appears only in a method invocation expression or as an element name in an element-value pair for annotations. Determination of the meaning of a name classified as a method name is as follows:

1. Simple Method Names: a simple method name appears as the element name in an element-value pair. The identifier in an element-value pair must be the simple name of one of the elements of the annotation type identified by TypeName in the containing annotation, otherwise a compile time error occurs.

Otherwise, a simple method name appears in the context of a method invocation expression.

2. Qualified Method Names: a qualified method name can only appear in the context of a method invocation expression. If given Q.id then Q has already been classified as a package name, a type name or an expression name. if Q is a package name, then compile time error results, otherwise id is the method name to be used for method invocation. If Q is a type name, then id must name at least one static method of the type Q. if Q is an expression name, then let T be the type of the expression Q; id must name one method of the type T.

ACCESS CONTROL: accessibility is a feature of the java programming language whereby access to details of entities in the language is allowed or otherwise disallowed. If allowed, the entity is said to be accessible.

Note: a. accessibility depends on type and declaration modifiers.

b. means of access to members of package and reference types are

– qualified names,

- field access expressions

- method invocation expressions

the three means above are called constructs for qualified access.

Access control applies to:

- qualified access

- the invocation of constructors by class instance creation expressions

- explicit constructor invocations

Determining accessibility:

package is always accessible
if a class or interface type is declared public, thus provided it is observable in its compilation unit, it may be accessed by any code, otherwise, where not public, access is from within the package in which it is declared.
an array type is accessible if and only if its element type is accessible
a member (class, interface, field or method) of a reference (class, interface or array) type or a constructor of a class type is accessible only if the type is accessible and the member or constructor is declared to permit access:

o if declared public (note: all members of interfaces are implicitly public)

o if declared protected, thus access is permitted for one of the following situations:

§ where access occurs from within the package containing the class in which the protected member or constructor is declared.

§ Access conforms to the section “details on protected access” (immediately below.)

o If declared private, access is permitted only within the body of the top level class that encloses the declaration of the member or constructor.

o Otherwise, there is default access (or package-private.) where access occurs only from within the package in which the type is declared.

Details on protected access: a protected member or constructor of an object may be accessed from outside the package (like public) in which it is declared only by code that is responsible for the implementation of that object, otherwise access is defined as:

An example:

package api_package;

public class T {

String monkey;

protected T(){ super();}

protected void throway(){}

}

public class S extends T {

String jungle;

S(){super();} //access permitted to T's constructor

//access to T's member, throway permitted from

//within this subclass.

void getFromT(){

throway(); //from T

jungle = monkey; //monkey from T

new T(); //anonymous class instance creation expression,

//allowed from protected superclass, T.

}

You can make up examples for all other modifiers or study that on the jls. Happy coding.

FULLY QUALIFIED NAMES AND CANONICAL NAMES: just read the jls. I can’t be rewriting what has already been written down. Redundancy in writing, methinks.

2007-04-10T03:54:00.000-07:00

NAMES (3)

DETERMINING THE MEANING OF A NAME: the meaning of a name depends on the context of usage. Name meaning determination requires 3 steps:

First step: context causes a name to syntactically fall into 1 of 6 categories of:

- PackageName

- TypeName

- ExpressionName

- MethodName

- PackageOrTypeName

- AmbigousName

Second step: if a name is initially categorized as PackageOrTypeName or AmbigousName, it is then reclassified to be either a

- PackageName

- TypeName

- ExpressionName

Third step: the resulting category then dictates the final determination of the meaning of the name (or a compilation error if the name has no meaning.)

Why use contexts for name determination? To minimize name conflicts between entities of different kinds.

Syntactic classification of a name according to context:

Syntactic classification of PackageName: either in a package declaration or to the left of the dot ‘.’ in a qualified PackageName.

Syntactic classification of TypeName: either of the following contexts,

- in a single-type-import declaration e.g import java.util.Vector

- to the left of the dot ‘.’ in a single static import declaration,

e.g import static Loader.name;

- to the left of the dot ‘.’ in a static import-on-demand declaration,

e.g import static Loader.*;

- to the left of the “<” in a parameterized type.

- In an actual type argument list of a parameterized type.

- In an explicit actual type argument list in a generic method or constructor invocation

- In an extends clause in a type variable declaration.

- In an extends clause of a wildcard type argument.

- In a super clause of a wildcard type argument.

- In an extends clause in a class declaration.

- In an implements clause in a class declaration.

- In an extends clause in an interface declaration.

- After the “@” sign in an annotation

- As a Type in any of the following:

1. in a field declaration

2. as the result type of a method

3. as the type of a formal parameter of a method or constructor

4. as the type of an exception that can be thrown by a method or constructor

5. as the type of a local variable

6. as the type of an exception parameter in a catch clause of a try statement.

7. as the type in a class literal

8. as the qualifying type of a qualified this expression

9. as the class type which is to be instantiated in an unqualified class instance creation expression

10. as the direct superclass or direct superinterface of an anonymous class which is to be instantiated in an unqualified class instance creation expression.

11. as the element type of an array to be created in an array creation expression.

12. as the qualifying type of field access using the keyword super.

13. as the qualifying type of a method invocation using the keyword super.

14. as the type mentioned in the cast operator of a cast expression.

15. as the type that follows the instanceof relational operator

Syntactic classification of ExpressionName:

- as the qualifying expression in a qualified superclass constructor invocation.

- As the qualifying expression in a qualified class instance creation expression.

- As the array reference expression in an array access expression.

- As a PostfixExpression.

- As the left hand operand of an assignment operator.

Syntactic classification of a MethodName,

- before the “(“ in a method invocation expression.

- To the left of the “=” sign in annotation’s element value pair.

Syntactic classificatioin of a PackageOrTypeName,

- to the left of the “.” in a TypeName

- in a type-import-on-demand declaration e.g import PackageOrTypeName.*;

Syntactic classification of an AmbiguousName,

- to the left of the “.” in a qualified ExpressionName

- to the left of the “.” in a qualified MethodName

- to the left of the “.” in a qualified AmbiguousName

- in the default value clause of an annotation type element declaration.

- To the right of a “=” in an element value pair.

Reclassification of contextually ambiguous names:

if the AmbiguousName is a simple name, i.e a single identifier

- if the appearance of the simple name is within the scope of a local variable, parameter declaration or field declaration, then reclassification as an ExpressionName.

- Otherwise, If a single-static-import declaration or static-import-on-demand declaration declares a field of that name, then reclassified as ExpressionName.

- Otherwise, if the identifier appears within the scope of a top-level class or interface type declaration, a local class declaration or member type declaration with that name, then reclassification as TypeName.

- Otherwise, if a type of that name is declared in a single-type-import declaration, type-import-on-demand declaration, single-static-import declaration or static-import-on-demand declaration, then reclassification of identifier as TypeName.

- Otherwise, reclassification as PackageName which is to be determined against existence.

if AmbiguousName is a qualified name, the name to the left of the dot “.” is first reclassified,

- if reclassified as a PackageName, check if a type declaration exists in the package that is similar to the identifier to the right of the “.”, if yes, then qualified name a TypeName, else a PackageName. Check for package existence.

- If reclassified as a TypeName, check if a member or field declaration exists in the class that is similar to the identifier to the right of the “.”, if yes, then qualified name an ExpressionName, else a TypeName. Check for compile time error.

- If reclassified as an ExpressionName, note the type T of the ExpressionName. If the identifier denotes a member or field in the type T, then classify as ExpressionName, else as TypeName if the identifier is a member type of T. check for compile time error.

NAMES (2)

2007-04-10T03:44:00.000-07:00

NAMES (2)
Shadowing declarations: when a declaration is in scope and visible at a point and another declaration using that name comes into being at the point, we say that the second same-named declaration shadows the first scoped and visible declaration at that point.

The example in §6.3.1 I believe is quite illustrative if you’ve been following this blog religiously. Questions?

Obscured declarations: where a simple name may potentially be referring to a variable, type or package, java will chose a variable in preference for a type and a type in preference to a package. Thus, in this situation, it may be impossible to refer to a visible type or package declaration via its simple name.
(Sorry, I tried obscuring in my favorite java compiler and it just keeps refusing my request. Maybe I was doing something wrong. Check yourself. )

MEMBERS AND INHERITANCE: Packages and reference types have members.

Members of type variables, parameterized types, raw types and intersection types: treated on earlier blogs.

Members of a package: the example below summarizes it.

package api_package;

//members of api_package are
//all top level class type of api_package
public class T {}

//all top level interface type of api_package
public interface IT{}

//all subpackages declared thus
package api_package.anotherpackage;

//Note: because a member of the package is T no other
//class type or interface type or subpackage which is
//member of this package can be so named!

The members of a class type: members of a class type are classes, interfaces, fields and methods. Members of a class are one of the following:
- members inherited from its direct superclass (if there is a superclass, otherwise from Object )
- members inherited from any direct superinterfaces
- members declared in the body of the class.
Note: constructors and type variables are not members of a class type.

package api_package;

public interface Colors {
int WHITE =0, BLACK = 1;}

public interface Separates {
int CYAN = 0, MAGENTA =1, YELLOW =2, BLACK =3;}

//TheClass inherits some fields from implemented interfaces
public class TheClass implements Colors, Separates{
//these are member fields declared
int x,y;
String mobi;

//this is a member method declared
void setClass(){}

//another member method declared with same name, setClass
//but different signature, note.the signature of a method
//is the simple name and the parameters of the method. setClass
//is said to be overloaded.
void setClass (int i){

}

//there is no restriction against a field, the String
//above and a method having same simple name, mobi!
void mobi (){}

//this is a member class declared
class InnerClass{}
}

public class Loader {
public static void main(String[] args){
//a class can only have two fields with the
//same simple names if they are declared in different
//interfaces and inherited, note!

//interface Colors, field BLACK
System.out.println("TheClass inherits a BLACK field from "
+ "Colors with value: "+Colors.BLACK);

//interface Separates, field BLACK
System.out.println("TheClass also inherits a BLACK field
from " +"Separates with value: "+Separates.BLACK);
}
}

The members of an interface type: the members of an interface type may be classes, interfaces, fields and methods. Members of an interface are:
- members declared in the interface
- those members inherited from direct superinterfaces
- every interface has an implicit undeclared method that is implemented by Object unless explicitly declared by the interface and if a method m is declared final in Object, no interface can explicitly declare it.
Note: type variables are not members.

Members of an array type: these section will be discussed in a later blog though, just illustrating with an example.

package api_package;

public class Loader {
public static void main(String[] args){
//aone array declared
int[] aone = new int[3];

//public final field, length, is a member of an array
System.out.println("aone array length is: "+aone.length);
for (int i=0; i<3;i++){
aone[i]=i;
System.out.println("Index "+i+" is "+aone[i]);
}

//the public method clone is a member that overrides
//same method in Object.
int[] atwo = aone.clone();
int pun = atwo.length;
System.out.println("atwo array length is: "+pun);
}
}

NAMES

2007-04-10T03:40:00.002-07:00

NAMES

Introduction: names are used to refer to entities declared in a program. Declared entities are package, class type (normal or enum type), interface type (normal or annotation type), member (class, interface, fields or methods) of a reference type, type parameters (of a class, interface, method or constructor), parameter (to a method, constructor or exception handler) or local variable.

This chapter discusses on types of names, scope of the declaration that introduces a name, members of entities such as package and reference types, and access control modifiers for the members of named entities.

The uses and meanings of names are also discussed.

Declaration: (these section should be retained as referential; most of the entities have already been discussed in blogs before this). A declaration introduces an entity into a program and it includes an identifier that can be used in a name to refer to this entity. A declared entity is one of the following:

1. a package, declared in a package declaration
2. an imported type, declared in a single-type-import declaration or a type-import-on-demand declaration.
3. a class, declared in a class type declaration.
4. a type variable, declared in a formal type parameter of a generic class, interface, method or constructor.
5. a member of a reference type, one of the following:
- a member class
- a member interface
- an enum constant
- a field, one of the following,
o a field declared in a class type
o a constant field declared in an interface type
o the field length which is implicitly a member of every array type
- a method, one of the following,
o a method (abstract or others) declared in a class type
o a method (always abstract) declared in an interface type
6. a parameter, one of the following,
- a parameter of a method or constructor of a class.
- a parameter of an abstract method of an interface
- a parameter of an exception handler declared in a catch clause of a try statement.
7. a local variable, one of the following,
- a local variable declared in a block
- a local variable declared in a for statement.

Note: constructors are also introduced by declarations, but use the name of the class in which they are declared rather than introducing a new name.

Names and identifiers:

First take it to heart that every name is an identifier but not all identifiers are names.
Where an identifier is also a name:
1. when the reference is to an entity declared in a program. These names can be simple names i.e single identifiers, or qualified names i.e a name with a ‘.’ token followed by an identifier.
Rules for determining the meaning of names will be in a later blog.
Where reference is not to an entity, then an identifier is not a name. identifiers that are not names are:
a. field acess expressions.
b. Method invocation expressions
c. In qualified class instance creation expressions.
d. As labels in labeled statements and in break and continue statements that refer to statement labels.

package api_package;

//we'll use a simple example here
//Loader is a name, refers to an entity
public class Loader {
String name; //name is also a name, entity variable

Loader(String givenname){
this.name=givenname;
}

int ageCounter(int anynumber){ //listPosition is a name
return anynumber*2;
}
public static void main(String[] args) {
//create an instance of Loader
//the qualified class instance creation expression
//is an identifier
Loader ourman = new api_package.Loader("Koro");

//method invocation expression is an identifier
int guessedage = ourman.ageCounter(15);

//we'll guess Koro's age
//the field access expression is identifier
System.out.print("This man "+ourman.name); //field access
System.out.print(" is really unbelievable for someone");
System.out.println(" above "+guessedage+" years.");
}
}

Scope of a declaration: the scope of a declaration is the region of a program within which the entity declared by the declaration can be referred to using a simple name(provided it is visible). A declaration is in scope at a particular point in a program if and only if the declaration’s scope includes that point.

Examples:
//api_package package is declared here, scope starts here
//and is observable here. scope ends on completion of every
//compilation unit in this package ends
package api_package;

//import declaration here, scope starts here, global type import
import java.io.Serializable;

public class Loader {
//scope of String type starts with its declaration here
//member scopesearcher has scope that is global, i.e in the
//entire body of class Loader
String scopesearcher;

//scope of parameter, expression is confined to the
//body of the method, setSearcher
void setSearcher(String expression){
try {
scopesearcher = expression;
//scope of myindex, local variable, starts from here
//to the end of this block
Integer myindex = 2;

//scope of n, exception handler parameter, is the entire catch clause block.
}catch (NumberFormatException n) {

}
}

//scope of type parameter, T in matchCase
//is the entire declaration of the method, and the
//type parameter's section itself.
void matchCase(T givennumber){

//scope of Forinit part, i.e i, includes the statements in
//parenthesis and the statements enclosed in the block.
//ends on block’s end therefore i can still be used
//outside the for statement.
for (int i=0; i<34; i++){
System.out.println(i);
}
}

//scope of HelpLoad, a local class, starts with its declaration
//to the end of the immediately onclosed block.
class HelpLoad{

}

public static void main(String[] args) {
}
}

CONVERSIONS AND PROMOTIONS(4)

2007-04-10T03:40:00.001-07:00

CONVERSIONS AND PROMOTIONS(4)

Assignment Conversions: assignment conversions occur when the value of an expression is assigned to a variable; the type of the expression must be converted to the type of the variable.

(as always, read the relevant sections of the jls, it’ll do u lots of good.)

public class Loader {
//note constants.
static byte first = 125;
static short second = 126;
static int fourth;

public static void main(String[] args) {
//assignment expression, by value.
fourth = first; //here, a widening primitive

//boxing conversion
Integer boxer = fourth;
System.out.println("value of boxer is: "+boxer);

//take the short constant, do narrowing primitive
//and then box it for an assignment conversion. if
//our short was outside byte range, it'll overflow
Byte firstbyte = (first = (byte)second );
System.out.println("Value of firstbyte is: "+firstbyte);

//therefore we can say the expressions above are
//assignable to the variables on the left by assignment
//conversion or assignment compatible
}
}

We’ve been doing assignment conversions since we encountered variables. This’ easy, right?

Method invocation expression: method invocation expression is applied to each argument value in a method or constructor invocation; the type of the argument expression must be converted to the type of the corresponding parameter.

public class Loader {
//first expression is constant, note.
static byte first = 125;
static short second = 126;
static int fourth;

void addSum(int thevar){
System.out.println("The sum is: "+thevar*2);
}
public static void main(String[] args) {
//method invocation conversion by identity conversion
Loader pupil = new Loader();

//identity conversion
pupil.addSum(fourth);

//widening primitive conversion, short to int
pupil.addSum(second);
}
}

Cough up examples of your own. Exciting!

String conversions: string conversions are effected on operands of binary operations when one of the arguments is a String. The other argument is converted to a String and a new String object, which is the concatenation of the 2 strings is the result of the operator +.

Casting conversion: casting conversion is applied to the operand of a cast operator; the integer of the operand expression must be converted to the type explicitly named by the cast operator.

public class Loader {
static Short i;
static Integer var;

public static void main(String[] args) {
S pss = new S();
T tee = new T();
//cast from S to T correct since S subclass
//of T.
tee = (T)pss;
//type from S to parameterized type T is correct
//but will be checked against erasure.
T mute = (T)pss;
}
}

The principles explained in detail in this section, §5.5 have been touched before except for arrays.

Numeric promotions: numeric promotions are applied to the operands of an arithmetic operator. Identity conversion, widening primitive conversion or an unboxing conversion can be used in numeric promotions.

Usage: used to convert the operands of a numeric operator to a common type so that an operation can be carried out.

Types: a. unary numeric promotion, b. binary numeric promotion.

A. UNARY PROMOTION:

Note:

1. in unary promotion, if the operand is of type Byte, Short, Character or Integer, it is unboxed and then promoted to type int by widening conversion or an identity conversion, else if byte, short, char, promotion to int is immediately carried out.

2. if the operand is of type Long, Float or Double, they are unboxed first and primitive type used. Value set conversion is next applied.

3. else the operand is left as-is.

Examples of expressions where unary promotion can be applied:

public class Loader {

public static void main(String[] args) {
byte b = 2;
int[] a = new int[b];//dimension expression promotion
char c = '\u0001';
a[c] = 1; //index expression promotion
a[0] = -c; //unary promotion
System.out.println("a: "+a[0]+" , "+a[1]);
b = -1;
int i = ~b; //bitwise complement promotion
System.out.println("~0x"+Integer.toHexString(b)
+"==0x"+Integer.toHexString(i));
i = b<<4L; //shift promotion, left operand
System.out.println("0x"+Integer.toHexString(b)
+"<<4L==0x"+Integer.toHexString(i));
}
}

B. BINARY NUMERIC PROMOTION: in binary numeric promotion, for a pair of operands, note that each of the operands must denote a value that is convertible to a numeric type. In binary numeric promotions, the following rules are applied, in order, using widening conversions:
- if any of the operands is of a reference type, unboxing conversion is performed then
- if either operand is of type double, then other is converted to double
- otherwise, if either operand is of type float, the other is converted to float.
- otherwise, if either is of type long, the other is converted to long
- otherwise, both operands are converted to type int.
After type conversion, value set conversion is applied to each operand.

Examples from the jls:

public class Loader {

public static void main(String[] args) {
int i = 0;
float f = 1.0f;
double d = 2.0;
//first int*float is promoted to float then
//float is promoted to double for double==double
if (i*f == d){System.out.println("oops!");}
else {System.out.println("correct maths!");}

//c&b is promoted to int&int
byte b = 0x1f;
char c = 'G'; //numeric value is 7
int control = c & b;
System.out.println(Integer.toHexString(control));

//int:float is promoted to float:float
f = (b==0)? i : 4.0f;
System.out.println(1.0/f);
}
}

CONVERSIONS AND PROMOTIONS(3)

2007-04-10T03:38:00.000-07:00

CONVERSIONS AND PROMOTIONS(3)

(Kinds of conversions):

7. BOXING CONVERSIONS: boxing conversions converts values of positive types to corresponding values of reference types.
- from type boolean to type Boolean
- from type byte to type Byte
- from type char to type Character
- from type short to type Short
- from type int to type Integer
- from type long to type Long
- from type float to type Float
- from type double to type Double

public class Loader {
public static void main(String[] args) {
//boxing from boolean to Boolean!
boolean p = true;
Boolean p2 = p;
System.out.print("According to the jls, ps is: ");
System.out.println(p2.booleanValue());
}
}

8. UNBOXING CONVERSIONS: this is BOXING CONVERSIONS the other way round. Note that a type is said to be convertible to a numeric type if it is a numeric type, or it is a reference type that may be converted to a numeric type by unboxing conversions. A type is said to be convertible to an integral type if it is an integral type, or it is a reference type that may be converted to an integral type by unboxing conversion.

9. UNCHECKED CONVERSION: if G is a parameterized type with n type parameters. There is an unchecked conversion from the raw type G to any parameterized type of the form G. A mandatory compile-time warning is generated in unchecked conversions.

public class Loader {
public static void main(String[] args) {
S pss = new S();
S maggie = pss;
}
}

10. CAPTURE CONVERSION: (sorry, my compiler does not allow wildcard parameters so at a loss on how to express this section. Will look for a way around this though.)

11. STRING CONVERSIONS: a string conversion to type String from every other type exists, including the null type.

12. FORBIDDEN CONVERSIONS: any non-explicitly allowed conversion is forbidden.

13. VALUE SET CONVERSION: value set conversion is the process of mapping a floating-point value from one value set to another without changing its type. Value set conversion occurs within expressions that are either or not FP-strict[1].

If an expression is FP-strict, the value set conversion must be within the float or double value set, to the nearest element, and may result in underflow or overflow.

If an expression is not FP-strict, the java programming language has optional value set conversion choices for implementation of the expression.
1. if the value is within the the float-extended-exponent value set, the implementation may optionally be to the nearest element of the float value set.
2. if the element is of the double-extended-exponent value set, then the implementation may optionally map the value to the nearest element of the double value set.

[1]. FP-strict expressions: these are expressions that are either 1, compile-time constant expressions , or b, if not the above then they must bear a strictfp modifier in its declaration. All FP-strict expressions provide intermediate values that lie within the floating-point value set.

CONVERSIONS AND PROMOTIONS(2)

2007-04-10T03:29:00.000-07:00

CONVERSIONS AND PROMOTIONS(2)

Kinds of conversions:

1. IDENTITY CONVERSIONS: these are conversions from a type to that same type. Although seemingly trivial, this has 2 practical considerations:
a. to begin with, to ensure desired expression typing
b. implies that programs are permitted to include redundant cast operations for clarity’s sake.

2. WIDENING PRIMITIVE CONVERSION: examples are:
- byte to short, int, long, float or double
- short to int, long, float or double
- char to int, long, float or double
- int to long, float or double
- long to float or double
- float to double

public class WideningPrimitive {
//variables that will engage in widening conversion
static byte first;
short second;
char third;
static int fourth;
long fifth;
static float sixth;
double seventh;

public static void main(String[] args) {
//a.widening primitive conversions do not
//lose info about the overall magnitude of a
//numeric value
first =120;
fourth = first;
System.out.print("from byte to int conversion gives: ");
System.out.println(fourth);

//int to float or double may lose precision in the
//least significant bit
fourth = 1234567890;
sixth = fourth;
//we should have a zero here.
System.out.print
("Subtracting same values though different types
gives: ");
System.out.println(fourth - (int)sixth);
}
}

3. NARROWING PRIMITIVE CONVERSIONS:
- short to byte or char
- char to byte or short
- int to byte, short or char
- long to byte, short, char or int
- float to byte, short, char, int, or long
- double to byte, short, char, int, long or float.

public class NarrowingPrimitive {
// variables for narrowing conversion
static byte first;
static short second;
static char third;
static int fourth;
static long fifth;
static float sixth;
double seventh;

public static void main(String[] args) {
//narrowing conversion loses magnitude and precision
fifth = +987654321;
second = (short)fifth;
System.out.println("The original, "+fifth+" and the converted, "+second);

third = '\u0098';
second = (short)third;
System.out.print("Narrowing a char, "+third+" to a short "+second);
}
}

4. WIDENING AND NARROWING PRIMITIVE CONVERSIONS:
- byte to char
This involve two steps, a widening conversion to int and then a narrowing to char.

5. WIDENING REFERENCE CONVERSIONS: widening reference conversions exist for any typye S to any type T, provided S is a subtype of T.

6. NARROWING REFERENCE CONVERSIONS: narrowing reference conversions consists of the following:
- from any type S to any reference type T, provided S is a proper supertype of T (special case: the narrowing conversion from the class type Object to any other reference type.)

public class S {}

public class T extends S {}

public class Loader {
public static void main(String[] args) {
S pss = new S();
T tss = new T();
tss = (T)pss; //to prevent run-time error,
//explicit casting done
}
}

- from any class type C to any non-parameterized interface type K, provided C is not final and does not implement K.

public class S {}

public interface K {}

public class Loader {
public static void main(String[] args) {
S pss = new S();
K mokay = (K)pss;
}
}

- from any interface type J to any non-parameterised class type C that is not final.

public class Loader {
public static void main(String[] args) {
//this is the above example other way round
K mokay = null;
S pss = (S)mokay;
}
}

- from the interface type Cloneable or java.io.serializable to any other type T[].
- from any interface type J to any non-parameterized interface type K, provided that J is not a subinterface of K.

public class Loader {
public static void main(String[] args) {
//where K and J are interface types
K mikay = null;
J jeekay = (J)mikay;
}
}

- from any array type S[] to any array type T[] provided that S and T are reference types and there is a narrowing conversion from S to T.

public class Loader {
public static void main(String[] args) {
//where S[] and T[] are arrays of reference types
//S and T.
S[] pss = new S[1];
T[] tee = new T[1];
tee[0] = (T)pss[0]; //first components pls.
}
}

CONVERSIONS AND PROMOTIONS

2007-03-30T04:57:00.000-07:00

CONVERSIONS AND PROMOTIONS

INTRODUCTION:
Type conversion is a facility in the java programming language whereby expressions whose type is not appropriately specified in a context can be implicitly converted from the type specified by the programmer to a type acceptable for its surrounding context.

A specific type conversion can also be asked for by a programmer. There is need for this in some cases:
a. to cause the java machine at run-time[1] to check for the validity of the conversion.
b. to cause a translation of the run-time value of the expression into a form appropriate for the new type.

The possible set of specific conversions in the java programming language are grouped into several broad categories:
- identity conversion
- widening primitive conversion
- narrowing primitive conversion
- widening reference conversion
- narrowing reference conversion
- boxing conversion
- unboxing conversion
- capture conversion
- String conversion
- Value set conversion

There are in addition 5 conversion contexts in which the conversion of expressions may occur. Each context allows conversion in some categories noted above but not in others.

Note that the term “conversion” is also used to describe the process of choosing a specific conversion for such a context. The 5 conversion contexts are:
- Assignment conversion: converts the type of an expression to the type of a specified variable.
- Method invocation conversion: this is applied to each argument in a method or constructor invocation and except in one case, performs the same conversion that assignment conversion does.
- Casting conversion: converts the type of an expression to the type explicitly specified by a cast operator
- String conversion: allows any type to be converted to type String
- Numeric promotion: brings the operands of a numeric operator to a common type so that ann operation can be performed.

(§5.1 of the jls has an example for the conversions above that I do not want to repeat. You can get it and study. )

Footers:

[1]. A run-time type refers to the classes of the object referred to by the value of the variable or expression at run-time, assuming that the value is not null.

TYPES, VALUES AND VARIABLES(11)

2007-03-30T04:56:00.000-07:00

TYPES, VALUES AND VARIABLES(11)

KINDS OF VARIABLES:
6. Exception handler parameter: an exception handler parameter is created each time an exception is caught by the catch clause of a try statement. The new variable is initialized with the actual object associated with the exception. The exception handler parameter ceases to exist when execution of the block associated with the catch clause is complete.

public class ExceptionHandler {
String name;

void writeName(String typed){

try{
name = typed;
}
//exception handler created here. variable of
//type NumberFormatException
catch (NumberFormatException n){
System.out.println("Wrong entry, please.");
}
}
}

7. Local Variable: is declared by a local variable declaration statement. When the flow of control enters a block or for statement, a new variable is created for each local variable declared in a local variable declaration statement immediately contained in a block or for statement.

A local variable declaration statement may contain an expression which initializes the variable. The local variable with an initializing expression is not initialized however until the local variable declaration statement that declares it is executed. The local variable effectively ceases to exist when the execution of the block or for statement is complete.

public class ArrayComponents {
//an array of integers as components
int[] five = new int[5];

//this method takes all the default values
//according to jls, 0 and prints them out.
void defaultvalue(){ //local variable declaration block
for (int i=0;i<5;i++ ){ //new variable i, for statement
System.out.print("The ");
switch(i){
case(0): System.out.print("first ");break;
case(1): System.out.print("second ");break;
case(2): System.out.print("third ");break;
case(3): System.out.print("fourth ");break;
case(4): System.out.print("fifth ");break;
default: ;break;
}
System.out.println("value is: "+five[i]);
}
}
}

Final Variables: a variable declared final may be assigned to only once. Never assign a once assigned final variable unless it has been unassigned prior to this.
A blank final is a final variable without an initializer in its declaration.
A final variable referring an object refers only to the object which returns its value. See example.
public class FinalExample {
static String bobby = "friend";
static final String drumboy = bobby; //refers to object

public static void main(String[] args){
System.out.println("Final drumboy is: "+drumboy);

//let's change the object
bobby = "enemy";

//but final will still refer to the first object
//you see why final is very useful?
System.out.print("Final drumboy after object reference change is: ");
System.out.println(drumboy);
}
}

Initial values of variables:
Every variable in a program must have a value before usage.
1. each class variable, instance variable, or array component is initialized with a default value when it is created.
- for type byte, the default is zero, (byte)0
- for type short, (short)0
- for type int, 0
- for type long, default is 0L
- for type float, default is positive zero, 0.0f
- for type double, default is positive zero, 0.0d
- for type char, the default value is the null character, i.e ‘\u0000’
2. each method parameter is initialized to the corresponding argument value provided by the invoker of the method
3. each constructor parameter is initialized to the corresponding argument value provided by a class instance creation expression or explicit constructor invocation.
4. an exception-handler parameter is initialized to the thrown object representing the exception.
5. a local variable must be explicitly given a value before use, either by initialization or assignment, in a compiler verifiable way using the rules for definite assignment.

TYPES, VALUES AND VARIABLES(10)

2007-03-30T04:54:00.000-07:00

TYPES, VALUES AND VARIABLES(10)

Heap pollution: When the possibility exists that a variable of a parameterized type refers to an object that is not of that parameterized type. Heap pollution can only occur if the program performed some operation that would give rise to an unchecked warning at compile time.

KINDS OF VARIABLES:
There are 7 kinds of variables:
1. class variables: in a class declaration a field is declared using the keyword static ; in an interface declaration, the field can be with(out) the keyword static.
Creation of class variables: when the class or interface is prepared and then initialized to a default value.

public class ClassVar {
//primitive and reference class variables prepared
static int number;

public static void main(String[] args) {
//they are now initialised, after initialisation
//you've created a class variable
number = 24;
}
}
2. Instance variables: an instance variable is a field declared in a class declaration without the keyword static. When instance variables occur in a class are created and initialized to a default value on the creation of a new object of the class or of any class that subclasses the class. An instance variable effectively ceases to exist when the object of which it is a field is no longer referenced, after any necessary object finalization[1] has been completed.

public class InstanceVar {
//primitive and reference class variables prepared
static int number;

//an instanc variable next
boolean monkey_tail; //default is false a la jls.
}

public class Loader {
public static void main(String[] args) {
//create an object of InstanceVar
InstanceVar mine = new InstanceVar();

//you'll realise that even without initialising
//it it is given default false
System.out.println(mine.monkey_tail);

//we can still assign it though
mine.monkey_tail = true;
}
}
3. Array components: these are unnamed variables that are created and initialized to default values whenever a new object that is an array is created. The array component effectively ceases to exist when the array is no longer referenced.

public class ArrayComponents {
//an array of integers as components
int[] five = new int[5];

//this method takes all the default values
//according to jls, 0 and prints them out.
void defaultvalue(){
for (int i=0;i<5;i++ ){
System.out.print("The ");
switch(i){
case(0): System.out.print("first ");break;
case(1): System.out.print("second ");break;
case(2): System.out.print("third ");break;
case(3): System.out.print("fourth ");break;
case(4): System.out.print("fifth ");break;
default: ;break;
}
System.out.println("value is: "+five[i]);
}
}
}
public class Loader {
public static void main(String[] args) {
ArrayComponents details = new ArrayComponents();
details.defaultvalue();
}
}
4. Method parameters: method parameters name argument values passed to a method. For every parameter declaration in a method declaration, a new variable is created each time that method is invoked, which is initialized with the corresponding argument value from the method invocation. The method parameter ceases to exist when the execution of the body of the method is complete.

public class MethodExample {
String id;
int tag;

//this method takes as parameters a String name
//and an integer as number.
void setName(String name, int number){
this.id=name;
this.tag=number;
}
}
public class Loader {
public static void main(String[] args) {
MethodExample taketwo = new MethodExample();

//method invocation. this passes the required
//arguments specified by the method parameter.
taketwo.setName("adewale", 42);
}
}
5. Constructor parameters: constructor parameters name argument values passed to a constructor. Each time a class instance expression or explicit constructor invocation invokes a constructor, a new parameter variable is created and initialized with the corresponding argument value from the creation expression or constructor invocation. The constructor parameter effectively ceases to exist when the execution of the body of the constructor is complete.

public class ConstructorExamples {
String name;
int tag;

//constructor without parameters
ConstructorExamples(){
this.name="nobody";
this.tag=0;
}

//this constructor has parameters
ConstructorExamples(String up, int number){
this.name = up;
this.tag = number;
}
}
public class Loader {
public static void main(String[] args) {
//invoking the constructor without parameters
ConstructorExamples beanpole = new ConstructorExamples();

//hey, what does it contain
System.out.println("Name: "+
beanpole.name+". Number: "+beanpole.tag);

//invoking the constructor with arguments
ConstructorExamples magpie = new
ConstructorExamples("elizabeth", 3);

//you contain something too not so?
System.out.println("Name: "+magpie.name+". Number:
"+magpie.tag);
}
}

Footers:

[1]. Object finalization: freeing up resources tat cannot be freed automatically by an automatic storage manager.

TYPES, VALUES AND VARIABLES(9)

2007-03-30T04:50:00.000-07:00

TYPES, VALUES AND VARIABLES(9)

Where types are used:
Types are used in declarations and expressions. Each of the usage below will be covered in subsequent blogs:
1. declarations:
- in imported types
- in fields
- as method parameters
- as method results (what a method returns)
- as constructor parameters
- as local variables
- as exception handler parameters
- as type variable

2. expressions
- class instance creation expressions
- generic class instance creation
- array creation
- generic method and constructor invocation
- casts
- the instanceof operator
- the arguments to parameterized types

VARIABLES:
A variable is a storage location and has an associated type, sometimes called its compile-time type, that is either a primitive type or a reference type.
All assignments to a variable are checked for assignment compatibility, usually at compile time but when involving arrays, a run-time check is made.
Variables of primitive types: these variables always hold a value of that exact primitive type.
Variables of reference types: let T be our reference type.
If T is a class type. It holds the following values:
A. a null reference e.g T var = null;
B. a reference to an instance of class T. e.g T secondvar = new T();
C. a reference to any class that is a subclass of T e.g
package api_package;

public class T {…}

public class Tsub extends T{…}

public class Loader {
public static void main(String[] args) {
T avar = new T();
Tsub anovar = new Tsub();
avar = anovar;
}
}

if T is an interface type, it can hold the following values:
a. a null reference
b. a reference to any instance that implements the interface.

public interface IT {}

public class T implements IT{}

public class Loader {
public static void main(String[] args) {
T avar = new T();
IT newvar = avar;
}
}

Note that a variable of type, array of T, T[], where
1. T is a primitive type can hold the following values:
a. a null reference
b. a reference to any array of type, T[]
public class Loader {
public static void main(String[] args) {
int[] nob = null;
int[] hope = nob;
}
}

2. T is a reference type, then a variable of type T[ ] can hold:
a. a null reference
b. a reference to any array of type, array of S, S[], such that type S is a subclass or subinterface of type T.

public class T implements IT{}

public class Tsub extends T{}

public class Loader {
public static void main(String[] args) {
T[] var = null;
var = new Tsub[1];
}
}

A variable of type Object[] can hold any array of any reference type.

A variable of type Object can hold:
a. a null reference
b. a reference to any object, whether class instance or array.

TYPES, VALUES AND VARIABLES(8)

2007-03-30T04:47:00.000-07:00

TYPES, VALUES AND VARIABLES(8)

TYPE ERASURE:
Type erasure is a mapping from types (possibly including parameterized types and type variables) to types (that are never parameterized types or type variables). We write |T| for the erasure of a type T.
Type erasure is defined as:
- erasure of a parameterized type G as |G|
- erasure of a nested type T.C as |T|.C
- the erasure of an array type T[] as |T|[]
- the erasure of a type variable is the erasure of its leftmost bound. For example, if
T extends M implements N, then its erasure M and if
T implements N, then its erasure is N.
- erasure of every other type in the type itself.
The erasure of a method signature, m(T t) is m and erasure of T.

REIFIABLE TYPES:
Types that are completely available at run-time, after erasures, are known as reifiable types. A type is reifiable if and only if:
- it is a non-reifiable type.
- If parameterized, it has unbounded wildcard as type argument.
- It is an array type whose component type is reifiable.
- It is a raw type
- It is a primitive type

RAW TYPES:
A raw type is a parameterized type derivation to facilitate interfacing with non-generic legacy code. It is either:
a. the name of a generic type declaration less the actual type arguments i.e S has as raw type, S.
b. any non-static type member of a raw type that is not inherited from a superclass or superinterface of R.

it’s important to note the discussion in the jls for §4.8, particularly the fact that it is better to insert the complete generics for a member of a generic type or the type itself when referring to them, but in interfacing to legacy code, check your erasures very well.

INTERSECTION TYPES:
An intersection type takes the form T1 … Tn, for positive n, n>0, where each T, Ti, is defined by 1≤ i ≤n , are type expressions. Intersection types arise in the processes of capture conversion[1] and type inference[2].

Realise that intersection types are not written directly as part of a program.

Members of an intersection type:
1. a class or interface type without any member and without any inherited members from a superclass is an intersection type. Its values should be null.
2. a superclass, Ck, for a class type, T, such that Ck, has a superclass, Ci, but Ck and Ci have the same and equivalent members.
3. interfaces implemented by a class type are intersection types.

SUBTYPING:
The subtypes and supertype relations are all binary relations on types.

A direct supertype relationship is written as >1 if S is a direct supertype of T, then S >1 T.
S :> T indicates that a supertype relationship exists between S & T. S is a proper supertype of T, written S > T, if S :> T and S ≠ T.

The subtype relationship is denoted by <: . We write T <: S to denote T has a subtype relationship with S. T is a proper subtype of S, written T < S if T <: S and S ≠ T.
T is a direct subtype of S, written as T <1 S if S >1 T.

Note: subtyping does not extend through generic types: T <: U does not imply C <: C.

Subtyping among primitive types:
double >1 float
float >1 long
long >1 int
int >1 char
int >1 short
short >1 byte

Subtyping among class and interface types:
if we have a declaration like this:

Given parameterized type, C where C is defined by C , the two argument types have ranges that are subtypes of their corresponding bounds. That is T1 is bound by an upper bound, B1 and T2 by a lower bound, B2.

Given C, the direct supertype of this parameterized type are all of the following:
1. the direct superclass of the erasure of the type or C
2. the direct superinterface of C
3. the type Object, if C is an interface type with no direct superinterface (i.e it has no declaratioin of the form: implements T ).
4. the raw type, C.

package api_package;

public class Nigerian {}

//the container type or supertype of Lagosian is
//Nigerian
public class Lagosian extends Nigerian{
public static void main(String[] args){
Lagosian you = new Lagosian();

//I can cast succesfully to the supertype
System.out.println((Nigerian)you);
}
}

Given a type C its direct supertype is D if:
1. D is a direct supertype of C and theta represents each C within each “cage” of D.
Example:
package api_package;

public class Nigerian {
String name="tunde";
}
//the container type or supertype of Lagosian is
//Nigerian
public class Lagosian
extends Nigerian{
}
public class Loader {

public static void main(String[] args) {
Lagosian you = new Lagosian();

//Lagosian can access yoruba
System.out.println(you.name);
}
}
2. C is a supertype where S1 contains T1 and S2 contains T2 respectively.

The direct supertypes of an intersection type are the members of the intersection type.
The direct supertype of a type variable are the types listed in its bound.
The direct supertype of the null type are all reference types other than the null type itself.

Subtyping among Array types:
The following rules define the direct subtype relation among array types.

1. if S & T are both reference types, then
- S[] >1 T[], iff S >1 T.
- Object >1 Object[]
- Cloneable >1 Object[]
- java.io.Serializable >1 Object[]

2. if p is a primitive type, then
- Object >1 p[]
- Cloneable >1 p[]
- java.io.Serializable >1 p[]

Footers:
[1]. Capture conversion, to be discussed later, denotes a conversion of generics to their equivalent type variables taking into account the superclasses and subclasses that the type variable will have a contract with.
[2]. This is a process of inferring type arguments from method and constructor invocations.

TYPES, VALUES AND VARIABLES(7)

2007-03-30T04:27:00.000-07:00

TYPES, VALUES AND VARIABLES(7)

This section, §4.5 needs just a little explanation and I’ve found it difficult to come up with an illustration, maybe as we go into later sections, one will spring up.

PARAMETERIZED TYPES:

A parameterized type consists of either one of a class or interface name C and an actual type argument list 1, …, T_N>. A compile time error results if C is not a class or interface name.

Vector //class or interface name, Vector. Arguments: accepts Integer.

Seq> //class or interface name, Seq. arguments: a generic class, Seq which

generic class has argument, A.

What this section is saying is that type variables could end up being parameterized types if declared so and that a parameterized type could be bounded by another type which bound is called the supertype. This type and its bound has a binary relation that defines the bound, and it is a proper supertype if the parameterized type is not equal to its bounding type.

On the other hand a type variable could have a supertype but when it is declared as a parameterized type, it’s supertype is the bounding on this parameter within this section of the class or interface and not the supertype when it was declared a type variable.

Type arguments and wildcards:

Type arguments are either:

A. Reference types.

B. Wildcards, which wildcard can be bounded with the words extends or super on a reference type.

Reference types have been dealt with above.

For a wildcard type argument, , if unbounded like below:

void printCollection(Collection c){

for (Object o: c){

System.out.println(o);

}

Then we say the wildcard allows any kind of Collection to be used as its parameter.

According to the discussion on §4.5.1 of the jls, assuming Object for a , which is natural, is discouraged in java because:

Object would be advisable to be explicitly stated if it is needed.
assuming acceptability of Object will probably be invalid because Object is rarely used as an argument.
the any parameter type is not enough for Object to be assumed

Features:

a. Wildcards are useful in situations when only partial knowledge about the type parameters is required.

b. wildcards may be given explicit bounds. An upper bound is signified by the syntax:

? extends B //where B is the bound

Using bounds on a wildcard is better than declaring genericity on method, if the type parameter is a method, although both methods could be used.

? super B //where B is the bound

c. 2 type arguments are provably distinct if neither of the arguments is a type variable or wildcard, and the two arguments are not the same type.

Not distinct: boolean addAll(Collection c) not distinct from boolean addAll(Collection c)

Distinct: boolean addAll(Collection c) distinct from, boolean addAll(Collection c)

TYPE ARGUMENT CONTAINMENT AND EQUIVALENCE: We’ll illustrate this using two classes, one NigerianPopulation class and LagosPopulation class. Let’s say NigerianPopulation class is defined by the numeric range i, where 10m ≤ i ≤ 130m and LagosPopulation is defined by the range j, where 3m ≤ j ≤ 5m. let’s assume that LagosPopulation is a subclass of NigerianPopulation,

Then LagosPopulation <: NigerianPopulation //LagosPopulation is a subtype of

NigerianPopulation

Where <= defines a contained in relationship

? extends LagosPopulation <= ? extends NigerianPopulation is true
? super LagosPopulation <= ? super NigerianPopulation is true
LagosPopulation <= LagosPopulation
LagosPopulation <= ? extends LagosPopulation
LagosPopulation <= ? super LagosPopulation

Members and constructors of parameterized types:

I’ll use just an example illustrating the notes in the jls:

package generic_example;

public class SecondGeneric {

Boolean makeBelieve = true;

String name;

//this method will be overridden

String getName(){

return name;

}

//the type parameters for FirstGeneric are

//String and Integer

public class FirstGeneric

extends SecondGeneric {

String name;

FirstGeneric(String thename){

this.name = thename;

}

//Note that the type of a method in this class

//corresponds to one of the type arguments of

//the class. type inference makes method genericity

//somewhat duplicative. the method's type is bound

//by the arguments that are substituting for each

//type parameter of the class. on extending

//the type of this method must be the same as the

//type of the method whose class is extended.

String getName(){

return name;

}

TYPES, VALUES AND VARIABLES(6)

2007-03-30T04:18:00.000-07:00

TYPES, VALUES AND VARIABLES(6)

TYPE VARIABLES:

(Note before: this sectiont contains components that will be expanded on in later blogs. If you have questions about any statement particularly the fact that I decided to produce a skeletal illustration, feel free. )

A type variable is an unqualified identifier. They are introduced by generic class declarations, generic interface declarations, generic method declarations and generic constructor declarations^[1].

Let’s think of typical declarations of type variables assuming our type variable is T and T may have superclass S and there are interfaces I₁, I₂.

a. where T is declaring a class.

class T extends S implements I₁, I₂ { }

Notes

1. a class can extend only one class, that is a class can have only one superclass otherwise compile time error.

2. extending and implementing are optional contracts T can chose to embark upon, if there is none, then superclass is Object.

3. the order of the bounds S, I₁, I₂ are important. A class implements only interfaces never another class.

4. if I₁, I₂ are parameterized types, they should not be the same erasures[2].

b. where T is declaring an interface.

Interface T extends I₁, I₂ { }

1. (2) above applies here.

2. (4) above also applies here.

3. an interface can extend any number of interfaces.

On the jls: the discussion on §4.4 is quite illustrative but for beginners, might be somewhat confusing, keep this for reference after parameterized types and modifiers are discussed.

Footers:

^[1]. Genericity: I can best try to define genericity in this terms, as the ability of a type to define what types it can accept as parameters within its “type entity” (what I can think of here is xml’s namespace).

For example, if a house is built with the stipulation that: “N has the first flat and D has the second flat and that is how it should be”, then we can call this house generic and declare it as,

class house {} //house is the type variable.

Generics will be dwelt with in the next blog and later, we’ll discuss the scope of generics.

^[2]. Erasures. Erasures are mappings from a generic type to a non-generic one. Assume a parameterized type P and P, both correspond to the same erasure |P|. Both M and P have different erasures, |M| and |P|.

SNIPPET: java.lang.String

2007-03-27T08:26:00.000-07:00

SNIPPET: java.lang.String

The java.lang.String class is final. This class represents character strings. Every string is an instance of this class. Strings are constant, immutable, and the value of a String instance can’t be changed after assignment, although the values can be shared. String buffers though are mutable.

package api_package;

public class CharacterObjects {

//we'll use our char to make strings

static char[] slimman = {'Y','A','R','\'','D','U','A'};

static char[] fatman = {'A','T','I','K','U'};

public static void main(String[] args) {

//we'll use a constructor that takes array of char

String slimstring = new String(slimman);

String fatstring = new String(fatman);

//we'll play with U like before.let's pick the letter

char container = slimstring.charAt(6);

//now what did we pick?

System.out.println("We picked "+container);

//i was wrong. i forgot this is index 0.

//let's ask the all knowing machine for index

System.out.println(slimstring.indexOf("U"));//5

//so let's do it again

container = slimstring.charAt(5);

System.out.println("We picked "+container);

//let's join the two strings.

System.out.print("Joining the two strings gives ");

System.out.println(slimstring+" " + fatstring);

}

If there are any tips and tricks you’d like to share, do. Responses are always welcome.

SNIPPET: java.lang.Float

2007-03-27T08:24:00.000-07:00

SNIPPET: java.lang.Float

We’ll play a little with floats here. Remember, you’ll love the language by getting worn out using it. One more exercise is not too much.

package api_package;

public class Lagosian {

static int ngozi_age = 25;

public static void main(String[] args) {

//note that this is in accord with IEEE 754

//floating point single-format bit layout.

System.out.print("Ngozi's age in floating point is: ");

System.out.println(Float.intBitsToFloat(ngozi_age));

//just to check that we are consistent

//note repetition of above methods

System.out.print("Just to be sure we're still on course:

");

System.out.println(Float.floatToRawIntBits(Float.intBitsToF

loat(ngozi_age)));

//try other exercises. you have the fundamentals to

//work with java for the maths inclined

}