QnA - Pano ba mag-write and mag-read ng text files?

Ang luma na nitong blog ko and tinigil ko na din ang pagpopost dito kasi nawala na yung mga nagtatanong dati. Then nakareceive uli ako ng question sa comments.  So eto uli tayo para mag-explain. :)

The question is from Maria Jean Cabs.  The way I understand it, gusto nya ng madaling way ng pag output (write) and input (read) ng file.  Anyway, there are several ways para makapag write and read ng files.  Lalo na ngayon sa JDK 7 meron na Paths and Path.  I'm assuming student ka kaya ang ituturo ko na lang ay yung madaling way para madali maintindihan.  Once na maintindihan mo na yun, madali mo na din magegets yung iba pang way.  Anyway, here it is:

Sa pag read ng files:


1  package com.pinoyjavatutorial.qna;
2  import java.io.FileNotFoundException;
3  import java.io.FileReader;
4  import java.util.Scanner;
5  public class IOFilesSample {
6 public static void main(String[] args) {
7 try {
8 Scanner scan = new Scanner(new FileReader("c:\\mau\\file.txt"));
9 while(scan.hasNext()){
10 System.out.println(scan.nextLine());
11 }
12 } catch (FileNotFoundException e) {
13 e.printStackTrace();
14 }
15 }
16 }


Sa lines 7-14 na tayo mag concentrate kasi I'm assuming alam mo na yung the rest.  At line 7, naglagay tayo ng try kasi yung FileReader na object pwedeng wala sya maread.  So kailangan gumamit ng try-catch or magthrow ng Exception.  Pinili ko na lang ang mag try and catch.  

Sa line 8, dalawa ang nangyayari dito.  Meron tayo para sa FileReader, meron din para sa Scanner.  Yung sa FileReader, nagcreate tayo ng new object na FileReader then yung parameter sa loob ay yung path and file ng kung saan yung gusto mong basahin na file.  Sa case natin dito, c:\mau\file.txt ang path and file natin.  Then nag declare tayo ng new object ng Scanner at ang parameter natin na ginamit ay yung FileReader na kakacreate lang din natin.  

At lines 9-11, dito naman ipiprint natin lahat ng laman ng file na nabasa natin.  Hanggang meron pang next line (scan.hasNext()), hindi tayo mag e-exit sa loop na yun.  Jut remember, ang pagbasa ni scan ay line by line.  So sa unang scan.nextLine() ang babasahin nya ay yung unang line ng text file.  Sa second na iteration ang babasahin naman nya ay yung second na iteration etc.   

Here's for writing files:


1 package com.pinoyjavatutorial.qna;
2 import java.io.BufferedWriter;
3 import java.io.FileWriter;
4 import java.io.IOException;
5 public class IOFilesSample {
6 public static void main(String[] args) {
7 try {
8        BufferedWriter out = new BufferedWriter(new FileWriter("c:\\mau\\file2.txt"));
9        out.write("hi and hello from\n");
10        out.write("Pinoy Java Tutorial");
11        out.close();
12    } catch (IOException e) {
13     e.printStackTrace();
14    }
15
16 }
17
18 }

Let's start sa line 8.  Kagaya kanina, dalawa nangyayari dito.  Una, we constructed a FileWriter object and it's pointed at c:\mau directory then ang filename ay file2.txt kaya sya c:\mau\file2.txt.  Then meron tayong BufferedWriter na object.  Kailangan natin to para makapag write ng file.  

Then the rest ng lines ay madali lang.  Line 9 will write "hi and hello from" sa file.  Yung "\n" ay hindi makakasama kasi it means "new line" if you'll remember yung mga escape characters sa Java.  Line 10 will again write to the file.  This time "Pinoy Java Tutorial" naman.  And lastly, Line 11 closes the stream.  

So ang output nyan ay:

hi and hello from

Pinoy Java Tutorial

Now if wala yung "\n", ang magiging output ay:

hi and hello fromPinoy Java Tutorial

Kasi nga nawala yung new line.

Again, may iba pang way para makapag read and write.  Ito lang yung naisip ko na pinakamadali tandaan and pinaka maikli.  

