bobhub

SCJP 1.6 Study Guide: Object Orientation Part 1

2009-11-19T23:39:00.012+08:00

Object Orientation

To be a Sun Certified Java Programmer, object-oriented concepts in Java should be second nature to you. In this section we will talk about the OO features of Java like encapsulation, inheritance, and polymorphism. We will continue our discussion in implementing interfaces, return type declarations and static variables and methods. We will also discuss topics like overloading/overriding, casting and coupling and cohesion. This is the second section of this series if you want to read the first section go here.

Encapsulation and Inheritance

Encapsulation. Encapsulation results to code flexibility and maintainability by hiding implementation details(instance variables) behind public interfaces(methods).

To implement encapsulation you must do the following:

Hide instance variables by using the private access modifier.
Create public methods to access private instance variables. This will ensure that users of your classes will go through the method where you can implement checks that will assure you that your classes will be used the right way. These methods are called getters and setters(some call them accessors and mutators). For these methods it is recommended to use the JavaBeans naming convention(getXxx and setXxx).

Example:
(No Encapsulation)

public class Person{
 public double weight;
}

public class TestPerson{
 public static void main(String[] args){
   Person person = new Person();
   person.weight = -1.0; // you probably don't want this to happen
 }
}

(With Encapsulation)

public class Person{
 private double weight;

 // getter
 public double getWeight(){
   return weight;
 }

 // setter
 public void setWeight(double weight){
   if(weight > 0){
      this.weight = weight; // better, right?
   }
 }
}

public class TestPerson{
 public static void main(String[] args){
   Person person = new Person();
   person.weight = -1.0; // this will compile but
        // will not change the value
        // of weight
 }
}

Inheritance. Inheritance as defined by Answers.com refers to the process of genetic transmission of characteristics from parents to offspring. That definition somehow mirrors what inheritance is in Java.

Inheritance in Java allows one class called the subclass to extend another class, the super class. Where the subclass by extending the super class inherits some or all of the super class' members(instance variables and instance methods) depending on the member's visibility.

You implement inheritance by using the extends keyword with the class declaration.

Example:

public class Person{
 private String firstName;

 public void setFirstName(String firstName){
   this.firstName = firstName;
 }

 public String getFirstName(){
   return firstName;
 }
}

public class Student extends Person{}

public class TestStudent{
 public static void main(String[] args){
   Student student = new Student();

   System.out.println(student.getFirstName());
   // wait Student has no getFirstName()
   // well, Student got it thru inheritance from Person
   student.setFirstName("Bob");
   System.out.println(student.getFirstName());
 }
}

Running TestStudent results to:

null
Bob

A class can only extend one class. You cannot say:

public class Student extends Person, Animal{}

The above example will not compile because there's no such thing as multiple inheritance in Java, but you must know that every class that Java programmers create implicitly extends the Object class.

Example:

public class TestClass{}

public class TestTestClass{
 public static void main(String[] args){
   TestClass test = new TestClass();
   System.out.println(test.toString());
   // where did toString() come from?
   // toString() returns a String representation
   // of an object in this case
   // a reference to the object test

   // let's check with instanceof operator
   if(test instanceof TestClass){
     System.out.println("test is a TestClass");
     // of course we declared it to be
     // a type of TestClass
   }

   if(test instanceof Object){
     System.out.println("test is an Object");
   }
 }
}

Running TestTestClass results to:

TestClass@addbf1
test is a TestClass
test is an Object

Inheritance is usually used for the following purposes:

Code reuse. Which is shown by our Person and Student class. We created a generic Person class with a firstName, getFirstName() and setFirstName() and then created a specialized Student class in which we need a firstName again but since the Person class already has them we just need to extend it and we'll be able to set and get the firstName of any Student object too.
Polymorphism. Polymorphism in Java allows any subclass of a superclass be treated as type of the superclass.

Example:

public abstract class Animal{
 public abstract void cry();
}

public class Dog extends Animal{
 public void cry(){
   System.out.println("Aw..Awoo..");
 }
}

public class Cat extends Animal{
 public void cry(){
   System.out.println("Me..Meowwww..");
 }
}

public class Vet{
 public void vaccinate(Animal animal){ // polymorphism in action
   animal.cry();
 }
}

public class TestVet{
 public static void main(String[] args){
   Dog dog = new Dog();
   Cat cat = new Cat();
   Vet vet = new Vet();

   // polymorphism in action
   vet.vaccinate(dog); // This will compile and run since
   vet.vaccinate(cat); // Dog and Cat are subclasses of Animal
 }
}

Running TestVet results to:

Aw..Awoo..
Me..Meowwww..

The example above is patterned from an example in Head First Java, 2nd Edition.

First, we've defined an abstract Animal class with abstract method cry(). Next we've defined Dog and Cat classes which extends Animal and both provided an implementation for the cry() method. We've then created a Vet class and defined a vaccinate() method which accepts an object of type Animal. We declared the method parameter for vaccinate() to be of type Animal so that we don't need to create several other vaccinate() methods each time we come up with a different class that extends the Animal class. We don't care what class is passed to the vaccinate() method as long as it can be treated as an Animal.

Observe that when we ran TestVet, the JVM still executed the cry() method of for the Dog and the Cat class. We'll discuss why this happened in the next post.

Polymorphism is implemented in interfaces as well, which means that a class can be considered a type of an interface if that class implements the interface.

Example:

public interface Rollable{
 void roll();
}

public class Dog extends Animal implements Rollable{
 public void cry(){
   System.out.println("Aw..Awoo..");
 }

 public void roll(){
   System.out.println("The dog is rolling...");
 }
}

public class TestRollableDog{
 public static void main(String[] args){
   Dog dog = new Dog();

   if(dog instanceof Rollable){
     System.out.println("dog is a Rollable");
   }
 }
}

Running TestRollable results to:

dog is a Rollable

IS-A.For the exam, we need to be able to determine if classes demonstrates IS-A or HAS-A relationship.

The IS-A relationship is based on class inheritance and interface implementation. You can always test this relationship by using the instanceof operator.

Example:

public class Animal{}

public interface Rollable{}

public class Dog extends Animal implements Rollable

public class Shitzu extends Dog

Listing the relationships we have:

