Category: Computer and IT

Let see I just built some strange structure of method extend… I want to see how much it can go with different level, where go in where go out. The entrance…

class A {
    public void what() {
        System.out.println("A what");
    }

    public void how() {
        System.out.println("How first?");
    }
}

class B extends A {
    public void how() {
        System.out.print("How second?");
        super.how();
    }
}

class C extends B {
    public void what() {
        System.out.println("C What");
    }

    public void why() {
        System.out.println("Why you want be special leH?");
    }
}

class D extends C {
    public void what() {
        System.out.println("D what");
    }
}

class E extends D {
    public void what() {
        System.out.println("E what");
    }
}

class ExtendMethod {
    public static void main(String args[]) {
        A a = new A();
        a.what();

        C c = new D();
        c.what();

        A someElse = new B();
        someElse.what();

        B someThingElse = new C();
        someThingElse.what();

        B someSpecial = new C();
        //someSpecial.why();

        D someThingSpecial = new E();
        someThingSpecial.why();

        C c2e = new E();
        c2e.how();
    }
}

Final variables declared inside class, it can be divided into final variable, or static final variable.

These two types have two different initialization method.

For final variable, the first type, we should declare it in constructor, or initializer block.

For static final variable, the second type, we should declare it in static initializer block.

These two methods unless you initialized them when you declare. I mean final int a = 3; you directly assign a number 3 to it.

Now, I am playing around with initialization of final variables, as the below is my coding, you all can refer it…

public class FinalStuff {
    final int a;

    static final int d;

    // use static initializer block to initialize static final int
    static {
        c = 3;
        d = 4;
        System.out.println("I am static initializer block");
    }
    static final int c;

    {
            a = 1 + this.b;
            b = 2 + this.d;
            System.out.println("I am initializer block");
    }
    final int b;
    // use initializer block OR FinalStuff constructor to initialize final int
    public FinalStuff() {
        //a = 1;
        //b = 2;
        System.out.println("I am constructor");
    }

    public static void main(String args[]) {
        FinalStuff f = new FinalStuff();
        System.out.println(f.a + " " + f.b + " " + f.c + " " + f.d);
    }
}

 

Enum is a new Java SE 5 features. It seem likes able to declare a new type, with limited specified value. Below is the demonstration of Enum.

enum Car {
    TOYOTA (30000,1000,"BIG"),
    CAMRY (100000,200,"BIG") {
        public int totalPrice() {
            return price * unit + 1500;
        }
    },
    PROTON (10000,5000,"MEDIUM");

    final int price;
    final int unit;
    final String size;

    Car(int price, int unit, String size) {
        this.price = price;
        this.unit = unit;
        this.size = size;
    }

    public int getPrice() { return price; }
    public int getUnit() { return unit; }
    public String getSize() { return size; }

    public int totalPrice() {
        return price * unit;
    }

    public String toString() {
        return "PRICE: " + price + "\tUNIT: " + unit + "\tSIZE: " + size;
    }
}

public class EnumPlay {
    public static void main(String args[]) {
        Car c1 = Car.TOYOTA;
        Car c2 = Car.CAMRY;
        Car c3 = Car.PROTON;

        for(Car c : Car.values()) {
            System.out.println(c.name()+ "\n" + c + "\nTotal: " + c.totalPrice() + "\n");
        }

        System.out.println("Split it up:");
        System.out.println(c1.name() + " has " + c1.getUnit() + " cars. Each price costs " + c1.getPrice() + ". But somehow it is " + c1.getSize().toLowerCase());
        System.out.println(c2.name() + " has " + c2.getUnit() + " cars. Each price costs " + c2.getPrice() + ". But somehow it is " + c2.getSize().toLowerCase());
        System.out.println(c3.name() + " has " + c3.getUnit() + " cars. Each price costs " + c3.getPrice() + ". But somehow it is " + c3.getSize().toLowerCase());
    }
}

Note that, System.out.printf and System.out.format is exactly the same, the Java engineer come out with System.out.printf may be want to make C Programmer happy.