That's it pancit. :)

QnA - Ano at pano po ba gamitin ang substring?

A substring returns a substring of a string. Pretty straightforward, right? :) Eto ang mga syntax nya:

substring(int beginIndex)

substring(int beginIndex,int endIndex)

Eto ang sample code using substring:

String subString1 = "Pinoy Java Tutorial by Mau Dim Jr";
System.out.println(subString1.substring(6));
System.out.println(subString1.substring(6, 10));

Sa unang print, ang lalabas ay "Java Tutorial by Mau Dim Jr". Kaya yun ang lumabas kasi isa lang ang pinasa natin na arguement ("6"). At dahil dun, from sa pang 6 na character hanggan sa dulo ng string. Kaya yan ang lumabas. Kindly note na ang unang character sa string ay index 0. Kaya ang pang 6 na character ay "J" kaya dun sya nagstart.

Sa second print, ang lalabas ay "Java". Kaya yun ang lumabas kasi dalawa yung arguement na pinasa natin ("6, 10"). At dahil dun, from sa pang 6 na character hanggan sa pang 10 lang ang kukunin nya.

Java - Lessons on Naming Conventions

Ok, bakit ba mahalaga ang naming conventions or standards? Kasi:

• 80% na binabayad sa software ay napupunta sa maintenance
  
• Bihirang bihira na ang original na author ng isang sofware ay sya na din ang magme-maintain ng code na yun sa buong lifetime ng software na yun. Usually, napapasa-pasa sa iba't ibang programmers ang pag maintain ng code.
  
• Nag-iimprove ang readability ng code kaya mas mabilis maintindihan ng mga susunod na programmers.
  

Pero strict ba dapat ang implementation nito? Hindi naman. Kasi kahit ano nga ang gamitin ng programmer/designer eh oks lang at mag ra-run din ang program. Or kaya minsan may sariling standards ang company or ang authord ng codes mismo. Maganda lang kung makakasunod tayo dito para compliant tayo sa standards at mas madaling maintindihan ng susunod na programmer.

Ano ba ang mga naming conventions:

Packages - lowercase lahat na usually ay nagsisimula sa isa sa mga top level domains: com, edu, gove, mil, net, org or kaya two-letter code ng isang bansa based sa ISO Standard 3166, 1981. Yung mga susunod ay internal standard na ng company.
-sa mga simpleng projects lang, pwede din kahit ano depende na sa programmer/designer. basta dapat all lower case pa din.
Example:

edu.up.linux.core
org.pinoyjavatutorial.main

Classes - haha :D dito ko guilty kasi minsan kahit ano na lang ang name ng class ko or kaya verb ang name na gamit ko. Anyway, ang dapat talaga ay noun. Mixed case ang gamit. Mixed case means yung first letter of each word ay upper case. Minsan tawag nila sa mixed case ay camel case. Kasi parang likod ng camel na may dalawang humps. Anyway, kung ano pa ang tawag dyan, ang mahala ang first letter ng word ay laging capital tapos walang space. Try to avoid acronyms and abbreviations. Unless na yung abbreviation ay mas gamitin kaysa sa meaning nya like URL, HTML, WWW.
Example:

class SchoolBus
class Pencil
class BufferedReader

Interface - Mixed case din sya. Kaya ang first letter ng word ay upper case. Para syang class pero wala na syang restriction na dapat ay noun.
Example:

interface RasterDelegate

Method - should be verbs na ang pagkakasulat ay kagaya ng sa class except yung first letter ay lower case then yung mga sumunod na first letter ng word upper case na.
Example:

doGet();
setName();
main();

Variables - same ng naming convention ng methods pero wala ng restriction na dapat eh verb. Nga pala, variables should not start with underscores (_) or dollar sign $ kahit na pinapayagan sya ng compiler. Confusing kasi tingnan. It should be short and meaningful. Avoid using one letter variables din (e.g. 'a', 'b'). Except kung temporary variables lang.
Example:

int screenWidth;
String name;
int i;

Constants - All upper case na yung space ay replaced by underscores (_).
Example:

final double PI = 3.1416;

static final int END_DATE = 25;