Shitzu extends Dog, which means Shitzu IS-A Dog
Dog extends Animal, so Dog IS-A Animal (we don't really care about grammar here.:D)
Dog implements Rollable, so Dog IS-A Rollable
Since Dog IS-A Animal and Shitzu IS-A Dog we can say that Shitzu IS-A Animal. This only shows that a class has an IS-A relationship with anything further up the inheritance tree.
Q: Can we say Shitzu IS-A Rollable?

HAS-A. In contrast with IS-A relationship, HAS-A relationship is based on usage/existence/possession instead of inheritance.

Example:

public class Person{}

public class Student extends Person{
 private Course course;
}

public class Course{}

In the above example we can say that Student IS-A Person and at the same time Student HAS-A Course. As you might have observed, if class A is an instance variable of class B then class B HAS-A class A.

That's it for this part we will discuss polymorphism deeper with the next post.

SCJP 1.6 Study Guide: Declarations and Access Controls Part 9

2009-11-16T16:32:00.006+08:00

Declaring Arrays, Enums and Methods with Variable Argument Lists (var-args)

This is the last part for the Declarations and Access Controls section. If you missed most of the parts of this section please go to the table of contents for this study guide series.

Methods with Variable Argument Lists. Variable argument lists or var-args has been available since Java 5.0. For now, let's focus on declaring var-args. Here are the rules in using var-args:

Just like declaring a regular method parameter, you must specify the type that your var-args will accept. This type maybe primitive or an object type.
To declare a var-args parameter you must follow the type immediately with an ellipsis(...), a space and then the name of the parameter.
It is legal to have other parameters in the method declaration, but there can be only one var-args parameter and it should be the last parameter.

Example Legal:

int addNumbers(int... numbers){}

void storeInformation(String s, int... x){}

void addContacts(String... contacts){}

Example Illegal:

int addNumbers(int numbers...){}

void storeInformation(int... x, String x){}

Declaring Arrays. Arrays are objects that can store multiple variables of the same type or subtypes(polymorphism). Arrays can hold either primitive variables or reference variables. An array is also an object, even if it is declared to hold primitives. For the exam you need to know how to declare arrays, construct arrays and initialize arrays, however, we will focus on declaring arrays first and discuss the remaining two later.

Just like variables arrays are declared by declaring the type of variables it will hold and a pair of square bracket after the type or after the variable name. It is recommended to put the square brackets right after the type and before the variable name for better readability.

Example:

int[] numbers; // recommended

int numbers[];  // legal

String[] names;

String names[];

You can also declare multidimensional arrays, which are simply arrays of arrays.

Example:

int[][] numbers; // two dimensional

String[][] names[];  // three dimensional

If you notice the names array has two square brackets after the type and one after the variable name. This is legal but not recommended.

Declaring Enums. Enums or items in an enumerated list was made available since Java 5.0. Emuns allows you to restrict a variable's value to just one of a predefined list of enumerated values.

Example:

enum ShirtSize {SMALL, MEDIUM, LARGE}; // this cannot be private or protected

In the example above, we've declared an enum ShirtSize so if we want to set a Shirt to be of small size then we just do this:

Example:

public class Shirt{
ShirtSize size;

public static void main(){
 Shirt shirt = new Shirt();
 shirt.size = ShirtSize.SMALL;
}
}

The basic component of an enum is its constants, so the declaration of ShirtSize is the barebones declaration of an enum, and you still can add other declarations.As you may have observed the enum constants are all in uppercase, this is not a requirement but just another area where we use Sun's naming convention for constants.

Enums can be declared separate from other classes(example) or within a class as a member but not inside any method.

Example:

public class Shirt{
enum ShirtSize {SMALL, MEDIUM, LARGE};

ShirtSize size;

public static void main(){
 Shirt shirt = new Shirt();
 shirt.size = Shirt.ShirtSize.SMALL; // enclosing class is required
}
}

Furthermore, it is also legal to omit the semi-colon after the enum declaration as it is optional.

Example:

public class Shirt{
enum ShirtSize {SMALL, MEDIUM, LARGE}

ShirtSize size;

public static void main(){
 Shirt shirt = new Shirt();
 shirt.size = Shirt.ShirtSize.SMALL;
}
}

Enum constants are not types like primitive types and reference types. The enum constants are different instances of the enum where it is declared. Take a look at the ff for a theoretical perspective of an enum:

Example:

public class ShirtSize{
public static final ShirtSize SMALL = new ShirtSize("S");
public static final ShirtSize MEDIUM = new ShirtSize("M");
public static final ShirtSize LARGE = new ShirtSize("L");
}

Each enum constant in an enum has its corresponding index which is determined by the order in which they are declared. So in our previous ShirtSize example SMALL has an index of 0, MEDIUM(1) and LARGE(2).

Enum Constructors, Methods and Variables Declaration. Since an enum is a special kind of class you can add constructors, instance variables and methods to its constants. You can also add what we call a constant specific class body.

So we've declared the enum ShirtSize with SMALL, MEDIUM and LARGE constants but how do we know or set the real values of the sizes? Simply by passing a value to a constructor of the enum.

Example:

enum ShirtSize{
SMALL(28), MEDIUM(32), LARGE(36);

ShirtSize(int inches){ // constructor
 this.inches = inches;
}

private int inches;

public int getInches(){
 return inches;
}
}

public class Shirt{
private ShirtSize size;

public void setSize(ShirtSize size){
 this.size = size;
}

public ShirtSize getSize(){
 return size;
}
}

public class TestShirt{
public static void main(String[] args){
 Shirt shirt = new Shirt();
 shirt.setSize(ShirtSize.SMALL);
 System.out.println(shirt.getSize() + " " + shirt.getSize().getInches());
 shirt.setSize(ShirtSize.MEDIUM);
 System.out.println(shirt.getSize() + " " + shirt.getSize().getInches());
 shirt.setSize(ShirtSize.LARGE);
 System.out.println(shirt.getSize() + " " + shirt.getSize().getInches());
}
}

Which prints:

SMALL 28
MEDIUM 32
LARGE 36

Note that to get all the constants of an enum you just have to call the values() method (i.e. ShirtSize.values()) which returns an array representation of the constants arranged in the order they were declared.

Things to remember about enum constructors:

You can never invoke an enum constructor directly. It is invoked automatically.
You can define several arguments in an enum constructor just like a regular class. We will discuss overloading in the next section.

Constant Specific Class Body. This is used when you want to override a method in an enum for a particular constant. For example, you want to have the default price for all the sizes except for LARGE to be 300. So you define a method to set the price to 300 and override that method in LARGE to give it a different value.

Example:

enum ShirtSize{
SMALL(28),
MEDIUM(32),
LARGE(36){ // code block that defines the body for this constant
 public int getPrice(){ // override the getPrice() method of ShirtSize
  return 500;
 }
}; // semi-colon is required to end the constant body
   // when more codes follow

ShirtSize(int inches){ // constructor
 this.inches = inches;
}

private int inches;

public int getInches(){
 return inches;
}

public int getPrice(){
 return 300;
}
}

public class TestShirt{
public static void main(String[] args){
 Shirt shirt = new Shirt();
 shirt.setSize(ShirtSize.SMALL);
 System.out.println(shirt.getSize() + " " + shirt.getSize().getPrice());
 shirt.setSize(ShirtSize.MEDIUM);
 System.out.println(shirt.getSize() + " " + shirt.getSize().getPrice());
 shirt.setSize(ShirtSize.LARGE);
 System.out.println(shirt.getSize() + " " + shirt.getSize().getPrice());
}
}

Which prints:

SMALL 300
MEDIUM 300
LARGE 500

This post ends the Declarations and Access Controls section. Next section will be Object Orientation.

SCJP 1.6 Study Guide: Declarations and Access Controls Part 8

2009-11-13T15:19:00.007+08:00

Variable Declaration

When we need to manipulate values provided by the users of our application we can temporarily store them in variables. But to be able to assign values to variables you need to declare themfirst. And when you declare a variable you need to define what type of values that variable can hold and the variable name.

Example:

public class Person{
int age; // instance variable declaration
         // where int means it can only store int values
String name;
}

Primitive and Reference Variable. We can categorize the age variable of class Person as a primitive variable. Primitive variables can be one of 8 types: char, boolean, byte, short, int, long, float or double. How about the name variable? It was declared to store values of type String. Whenever a variable is declared to be a type of something other than the primitive types then it's called a reference variable. A reference variable can be used to refer to an object of the declared type or a subtype of the declared type through polymorphism which we will discuss in the next section.

Declaring Primitive Variables. Primitive variables can be declared as instance variables, class variables(static variables), method parameters or local variables. We will only focus on declaring variables and discuss the several ways of assigning values to them on a later post.

Example:

public class Student{
private int yearLevel, age;
public static final int TOTAL_NO_OF_YEARS = 4;

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

public int getRemainingYears(){
 int remainingYears = TOTAL_NO_OF_YEARS - yearLevel;
 return remainingYears;
}
}

The example above declares primitive variables as instance variable(yearLevel and age), class variable(TOTAL_NO_OF_YEARS), local variable(remainingYears) and method parameter(age). Another thing to learn from the example is that you can declare several primitive variables of the same type on one line(like yearLevel and age), just separate them with comma.

Type	Bits	Range
byte	8	-2⁷ to 2⁷-1
short	16	-2¹⁵ to 2¹⁵-1
int	32	-2³¹ to 2³¹-1
long	64	-2⁶³ to 2⁶³-1
float	32	n/a
double	64	n/a

The table above shows the range of the six primitive number types. Determining the range of floating point numbers is very complicated, fortunately we don't need to know them for the exam.

Variables of the boolean type can only be true or false.

The char type may contain a 16-bit Unicode character. The char variable is really an unsigned 16-bit integer type(0-65535) and can be assigned to any number type large enough to hold 65535.

Declaring Reference Variables. Like primitive variables, reference variables can be declared as instance variables, class variables, method parameters or local variables.

Example:

public class Student{
private String firstName, lastName;
public static final String SCHOOL_NAME = "My School";

public void setFirstName(String firstName){
 this.firstName = firstName;
}

public void getFullName(){
 String fullName = firstName + " " + lastName;
 return fullName;
}
}

Let's discuss the differences of instance variable, static variable, local variable and method parameter.

Instance Variables. Instance variables are variables declared inside a class but outside of any methods. When you don't give initial values to instance variables they will be given default values depending on their type.

Type	Default Value
byte	0
short	0
int	0
long	0L
float	0.0F
double	0.0
char	'\u0000'
boolean	false
String	null
Other Objects	null

These are the list of modifiers which can be used in declaring instance variables:

Any of the four access levels (three access modifiers: public, private and protected)
final
transient
static (but this variable is already a class variable or a static variable not an instance variable)

We'll discuss more on the difference of an instance member(non-static variable and method) and a class member(static variable and method).

Local Variables. Local variables are variables declared inside a method.

Example:

public class Student{
String firstName, lastName;

public void setFirstName(String firstName){ // firstName parameter is
 this.firstName = firstName;                // also a local variable
}

public void getFullName(){
 String fullName = firstName + " " + lastName; // fullName is a local variable
 return fullName;
}
}

Method parameters are also considered as local variables since they are declared in the method declaration.

A local variable lives when declared inside a method and dies when the method has completed. Basically it is already non-accessible outside the method. The following code will not compile.

Example:

public class Student{
String firstName, lastName;

public void getFullName(){
 String fullName = firstName + " " + lastName; // fullName is a local variable
 return fullName;
}

public String toString(){
 return fullName; // compile error fullName is not declared
                  // inside toString() but inside getFullName()
}
}

Unlike instance variables which can have default values, local variables needs to be initialized before it is used by any statement. Usually you give a local variable a value on the same line where you declare it. However, you can initialize a local variable on a different line just as long as it is not used first.

Example:

public class Student{
String firstName, lastName;

public void getFullName(){
 String fullName = firstName + " " + lastName; // fullName is initialized
 return fullName;
}

public String toString(){
 String fullName; // fullName is declared but not initialized
 return fullName; // compile error
}
}

Local variables can only be marked with the final modifier.

Shadowing. Shadowing happens when you try to declare a local variable with the same name as an instance variable. You usually do this in naming method parameters to achieve readability. The following code is an example but will cause what we call naming collision. It will still compile but should not be followed.

Example:

public class Student{
String firstName, lastName;

public void setFirstName(String firstName){
 firstName = firstName; // naming collision
}
}

To resolve naming collision the this keyword is used to refer to the current active object. Question: Which firstName is being referred by the two firstName variables inside setFirstName()?

Example:

public class Student{
String firstName, lastName;

public void setFirstName(String firstName){
 this.firstName = firstName; // firstName on the left refers
                    // to the instance variable firstName
                    // since we used the this keyword
}
}

Final Variables. When a variable is declared with the final keyword you are not allowed to reassign a value to that variable. For primitive variables this means that you cannot alter it's initial value.

Example:

public class Student{
private static final String SCHOOL_NAME = "My School";

public static String getSchoolName(){
 SCHOOL_NAME = "Your School"; // compile error can't reassign value
                              // to final a variable
 return SCHOOL_NAME;
}
}

For a reference variable it means you cannot assign it to another object but you still can modify the state (values of the instance variables of the object it refers to). There are no final objects just final references. We'll discuss more on this on a later post but here's a quick look:

Example:

public class Student{
String firstName, lastName;

public void setFirstName(String firstName){
 this.firstName = firstName;
}
}

public class TestStudent{
public static void main(String[] args){
 final Student student = new Student();
 student.setFirstName("Bob"); // OK to modify firstName

 Student stud = new Student();
 student = stud; // compile error
}
}

Transient Variables. When you mark a variable with the transient keyword you're telling the JVM to skip that variable when you attempt to serialize the object containing it. Simply put serialization allows you to save an object to a file or send it through a network. We'll discuss serialization on later posts. The transient keyword can only be used with instance variables.

Volatile Variables. When a variable is declared with the volatile modifier it tells the JVM that a thread accessing that variable must always reconcile(check) its own private copy with the master copy. You don't really need to know more about the volatile keyword except that like the transient keyword it can only be used with instance variables.

Static Variables and Methods. Static variables and methods are variables and methods marked with the static keyword. They are usually called class members.

Class members exist independent of any instance of the class they are declared in. They are created first before any creation of object of that class. There will be only one copy of each class members regardless of the number of instances of that class.

The following can be declared as static:

methods
variables except local variables
nested class (except classes declared inside a method)
initialization blocks

This post is definitely a long one. I suggest to read it a second time and try to code if something is not clear to you. Static variables and methods will be discussed deeper on later posts. The next post will discuss on declaring arrays and enums and it will be the last part for the Declarations and Access Controls section.

SCJP 1.6 Study Guide: Declarations and Access Controls Part 7

2009-11-12T22:35:00.005+08:00

Class Members and Non-Access Modifiers

The previous post discussed how to declare class members and how to modify them using access modifiers. Now that you know how visibility affects your code we will take a look at how non-access modifiers affect our code.

You are already familiar with some of the non-access modifiers we can use with class members, final, abstract and strictfp, but we will also take a look at transient, synchronized, native and static. We'll discuss how these modifiers affect our code when applied to methods in this post and then to variables in the next post. Static methods and variables will be discussed after the next post.

Final Methods. When applied to a method, the final keyword does not allow subclasses to override the method.

Example:

public class Person{
public final void eat(){
 System.out.println("A person eats using his/her mouth.");
}
}

It is legal to extend Person but you cannot override the eat() method.

Final Arguments. Arguments are the variables we declare inside the parentheses in a method declaration.

Example:

public class TaxCalculator{
private double taxRate;

public void setTaxRate(double rate){
 rate = rate * 0.1;
 taxRate = rate;
}
}

In the example above the argument is rate. When we declare a method argument to be final we are telling the compiler that rate cannot be reassigned with a new value.

Example:

public class TaxCalculator{
private double taxRate;

public void setTaxRate(double final rate){
 rate = rate * 0.1;  // compiler error
 taxRate = rate;
}
}

Abstract Methods. An abstract method is generally just a method declaration without any implementation. And if you remember the discussion regarding abstract classes, if a class has an abstract method it should be declared abstract too.

Once a class extends from an abstract class it is forced to implement that abstract method unless that class is abstract as well. The general rule to follow is: The first concrete(non-abstract) class that extends an abstract class should implement all abstract methods declared in the abstract class.

Example:

public abstract class Animal{
private String name;

public abstract void makeSound();

public String getName(){
 return name;
}
}

public abstract class Dog extends Animal{
private Collar collar;

public Collar getCollar(){
 return collar;
}

// still abstract, no need to implement makeSound()
}

public class Basenji extends Dog{
// not abstract(concrete) class
// needs to implement bite() from Dog
// no need to really put code here
// just change semi-colon to pair of braces
public void bite(){}

// also needs to implement makeSound() from Animal
// since Dog did not implement makeSound()
public void makeSound(){
 System.out.println("Yodelehihoo");
}
}

The abstract keyword when used in a method is not allowed to combine with static, final and private keywords.

Synchronized Methods. Marking a method with the synchronized keyword makes a method accessible to only one thread at a time. We'll discuss more on this when we get to Threads.

Example:

public class AccountManager{
public synchronized void withdraw(double value){}
}

You can also mix access modifiers with the synchronized keyword. What non-access modifiers can you combine with synchronized?

Native Methods. The native keyword indicates that a method contains platform-dependent code usually in C. You only need to know that this keyword can only be used with methods.

Strictfp Methods. When you use strictfp with methods you are sure how your floating points will behave regardless of platform. Check Part 4 for details.

You cannot use strictfp with variables.

Constructor Declarations. When you create a Java application you will make, instantiate or create objects to communicate with each other and when you create an object at least one constructor is invoked.

Every class in Java has a constructor. The compiler will provide one(default constructor) for you if you don't. There are several things to consider in declaring a constructor which we will discuss on a later post. But for now, let's take a look at a basic constructor declaration:

Example:

public class Person{
public Person(){} // this is a valid Person constructor

public void Person(){} // this is a valid but badly named method
}

If you notice, the Person() constructor looks like the Person() method. The main difference is that constructors cannot have a return type. Constructors also must have the same name as the class in which they are declared.

Constructors can be marked with access modifiers. Non-access modifiers like static, final and abstract cannot be used with constructors.

Be sure that you have understood what access and non-access modifiers we can use with methods and how they affect those methods. Try using and combining them as practice. The next post will handle variable declarations.

SCJP 1.6 Study Guide: Declarations and Access Controls Part 6

2009-11-09T17:44:00.013+08:00

Declaring Class Members and Access Modifiers

By this time I hope you have grasped all the required concepts in declaring and modifying classes. If not go back and I suggest you try coding at the same time. Those concepts are necessary before reading the next posts regarding declaring class members.

Class Members. When we mention class members we are talking about instance variables, static variables, instance methods and static variables.

Both instance and static variables are variables declared inside a class but outside any methods. The most obvious difference that you will see between instance and static variables is that static variables are variables declared with the static keyword, which is the same with instance and static methods.

Example:

public class Student{
 public int yearLevel;  // instance variable
 public static int noOfStudents;  // static variable

 public void doHomework(){}  // instance method
 public static void getNoOfStudents(){}  // static variables
}

We'll go deeper with static variables and methods in later posts.

Access Modifiers. As we've discussed in an earlier post, Java has four access control levels (public, private, protected and default access), but only three modifiers (public, private and protected). You get the default access when you don't specify any access modifier.

Unlike classes where you can only have two access control levels (public and default), you can have all four with class members.

The following are the things you should remember when a class (class A) has access to members of another class (class B):

A method in class A has access to class members of class B.

package bobhub;
public class B{
 public int x;

 public void doBThings(){}
}

package scjp;
import bobhub.B;
public class A{
 public void doAThings{
   B b = new B();
   b.x = 2;  // doBThings has access to x from a reference of class B
   b.doBThings();  // doBThings can invoke doAThings() from a reference of class B
 }
}

What class members are inherited by class A when it extends class B.

package bobhub;
public class B{
 public int x;

 public void doAThings(){}
}

package scjp;
import bobhub.B;
public class A extends B{
 public void doAThings{
   doBThings(); // since A extends B and it inherits doBThings()
                // it can invoke doBThings() as if it is declared in
                // class A. Sometimes you can use the this reference
                // for clarity. e.g. this.doBThings();
   x = 24;  // A also inherits x from B
 }
}

Now that we have access modifiers for classes and for its members we must consider combination of access modifiers. Of course, you need to take a look at the class first, if class B is not visible to class A then all the members of class B is not visible to class A. When class B is visible to class A that's the time you need to take a look at the visibility of each member of class B. For the next post let's assume that all classes are visible unless stated in the examples.

Public Members. A class member is considered a public member when it is declared with the public keyword (e.g. public String name; public void doSomething();).

A public member is accessible to all other classes regardless of package(See example). Public members are inherited by subclasses of its class(See example).

Private Members. Declaring class members with the private keyword makes them inaccessible to any class except to the class where it was declared.

Example:

package bobhub;
public class B{
 private int x;

 private void doBThings(){}
}

package scjp;
import bobhub.B;
public class A extends B{
 public void doAThings{
   B b = new B();
   b.x = 24;  // compiler error

   doBThings();  // compiler error
 }
}

Class B above compiles just fine but we will run through an error in A when it tries to access x(b.x = 24;), since x is declared with the private keyword B is the only class allowed to access x.

Another line which will result into a compiler error is when doAThings() method tries to invoke doBThings() method because subclasses do not inherit private members of its superclass. However, you can declare a method in A with the same signature as doBThings() method but it's not considered as overriding(We will discuss more on overriding on later posts). Try this in coding.

Default Members. When you don't explicitly provide an access modifier you get the default access. Default members may be accessed only by classes in the same package where you declared the members.

Example:

package bobhub;
public class B{
 int x;

 void doBThings(){}
}

package scjp;
import bobhub.B;
public class A extends B{
 public void doAThings{
   B b = new B();
   b.x = 24;  // compiler error

   doBThings();  // compiler error
 }
}

Accessing x in doAThings() method results in compiler error since x has default access and A is in a different package than B. Also invoking doBThings() thruough inheritance will result to compiler error because just like private members, a subclass does not inherit protected members of its superclass.

Protected Members. Members declared with the protected keyword behaves like default members most of the times except with inheritance. Protected members like default members are accessible only to classes within the same package AND also are visible through inheritance by subclasses even if they are on a different package.

Example:

package bobhub;
public class B{
 protected int x;

 protected void doBThings(){}
}

package scjp;
import bobhub.B;
public class A extends B{
 public void doAThings{
   B b = new B();
   b.x = 24;  // compiler error

   doBThings();  // compiles
 }
}

Accessing x in doAThings() method using a reference to an object B results in compiler error since x has protected access and A is in a different package than B. However, invoking doBThings() through inheritance will NOT result to compiler error since subclasses, even if they are in a different package, will inherit its superclass' protected members.

Local Variables and Access Modifiers. Local variables are variables usually inside a method. Local variables CANNOT be marked with access modifiers. And there is only one modifier you can use with local variables and that is the final keyword.

Below is a table from SCJP 1.6 Study Guide Book to summarize visibility of class members using access modifiers.

Visibility	Public	Protected	Default	Private
Same class	Yes	Yes	Yes	Yes
Any class in the same package	Yes	Yes	No	Yes
A subclass in the same package	Yes	Yes	Yes	No
A subclass outside the same package	Yes	Yes	No	No
A non-subclass outside the same package	Yes	Yes	No	No

We will discuss class members and non-access modifiers in the next post.

SCJP 1.6 Study Guide: Declarations and Access Controls Part 5

2009-11-08T21:59:00.009+08:00

Declaring Interfaces

Part 3 and Part 4 of Declarations and Access Controls discussed how we can declare and modify classes. This part will turn our attention to declaring interfaces.

Interfaces are 100% abstract classes, they define abstract methods which creates a contract on what a class can do without imposing how the class will do it. Classes do not extend interfaces they implement them and when they implement interfaces they should implement the methods defined in the interfaces. Interfaces are declared using the interface keyword.

Example:

package bobhub.food;
public interface Edible{
 void cook();
 void prepare();
}

package bobhub.food;
public class Apple implements Edible{
 public void cook(){
   // you don't need to actually write code here
   // you just need to change the semi-colon to
   // a pair of braces
 }

 public void prepare(){
   System.out.println("Slice... Slice... Slice...");
 }
}

When I said earlier that interfaces are 100% abstract classes I mean you can only define abstract methods and constants in an interface, no more no less. The following are rules on declaring interfaces:

An interface must be declared with the interface keyword, not the class keyword.
An interface can extend one or more interfaces (comma-separated).
An interface can only extend another interface.
An interface cannot implement anything (A class or another interface).
Interfaces can have public or default access.
All interface methods are implicitly public and abstract. Take a look at the prepare() method of the Edible interface:
```
void prepare();
```
We can only define abstract methods in an interface but why is the prepare() method defined without the public and abstract keywords? Since interface methods are implicitly public and abstract we don't need to mark interface methods with those keywords. Marking them with public and abstract is legal but redundant. So we can define the prepare() method like these:
```
public abstract void prepare();
```
OR
```
public void prepare();
```
OR
```
abstract void prepare()
```
Interface methods cannot be marked with these keywords: static, final, strictfp or native.

All variables defined in an interface should be and implicitly public, static and final, which means they should all be constants. The following are valid interface constant declarations:

int MINIMUM_PREPARATION_TIME;

final int MINIMUM_PREPARATION_TIME;

static int MINIMUM_PREPARATION_TIME;

public int MINIMUM_PREPARATION_TIME;

static final int MINIMUM_PREPARATION_TIME;

public final int MINIMUM_PREPARATION_TIME;

public static int MINIMUM_PREPARATION_TIME;

public static final int MINIMUM_PREPARATION_TIME;

When a class implements an interface it inherits all the constants from the interface. But remember that you cannot change the value of a constant. Also, we can interchange the order of the modifiers we use. The Apple class in the following code will not compile:

package bobhub.food;
public interface Edible{
 int MINIMUM_PREPARATION_TIME = 60;
 void prepare();
}

package bobhub.food;
public class Apple implements Edible{
 public void prepare(){
   MINIMUM_PREPARATION_TIME = 120;
 }
}

That's it for now for interfaces but we will discuss them again when we talk about Polymorphism as we will learn that interface types can be used polymorphically. In the next post we will learn how we can add class members(instance and static variables and methods) and modify them with access modifiers.

SCJP 1.6 Study Guide: Declarations and Access Controls Part 4

2009-11-08T12:33:00.007+08:00

Final Class and Abstract Class

We'll pick it right off Part 3 of Declarations and Access Controls where we discussed how a regular class is declared in Java and the 2 access modifiers we can define for our classes. With this post, I hope you will learn more about final classes and abstract classes.

In addition to access modifiers you can still modify a class by using non-access modifiers like strictfp, final and abstract keywords. But remember that you can't always mix non-access modifiers. You can combine strictfp with either final or abstract but you cannot combine final and abstract as you will learn later.

Final Class. When you use the final keyword in a class declaration you define that class to be a final class which means it cannot be subclassed. Any attempt to extend a final class will result into a compiler error. Also, since you cannot subclass a final class, you won't be able to override its methods (Overriding is discussed in Section 2: Object Orientation).

So when do you a class final? If you look at the javadocs of some classes of the Java core libraries you will see that most are declared to be final which guarantees that those classes will not be modified by others so that they will behave the same on all applications that use them. Therefore, if you depend heavily on the implementations of a class and you want it to behave exactly the same every time it is used then most probably you want that class to be a final class.

Example:

package bobhub.animal;
public final class Animal{
public void eat(){}
}

package bobhub.animal.mammals;
public class Dog extends Animal{}

The Animal class will compile, but if you try compiling the Animal class you will get a compiler error. Try it to see the error. In the course of your development, you will rarely make a final class.

Abstract Class. When we use the word abstract as an adjective we usually mean to say it's something generic.

An abstract object is an object which does not exist at any particular time or place, but rather exists as a type of thing.-Answers.com

Abstract classes are classes that you cannot instantiate. Instead you extend them. And when you are brave enough to instantiate an abstract class the compiler will curse at you with a compiler error.

Example:

package bobhub.animal;
public abstract class Animal{
public String name;
public double height;

public abstract void eat();
public abstract void sleep();
}

package bobhub.animal;
public class Dog extends Animal{
public void eat(){
System.out.println("Eating...");
}
public void sleep(){}
}

package bobhub.test;
import bobhub.animal.Animal;
import bobhub.animal.Dog;
public class TestAnimal{
public static void main(String[] args){
 Animal animal = new Animal();
 Dog dog = new Dog();
}
}

The above classes will compile except for TestAnimal where we tried to instantiate the Animal class. If you delete that line the TestAnimal class will compile.

Let's take a closer look at the Animal class. If you notice the eat() method was declared with the abstract keyword and ends in a semi-colon instead of a pair of braces.

public abstract void eat();

The eat() method is considered an abstract method since it was declared with the abstract keyword. If you see an abstract method in a class then the class should be declared abstract as well or else you will get a compiler error. When a class extends an abstract class with abstract methods the extending class should implement those abstract methods where you will define how the method should work (See example above). Moreover, an abstract class can define non-abstract methods as well. We will discuss abstract methods more on later posts.

strictfp. The strictfp keyword is used to modify a class or a method and never a variable. Floating points in a Java application may behave differently in different platforms but declaring a class as strictfp will make all methods in the class conform to the IEEE 754 standard rules for floating points. If you don't define a class as strictfp you can make individual methods as strictfp.

Example:

strictfp class Calculator{}

class TaxAnalyzer{
public strictfp analyzeTax(){}
}

This post ends the topic on how we declare and modify Java classes. The next posts will talk about declaring interfaces. See you until then!

SCJP 1.6 Study Guide: Declarations and Access Controls Part 3

2009-11-06T00:55:00.013+08:00

In Declarations and Access Controls Part 2, I discussed what it means to be a legal identifier and what is widely accepted in practice. Again, remember that an identifier does not need to conform to conventions to be legal. Take a quick look of the rules here.

Class Declaration and Access Modifiers

In creating a Java application you will mostly create classes and interfaces and how you write them will heavily affect your whole application. In this part I will discuss how we declare classes and how you can modify access to them.

Source File Declaration Rules. Before going to declaring classes let's first take a look at the rules in naming your source files, defining packages and using import statements. In the last section of this series we will go deeper into import statements and packages but if you want to know more about them you can go to Sun's Java Package Tutorial.

You can have multiple classes in a source file but only one public class is allowed per source file.
If your source file has a public class, the name of the source file should be the same as the public class' name (e.g. a class declared as public class Person should be in a source code file Person.java).
A source file can have multiple non-public classes.
A source file with no public class can have any filename.
If the class is part of a package, the package declaration should be the first line in the source file.
If you are using classes from different packages in a source file then import statements for those classes should come next after the package declaration and before the class declaration. If the class is not part of a package the import statements should be the first lines in the source file. If there are no package declaration and import statements, the class declaration should appear on the first line in the source file.
Import statements and package declaration in a source file applies to all classes within the source file. You cannot declare different packages for each class in your source file.
Lastly, comments may appear anywhere in the source file. They are exempted from the rules mentioned above.

Example:

package com.blogspot.bobhub.scjp;

import java.util.*;
import javax.swing.*;

public class Person{}
class Employee{}

This should be saved in Person.java.

Class Declaration. Nested classes will be discussed in future posts. The following code is a basic class declaration:

class Person{}

Classes are declared using the class keyword followed by the name of the class. The opening brace({) signifies the beginning of the class and the close brace (}) ends the class. The code above compiles and you'll learn that it's the minimum requirement for declaring a class (If you have doubts try it. For a quick help on compiling your .java files go here). In addition to the basic class declaration you can add modifiers. We will discuss class access modifiers first and non-access modifiers next.

Class Access Modifiers. Access modifiers restrict or allow usage of a class. Technically there are 4 access levels but there are only 3 access modifiers (public, private and protected), the last one is called default or package access which you get when you don't specify any access modifier like our first class declaration example. Access modifiers are also used with methods and instance variables.

Although Java has 4 access levels a class can only be declared with a public or default access.

Access control for classes dictates what a class can do with another class. Let's say we have two classes, class X and class Y. When we say that class X has access to class Y it means class X can do one or more of these:

Create an instance of class Y.

class Y{}
class X{
  public Y y = new Y(); //instance variable
}

Extend class Y.
```
class Y{}
class X extends Y{}
```

Access certain variables and methods within class Y, depending on the access control of those variables and methods.

class Y{
  public int value; //instance variable
}
class X{
  public static void main(String[] args){
    Y y = new Y();
    y.value = 24; //access "value"
  }
}

Access level is sometimes called visibility. Access modifiers and non-access modifiers are placed anywhere before the class keyword but you will notice that access modifiers usually are placed before non-access modifiers. Suffice to say, a class can only have one access modifier at a time.

Public Access. If a class is declared with a public keyword then all of the classes in any package can access that class. Just don't forget that you still need to import the public class if you're going to use it in a class on a different package.

Example:

package bobhub;
public class Person{}

package bobhub;
public class Employee extends Person{}

Default Access. A class with no access modifier is said to have default or package-level access. This means that only classes within the same package as the declared class has access to it.

Example:

package bobhub;
class Employee{}

package bobhub;
public class TestEmployee{
  public static void main(String[] args){
      Employee employee = new Employee();
  }
}

Class Employee and class TestEmployee will compile. But what if class TestEmployee is declared like this:

package scjp;

import bobhub.Employee;

public class TestEmployee{
  public static void main(String[] args){
      Employee employee = new Employee();
  }
}

Try this on your own and take note of the result.

That ends this post. The next post will be about non-access modifiers we can use with classes. If you have something to share feel free to comment. Discussion is another way to study exams like the SCJP.

SCJP 1.6 Study Guide: Declarations and Access Controls Part 2

2009-11-05T01:19:00.017+08:00

This is Part 2 of Declarations and Access Controls Section. Part 1 was just a refresher if you have been away from Java for long. I will discuss legal identifiers, keywords, Sun/Java naming conventions, and the JavaBean naming convention.

Identifiers and JavaBeans

In Java, we will be creating lots of classes with variables and methods. As such, we need to be able to identify each one to be able to use them, same as us having names to call each other. We call these names as identifiers and Java has rules on creating them.

Legal Identifiers. Legal identifiers are identifiers which comply to rules in creating identifiers set by Java.

Rules for Legal Identifiers:

Must start ONLY with a letter, a dollar sign ($), or an underscore (_).
After the first character, the identifier can contain any combination of letters, numbers, dollar signs and underscores.
Must not be one of the Java keywords.
Identifiers are case-sensitive. So bar is different from Bar (Not exactly a rule but you need to remember this when you are using identifiers)

Examples of LEGAL identifiers:

int buzz;
int $name;
int _AgE;
int $$_$;
int an$unnecessarily_long$identifier_;

Examples of ILLEGAL identifiers:

double 8uZz;
double !add;
double e-mail;
double %xyz;
double Abc def;

Keywords. Keywords are reserved words by Java. These are primarily used as syntax in Java. Below is a table of Java keywords. Don't worry if you are not yet familiar with some of them we will tackle them as we go along. Click here to see the table.

Java Code Convention. Using a set of code standards helps in reducing effort in testing, maintaining and enhancing existing codes.

Remember that even if an identifier does not follow the naming convention if it adheres to the rules of a legal identifier your code will still compile.

Classes and Interfaces. First letter should be capitalized and if the identifier is composed of several words then the first letter of each subsequent word should be capitalized as well.

Class names should be nouns.
Examples:

Person
DepartmentHead
MyPetStore

Interface names should be adjectives.
Examples:

Serializable
Comparable
Runnable

Methods. Should follow camelCase convention. First letter of first word is lowercase and the first letter of the succeeding words should be capitalized. Method names typically are verb-noun compounds.

Examples:

drawShape
createPlayer
interpolateValue

Variables. Should follow camelCase convention as well. Variable names are usually nouns. Make them short but descriptive.

Examples:

firstName
candidateList
result

Constants. Java constants are created by using the keywords static and final. All letters are capitalized and words are separated by underscores.

Examples:

BUTTON_WIDTH
STEEL_GAGE
YOUNGS_MODULO

JavaBeans Standards. JavaBeans are classes with properties which usually are private instance variables. Private properties can be accessed by other class only through getters and setters. Getters are methods which retrieve a property's value and setters are methods which change a property's value.

If the property is not boolean then the method name's prefix should be get (e.g. getName()).
If the property is boolean the method name's prefix may either be get or is (e.g. isValid()).
The setter method prefix should be set (e.g. setName()).
To complete the method name just capitalize the first letter of the property's name and append it to the prefix. (e.g. property name: account, getter: getAccount(), setter: setAccount()).
Setters should be marked public, takes an argument of the property's type and returns void.
Getters should be marked public, takes no argument and should return a value of the property's type.

Example

public class Person{
   private int age;

   public int getAge(){
       return age;
   }

   public void setAge(int value){
       age = value;
   }
}

Events. "The JavaBean spec supports events which allow components to notify each other that something happened (from SCJP 1.6 Study Guide book)". Events are used primarily with GUI applications.

The object which receives the event object is called the listener. Like private instance variables, listeners are added and removed by methods which may follow these conventions:

Methods which add/register a listener to a component should be prefixed with "add" (e.g. addMouseListener()).
Methods which remove/unregister listeners from a component should be prefixed with "remove" (e.g. removeMouseListener()).
Register and unregister methods should always end with "Listener".
addXxxListener and removeXxxListener methods should take an argument with the type of listener.

Examples of VALID JavaBean method signatures:

public void setBalance(double balance)
public double getBalance()
public boolean isEnabled()
public void addWindowListener(WindowListener w)
public void removeWindowListener(WindowListener w)

Examples of INVALID JavaBean method signatures:


//should be public
private void setBalance(double balance)
//should return a value of the property's type              
public void getBalance()
//should start with either set or is                            
public boolean determineIfSuccessful()
//listener type mismatch              
public void addWindowListener(KeyListener k)
//listener type mismatch        
public void removeActionListener(WindowListener w)

Part 3 of the Declarations and Access Controls section will discuss about Class Declaration and Modifiers.

SCJP 1.6 Study Guide: Declarations and Access Controls Part 1

2009-11-04T17:04:00.010+08:00

Objectives:

Declare classes and interfaces (Normal class, abstract class and interface)
Use primitives, arrays, enums and legal identifiers
Use static methods, JavaBeans naming and var-args

As I've said on the parent post this is a study guide for the SCJP 1.6 Exam so I assume you have at least some knowledge of Java already. But here's a refresher:

Refresher

Class - A blueprint that defines the state and behavior for an object.

Object - Instance of a class with its own state and access to behaviors defined in its class. Usually created using the new operator.

State - Instance variables of a class.

Behavior - Methods of the class.

Example 1.1:

public class Person{
  public String name;
  public int age;

  public void eat(){
    System.out.println("Eating...");
  }
}

public class TestPerson{
  public static void main(String[] args){
    Person p = new Person()
    p.name = "John Doe";
    p.age = 24;
    p.eat();
  }
}

In the example we have a Person class with instance variables name and age and an eat() method. When we created a Person object (Person p = new Person) we gave it a name and an age (John Doe, 24) which defines the state of object p. We also can use the eat() method since the p object can access it.

Most Java programs will be composed of objects created from different classes communicating with each other.

Identifiers and Keywords. All classes, variables and methods that we will create need names and we call them identifiers and there are rules on how we create legal identifiers.

Moreover, since the creators and developers of Java knew that it will be used by a large community they developed conventions in creating identifiers so we could understand each others code.

Remember that for our codes to compile we only need our identifiers to be legal. But when you are developing your application it is highly recommended that we follow the conventions.

In Example 1.1 class Person defined these identifiers:

Person
name
age
eat

Inheritance. Inheritance is one of the concepts of Object Orientation. It allows one class to be reused or extended by another class.

A class that is extended by another class is called the super class and the class extending the super class is called a subclass.

A subclass automatically inherits accessible instance variables and methods of the super class.

A subclass may also override methods it inherits from the super class.

Interfaces. Interfaces are 100% abstract classes. Classes implement interfaces instead of extending.

An interface defines methods that an implementing class should have but does not dictate how those methods should be written. The implementing class should define the actual code for those methods.

Packages. A typical Java application will usually use many classes. As such it is best to group related classes into packages or folders to give developers a consistent way of naming, accessing different classes and prevent naming conflicts.

That's it for this post. Part 2 will tackle Identifiers and JavaBeans.

SCJP 6 Study Guide

2009-11-04T16:39:00.015+08:00

Since I'm reviewing for the SCJP 1.6 Exam (Exam 310-065) I thought writing about the topics I study will help me remember them better. So this series of posts is basically based on what I'll read from the SCJP Sun® Certified Programmer for Java™ 6 Study Guide book by Kathy Sierra and Bert Bates and things I pick up from other sources which I will mention accordingly.

This series can also be a reference for people starting to learn Java but I recommend checking Sun's Java Tutorials.

Here are the topics I'll cover:

Declaration and access control - 1|2|3|4|5|6|7|8|9
Object orientation - 1
Assignment
Operators
Flow control
Exceptions
Assertions
String IO, formatting and parsing
Generics and collections
Inner classes
Threads
Development

For a detailed description of the exam objectives go to SCJP 1.6 Objectives. If a topic is ready it will appear on the list above as a link. Hope you can discuss with me on each one. Please don't ask me for a copy of the book, go buy one and help the authors and the people who contributed to help us prepare for the exam.

Slow MySQL Remote Connection

2009-10-30T16:13:00.005+08:00

If your application is connecting very slow to a remote MySQL database you might want to try adding this line to the my.ini file of the server:

skip-name-resolve

Basically, when a new client connects to MySQL, it spawns a new thread to handle the request. This thread first checks whether the host name is in the host name cache. If not, the thread attempts to resolve the host name. This may take a lot of time to finish so to ignore this process we add the above line to my.ini file.

Please see MySQL documentation for further explanation.

Installing an Epson TM U220 using USB in Windows XP

2009-10-13T20:57:00.008+08:00

Today I was tasked to go to one of our clients in Makati to install a receipt printer (Epson TM U220) and use a printer port-usb connector because the CPU there does not have any parallel port (I think almost all modern CPUs do not have parallel ports already, at least my laptop doesn't have one).

I was looking for the CD installer of the printer but could not find it. Fortunately, after 30 minutes of sniffing the web I was able to find one. So for those who need it go to http://install.westgatesoftware.com/drivers/PRINTERS/Epson/TM-T90/ and download APD304e.exe or just search for that executable file using Google. Just follow these steps to install the driver:

Run the installer.
Select the right OS.
Select USB as the port to be used.
Select the correct model from the list.
Let the installer do its work.
Restart your computer.

The other hard part is, if you're not familiar with installing printers using USB port instead of a printer port without the CD installer which I am earlier), how do I make it work after running the installer. Here's a simple procedure:

Go to Control Panel and select Printer and Faxes.
Select the correct printer from the list, in this case it's Epson TM U220, right click and select Properties.
Go to the Port tab.
You'll see that the printer you've just installed is using USB. You have to change that. Look for `Virtual Printer Port for USB` and select it and Apply.
If you check the Printer and Faxes folder again, the status of the printer should be `Ready`. If it's not just restart your computer.
After restarting, go right back to the Properties of the printer and go to the Port tab and uncheck both `Enable bidirectional support` and `Enable printer pooling`.
Run a Test Print.
If it did not print then go to Code and Cook where I got most of this (look at the comments maybe those can help you) and what made me write about it again because I thought it is a helpful article.

Good luck and share your experience.

- Bob

Blogging at Blogger

2009-10-12T23:22:00.006+08:00

Hi all! I'm Bob Santos and this blog will be my personal repository of things I find worth writing. Topics may range from programming to gaming, from music to movies and from humor to politics.