Now, I am going to use this System.out.printf to format my money, in account book, for example, there are different type of formatting. I now tied up with my code, and the output let you to see what happen in this.

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

class MoneyForm {
    private double amount;
    private int type;
    public MoneyForm(double amount, int type) {
        this.amount = amount;
        this.type = type;
    }

    public void generateForm() {
        switch(type) {
            case 0:
            System.out.printf(" >$%1$-+,(15.3f< ", amount);
            break;
            case 1:
            System.out.printf(" >$%1$0+,(15.3f< ", amount);
            break;
            case 2:
            System.out.printf(" >$%1$0+(15.3f< ", amount);
            break;
            case 3:
            System.out.printf(" >$%1$+(15.3f< ", amount);
            break;
            case 4:
            System.out.printf(" >$%1$+,(15.3f< ", amount);
            break;
        }

        System.out.println();
    }
}

class Money {
    public static void main(String args[]) {
        for(int i=0; i<5; i++)
            printMoney(i);
    }

    public static void printMoney(int type) {
        System.out.println("Money Form of type: " + type);
        for(int i=-3; i<=3; i++)
            new MoneyForm(i * 1530.21, type).generateForm();

    }
}

I just discovered one strange and interesting thing. I get confused when first seeing this one.

How about I write this code?

Integer i1 = 1000;
Integer i2 = 1000;
System.out.println(i1==i2);

It will return "false". Whenever the Integer is a wrapper class, so it will belongs to different objects.

How about this one?

Integer i3 = 10;
Integer i4 = 10;
System.out.println(i3==i4);

It will return "TRUE". Why? Why show two different results, one return false the other return true. But how come, it is same concept!!!

Confusing?

The answer is, in order to save memory, two instances of the following wrapper objects will always be == when their primitive value are the same.

• Boolean
• Byte
• Character from \u0000 to \u007f (7f is 127 in decimal)
• Short and Integer from -128 to 127.

Yes, I know it, in order to save memory, so it become like that. So why first time I see it I will get confused, is it the book talk wrong thing? Not! I try in my machine, it showed the same result.

If I not see this, if the Sun Exam come out this question, I definite will… So I need to be very very careful about this. Since Java 5 the creator of Java is giving programmer more convenient way to construct code, so it may be some things not following logic, so as a testtaker we need to be very careful about this.

This is the demonstration on how to use java.util.Comparable and java.util.Comparator to sort data. In this example, I would using some example of student data, to sort it using both ways.

Comparable is an interface under java.util, the class of the student data must implements it, in order using Collections.sort() to sort it. The programmer need to implements the compareTo() method in order to achieve it.

Comparator is another interface under java.util, it provide more flexibility in sorting the data in many ways. With using Comparator,  the programmer is required to make another class which implements Comparator but no implements on class of student data. The benefits are we need not to modify the class of data being sorted, and also we can create as more as possible the Comparator class, provide many sorting method. Lastly, the programmer need to implements the compare() method in order to achieve it.

Here I using the Comparable to sort the Student Data. Below is the code and the output.

import java.util.*;

// Demonstrate using Comparable to sort the student data based on ID, Name, Age

class Student implements Comparable<Student> {
    private int ID;
    private String name;
    private int age;

    public Student(int i, String s, int a) {
        ID = i;
        name = s;
        age = a;
    }

    public int getID() {return ID;}
    public String getName() {return name;}
    public int getAge() {return age;}

    public int compareTo(Student stu) {
        // sort based on ID
        return this.ID – stu.ID;
    }

    public String toString() {
        return ID + "\t" + name + "\t" + age;
    }
}

public class StudentData {
    public static void main(String args[]) {
        List<Student> list = new ArrayList<Student>();
        list.add(new Student(3,"Mohan",50));
        list.add(new Student(2,"fyhao",20));
        list.add(new Student(5,"Ahmin",35));
        list.add(new Student(6,"Abang",32));
        list.add(new Student(1,"Meili",13));

        System.out.println("Before Sort:\nID\tName\tAge");
        for(Student stu : list) {
            System.out.println(stu);
        }

        Collections.sort(list);

        System.out.println("After Sort:\nID\tName\tAge");
        for(Student stu : list) {
            System.out.println(stu);
        }
    }
}

 