QnA - Para saan po ba ang 'private', 'public', 'static' at 'final' sa pag declare variable?

Sige explain ko yang mga yan pero isasama ko na ang iba pa:

private
public
protected
default

itong dalawa pa:

static
final

ay ihihiwalay natin. Kasi yung static and final ay mga keywords. Yung private, public, protected at default naman ay mga access modifiers. Now lets begin:

Mga Access Modifers sa Java:

private - pinaka restrictive. Ang mga variables (fields), constructors and methods na declared na private ay hindi pwedeng gamitin ng ibang class at interface. Ang pwede lang gumamit ay yung class na kung saan declared ang fields or methods na ito. example:

Person.java:
package org.pinoyjavatutorial.myclasses;

public class Person {

private String name;

public String getName() {
return name;
}

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

Ang pwede lang gumamit kay 'name' ay yung class na 'Person'. Kaya kung may code tayo na ganto:

MainClass3.java:
1 import org.pinoyjavatutorial.myclasses.Person;

2 public class MainClass3 {

3 public static void main(String[] args) {

4 Person human = new Person();
5 human.setName("mau dim jr");
6 System.out.println(human.name);
7 }
8 }

mag e-error yung line 6 kasi we are attempting to use the 'name' variable eh private yun kaya ang makakagamit lang nun ay si 'Person' na class.

public - pinaka least restrictive. Variables (fields), methods, constructors na declared sa isang public class ay pwedeng gamitin ng ibang class sa java kahit nasa ibang package pa sila.

Sa same example natin:

Person.java:
package org.pinoyjavatutorial.myclasses;

public class Person {

public String name;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}
}
Hindi na mag e-error yung line 6 ng MainClass3.java natin kasi 'public' na si 'name'.

protected - medyo tricky to. Pag hindi same package, ang pwede lang gumamit ng variables (fields) and methods declared na 'protected' ay classes na subclass lang nya. Pag same package naman, pwede nya gamitin ang mga fields and methods na declared as protected na parang public lang sya.

default - pag wala kang nilagay na private, public or protected, ang access modifier nya ay default which is also known as 'no modifier' or kaya 'package-private'. Ang makakagamit lang ay yung mga classes na nasa same package nya.

Now, regarding static and final:

Static: isa lang ang value ng variable na static sa lahat ng instance ng class na yun. Example:

MainClass3.java:
1 package org.pinoyjavatutorial.myclasses;

2 import org.pinoyjavatutorial.main.Person;

3 public class MainClass3 {

4 public static void main(String[] args) {

5 Person human1 = new Person();
6 human1.setName("mau dim jr");
7 Person human2 = new Person();
8 human2.setName("jv dim");
9 human2.setFavoritelanguage("Japanese");

10 System.out.println("Name of human1: " + human1.getName());
11 System.out.println("Name of human2: " + human2.getName());
12 System.out.println("Favorite Language of both Persons: " + human1.getFavoritelanguage());

13 }
14 }


Person.java:
package org.pinoyjavatutorial.main;

public class Person {

private String name;
private static String favoriteLanguage;

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

public String getName() {
return name;
}

public void setFavoritelanguage(String language){
this.favoriteLanguage = language;
}

public String getFavoritelanguage(){
return favoriteLanguage;
}
}

Sa example natin, nag create tayo ng dalawang instance ng Person. Isa ay si 'human1' at ang isa pa ay si 'human2' (lines 5 and 7). Nag-set pa nga tayo ng name ng bawat isa. Ang value ng 'name' ni 'human1' ay "mau dim jr" at ang value naman ng name ni 'human2' ay "jv dim" (lines 6 and 8).

Now, tingnan mo, nagset tayo ng favorite language kay human2 (line 9). At nung nagprint tayo ay si human1 ang ginamit natin (line 12). Pero diba hindi pa tayo nagset ng value ng favorite language ni human1 pero nung nag print tayo ng favorite language nya ay pareho ng value na sinet natin kay human2 ang lumabas. Ito ay kasi static ang declaration sa 'favoriteLanguage'. Which means, kung ano ang nilagay mo sa isa, yun din ang magiging value ng lahat ng instances ng class na yun. So kung babaguhin mo yung value ni 'favoriteLanguage' kay human1, mababago din ang value ni human2 kasi nga static silang dalawa. :)