Where below is the implementation of the code using Comparator to sort it. I demonstrated it using three different sorting method, you all can check it out from below the code and the output.

import java.util.*;

// Demonstrate using Comparator to sort the student data based on ID, Name, Age

class Student {
    private int ID;
    private String name;
    private int age;

    public Student(int i, String s, int a) {
        ID = i;
        name = s;
        age = a;
    }

    public int getID() {return ID;}
    public String getName() {return name;}
    public int getAge() {return age;}

    public String toString() {
        return ID + "\t" + name + "\t" + age;
    }
}

class reverseAge implements Comparator<Student> {
    public int compare(Student s1, Student s2) {
        return s2.getAge() – s1.getAge();
    }
}

class reverseAlphabetical implements Comparator<Student> {
    public int compare(Student s1, Student s2) {
        return s2.getName().compareTo(s1.getName());
    }
}

class naturalID implements Comparator<Student> {
    public int compare(Student s1, Student s2) {
        return s1.getID() – s2.getID();
    }
}

public class StudentData {
    public static void main(String args[]) {
        List<Student> list = new ArrayList<Student>();
        list.add(new Student(3,"Mohan",50));
        list.add(new Student(2,"fyhao",20));
        list.add(new Student(5,"Ahmin",35));
        list.add(new Student(6,"Abang",32));
        list.add(new Student(1,"Meili",13));

        System.out.println("Before Sort:\nID\tName\tAge");
        for(Student stu : list) {
            System.out.println(stu);
        }

        Collections.sort(list, new reverseAge());

        System.out.println("After Sort (Reverse Age):\nID\tName\tAge");
        for(Student stu : list) {
            System.out.println(stu);
        }

        Collections.sort(list, new reverseAlphabetical());

        System.out.println("After Sort (Reverse Name):\nID\tName\tAge");
        for(Student stu : list) {
            System.out.println(stu);
        }

        Collections.sort(list, new naturalID());

        System.out.println("After Sort (Natural ID):\nID\tName\tAge");
        for(Student stu : list) {
            System.out.println(stu);
        }
    }
}

 

All right, any more questions about this? I will waiting for your reply.

I currently doing some sample or experiments about generic collection, a new thing added in Java SE 5. It is very interesting but a bit complex, so I need to deep study about it.

Here is my code and the interface shown.

import java.util.*;

class Some {
    public <T> T getCode(T n) {
        return n;
    }
}

abstract class Animal<E> {
    abstract void eat(E x);
}

class Fish<E extends Animal> extends Animal<E> {
    public void eat(E x) {
        System.out.println("Fish: " + x);
    }
}

class Cat<E extends Fish> extends Animal<E> {
    public void eat(E x) {
        System.out.println("Cat: " + x);
    }
}

class Dog<E extends Animal> extends Animal<E> {
    public void eat(E x) {
        System.out.println("Dog: " + x);
    }
}

class MyEatList {
    public void addFish(List<? super Fish> list) {
        list.add(new Fish());
    }

    public void addDog(List<? super Dog> list) {
        list.add(new Dog());
    }

}

class GenericClass {
    public static void main(String args[]) {
        Some s = new Some();
        System.out.println(s.getCode(1));
        System.out.println(s.getCode("2"));
        System.out.println((s.getCode(1) instanceof Integer));
        System.out.println(s.getCode("2") instanceof String);

        Cat<Fish> c = new Cat<Fish>();
        c.eat(new Fish());

        Dog<Cat> d = new Dog<Cat>();
        d.eat(new Cat());

        List<Animal> eatList = new ArrayList<Animal>();
        MyEatList menu = new MyEatList();
        menu.addFish(eatList);
        menu.addDog(eatList);
        menu.addFish(eatList);
        menu.addDog(eatList);
        System.out.println(eatList);
    }
}