Final - as the name implies, final na sya. Kung sa class mo sya ginamit, hindi sya pwedeng magkaroon ng subclass nya. Kung sa method mo sya nilagay, hindi sya pwede ma-overridden. Kung sa variable, isang beses mo lang sya pwede lagyan ng laman at final na yun. Kung baga sa VB ay 'const' na sya.

QnA - Para saan po ang pag gamit ng mga overloaded na constructor?

Ah, bale ganto po yan. Supposed you're going to create a Java program na merong object na Pencil. Tapos, pag brand lang ang binigay, magkakaroon kagad ng default na grade ang Pencil na object. And default value ng grade ng Pencil ay 'HB'. Pero pag nagbigay ang user ng grade, ang grade na binigay ng user ang gagamitin:

Pencil.java:
package org.pinoyjavatutorial.myclasses;

public class Pencil {

private String brand_1;
private String grade_1;

public Pencil(String brand, String grade){
brand_1 = brand;
grade_1 = grade;
}

public Pencil(String brand){
brand_1 = brand;
grade_1 = "HB";
}

public String toString(){
return brand_1 + " "+ grade_1;
}

}

At ang MainClass.java (nilagyan ko nang line number sa gilid):
1 package org.pinoyjavatutorial.main;

2 import java.util.Scanner;

3 import org.pinoyjavatutorial.myclasses.Pencil;

4 public class MainClass {

5 public static void main(String[] args) {

6 Scanner scan = new Scanner(System.in);
7 String brand,
8 grade;

9 System.out.println("Input brand: ");
10 brand = scan.nextLine();
11 Pencil pencil = new Pencil(brand);
12 System.out.println(pencil);

13 System.out.println("Input another brand: ");
14 brand = scan.nextLine();
15 System.out.println("Input pencil's grade (HB, B, H, etc.): ");
16 grade=scan.nextLine();
17 Pencil pencil2 = new Pencil(brand, grade);
18 System.out.println(pencil2);
19 }
20 }


Kung titinangnan po natin yung line 11, nung nag instantiate po sya ng new Pencil, ang nilagay po nyang parameter ay 'brand' lang. So sa class po natin na Pencil, ang gagamitin na constructor ay ito kasi isang string lang ang parameter:

public Pencil(String brand){
setBrand_1(brand);
setGrade_1("HB");
}

Pero dun sa sa line 17, dalawa na ang argument na nilagay kaya ang gagamitin ng java na constructor ay ito:

public Pencil(String brand, String grade){
setBrand_1(brand);
setGrade_1(grade);
}

Isa pang tanong, pwede kaya na isa lang ang constructor? Tapos manually na lang ilagay yung grade na 'HB' pag brand lang ang binigay? Ang sagot, opo pwede din. Bale magiging ganto ang hitsura ng code natin:

MainClass2.java:
1 package org.pinoyjavatutorial.main;

2 import java.util.Scanner;

3 import org.pinoyjavatutorial.myclasses.Pencil2;

4 public class MainClass2 {

5 public static void main(String[] args) {

6 Scanner scan = new Scanner(System.in);
7 String brand,
8 grade;

9 System.out.println("Input brand: ");
10 brand = scan.nextLine();
11 Pencil2 pencil2 = new Pencil2(brand);
12 pencil2.setGrade_1("HB");
13 System.out.println(pencil2);

14 System.out.println("Input another brand: ");
15 brand = scan.nextLine();
16 System.out.println("Input pencil's grade (HB, B, H, etc.): ");
17 grade=scan.nextLine();
18 Pencil2 pencil2a = new Pencil2(grade);
19 pencil2a.setGrade_1("grade");
20 System.out.println(pencil2);
21 }
22 }

Pencil2.java:
package org.pinoyjavatutorial.myclasses;

public class Pencil2 {

String brand_1;
String grade_1;

public Pencil2(String brand){
brand_1 = brand;
}

public void setGrade_1(String grade){
grade_1 = grade;
}

public String toString(){
return brand_1 + " "+ grade_1;
}
}

Kaso ang pangit dito ay everytime na brand lang ang binigay, kelangan pa natin i-set manually sa code natin yung default value ng grade (line 12 ng MainClass2). Eh pano kung maraming beses sa codes natin na puro brand lang ang binigay, e di set tayo ng set ng default value. Bukod sa set tayo ng set, pag nag palit tayo ng default value, yung lahat ng mga set natin ng grade eh papaltan natin ng new value. Pero kung dun sa dalawang constructor ang gagamitin natin, pag nagpalit ng value yung default na grade, sa constructor lang tayo magpapalit.

Actually, pwede naman gamitin ang kahit ano sa kanilang dalawa. Mas convinient lang gamitin yung unang approach (yung dalawa ang constructor) sa program na ito kaysa sa pag isa lang ang constructor. Pero it doesn't mean na ang overloaded constructor ang pinaka magandang approach. Depende na yan sa diskarte ng programmer or designer kung anong approach ang gagamitin depende kung anong klaseng program ang gagawin. Ang mahalaga eh alam natin kung pano gumagana ang mga overloaded constructor (mga classes na more than 1 ang constructor kagaya nung Pencil.java).

Now, pwede bang 'Pencil pencil = new Pencil();' ang gamitin. Hindi po kasi wala namang constructor na walang parameter sa class na Pencil. Ang meron lang ay 'Pencil(String brand, String grade)' at 'Pencil(String brand)'. Unless maglagay po tayo ng pang tatlong constructor na 'Pencil()'. Pag naglagay po tayo ng constructor na yan, pwede na pong gamitin ang 'Pencil pencil = new Pencil();'.

Isa pa pong tanong, pano kung wala akong ginawang constructor. Kagaya nito:

package org.pinoyjavatutorial.myclasses;

public class Person {

private String name;

public String getName() {
return name;
}

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

}

Kung mapapansin, walang constructor tayo dito. Puro methods ('public String getName()' at 'public void setName(...)') at 'private String name;' lang ang laman ng class natin. Bakit pag ginamit natin dito:

package org.pinoyjavatutorial.main;

import org.pinoyjavatutorial.myclasses.Person;


public class MainClass3 {

public static void main(String[] args) {

Person human = new Person();
human.setName("mau dim jr");
System.out.println(human.getName());

}
}

ay wala syang error eh wala namang constructor yung Person na class. Ang sagot, this is because pag walang constructor na nilagay sa class natin, JVM will automatically create a default constructor na blank lang, based sa name ng class. Kaya sa 'Person human = new Person();' ay hindi sya nag error kahit wala namang 'Person()' na constructor yung Person na class.

QnA - Bakit po pare-pareho ang pangalan ng methods at variables?

Ok, our good friend from Symbianize, sir lhandbhel, posted this question. Eto yung code na tinutukoy nya:

public class Card {
public static final int JACK = 11,
QUEEN = 12,
KING = 13,
ACE = 14,
MIN = 2,
MAX = 14;
protected int faceValue;
protected int actualValue;
protected char suit;
protected boolean visible;

public Card(int fv, char s, boolean v){
this(fv,fv,s,v);
}

public Card(int fv, int av, char s, boolean v){
faceValue = (fv >= MIN && fv <= MAX) ? fv : 2;
actualValue = av;

if(s == 'C' || s == 'H' || s == 'D' || s == 'S'){
suit = s;
}
else{
suit = 'C';
}
visible = v;
}

public void setVisible(boolean v){
visible = v;
}

public boolean getVisible(){
return visible;
}

public String toString(){
if(!visible){
return "??";
}
String face;
if(faceValue >= 2 && faceValue <= 10){
face = String.valueOf(faceValue);
}
else{
switch(faceValue){
case JACK:
face = "J";
break;
case QUEEN:
face = "Q";
break;
case KING:
face = "K";
break;
case ACE:
face = "A";
break;
default:
face = "2";
}
}
face += suit;
return face;
}

public void setValue(int av){
actualValue = av;
}
public int getValue(){
return actualValue;
}

public int getFaceValue(){
return faceValue;
}

public static char[] getSuit(){
char[] suits = {'C','H', 'S', 'D'};
return suits;
}

public boolean isPictureCard(){
if (faceValue >= JACK && faceValue <= KING){
return true;
}
return false;
}
}

Ang tanong nya po, bakit nga naman merong dalawang parang method na same ang pangalan:

public Card(int fv, char s, boolean v)public Card(int fv, int av, char s, boolean v)

First off, di po yan method, its a constructor. Tawag ng iba dyan ay special methods daw. Pero techinically, magkaiba po ang constructor and methods. To po yung difference nila:

1. A constructor will never have an explicit return type. Unlike sa mga methods, may mga statement na kagaya ng 'return x + x' or something similar to that. Or kaya merong nakalagay na 'void' kung walang return type. Ang constructor po walang ganun.
2. di po sya inherited.

Now, para san po ba ang mga constructor? Bale ganto po yan, sa java pag nag-instantiate ka ng new object:

Card kard = new Card(2, 'H', v)

or kaya

Card kard = new Card(2, 3, 'H', v)

yung mga statements na may 'new' na keyword, pag ginamit mo yun, naiinvoke yung mga constructor. Now depende kung ilan yung nilagay mong arguments ang tatawagin ng JVM na constructor. Kung 3 lang, yung unang Card(..) ang tatawagin; kung 4 ang arguments na nilagay mo, yung second ang tatawagin. Ang tawag po dito ay overloaded constructor. Normally isa lang po ang constructor ng isang class. Pero pwede din naman madami, kagaya nitong code na sinend sakin. At yun nga, pag madami ang constructors ang tawag dun ay overloaded constructors.

Nga pala, meron din pong overloaded methods. Kagaya din po ng overloaded na constructor kung pano sila mag work: same name then iba-iba yung dami ng mga parameters. Yung nga lang, instead of constructors, sa methods naman sya. Kagaya nito:

public void doDance(String steps){
....
}

public void doDance(String steps, String musicTitle){
....
}

Regarding sa parehong mga variable names, ok lang po yan kasi diba merong mga scopes ang variables. Example:

public void doDance(String steps){
....
}
Sa method na to meron tayong 'steps' na variable. Pero itong 'steps' na variable na to ay magagamit lang within sa doDance method. Depende kasi kung saan declared yung variable ang lawak ng scope nya. Eto pa ang isang example:

for(int counter = 0; counter <>
...
}

Now hindi mo pwede gamitin sa labas ng for-loop yung 'counter' variable kasi declared sya within the for-loop kaya dun lang scope nya.

Dun po sa code na pinost, ok lang po yan at magwowork kahit may same name. Kasi sa magkaibang constructor naman po sila nilagay. :)

QnA - Pano po ang sample Splash Screen sa J2ME?

Ah, madali lang yan. :) Meron akong nabasang book dati pa. Parang sa Sun ata na book yun. Anyway, eto po yun:

Name this as SplashScreen.java:

package com.pinoyjavatutorial.screens;

import java.util.Timer;
import java.util.TimerTask;

import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Graphics;

public class SplashScreen extends Canvas {
private Display display;
private Displayable next;
private Timer timer = new Timer();

public SplashScreen(
Display display, Displayable next ){
this.display = display;
this.next = next;

display.setCurrent( this );
}

protected void keyPressed( int keyCode ){
dismiss();
}

protected void paint( Graphics g ){
g.setColor(0x000000);
g.drawString("Hello World from Pinoy Java Tutorial!", getWidth() / 2, getHeight() / 2, Graphics.HCENTER | Graphics.TOP);
}

protected void pointerPressed( int x, int y ){
dismiss();
}

protected void showNotify(){
timer.schedule( new CountDown(), 5000 );
}

private void dismiss(){
timer.cancel();
display.setCurrent( next );
}

private class CountDown extends TimerTask {
public void run(){
dismiss();
}
}
}

then to naman yung mismong main class: Main.java
package com.pinoyjavatutorial.main;

import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;

import com.pinoyjavatutorial.screens.SplashScreen;

public class Main extends MIDlet implements CommandListener {

private Display display;
private Command exit = new Command("Exit", Command.EXIT, 1);

protected void destroyApp(boolean bool)
throws MIDletStateChangeException {
exitMIDlet();
}

protected void pauseApp() {
}

protected void startApp() throws MIDletStateChangeException {
if (display == null) {
display = Display.getDisplay(this);
new SplashScreen(display, new FormTalaga());
}
}

public void exitMIDlet() {
notifyDestroyed();
}

public void commandAction(Command c, Displayable d) {
exitMIDlet();
}


class FormTalaga extends Form {
FormTalaga() {
super("FormTalaga");
addCommand(exit);
setCommandListener(Main.this);
}
}
}

Ang maganda po dito, pag pumindot kayo, mawawala na yung screen. Yung ibang approach kasi like while and for loops medyo minsan ayaw mawala nung splash screen pag pumindot ka na. Or kaya it tends to be inconsistent kasi based sya sa frequency ng processor ng device.

QnA - Bakit po hindi pwedeng mag add ng textfield sa canvas?

Adding textfield to a canvas? Oo at maybe ang sagot dyan. :) Naturally, hindi kasi a textfield is somewhat a higher type of UI and canvas is a lower type.

Ganto kasi, think of it this way: a textfield is a doc type of file and a canvas is a text file. If titingnan mo yung dalawa, parehas silang nakakapag store ng strings. However, the way a text file is stored is very different sa way a doc file is stored. Kasi ang a doc file can contain graphics, font formatting, etc. Pero ang text file is just a simple low level flat file.

Now, ang textfield at canvas ay parehong J2ME class. Pero kagaya ng text file and doc file na ang way ng representation ay magkaiba, the way a textfield and canvass are represented sa JVM and how they work ay different din which makes them incompatible sa isa't isa kaya you can't mix them on the same screen.

Sabi ko kanina maybe pwede din sila magkasama. Kasi a couple of months ago, may nabasa ko about Synclast. I think may custom class sila which enables you to work both on textfields and canvass. I haven't tried it yet kaya I can't vouch for this pero if my memory serves me right, pwede po ito. :)

QnA - Para saan po ang property file?

A property file is just an ordinary text file that holds data that can be use by the java program. Think of it as a .ini file sa mga windows program. Sa case ng java, .properties naman ang extension nya.

QnA - Bat ayaw gumana ng 'Double.parseDouble(...)' sa J2ME application ko?

Naencounter ko lang tong tanong na to lately. Two things:

1. Meron kang class na ginawa na ang name ay 'Double'
2. Ang configuration mo ay CLDC 1.0 instead of CLDC 1.1

Now yung number 1 sa taas, madali lang gawan ng paraan. Either use a fully qualified name or rename mo na lang yung class mismo.

Yung number 2, madali lang din gawan ng paraan. If you're using Netbeans:

1. sa kaliwa ng screen, there's a 'Projects' tab. Right click mo yung project mismo na nag e-error yung 'double' then select 'Properties'.
2. Sa 'Device Configuration:' na field, select 'CLDC-1.1' instead of 'CLDC-1.0' and hit 'Ok'. That should do the trick.

Under Eclipse, accidentally setting it to CLDC 1.0 ay may pagka-rare kasi puro 1.1 na yung configuration but just in-case you want to know kung pano gawin to under Eclipse:

1. Sa 'Package Explorer' sa kaliwang side ng screen, Right click mo yung project mismo na nag-e-error yung 'double' then select 'Properties'.
2. Sa mga choices sa kaliwa, click on 'Java ME'
3. Click on 'Manage Devices' button sa kanan.
4. Click mo yung appropriate na device that you are developing for. Just make sure na 'CLDC1.1' yung pipiliin mo sa mga choices. then click 'Ok' sa mga window.

Brief background lang kung bakit sa CLDC1.0 eh nag-e-error yung mga double, float, etc. Kasi sa CLDC1.0, floating point operations are not fully supported. Kasi during that time, yung mga small device processors na target ng J2ME does not support floating point operations. Pero sa CLDC1.1, wala na po tong problem na to.

That's it pancit! :) Happy coding! :D