අපි Java ඉගෙන ගනිමු

J2ME වැඩසටහන් සඳහා අතුරුමුහුණත් සැකසීම (LWUIT part1)

2012-02-10T11:23:00.000+05:30

අපි අද සිට ඉගෙනගන්න යන්නේ J2ME වැඩසටහන් ලිවීමේදී අතුරුමුහුණත් හදන්නෙ කොහොමද කියල. මේ සඳහා ක්‍රම ගණනාවක් තිබුනත් සුදුසුම ක්‍රම 2 ක් විශේශයි. අපි දැන් බලමු ඒ මොනවාද කියල.

LCDUI (Limited Capability Device User Interface) : මෙය මූලික සහ ප්‍රධානම අතුරු මුහුනත් සැකසීමේ ක්‍රමයයි. සීමාසහිත පහසුකම් තමයි මෙමගින් ලබාගන්න පුලුවන්
LWUIT (Light Weight User Interface Toolkit) : මෙමගින් අපිට පුලුවන් වඩා දියුණු user interface සැකසීමට. Layouts සහ අනෙකුත් බොහොමයක් අපිට හුරු පුරුදු widgets සඳහා මෙහි සහය දක්වනවා. මූලික OOP සංකල්ප ගැන, event handling ගැන අවබෝධයක් තිබේනම්. මෙය සමග වැඩකරන එක බොහොම පහසුයි. එමෙන්ම MIDP 2.0 මත ක්‍රියාත්මක වන device independent ක්‍රමයක්.

අපි ඉදිරි ලිපි පෙලින් මේ LWUIT ගැන අවබෝධයක් ලබාගැනීමට උත්සාහ කරමු.

මේ සම්බන්ද මුල්ම පාඩමෙන් පෙන්වාදුන් නිසා මේ ලිපිය කියවන අය sun wireless toolkit එක බාගත කරගෙන , ස්ථාපනය කරගෙන ඇති කියල සිතනවා.

අපි දැන් පියවරින් පියවර බලමු කොහොමද අතුරුමුහුණත් සැකසීමට LWUIT යොදාගන්නෙ කියල. Official LWUIT tutorial එක බොහොම ප්‍රයෝජනවත් මෙම ලින්ක් එකෙන් ඒ PDF එක භාගත කරගන්න පුලුවන්.

පියවර 1 : අලුත් project එකක් ආරම්භ කිරීම.

File -> New Project -> MIDP Application යන්න තෝරා next ලබාදෙන්න. ඉන්පසු ලැබෙන වින්ඩෝ එකේ ප්‍රොජෙක්ට් එකේ නම ලබාදෙන්න.

"create Hello midlet" untick කරන්න. (screenshot එක බලන්න)

දැන් next ක්ලික් කරන්න. ඉන්පසු ලැබෙන වින්ඩෝවේ ඇති "finish" යන බට්න් එක ක්ලික් කරන්න.

දැන් ඔබට පෙනෙනවා ඇති project panel එකේ අපි ආරම්භ කල ප්‍රොජෙක්ට් එක පෙන්වන ආකාරය.

එහි default package එක යටතේ කිසිඳු midlet එකක් දැකිය නොහැකියි.

පියවර 2 : LWUIT library එක ප්‍රොජෙක්ට් එකට ඇතුලත් කර ගැනීම.

LWUIT library එක MIDP specification එකට අදාල එකක් නොවේ. එය වෙනම library එකක්. එම නිසා එය අපගේ ප්‍රොජෙක්ට් එකට අන්තර්ගත කරගැනීම කල යුතුයි.

මේ සඳහා අපේ ප්‍රොජෙක්ට් එක යටතේ පවතින "resources" මත right click කර "add library" තෝරාගබ්න්න. ඉන්පසු ලැබෙන ලිස්ට් එකෙන් LWUIT තෝරාගෙන "add library" ක්ලික් කරන්න.

පියවර 3 : වැඩසටහන්කරණය සිදුකිරීම

දැන් අපිට පුලුවන් අලුත් midlet එකක් හදාගෙන වැඩසටහන ආරම්භ කිරීමට. ඒ සදහා default package එක මත right click කර new->midlet තෝරාගන්න.

midlet එකට නමක් දෙන්න.

ඉන්පසු අලුතින් ඇතුලත් කල midlet එකට අදාලව පහත ආකාරයෙන් කේතයක් ස්වංක්‍රීයව ලැබිය යුතුය.

import javax.microedition.midlet.*;

/**
 * @author Kanishka
 */
public class FirstMidlet extends MIDlet {
    public void startApp() {
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }
}

දැන් අපි බලමු සරල වැඩසටහනක් ලියන අන්දම.

import com.sun.lwuit.Display;
import com.sun.lwuit.Form;
import com.sun.lwuit.Image;
import com.sun.lwuit.Label;
import com.sun.lwuit.layouts.BorderLayout;
import java.io.IOException;
import javax.microedition.midlet.*;

/**
 * @author Kanishka
 */
public class FirstMidlet extends MIDlet {
    public void startApp() {
        Display.init(this);
        Form f = new Form("My LWUIT Demo");
        f.setLayout(new BorderLayout());

        Image img;
        try {
            img = Image.createImage("/img/img.png");

            Label centerLabel = new Label("Center Label");
            centerLabel.setIcon(img);
            f.addComponent(BorderLayout.CENTER, centerLabel);
            f.addComponent(BorderLayout.NORTH, new Label("North Label"));
            f.show();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }
}

පැහැදිලි කිරීම .

Line 14 : Display.init(this);

මෙහිදී අප සිදුකරනුලේ lwuit framework එක initialize කිරීමයි.

Line 15 : Form f = new Form("My LWUIT Demo");

මෙහිදී අපි විසින් UI එකට අදාල form object එක සකසාගැනීම සිදුකරනවා. ඉදිරියේදී UI එකට අදාල widgets ඇතුලත් කරනු ලබන්නේ මේ form object එක යටතේයි.

Line 16 : f.setLayout(new BorderLayout());

layout එක set කිරීම මෙහිදී සිදුකෙරෙනවා. එය form object එකට අදාලවයි සිදුකරන්නේ. අපි ඉදිරි පාඩම්වලදී බලමු layout පිලිබඳව.

Line 22 : Label centerLabel = new Label("Center Label");

ලේබල් object එක සකසාගැනීම මෙහිදී සිදුකෙරේ.

Line 24: f.addComponent(BorderLayout.CENTER, centerLabel);

අප create කරගත් Label object එක form එකට ඇතුලත් කරගැනීම මෙහිදී සිදුකෙරේ. අප form එකට ලබාදී ඇත්තේ Border layout එක නිසා ලේබල් එක ස්ථානගතවිය යුත්තේ කවර ආකාරයෙන්ද යන්නත් මෙහිදී සඳහන් කර තිබෙනවා BorderLayout.CENTER

Line 26 : f.show();

මෙමගින් සිදුකරන්නේ form object එක ජංගම දුරකතන තිරයේ දර්ශනය වීමට සැලැස්වීමයි.

අපි දැන් මෙහි output එක විමසා බලමු.

ඉදිරි පාඩම් වලදී අනෙකුත් widgets පිලිබදව සොයාබලමු.

J2ME සඳහා අතුරුමුහුණත් සැකසීම (Alert View)

2011-11-19T12:08:00.000+05:30

J2ME සඳහා අපි පසුගිය ලිපිවලින් ප්‍රවේශයක් ලබාගත්තා. අපි මින් ඉදිරියට බලමු J2ME සඳහා අතුරුමුහුණත් සකසන අන්දම. මුලින්ම අපි සලකා බලමු Alert class එක පිලිබදව. අපිට Alert class එක හමුවනුයේ javax.microedition.lcdui පැකේජය තුලදීය. එහි ස්වරූප කිහිපයක් ඇත අවස්ථානුකූලව අපට ඒ ඒ අන්දමින් Alert object සාදා භාවිතාකිරීමට එම නිසා හැකියාව ඇත. Alert එකක විවිධ ස්වරූපයන් AlertType class එක තුල define කර තිබේ. අපි දැන් බලමු J2ME හිදී සරල Alert එකක් පෙන්වන ආකාරය.

import java.io.IOException;
import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.AlertType;
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.lcdui.Image;
import javax.microedition.midlet.*;

/**
 * @author Kanishka
 */
public class MidletGUIDEmo extends MIDlet implements CommandListener{
    Form frm;
    Alert alert;
    Command exitCmd;
    

    public MidletGUIDEmo() throws IOException {
        frm=new Form("Alert Demo");
        Image img=Image.createImage("/Sri_Lanka.png");
        this.alert = new Alert("Access Granted!", "You have logged in succesfully!", img, AlertType.INFO);
        
        exitCmd=new Command("Exit", Command.EXIT, 0);
        frm.addCommand(exitCmd);
        frm.setCommandListener(this);
    }

    public void startApp() {
        frm.append(new String("This midlet demonstrates the Alert view and its attributes"));
        Display.getDisplay(this).setCurrent(frm);
        Display.getDisplay(this).setCurrent(alert);
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }

    public void commandAction(Command c, Displayable d) {
        if(c==exitCmd){
            destroyApp(false);
            notifyDestroyed();
        }
    }
}

Output:

දැන් අපි මෙහි ක්‍රියාකාරීත්වය වටහාගැනීමට උත්සාහ කරමු.

1 සිට 10 වන පේලිය දක්වා ඇති import statement වලින් සිදුකෙරෙනුයේ අප භාවිතාකල J2ME specification එකට අයත් classes import කරගැනීමයි.

අපගේ midlet class එකෙහි ආරම්භය 15 වන පේලියයි. එහි ඔබට පෙනනවා ඇති සාමාන්‍ය MidletGUIDEmo නම් අප විසින් define කර ඇති class එක MIDlet නම් class එකෙන් extend කර ඇති ආකාරය. යම් class එකක් midlet එකක ක්‍රියාකාරීත්වය දැක්වීමට නම් එය MIDlet නම් class එකෙහි subclass එකක් විය යුතුය. මෙහිදී භාවිතාවන්නේ inheritance නම් Object Oriented ගුණාංගයයි. inheritance පිලිබඳ වැඩිදුර දැනගැනීම පිණිස පසුගිය inheritance පාඩම සඳහා මෙතනින් පිවිසෙන්න.

15 පේලියේ CommandListener නම් interface එක implement කරන බව දක්වා ඇත්තේ මෙම වැඩසටහනේ command event handle කිරීමට අපවිසින් සැලසුම් කර ඇති නිසයි. CommandListener එක implement කරන නිසා public void commandAction(Command c, Displayable d) නම් method එක අපට සම්පූර්ණ කිරීමට සිදුවේ. මෙහිදී සිදුවන්නේ event handling කිරීමකි.

MidletGUIDEmo හි constructor එකේදී 22 පේලියේ අප විසින් frm නමින් Form object එකක් සාදා තිබේ. එමගින් සිදුවන්නේ අපගේ වැඩසටහනට මුහුණතක් නිර්මාණය කිරීමට පසුබිම සැලසීමයි.

24 පේලියේදී අප විසින් Alert object එක සෑදීම සිදුවේ. එහිදී පළමුවෙනි parameter එක සඳහා Alert එකෙහි title එකද, 2 වන parameter එක සඳහා Alert එකෙහි අපි පෙන්වන පණිවුඩයද, 3 න් වන parameter එක සඳහා Alert එකෙහි image එකක් අන්තර්ගත කරන්නේ නම් එම Image object එකද image එකක් පෙන්වන්නේ නැතිනම් ඒ වෙනුවට null යෙදිම සිදුකලයුතුය , 4 වන parameter එක සඳහා alert එකෙහි type එකද දැක්වීම සිදුවේ.

Alert type ආකාර පහත පරිදි වේ.

ALARM
CONFIRMATION
ERROR
INFO
WARNING

26 පේලියේදී අප විසින් සිදුකරනුයේ exitCmd නමින් Command Object එකක් සාදාගැනීමයි. එහි 27 පේලියේදී එම සාදාගත් command එක අප විසින් සාදාගත් Form object එකට සම්බන්ද කරගැනීම සිදුකර තිබේ. 28 වන පේලියේදී සිදු කරනුයේ Form එකට CommandListener එක set කිරීමයි. එහිදී අප විසින් CommandListener එකක් ලෙස දක්වා ඇත්තේ this යන්නයි. එසේ කිරීමට අපට හැකියාවක් ලැබුනේ අපගේ midlet class එක CommandListener එක implement කර තිබීම නිසයි.

31 පේලියේ තිබෙන්නේ app එක ක්‍රියාත්මක වන අවස්ථාවේ සිදුවිය යුතු කාර්‍යභාරයයි. එහිදී අපි Form object එකට String object එකක් එකතු කිරීම සිදුවේ. 2 වන රූපෙයෙන් පෙනෙන්නේ එම form එකයි.

33 පේලියෙන් සිදුකරනුයේ අප සාදාගත් form object එක දිස්වීමට සැලැස්වීමයි ඒ සඳහා lcdui පැකේජයේ ඇති Display class එක යොදාගෙන current display instance එක ලබාගැනේ. ඉන්පසු current display instance එක ලෙස form object එක set කිරීම සිදුවේ

34 පේලියෙන් අප විසින් form object එක set කල වහාම අප සාදාගත් alert object එක දිස්වීමට සලස්වයි එම නිසා මෙම වැඩසටහන ක්‍රියාත්මක කිරීමේදී අපට මුලින්ම දැකගැනීමට හැකිවන්නේ form එක නොව alert එකයි. alert එකෙන් ඉවත් වූ පසු ඊට පෙර තිබූ form එක නැවත දිස්වීම සිදුවේ.

43 සිට 48 දක්වා ඇත්තේ event handling සඳහා අදාල කොටසයි. එහිදී ලබාදුන් command එක කුමක්ද යන්න if statement යොදාගැනීමෙන් සොයාබැලේ. මෙම වැඩසටහනට අදාලව සිදුව ඇත්තේ ලබාදුන් command එක exit command එකද යන්න පරීක්ෂාකිරීමකි.

ඉහත අප විසින් ලබාගත් දැණුම උපයෝගී කරගෙන දැන් අපි බලමු confirmation dialog එකක් Alert class එක උපයෝගී කරගෙන සකසාගන්නා අන්දම.

මේ සඳහා අප විසින් කල යුත්තේ ඉහත ආකාරයටම Alert එකක් සකසාගෙන එයට Yes, No වැනි command 2 ක් add කර එම command handle කිරීමට command listener එකක් යෙදීමයි. අපි දැන් බලමු මෙය සිදුරගන්නේ කොහොමද කියල.

import java.io.IOException;
import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.AlertType;
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.lcdui.Image;
import javax.microedition.midlet.*;

/**
 * @author Kanishka
 */
public class MidletGUIDEmo extends MIDlet implements CommandListener{
    Form frm;
    Alert alert;
    Command exitCmd;
    Command yesCmd,noCmd;
    

    public MidletGUIDEmo() throws IOException {
        frm=new Form("Alert Demo");
        Image img=Image.createImage("/qs.png");
        alert = new Alert("Confirmation!", "Are you a student?", img, AlertType.WARNING);

        //adding commands to the alert
        yesCmd=new Command("Yes", Command.ITEM, 1);
        noCmd=new Command("No", Command.ITEM, 1);
        alert.addCommand(yesCmd);
        alert.addCommand(noCmd);
        //set the command listener to the Alert object
        alert.setCommandListener(this);

        //adding a command to the form
        exitCmd=new Command("Exit", Command.EXIT, 0);
        frm.addCommand(exitCmd);
        frm.setCommandListener(this);
    }

    public void startApp() {
        frm.append(new String("This midlet demonstrates the Alert view and its attributes"));
        Display.getDisplay(this).setCurrent(frm);
        Display.getDisplay(this).setCurrent(alert);
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }

    public void commandAction(Command c, Displayable d) {
        if(c==exitCmd){
            destroyApp(false);
            notifyDestroyed();
        }else if(c==yesCmd){
            Display.getDisplay(this).setCurrent(frm);
            frm.append(new String("\nYou are a student"));
        }else if(c==noCmd){
            Display.getDisplay(this).setCurrent(frm);
            frm.append(new String("\nYou are not a student"));
        }
    }
}

මෙහිදී අපි 18 , 19 පේලි 2 හිදි command 3 ක් declare කර තිබෙනවා exitCmd එක form එකටද yesCmd, noCmd දෙක alert එකටද පිලිවෙලින් 37 , 30 , 31 පේලි වලදී යොදා තිබෙනවා.

53 sita 64 දක්වා ඇත්තේ අප විසින් එකතු කරන ලද command සදහා කර ඇති event handling කේත කොටසයි.

මෙහිදී form එක සහ alert එකට වෙන වෙනම listeners නොයොදා එකම listener එකකින් එනම් midlet එක implement කර ඇති listener එකෙන්ම form එකට සහ alert එකට සම්බන්ද command අදාල කේතයන් සිදුකර තිබෙනවා.

මෙය එතරම් හොඳ practice එකක් නොවන බව බැලූ බැල්මටම ඇතමෙක්ට හිතෙන්න පුලුවන්. ඒ වෙනුවට alert එකට වෙනම listener එක්ද form එකට වෙනම listener එක්ද යෙදුවේනම් වැඩසටහනෙහි readability එක වැඩිවන බව පෙනුනත් අප මෙහිදී විශේෂයෙන්ම සලකා ඇත්තේ වැඩසටහනෙහි performance එකයි. listener එකක් background thread එකක ක්‍රියාකාරීත්වය දක්වයි. එමනිසා listener ගණනාවක් යෙදීම හැකිතාක් අඩුකරගත යුතුය. listener එකක් ධාවනය වීමට allocate වනුයේ ජංගම දුරකතනයක resources නිසා අප desktop application එකක මෙන් නොව මෙහිදී listeners පිලිබඳ විශේෂ සැලකිල්ලක් දැක්විය යුතුවේ.

අපි ඊලඟ පාඩමෙන් අනෙකුත් J2ME GUI classes පිලිබඳ සලකා බලමු.

J2ME ක්‍රමලේඛණය සඳහා ආරම්භයක්

2011-11-18T10:30:00.000+05:30

පසුගිය ලිපියේ අපි J2ME සඳහා හැඳින්වීමක් සහ J2ME සමග වැඩකිරීමට සඳහා අවශ්‍යවන මෘදුකාංග පිලිබඳ සොයා බැලුවා. අපි මෙම ලිපියෙන් අදහස් කරන්නේ Java ME යොදාගෙන මෘදුකාංග සංවර්ධනය කිරීමේදී දැනගත යුතු මූලික සංකල්ප පිලිබඳවයි.

මුලින්ම අපි බලමු sun wireless toolkit එක යොදාගෙන J2ME ව්‍යාපෘතියක් ආරම්භ කරන ආකාරය. ඔබගේ පරිගණකයේ සාර්ථකව sun wireless toolkit එක ස්ථාපනය කර ඇත්නම් desktop හි Java(TM) ME Platform SDK නමින් shortcut එකක් තිබිය යුතුයි. එසේ නොමැතිනම් all programs හි Java(TM) ME Platform SDK යටතේ එය සොයාගත හැකියි.

අලුතෙන් ව්‍යාපෘතියක් පටන්ගන්නා අන්දම.

File->New Project යටතේ MIDP Application තෝරා ගන්න.

ඉන්පසු ලැබෙන වින්ඩෝ එකෙහි ව්‍යාපෘතිය සඳහා නමක් ලබාදෙන්න.

Default Platform එක සඳහා පහත screenshot එකේ අන්දමට සැකසුම් ලබාදෙන්න.

එවිට සැදෙන නව ව්‍යාපෘතිය සරල midlet එකක් දැන් ඔබට දැකගත හැකිවනු ඇති. අපට අවශ්‍ය අන්දමින් ව්‍යාපෘතිය ඉදිරියට ගෙනයාම සඳහා එහි ස්වයංක්‍රීයව generate වී ඇති hello පැකේජය මකාදමන්න.

ඉන්පසු ඔබගේ ව්‍යාපෘතිය මත right click කර එහි properties හි ඇති delete කරන ලද midlet එකේ නම midlet suit list එකෙන් ඉවත් කරන්න.

දැන් ව්‍යාපෘතිය තුල සුදුසු නමකින් අලුත් midlet එකක් සාදාගන්න (new -> midlet ) එවිට පහත අන්දමේ කේත කොටසක් අලුත් midlet class එක තුල ඔබට දැකගත හැකිවනු ඇති.

import javax.microedition.midlet.*;

/**
 * @author Kanishka
 */
public class MidletGUIDEmo extends MIDlet {
    public void startApp() {
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }
}

Midlet lifecycle

අපි මීට පෙර Applet , Thread යනාදියේ life cycle පිලිබඳ සාකච්ඡා කර තිබෙනවා. life cycle එකක් නිරූපණය කරනුයේ state transition diagram එකකිනි. පහත දැක්වෙන Midlet lifecycle එකෙහි නිරූපණය වනුයේ Midlet එකක ප්‍රධානම state 4 නිරූපණය කරන state transition diagram එකකි. එනම් midlet lifecycle එකයි.

midlet එක install කර ඇති ජංගම දුරකතනයට ඇමතුමක් ලැබීමේදී midlet එක pause state එකට පැමිණීම සිදුවේ. midlet එකෙන් exit වූ පසු එය destroyed state එකට පැමිණේ. මෙම states පිලිබඳ වැඩිදුර අවබෝධයක් ඉදිරි අධ්‍යයනයන්හිදි ලබාගත හැකිය.

J2ME යොදාගෙන මෘදුකාංග ලිවීමේදී අනුගමනය කල යුතු රීති

සරල බව

application එක සරල විය යුතුය. උදා : සංකීර්ණ menus නොයෙදීම. කුඩා කාර්යයක් සිදුකිරීමටත් forms ගනනාවක් අතර යාමට ඉඩ නොතැබීම. inheritance hierarchy එකෙහි height එක අඩු අගයක පවත්වාගැනීම, modules කිහිපයක් ඇත්නම් ඒවා අතර low coupling එකක් පවත්වාගැනීම ආදියයි.

Memory භාවිතය අඩුවෙන් පවත්වාගැනීම

ජංගම දුරකතන යනු desktop හෝ laptop පරිගණක වැනි ඉහල ධාරිතාවයකින් යුතු RAM එකක් අන්තර්ගත කර ඇති devices නොවේ. ඇතැම් අවස්ථාවල එය මෙගාබයිට් කිහිපයක් විය හැකිය. කෙසේවෙතත් Midlet ධාවනය සඳහා KVM එකට ලැබෙන Memory ප්‍රමාණය එහි RAM එකේ ප්‍රමාණය මෙන් අර්ධයකටත් වඩා අඩුවිය හැකිය. එම නිසා අප විසින් ලියනු ලබන වැඩසටහනෙහි logic එක හා එය හා සම්බන්ද algorithm අඩු memory භාවිතයක් සඳහා සැලසුම් කල යුතුය.

Midlet එකෙහි විශාලත්වය කුඩා අගයක පවත්වාගැනීම

මෙයද ඉතාවැදගත්වේ. application එකෙහි ප්‍රමානය ඉතාවැඩිනම් එය භාගත කරගැනීමට වැඩි ඩේටා ප්‍රමානයක් වැයවීම සිදුවේ. එමෙන්ම ඇතැම් device හි Midlet එකෙහි ප්‍රමාණය සඳහා සීමා තිබේ උදා : samsung e900 දුරකථනයක midlet එකක් උපරිම 700KB ප්‍රමාණයක් විය යුතුය ඊට වැඩි midlet එහි ස්ථාපනය කල නොහැක.

සරළ GUI(Graphical user interface) පවත්වාගැනීම

Desktop , laptop පරිගණක හිදී මෙන් නොව mobile device එකක screen resolution එක කුඩාය. අනෙකතට ඩෙස්ක්ටොප්, ලැප්ටොප් පරිගණකවල සංකීර්ණ ගැෆික් අතුරුමුහුණත් භාවිතා කිරීම සඳහා නිසිආකාර input ක්‍රමවේදයක් ඇත (උදා : mouse pointer, touch input) නමුත් ජංගම දුරකතනයන්හිදී එය සීමා සහිතවේ. දැන් තිබෙන touch input සහිත device වලදී වුනද සංකීර්ණ GUI හැසිරවීමට බාධක තිබේ.

Network connection භාවිතය අවම කිරීම

දැන් දැන් ජංගම දුරකතන HSPA තාක්ෂණයන් ගෙන් සමන්විතව වෙළඳපොලට ඒමත් data සඳහා දැන් වැයවන මුදලත් ඉතා අඩු අගයක තිබීමත් නිසා යමෙකුට හිතෙන්න පුලුවන් මෙය එතරම් සැලකිල්ලකට ගතයුතු දෙයක් නොවන බව. නමුත් අමතක නොකල යුතු කාරණය නම් බහුතරයක් දුරකතන වේගවත් දත්ත හුවමාරු කිරීමේ තාක්ෂණයන්ගෙන් සමන්විත නොවන බවත් network connection හරහා දත්ත බහුලව හුවමාරු කිරීම දුරකතනයේ බැටරිය විසර්ජනය වීම(discharge) වේගවත් කල හැකි සාධකයකි. එම නිසා network resources හැකිතාක් අඩුවෙන් භාවිතාවන අන්දමට application එක design කල යුතුය. (උදා : proxy design pattern එක යෙදීම )

විශාල processing power එකක් අවශ්‍ය මොඩියුල් server එකක ස්ථාපනය කර ඒවායේ සේවය ලබාගැනීම

ජංගම දුරකතනයක ඉතා විශාල processing power එකක් නොමැත. එමනිසා විශාල processing power එක් අවශ්‍ය තැන්හිදී එම මොඩියුලය සර්වර් එකක ස්ථාපනය කිරීම එක් විසඳුමකි. ඉන්පසු එම මොඩියුලයේ සේවාව ලබාගැනීමට web services, Java RMI (remote method invocation) වැනි ක්‍රමවේදයක් භාවිතා කල හැක.

හැකි සෑම විටම එක දුරකතනයක specification සඳහා සීමා නොවීම

අප විසින් සැලසුම් කරන වැඩසටහන specific screen resolution එකක් ඉලක්ක කරගෙන සිදුකිරීමෙන් ඇතැම් විට වෙනත් දුරකතන වලදී එම වැඩසටහනෙන් නිසි ප්‍රයෝජනයක් ගත නොහැකි විය හැකිය. එමෙන්ම එක් එක් vendor විසින් ලබාදෙන එම brand එකට ආවේනික API (application programming interface) භාවිතය අඩුකර cldc හා midp specification එකටම හැකි සෑම විටම අනුගත වීම කල හැක.

මේ අන්දමින් තවත් රීති කිහිපයක් ඇත ඒවා අපි ඉදිරි පාඩම්වලදී සුදුසු අවස්ථාවන්හිදී සාකච්ඡා කරමු. මෙම රීතින් ජංගම දුරකතන භාවිත යෙදුම් සැකසීම සඳහා වන අනෙකුත් තාක්ෂණයක්(උදා : Android, iOS) සඳහාද අනුගමනය කල හැකිය.

අපි ඊලඟ පාඩමෙන් J2ME තාක්ෂණය යොදාගෙන ජංගම දුරකතන සඳහා අතුරු මුහුණත් සැකසීම ගැන අධ්‍යයනය කරමු.

Java ME සමහ ජංගම දුරකතන සඳහා මෘදුකාංග නිර්මාණයට අත්පොත් තබමු

2011-11-05T18:11:00.000+05:30

ජංගම දුරකතන සඳහා මෘදුකාංග නිර්මාණය කිරීමට platform බොහොමයක් මේ දිනවල දැකගන්න පුලුවන්. මේ දිනවල බහුල වශයෙන් භාවිතා යෙදුම් නිර්මානය කෙරෙණුයේ Android, iOS මෙහෙයුම් පද්ධති සඳහායි. එමෙන්ම දැනට බිලියන ගනණක් ජංගම දුරකතනයන්හි අන්තර්ගත කර ඇති J2ME තාක්ෂණයත් අමතක කරන්න බැහැ. අද සිට අපි උත්සාහ කරමු Java ME platform එක සඳහා මෘදුකාංග නිර්මාණය කිරීම පිලිබඳව අධ්‍යයනය කිරීමට. මේ පිලිබඳව මුලින්ම J2ME තෝරාගන්නට සිතුවේ ඉදිරියේදී Android වැනි platform පිලිබඳ අධ්‍යයනය කිරීමේදී පහසුවක් වන නිසයි.

Java ME තාක්ෂණය අඩු memory මට්ටමක් යටතේ ක්‍රියාත්මක වීම සඳහා optimize කරන ලද Java platform එකකි. එමනිසා මෙහිදී ජංගම දුරකතනයේ memory එක භාවිතා කිරීමේදී සැලකිලිමත් විය යුතුයි. මෙහි හරය ලෙස KVM එක හඳුනා ගන්න පුලුවන්. KVM යනු optimize කරන ලද Java Virtual Machine එකකි. පහත දැක්වෙනුයේ J2ME architecture එකයි.

අපි දැන් බලමු අපිට ආරම්භයේදී අවශ්‍යවන මෘදුකාංග මොනවද කියල.

1) Java ME SDK

http://www.oracle.com/technetwork/java/javame/javamobile/download/overview/index.html

2) Microemu J2ME simulator

http://code.google.com/p/microemu/downloads/list

මෙහිදි අත්‍යවශ්‍ය වන්නේ Java ME SDK එක පමනයි. Microemu simulator එකත් තිබේනම් නොයෙක් J2ME වැඩසටහන් පහසුවෙන් run කර බැලිය හැකියි.

සැයු : Java ME SDK ස්ථාපනය කිරීමට පෙර ඔබගේ පරිගනකයේ Java SE SDK එක ස්ථාපනය කරගෙන සිටිය යුතුයි. මෙතැනින් පිවිසීමෙන් එය බාගත කරගත හැකිවේ. එය ස්ථාපනය කරන අන්දම මෙම පාඩමෙන් දැනගත හැකිය.

ප‍රිගණකය තුල ජාවා ස්ථාපනය කිරීම :: Installing Java

මෙම පාඩම් මාලාව සඳහා Java මූලික සංකල්ප පිලිබඳ දැණුම මෙන්ම ජාවා සමග Object Oriented සංකල්ප හාවිතය පිලිබදව දැණුමක් අවශ්‍යවේ. මෙහි පෙර ජාවා පාඩම් වෙත පිවිස එම දැණුම ලබාගත හැකිවේ යයි සිතමි.

J2ME පාඩම් මාලාව යටතේ අපි අධ්‍යයනය කිරීමට බලපොරොත්තු වන්නේ.

Java ME platform හි මූලික සංකල්ප
මූලික GUI components සහ ඒවායේ භාවිතය
Low level UI (Canvas)
LWUIT (Light weight UI Toolkit)
Network Programming
J2ME persistence
Java ME MMAPI

අපි ඊලඟ පාඩමෙන් බලමු Java ME SDK එක යොදාගෙන J2ME වැඩසටහනක් ලියන අන්දම.

JAVA තුල VECTORS භාවිතය

2011-03-19T09:40:00.004+05:30

JAVA තුල ARRAYS භාවිතය ගැන මීට කලින් කොටස් වලදී මගේ මිත්‍රයා කණිෂ්ක විස්තර කරා ඔයාලට මතක ඇති.දැන් මම ඒ ARRAYS වලට තරමක් දුරට ආසන්නතාවයක් තියෙන ඒත් තරමක් වෙනස් VECTORS පිලිබදව ඔබව තරමක් දුරට දැනුවත් කරන්නයි හදන්නේ. සමහර විට මේ වන විටත් ඔබට VECTORS පිලිබද යම් අදහසක් ඇති කියා මා සිතනවා.

එහෙනන් අපි ප්‍රථමයෙන්ම බලමු , ඇත්තතටම මේ VECTOR කියල කියන්නෙ මොකක්ද කියලා.සරලව කිව්වොත් , Vector එකක් කියන්නෙ , DYNAMIC( ගතික ) තත්වයේ පවතින ARRAY එකක්. VECTOR CLASS එක අන්තර්ගත වෙලා තියෙන්නේ JAVA වල java.util පැකේජය තුලයි. මෙම VECTOR එකට අවශ්‍යතාවය අනුව ස්වයන්ක්‍රීයව වර්ධනය වෙන්න පුලුවන්.තවද, VECTOR එකකට String Array සහ int Array වලදි වගේ නිශ්චිත ස්ථීර ඉඩ ප්‍රමාණයක් අවශ්‍ය වන්නේත් නෑ.කෙසේ හෝ ,Vector එක නිර්මාණය වීමෙන් අනතුරුව,එයට Elements Add කිරීම හෝ Remove කිරීමට අනුකූලව එහි ඉඩ ප්‍රමාණය වර්ධනය වීමට හෝ හැකිලීමට උදව් වෙනවා.

Array එකකදී වගේම ,Integer Index එකක් යොදාගෙන Access කරන්න පුලුවන් Elements/Components මෙහිදී ද අඩන්ගු වෙනවා.අපි දැන් සරලව VECTOR OBJECT එකක් නිර්මාණය කරගන්නා අයුරු සලකා බලමු.

ආරම්භක DEFAUT ප්‍රමාණය(size) සමග VECTOR එකක් නිර්මාණය කිරීම
```
Vector v=new Vector();
```
ආරම්භක ප්‍රමාණය සමග VECTOR එකක් නිර්මාණය කිරීම
```
Vector v = new Vector(100)
```
මෙහි v වෙනුවට අපට අවශ්‍ය වෙනත් නමක් කැමතිනම් යොදාගත හැකියි.

VECTORS වල METHODS භාවිතා කිරීම
VECTOR එකක අවසානයට ELEMENTS ADD කිරීම

v.add(s); //  Vector v එකේ අවසානයට s Add කිරීම

VECTOR එකකින් පිටතට ELEMENT VALUES ලබා ගැනීම

v.get(i); //Vector එකේ i වෙනි index එකේ object එක return කරනවා
v.firstElement(); //Vector v එකේ ප්‍රථම element එක return කිරීම 
v.lastElement();  //Vector v එකේ අවසාන element එක return කිරීම

VECTOR එකේ ELEMENTS ඉවත් කිරීම

v.clear(); //Vector v එකේ සියලුම Elements ඉවත් කිරීම
v.remove(i); //Vector v එකේ i index එකේ element එක ඉවත් කර අනෙක්  පහල elements ටික shift කිරීම

VECTOR එකේ SIZE එක ලබා ගැනීම.

v.size(); //Vector v එකේ තිබෙන මුලු elements ප්‍රමාණය Return කරයි.

VECTORS භාවිතය සරල නිදසුනක් මගින්

දැන් අපි VECTORS වල METHODS භාවිතය නිදර්ශනයක් මාර්ගයෙන් සරල ලෙස වටහා ගැනීමට උත්සාහ කරමු.පහත දක්වා ඇත්තේ එම JAVA වැඩසටහනයි.

/*
# Explaining Java Vector Operations
# Madhawa Udayakantha Gunasekara
# Blog   : http://javaxclass.blogspot.com    
*/

import java.util.*;

public class VectorOperation {

 public static void main(String[] args) {

 //create a Vector object
  Vector v = new Vector();

 /*
 Add elements to Vector (to the end of the vector)
 */
  v.add("1");
  v.add("2");
  v.add("3");


 /*
 display elements of Vector by using get method
 */
 System.out.println("Getting Vector Elements");
        for(int i=0;i<v.size();i++)
          System.out.println(v.get(i));

 System.out.println();

 //displaying first and last elements
  System.out.println("Display only first and last elements");
  System.out.println("First Element: "+v.firstElement());
  System.out.println("Last Element: "+v.lastElement()+"\n");


 //Remove desired elements(in this example 1st index)
  v.remove(1);


 //Display the remaining elements after remove
  System.out.println("Remaining Elements");
  for(int i=0;i<v.size();i++)
   System.out.println(v.get(i));

 System.out.println();


 //Remove all elements from the vector
 v.clear();


 //Adding new list and print
  System.out.println("New Vector List");
   v.add("4");
   v.add("5");
  for(int i=0;i<v.size();i++)
   System.out.println(v.get(i));

  }

}

පැහැදිලි කිරීම

ප්‍රථමයෙන්ම මෙහිදී අපගේ program එකට vectors භාවිතා කර ගැනීම උදෙසා java හි ඇති util පැකේජය යොදාගෙන තිබෙනවා.මෙහිදී PUBLIC CLASS එක VectorOperation යැයි ගනිමු.

17 LINE: v නැමැති VECTOR OBJECT එක නිර්මාණය කරන ආකාරය දක්වා තිබෙනවා.

22-24 LINES: VECTOR එකට අවශ්‍ය ELEMENTS ටික(1,2,3 යන ඒවා ) add() method එක අධාරයෙන් ADD කරයි.

31-33 LINES:මෙහිදී get() METHOD එක අධාරයෙන් FOR LOOP එකක් යොදා ගෙන VECTOR එකේ ELEMENTS සියල්ල කර ගැනීම සිදු කර ගෙන තිබෙනවා.මෙහිදී VECTOR එකේ ELEMENTS සියල්ල දක්වා එකින් එක යාම සදහා FOR LOOP එක තුල CONDITION එකේ v.size() යන්න යොදා ගෙන එහි මුලු ELEMENTS ගණන සමග සැසදීමක් කර තිබෙනවා.තවද මෙහිදී get() METHOD එක ELEMENTS පිටතට ලබා ගැනීමට භාවිතා කර තිබෙනවා.

41-42 LINES: v.firstElement() මගින් VECTOR එකේ FIRST ELEMENT එකත්, v.lastElement() මගින් LAST ELEMENT එකත් පමණක් ලබා ගැනීම සිදු කර තිබෙනවා.

46 LINE: VECTOR එකේ 1 වැනි INDEX එක පමණක් ඉවත් කර තිබෙනවා.

50-52 LINES: 1 වැනි INDEX එකේ ELEMENT එක ඉවත් කරායින් පසුව ඉතිරිවන ELEMENT ටික PRINT කර ගැනීමට පෙර විස්තර කල පරිදිම FOR LOOP එකක් යොදා ගෙන තිබේ.

58 LINE: VECTOR එක තුල පවතින සියලුම ELEMENTS ඉවත් කර VECTOR එක හිස් කිරීම.

62-66 LINES: හිස්ව පවතින VECTOR එකට නැවත අලුතින් ELEMENTS ADD කර නැවත පෙර පරිද්දෙන්ම නව ELEMENTS ටික PRINT කර ගැනීම.

OUTPUT එක

Compile: javac VectorOperation.java

Run : java VectorOperation

ජාවා වැඩසටහනක් සහ PHP වැඩසටහනක් අතර දත්ත හුවමාරු කරන අන්දම

2010-12-29T12:01:00.000+05:30

එක දිගටම ජාවා සම්බන්ද මූලධර්ම සාකච්ඡා කරපු නිසා අපි මේ පාඩමෙන් ප්‍රායෝගික පැත්තට බර කරුණු ටිකක් අධ්‍යයනය කරමු. මේ වන විට පරිගණක වැඩසටහනක් යනු හුදෙක්ම එක් පරිගණකයකට සීමාවූ දෙයක් නොවන බව අපි කවුරුත් දන්න දෙයක්නේ. බොහොමයක් පරිගණක වැඩසටහන් අන්තර්ජාලයට සම්බන්දව පවතිනවා. උදාහරණ විදියට internet messenger වැඩසටහන් , virus guards, වැනි වැඩසටහන් දක්වන්න පුලුවන්. වයිරස් ගාඩ් එකක් සැලකුවොත් එය අන්තර්ජාලය හා සම්බන්ද වන අවස්ථා තමයි අලුත් virus definition තිබේ දැයි පරීක්‍ෂා කිරීම, අලුත් virus definition තිබේනම් ඒවා ලබා ගැනීම, සැක සහිත ගොණුවක් අදාල ආයතනයට upload කිරීම වැනි අවස්ථා. මෙහිදී මූලිකවම සිදුවන්නේ දුරස්ථ සර්වරයක ඇති වැඩසටහනක් හා කිසියම් සන්නිවේදනයක් කිරීමයි.

අපි මෙම පාඩමෙන් අධ්‍යයනය කිරීමට යන්නේ ජාවා වැඩසටහනකින් දුරස්ථ වැඩසටහනක් සමග සම්බන්ද වන ආකාරයයි. මාතෘකාවට අනුව අපි දුරස්ථ වැඩසටහන ලෙස යොදාගන්නේ PHP script එකක්. නමුත් මෙම දුරස්ථ වැඩසටහන Python හෝ Perl script එකක් හෝ වෙනත් ඕනෑම server side script එකක් වීමට පුලුවන්.

කොහොමද දුරස්ථ වැඩසටහනට දත්ත යවන්නේ?

මේ සඳහා අපි යොදාගන්නේ POST method එකයි. HTTP (Hypertext Transfer Protocol) එකට අනුව දත්ත හුවමාරු කිරීමේදී GET සහ POST යනුවෙන් ක්‍රම දෙකක් පවතිනවා. ඉන් GET ක්‍රමයට අනුව දත්ත හුවමාරු කිරීමේදී අදාල දත්ත URL එකට අමුණා යැවීම සිදුවනවා එනම් මෙම දත්ත පිටතට දෘෂ්‍යමාන වනවා එම නිසා password සම්බන්ද දත්ත මෙම ක්‍රමයට හුවමාරු කරන්නේ නැහැ. අනික වරකට යැවිය හැකි දත්ත ප්‍රමාණයේ සීමාවක්ද පවතිනවා.

GET Request එකකට උදාහරණයක්

http://mydomain.org/process.php?name=Kanishka&passw=hellox

POST method එකේදී HTTP request එකේ header එක තුල අදාල දත්ත ඇතුලත්කොට යැවීම සිදුකරනවා. මෙම වැඩසටහනේදී අපි යොදාගන්නේ POST method එකයි. මෙම methods ගැන වැඩිදුර තොරතුරු දැනගැනීම සඳහා මෙතනින් පිවිසෙන්න.

අපිට මේ සඳහා මීට පෙර ඉගෙනගත් streams සම්බන්ද දැනුම වැදගත් වනවා. මෙම වැඩ සටහනෙන් සිදුකරනුයේ දෙන ලද නගරයකට අදාල area code එක ලබාදීමයි. මෙම PHP script එක පහත දැක්වෙනවා.

telCodes.php

<?php
/**      
*Script  : telCodes.php
*Author  : Kanishka Dilshan      
*Purpose : Processing a remote request
*Blog    : http://javaxclass.blogspot.com      
*/ 

$code=$_POST['code'];
$file=fopen("codes.txt","r") or exit("Data file is missing!");
$status=FALSE;
while(!feof($file)){
 $str=fgets($file);
 if(strpos($str,$code)!==FALSE){
  echo $str;
  $status=TRUE;
  break;
 }
}
if($status===FALSE){
 echo "code is not found!";
}
fclose($file);
?>

මෙම වැඩසටහනේ 09 වන පේලියේදී POST request එක මගින් එවන ලද අදාල දත්තය ලබාගන්නවා එය code නම් parameter එක සමග සම්බන්දව පවතිනවා. ඉන්පසු data file එක විවෘත්ත කර එවන ලද code එක එතුල තිබේදැයි පේලියෙන් පේලිය කියවා පිරික්සා බලනවා. එය හමුවූ විට echo විධානය භාවිතාකර අදාල response එක ලබාදෙනවා.

දැන් අපි බලමු මෙම PHP Script එකට දත්ත යවා එහි response එක ලබාගැනීමට ලිවිය හැකි ජාවා වැඩසටහන. මෙම ක්‍රියාවලිය සිදුකරගැනීමට අපි මෙහිදී යොදාගන්නේ net පැකේජය තුල ඇතුලත් URL සහ URLConnection නම් classes දෙකයි. URLConnection එක streams කිහිපයකට සම්බන්ද කරගෙන අදාල ක්‍රියාවලිය සිදුකරගැනීම මෙහිදී මූලික වශයෙන් සිදුවනවා. මෙම ක්‍රියාවලිය Sockets යොදාගෙනද සිදු කිරීම කල හැකියි. අපි ඉදිරි පාඩම් පෙළකින් Sockets පිලිබඳ සාකච්ඡා කරමු.

Java_POST_Req.java

/**      
*class  : Java_POST_Req
*Author : Kanishka Dilshan      
*Purpose: Making a post request to a php script and retrieve the response
*Blog   : http://javaxclass.blogspot.com      
*/ 

import java.net.*;
import java.util.Scanner;
import java.io.*;

class Java_POST_Req{
 public static void main(String args[]){
  Scanner sc=new Scanner(System.in);
  System.out.print("Enter the area code or area : ");
  String value=sc.nextLine();
  
  OutputStreamWriter outWrtr=null;
  BufferedReader buffRdr=null;
  try{
   String httpdata=URLEncoder.encode("code","UTF-8")+"="+URLEncoder.encode(value,"UTF-8");
   URL remoteResource=new URL("http://kanishka.hostei.com/telcodes/telCodes.php");
   URLConnection conn=remoteResource.openConnection();
   conn.setConnectTimeout(30*1000);
   conn.setDoOutput(true);
   outWrtr=new OutputStreamWriter(conn.getOutputStream());
   outWrtr.write(httpdata);
   outWrtr.flush();
   
   //read the response
   buffRdr=new BufferedReader(new InputStreamReader(conn.getInputStream()));
   String line;
   while((line=buffRdr.readLine())!= null){
    System.out.println(line);
   }
  }catch(Exception e){
   System.err.println("Error : "+e.getMessage());
  } finally{
   try{
    outWrtr.close();
    buffRdr.close();
   }catch(Exception e){}
  }
 }
}

output :

මේ සඳහා ලියන ලද පහත දැක්වෙන applet එක භාවිතා කර මෙහි සිදුවන ක්‍රියාවලිය පිරික්සා බලන්න.

සියලුම කේත පාඩම අවසානයේ අමුණා ඇත.
අපි දැන් මෙම ජාවා වැඩසටහන පේළිය විස්තර කරගනිමු.

Line14 - Line 16 :

මෙහිදී Scanner object එකක් සාදාගෙන console එකෙන් user input එකක් ලබාගැනීම සිදුවනවා.

Line21:

මෙහිදී PHP වැඩසටහනට යැවීමට අවශ්‍ය data සූදානම් කිරීම සිදුකෙරෙනවා. encode("code","UTF-8") මගින් parameter එකද URLEncoder.encode(value,"UTF-8") මගින් අදාල velue එකද UTF-8 ක්‍රමයට එනම් unicode ක්‍රමයට encode කිරීම සිදුකෙරෙනවා.

Line22:

PHP script එකට අදාල URL object එකක් සෑදීම මෙහිදී සිදුකෙරෙනවා.

Line23:

අදාල PHP script එක සමග සම්බන්දතාවය නිරූපණය වන URLConnection object එකක් මෙහිදී සකසාගැනීම සිදුකෙරෙනවා.

Line24:

connection timeout එක සඳහන් කිරීමෙන් සිදුකර ඇත්තේ අදාල PHP වැඩසටහන සමග connection එකක් ස්ථාපනය කරගැනීමට උපරිම වශයෙන් තත්පර 30ක කාලයක් ලබාදීමයි.

Line25:

මෙමගින් URLConnection ඔබ්ජෙක්ට් එක මගින් ඒසමග සම්බන්දවී ඇති PHP වැඩසටහනට දත්ත ලිවීම සිදුකරන බව ඇඟවීම සිදුකරනවා.

Line26-Line27:

මෙහිදී නව OutputStreamWriter object එකක් සකසාගෙන එයට අදාල URLConnection එකෙහි output stream එක සම්බන්ද කරගෙන සකස් කරගත් HTTP data එම URLConnection එකෙහි output stream එකට ලියනු ලබනවා. එනම් අදාල PHP script එක වෙත යවනු ලබනවා.

Line31-Line34:

PHP වැඩසටහන අප යවන HTTP request එක process කිරීමෙන් අනතුරුව ලබාදෙන response එක කියවීම මෙහිදී සිදුවනවා. මෙහිදී සකසාගෙන ඇති BufferedReader object එක සම්බන්ද වී ඇත්තේ URLConnection එකෙහි input stream එකටයි. එනම් PHP වැඩසටහන මගින් ලබාදෙන output එකටයි.

Line36-Line42:

මේ පිලිබඳව අපි Streams සම්බන්ද පාඩම් වලදී විස්තරාත්මකව අධ්‍යයනය කර තිබෙන නිසා මෙහිදී එය නැවත විස්තර කිරීම අනවශ්‍යවේ.

ඉහත දක්වා ඇති source code සහ applet එකට අදාල මූලාශ්‍ර කේත ලබා ගැනීමට පහත දක්වා ඇති link එක භාවිතාකරන්න.

ජාවා Data Streams භාවිතා කරන අයුරු

2010-12-18T15:39:00.000+05:30

මේ වනවිට අපි ඉතා වැදගත් stream වර්ග කිහිපයක් ගැන කතාකලා. byte stream, character stream, buffered stream එම stream පිලිබඳ ඔබට මේ වනවිට හොඳ අවබෝධයක් ඇති බව උපකල්පනය කරමින් අපි මෙම පාඩමෙන් සාකච්ඡා කිරීමට යන්නේ data streams පිලිබඳවයි.

Data stream බාවිතයෙන් stream එකකට primitive data ලිවීමට සහ data stream එකකින් primitive data කියවීමට පුලුවන්. එනම් int, float, double, long, boolean, char, byte මෙන්ම primitive data type එකක් නොවුවද String සඳහා data streams සහය දක්වනවා.

DataInputStream සහ DataOutputStream නම් class වර්ග 2 යොදාගෙන data streams නිරූපණය කෙරෙනවා. එවන් stream එකකින් දත්ත කියවීමට DataInputStream ද ඒවාට ලිවීමට DataOutputStream class එකද යොදාගැනෙනවා.

හොඳින් මතක තබාගත යුතු කාරණාවක් තමයි සෑම විටම data stream object එකක් construct කල යුත්තේ byte stream එකක් wrap කිරීමෙන් බව.

DataInputStream භාවිතාකරන අන්දම...

මෙහිදී readInt(), readLong(), readUTF()... යනාදී වශයෙන් primitive data කියවීමට වැදගත් methods ගණනාවක් යොදාගන්න පුලුවන්. Java Documentation එක බැලිමෙන් මෙම methods සවිස්තරාත්මකව දැනගැනීමට පුලුවන්.

කලින් අධ්‍යයනය කල stream වලදී මෙන් නොව data stream වලදී File එකේ අවසානය (EOF) හඳුනාගැනීමට සෘජු ක්‍රමයක් නැහැ. එම නිසා EOFException එක catch කිරීමෙන් file එකක අවසානය හඳුනාගතයුතු වනවා.

DataOutputStream භාවිතාකරන අන්දම...

මෙහිදී writeInt(), writeLong(), writeUTF()... යනාදී වශ්යෙන් primitive data ලිවීමට වැදගත් වන methods ගනණාවක් තිබෙනවා. මීට පෙර stream වලට පොදුවූ flush(), close() යනාදී methods ද මෙම data stream විසින් inherit කරගෙන සිටිනවා.

අපි දැන් බලමු data stream එකක ක්‍රියාකාරීත්වය වටහාගැනීමට පහසුවන අන්දමේ සරල ජාවා වැඩසටහනක්.

/**       
*class  : Test 
*Author : Kanishka Dilshan       
*Purpose: Demonstrate how to use data streams  
*Blog   : http://javaxclass.blogspot.com       
*/ 

import java.io.*;

class Test {
 public static void main(String args[]){
  try{
   DataOutputStream dout=new DataOutputStream(
     new BufferedOutputStream(
     new FileOutputStream("myDataFile.dat")));
   
   dout.writeUTF("Kanishka");
   dout.writeFloat(83.23f);
   dout.writeBoolean(true);   
   
   dout.writeUTF("Ravindu");
   dout.writeFloat(98.12f);
   dout.writeBoolean(false); 
   
   dout.writeUTF("Madhawa");
   dout.writeFloat(84.65f);
   dout.writeBoolean(false);
   
   dout.close();
   
   DataInputStream din=new DataInputStream(
     new BufferedInputStream(
     new FileInputStream("myDatafile.dat")));
   try{
    while(true){
     String name=din.readUTF();
     float marks=din.readFloat();
     boolean val=din.readBoolean();
     System.out.println(name+"   "+marks+"   "+val);
    }
   }catch(EOFException e){
    System.out.println("End of the data file");
   }finally{
    try{
    
    }catch(Exception e){
     din.close();
    }
   }
  }catch(Exception e){
   System.err.println(e.getMessage());
  }
 }
}

Output :

ඉහත code එක මගින් සිදුවන ක්‍රියාවලිය වටහා ගැනීමට උත්සාහ කරමු.

Line 13,14,15 මගින් සුදුසු byte stream එකක් output data stream එකක් මගින් wrap කිරීම සිදුකර ඇත.

Line 17,18,19 මෙහිදී කිසියම් පිලිවෙලකට අනුව data stream එකට දත්ත ලිවීම සිදුකර ඇත. එනම් මුලින් String data ද දෙවනුව float data ද අවසන boolean data ද stream එකට එනම් myDataFile.dat file එකට ලියා ඇත.

Line 31,31,33 මෙහිදී byte stream එකක් input data stream එකක් මගින් wrap කිරීම සිදුකර ඇත. මෙහිදී සාදාගන්නා din object එක හරහා data කියවීම සිදුකෙරේ.

Line 34 - Line 48 මෙහිදී අදාල data file එක අවසන් වනතෙක් කියවීම සිදුකර එම දත්ත console එකෙහි දර්ශනය කරයි. line 35 න් ආරම්භ වන while loop එක infinite loop එකක් ලෙස පෙනුනද file එකේ අවසානයේ EOFException එකක් throw කරන නිසා file එක අවසානය වනතෙක් පමණක් loop එක ක්‍රියාත්මක වේ.

Streaming වල තවත් වැදගත් කොටසක් වන Standard streams පිලිබඳ අපි මීලඟ පාඩමෙන් සාකච්ඡා කරමු.

Buffered Stream යොදාගෙන File Copy කරන අන්දම

2010-12-17T16:44:00.001+05:30

අපි මීට පෙර පාඩමෙන් Buffered stream පිලිබඳව අධ්‍යයනය කලා. අපි මෙම පාඩමෙන් එම සිද්ධාන්ත යොදාගනිමින් File copy කිරීම සඳහා වැඩසටහනක් ලිවීමට උත්සාහ කරමු. මේ සඳහා අපි එම buffered stream classes තුල ඇති read() ,write() , flush(), close() යන methods භාවිතයට ගනිමු. පහත දැක්වෙන්නේ ඒ සඳහා වන කේත කොටසයි.
FileOperations.java

/**       
*class  : FileOperations 
*Author : Kanishka Dilshan       
*Purpose: Using buffered Streams to copy a file  
*Blog   : http://javaxclass.blogspot.com       
*/ 

import java.io.*;

class FileOperations {
 public static final int BUFF_SIZE=8*1024*1024;//8 MB
 
 public boolean fileCopy(String source,String dest){
  boolean isCopied=false;
  BufferedInputStream buffIn=null;
  BufferedOutputStream buffOut=null;
  byte buffer[]=new byte[BUFF_SIZE];
  try{
   buffIn=new BufferedInputStream(new FileInputStream(source),8*1024*1024);
   buffOut=new BufferedOutputStream(new FileOutputStream(dest),8*1024*1024);
   
   int len;
   while((len=buffIn.read(buffer))>0){
    buffOut.write(buffer,0,len);
    buffOut.flush();
   }
   isCopied=true; //file copied successfully
  }catch(FileNotFoundException e){
   System.err.println("Cannot find the file : " + e.getMessage());
  }catch(IOException e){
   System.err.println("IO Error : " + e.getMessage());
  }finally{
   if(buffIn!=null){
    try{
     buffIn.close();
    }catch(IOException e){}
   }   
   if(buffOut!=null){
    try{
     buffOut.close();
    }catch(IOException e){}
   }
  }
  return isCopied;
 }
}

FileCopy.java

class FileCopy{
 public static void main(String args[]){
  if(args.length!=2){
   System.out.println("Incorrect syntax!");
   System.out.println("Use Following Syntax");
   System.out.println("java FileCopy #source_file# #estination_file#");
   System.exit(0);
  }
  
  FileOperations fo=new FileOperations();
  boolean status=fo.fileCopy(args[0],args[1]);
  if(status==true){
   System.out.println("File was copied successfully!");
  }else{
   System.out.println("File was not copied");
  }
  
 }
}

අපි දැන් ඉහත වැඩසටහනේ ක්‍රියාකාරීත්වය අධ්‍යයනය කරමු.
Line 11 : මෙහිදී BUFF_SIZE ලෙස 8MB constant අගයක් declare කර ගැනීම සිදුකෙරෙනවා. පසුව buffer එකේ ඇතිදෑ කියවීමට සහ buffer එකට ලිවීමට මෙම constant අගයට අනුව සකසන byte array එකක් යොදාගනු ලබනවා.

Line 12 : boolean isCopied=false; මෙය යොදාගන්නේ file එක සාර්ථකව කොපි වූවාද නැද්ද යන්න return කිරීම සඳහායි.

Line 17 : byte buffer[]=new byte[BUFF_SIZE]; මෙහිදී 8MB ප්‍රමාණයකින් යුතු "buffer" නම් byte array එකක් සකසාගනු ලැබේ.

Line 19, 20 : buffIn සහ buffOut යනුවෙන් buffered stream object 2ක් සකසාගනු ලැබේ(class type සලකා බලන්න) මින් buffIn object එක යොදාගනුයේ source file එක කියවීමටය. එමෙන්ම buffOut යොදාගනුයේ destination file එකට ලිවීමටය. මෙම object සැදිමේදී ඒවාට අදාල buffer size එකද විශේෂයෙන් සඳහන් කර ඇත.

Line 23 : මෙම while loop එක තුලදී මූලිකවම කාර්‍යයන් 2 ක් සිදුකෙරේ len=buffIn.read(buffer) මගින් සිදුකරන්නේ input stream එකෙන් කියවන ලද අගයන් buffer නම් byte array එකේ store කර len නම් int විචල්‍යය තුල කියවන ලද ඩේටා ප්‍රමාණය assign කිරීමයි.

එහිදී සිදුකරන අනෙකුත් කාර්‍යය නම් එම කියවන ලද ඩේටා ප්‍රමාණය 0 ට වඩා වැඩිද යන්න පරීක්ෂා කර බැලීමයි. කියවන ලද ඩේටා ප්‍රමාණය -1 ලෙස ලැබේ නම් ඉන් ගම්‍ය වනුයේ stream එකෙහි අවසානයට ලඟාවී ඇති බවයි නැතහොත් end of file(EOF) බවයි මෙවිට output stream එකට ලිවීමට අවශ්‍ය නැත. කියවන ලද ඩේටා ප්‍රමාණය 0 නම්ද output stream එකට ලිවීමට අවශ්‍ය නැත. එම නිසා (len=buffIn.read(buffer))>0 නම් condition එක true නම් පමණක් while loop එක ක්‍රියාත්මකවේ.

Line 24 : buffOut.write(buffer,0,len); මෙහිදී සිදුකරනුයේ කියවන ලද ඩේටා (byte array එක) output stream එකට ලිවීමයි. 0 සහ len යන parameters වලින් කියවෙනුයේ එම byte array එකේ 0 සිට len යන අගය දක්වා byte ප්‍රමාණය output stream එකට ලිවිය යුතු බවයි.

Line 25 : buffOut.flush(); මෙහිදී output stream එක clear කිරීම සිදුකරයි.

Line 27 : while loop එක අවසන් වී මෙම line එකට පැමිණියා යනු file එක සාර්ථකව ලියා අවසන් බවට සහතික විය හැකිය මන්දයත් IO Operations සිදුකර ඇත්තේ exception handle කල හැකි පරිදි try-catch block තුලය. එම නිසා මෙහිදී isCopied නම් විචල්‍යයේ අගය true ලෙස සටහන් කරනු ලැබේ.

Line 32: catch block එක තුලදී සිදුකර ඇති දෑ පහසුවෙන් තේරුම් ගත හැකි නිසා finally block තුලදී කුමක් සිදුවන්නේද යන්න සලකා බලමු. මෙහිදී ඉහත open කරගන්නා ලද input සහ output stream 2ම close කිරීම සිදුකරයි මෙය සිදුකරන්නේ තවත් try-catch block එකක් තුලදීය.

වැඩසටහන මගින් source file එකේ binary pattern එක ඒ ආකාරයෙන්ම destination file එකේ තිබේ දැයි බැලීමට hash calculator එකක් යොදාගත හැක.

මෙම ක්‍රියාදාමය වටහාගැනීම සඳහා ඉහත පැහැදිලි කිරීම ප්‍රමාණවත් යයි සිතමි. කෙසේ වෙතත් තවදුරටත් පැහැදිලි කල යුතු යමක් ඇත්නම් ඉදිරිපත් කරන මෙන් ඉල්ලා සිටින්න කැමතියි.

ඉහත දක්වා ඇති source code එක සහ byte code files ලබා ගැනීමට පහත දක්වා ඇති link එක භාවිතාකරන්න.

ජාවා වැඩසටහන් තුල Buffered Stream යොදාගන්නා අයුරු

2010-12-16T12:32:00.001+05:30

මීට පෙර පාඩම් වලදී අපි Stream පිලිබඳ කතාකලානෙ අපි මෙම පාඩමෙන් තවත් වැදගත් Stream වර්ගයක් වන Buffered Stream පිලිබඳ අධ්‍යයනය කරමු.

අපි මීට පෙර සලකා බලන ලද FileInputStream , FileReader යන Stream වර්ග සැලකූ විට කෙලින්ම ඒවා යොදාගෙන කිසියම් resource එකක් භාවිතා කිරීමේදී ඒවායෙන් ලබාදෙන සෑම read, write request එකක් සඳහාම අදාල resource එක access කිරීම සිදුවනවා. උදාහරණයක් ලෙසට අපි හිතමු අපිට access කිරීමට අවශ්‍ය resource එක disk file එකක් කියල. එහිදී සෑම read, write request එකකදීම hard disk එකේ අදාල file එක access කිරීම සිදුවනවා. මෙහිදී JVM (Java Virtual Machine) එක විසින් native calls(operating system එකට අදාල low level methods) භාවිතා කිරීම සිදුකෙරෙනවා. එනම් සෑම read, write request එකකටම native calls invoke කිරීමට සිදුවනවා. තවත් උදාහරණයක් ලෙස අපි සලකමු මෙම resource එක client Socket එකක් කියල. එවිට ඉහත ආකාරයේ buffered නොවන Stream එකක් යොදාගත්තොත් සෑම read, write request එකක් සඳහාම network resources භාවිතාවීම සිදුවනවා. කාර්‍යක්ෂමතාව අතින් සැලකීමේදී මෙය හොඳ විසඳුමක් වන්නේ නැහැ.

අපි දැන් Buffered Stream එකකදී සිදුවන ක්‍රියාවලිය කුමක්දැයි සලකා බලමු, Buffered Stream එකකදී read, write යනාදිය සිදුකරනුයේ සෘජුව අදාල resource එක සම්බන්දවී නොවේ "buffer" නම් memory area එකකිනි. මේ සඳහා "buffer" යනුවෙන් හැඳින්වෙන ප්‍රදේශයක් ප්‍රධාන මතකයේ (main memory/RAM) වෙන්ව පවතී. buffer එක හිස්වූ විට පමණක් OS එකට අදාල low level methods invoke වීම සිදුවී "buffer" එක පිරේ(read කරන විටදී). RAM එක සම්බන්ද I/O operations දෘඩ තැටිය සම්බන්ද I/O operations වලට වඩා ඉතා වේගවත් නිසා Buffered stream යොදාගෙන I/O operations සිදුකිරීමේදී උපරිම කාර්‍යක්ෂමතාවයක් ලබාගත හැකිය. දැන් ඔබට වැටහෙනවා ඇති Buffered Stream භාවිතයේදී ඉහත සඳහන් කල Buffered නොවන stream වලදී ඇතිවන ගැටලුවට සාර්ථක විසඳුමක් ලැබී තිබෙන ආකාරය.

Buffered Stream එකක් සකසාගන්නේ කොහොමද?

මෙහිදී සිදුකරන්නේ non buffered stream object එකක් buffered stream object එකක් මගින් wrap කිරීමයි. පහත දැක්වෙන පරිදි මෙය සිදුකල හැකිය.

Syntax 01

//for input operations
FileReader fileRdr=new FileReader("myFile.txt");
BufferedReader buffRdr=new BufferedReader(fileRdr);

//for output operations
FileWriter fileWrtr=new FileWriter("myFile2.txt");
BufferedWriter buffWrtr=new BufferedWriter(fileWrtr);

Syntax 02 (ඉහත ක්‍රියාවලියම කෙටියෙන්)

//for input operations
BufferedReader buffRdr=new BufferedReader(new FileReader("myFile.txt"));

//for output operations
BufferedWriter buffWrtr=new BufferedWriter(new FileWriter("myFile2.txt"));

ඉහත උදාහරණ වලින් පෙන්වා ඇත්තේ character stream handle කිරීම සඳහා buffered stream යොදාගන්නා ආකාරයයි. Byte streams සඳහා BufferedInputStream සහ BufferedOutputStream යොදාගත හැකිය.

Buffered stream එකක buffer size එක ලබාදෙන්නේ කොහොමද?
අපි ඉහත දක්වා ඇති උදාහරණ වලදී buffer size එකක් ලබාදී නොමැත constructor එකෙහි ලබාදී ඇත්තේ wrap කිරීමට stream object එක පමණි. එවිට JVM එක විසින් කිසියම් default අගයක් buffer size එක ලෙස තෝරා ගනී. මෙම අගය රඳාපවතිනුයේ OS එක, system configuration එක, Main memory ධාරිතාවය වැනි සාධක මතය. නමුත් අපට buffer size එක අපේ අභිමතය පරිදි ලබාදිය යුතු නම් buffered input සහ buffered output යන stream දෙවර්ගයටම buffer size ලබාදිය හැකිය. පහත දැක්වෙන අන්දමට එය සිදුකල හැකිය.
Syntax 03

BufferedReader bfrRdr=new BufferedReader(new FileReader("myFile.txt",512*1024);
BufferedWriter bfrRdr=new BufferedWriter(new FileWriter("myFile2.txt",512*1024);

ඉහත උදාහරණයේදී Buffer size එක ලෙස 512KB ප්‍රමාණයක් ලබාදී ඇත මෙම අගය bytes වලින් ලබාදිය යුතු නිසා (512*1024) ලෙස ලබාදී ඇත.

Buffered Stream එකක් flush කිරීම යනු කුමක්ද?

ඇතැම් වැදගත් අවස්ථා වලදී buffer එකේ ඇති තොරතුරු resource එකට ලිවීමට සිදුවන අවස්ථා පැමිණේ. මෙවැනි අවස්ථාවකදී flush නම් ක්‍රියාවලිය සිදුකරයි. මේ සඳහා flush() නම් විධානය භාවිතා කරයි.
Non buffered stream සඳහාද flush() method එක පවතී. නමුත් ඒවායේදී flush() කිරීම මගින් කිසිම ප්‍රතිඵලයක් නොමැත. එයට හේතුව ඔබට මේ වනවිට සිතාගත හැක. Non buffered stream වලදී flush කිරීමට memory area එකක් නොමැති වීම මීට හේතුවයි.

Java 1.6 Documentation එකෙහි දැක්වෙන පරිදි Buffered Stream සඳහා අදාල වන constructors සහ methods පහත දක්වා ඇත.

Class BufferedInputStream

Constructor Summary
`BufferedInputStream(InputStream in)` Creates a `BufferedInputStream` and saves its argument, the input stream `in`, for later use.
`BufferedInputStream(InputStream in, int size)` Creates a `BufferedInputStream` with the specified buffer size, and saves its argument, the input stream `in`, for later use.

Method Summary
`int`	`available()` Returns an estimate of the number of bytes that can be read (or skipped over) from this input stream without blocking by the next invocation of a method for this input stream.
`void`	`close()` Closes this input stream and releases any system resources associated with the stream.
`void`	`mark(int readlimit)` See the general contract of the `mark` method of `InputStream`.
`boolean`	`markSupported()` Tests if this input stream supports the `mark` and `reset` methods.
`int`	`read()` See the general contract of the `read` method of `InputStream`.
`int`	`read(byte[] b, int off, int len)` Reads bytes from this byte-input stream into the specified byte array, starting at the given offset.
`void`	`reset()` See the general contract of the `reset` method of `InputStream`.
`long`	`skip(long n)` See the general contract of the `skip` method of `InputStream`.

Class BufferedOutputStream

Constructor Summary
`BufferedOutputStream(OutputStream out)` Creates a new buffered output stream to write data to the specified underlying output stream.
`BufferedOutputStream(OutputStream out, int size)` Creates a new buffered output stream to write data to the specified underlying output stream with the specified buffer size.

Method Summary
`void`	`flush()` Flushes this buffered output stream.
`void`	`write(byte[] b, int off, int len)` Writes `len` bytes from the specified byte array starting at offset `off` to this buffered output stream.
`void`	`write(int b)` Writes the specified byte to this buffered output stream.

ඉහත දැක්වෙන methods භාවිතාකරන අන්දම හොඳින් වටහාගැනීමෙන් වඩාත් කාර්‍යක්ශම වැඩසටහන් ලිවිය හැකිය.

අපි මීලඟ පාඩමෙන් Buffered Stream යොදාගෙන ප්‍රායෝගික ජාවා වැඩසටහනක් ලියන අන්දම බලමු.

ජාවා Byte Streams භාවිතා කරන අයුරු

2010-12-08T20:22:00.000+05:30

කලින් පාඩමෙන් අපි කතාකලා ජාවා stream පිළිබඳව. දැන් අපි බලමු byte stream භාවිතා කරන්නේ කුමනාකාරයෙන්ද කියල. Byte stream එකක් input / output operations සිදු කරනුයේ 8-bit අකාරයටයි. එනම් character streams වලදී මෙන් නොව මෙහිදී characters වෙනුවට raw bytes කියවීම සහ ලිවීම සිදුකෙරේ. එම නිසා data file copy කිරීම යනාදී වැඩ වලට යොදාගත යුත්තේ byte stream වේ. නමුත් භාවිතාවන data, character වලින් යුක්ත නම් character streams වලට යෑම වඩාත් ඵලදායීවේ.

අහත දැක්වෙන ආකාරයට ජාවා වැඩසටහනක් තුලදී byte streams යොදාගත හැකිය. මෙහිදී I/O Stream නිරූපණය කිරීම සඳහාjava.io පැකේජයේ ඇති FileInputStream සහ FileOutputStream class යොදාගැනේ.

/**      
*class  : ByteOperations
*Author : Kanishka Dilshan      
*Purpose: Showing how to use byte streams
*Blog   : http://javaxclass.blogspot.com      
*/ 


import java.io.*;

public class ByteOperations{
 public static void main(String args[]){
  FileInputStream fileInpStrm=null;
  FileOutputStream fileOutStrm=null;
  try{
   fileInpStrm=new FileInputStream("myDataFile.dat");
   fileOutStrm=new FileOutputStream("newDataFile.dat");
   int tmp;
   while((tmp=fileInpStrm.read())!=-1){
    fileOutStrm.write(tmp);
   }

  }catch(FileNotFoundException e){
   System.err.println("File NOt Found : " + e.getMessage());
  }catch(IOException e){
   System.err.println("IO Exception : " + e.getMessage());
  }finally {
   try{
    if(fileInpStrm!=null){
     fileInpStrm.close();
    }
      }catch(IOException e){}
   try{   
    if(fileOutStrm!=null){
     fileOutStrm.close();
    }
   }catch(IOException e){}
  }
 }
}

මෙහිදී සිදුවනුයේ myDataFile.dat file එකේ clone එකක් newDataFile.dat ලෙසින් සෑදීමයි. පෙර පරිදිම මෙහිදීද open කරන ලද ස්ට්‍රීම් close කර තිබේ.

FileInputStream යනු InputStream යන abstract class එකෙහි child class එකක් වේ. ඒම class අතර සම්බන්දය පහත පරිදි වේ.

තවත් ස්ට්‍රීම් වර්ග හා ඒවා යොදාගන්නා ආකරයන් පිලිබඳව අපි ඉදිරි පාඩම් වලදී සාකච්ඡා කරමු.

ජාවා තුල යෙදෙන I/O Streams යනු මොනවාද | Java I/O Streams

2010-12-07T18:14:00.003+05:30

සියලුම පරිගණක භාෂාවන් හි Input සහ Output ක්‍රියාවලීන් සිදුකර ගැනීමට කිසියම් යාන්ත්‍රණයක් පවතිනවා. උදාහරණයක් වශයෙන් කිසියම් calculation එකක් සඳහා ලියන ලද පරිගණක වැඩසටහනකට දත්ත input කිරීමට සහ එහි ප්‍රතිඵලය පිටතට ලබාදීම සඳහා යොදාගන්නා ක්‍රම සැලකිය හැකිය.

ජාවා වැඩසටහන් තුලදී Input සහ Output ක්‍රියාවලීන් සිදුකරගැනීමට විවිධ ක්‍රම පවතී ඒවා නම් Streams, Files, Channels යනාදී වශයෙනි. අපි මෙහිදී වැඩිදුරටත් සාකච්ඡා කරනුයේ ජාවා තුල යෙදෙන Streams පිලිබඳවයි.

ස්ට්‍රීම්(Streams) මගින් විවිධ Input සහ Output Sources(ප්‍රභව) නියෝජනය වීම සිදුකෙරේ. එනම් පරිගණක ක්‍රමලේඛකයාට streams භාවිතයෙන් input / output sources සමග සන්නිවේදනය කල හැකිය. උදාහරණ ලෙස Disk Files, Sockets, Devices සහ වෙනත් Process එකක් වුවත් විය හැකිය.

අපි දැන් බලමු ස්ට්‍රීම් එකක ස්වභාවය කුමක්ද කියල. ස්ට්‍රීම් එකක් කිව්වම අපිට එකපාරට මතක් වෙන්නෙ ගලාගෙන යන ස්වභාවය නේ. ඒ වගේම තමයි ස්ට්‍රීම් එකක තිබෙන්නෙ කිසියම් දත්ත ප්‍රවාහයක් ජාව තුල ස්ට්‍රීම් භාවිතයේදී එම ප්‍රවාහය මූලික දත්ත ආකාරයෙන් පැවතිය හැකියි නැතිනම් එම ප්‍රවාහය Object data ප්‍රවාහයක් උනත් විය හැකියි. Stream එකක පවතින්නේ data sequence එකක්.

උදා: Binary stream එකක්

1000100010000000000100

පරිගණන වැඩසටහන් මගින් Data Source එකක් ප්‍රවේශනය කිරීමේදී(Access) සිදුවන ක්‍රියාවලිය පහත පරිදි රුපමය වශයෙන් පෙන්විය හැකිය.

Input Stream එකක් ක්‍රියාකරන අයුරු

Output Stream එකක් ක්‍රියාකරන අයුරු

*කහ පාටින් දැක්වෙන්නේ Stream එකයි.

ඇතැම් ස්ට්‍රීම් එතුලින් දත්ත ගමන් කරවීමට සහය දක්වන අතර(උදා : FileInputStream,) ඇතැම් ඒවා එතුලින් යන දත්ත වෙනත් ආකාරයකට/ස්වභාවයකට පත්කරනු ලබයි(උදා: GZIPInputStream, DeflaterOutputStream).

Streams තුලින් යවන්නාවූ දත්ත වල ස්වභාවය අනුව මූලික වශයෙන් ස්‍ර්ටීම් වර්ග 2ක් හඳුනාගත හැකිය.

Character Streams

මෙමගින් මිනිසාට කියවිය හැකි ආකාරයේ දත්ත ගලා යාම සිදුකෙරේ(උදා : ඉලක්කම්, අකුරු යනාදිය)

Byte Streams

මේවායේ යවනුයේ machine-formatted ආකාරයේ දත්තවේ. මේවා පවතිනුයේ ද්වීමය(binary) ආකාරයෙනි(උදා:110110).

අදාලතාවය අනුව සුදුසු Stream ආකාරය තෝරාගත යුතුය. අනෙකුත් සියලුම ස්ට්‍රීම් වර්ගයන්හි පදනම වනුයේ Byte Stream වේ.

සුදුසු Stream එක තෝරාගන්නේ කෙසේද?

කිසියම් data source එකක් low-level මට්ටමෙන් ප්‍රවේශනය කිරීමට අවශ්‍ය විට byte stream එක සුදුසුය.උදා: data file copy කිරීම, Audio files edit කිරීම යනාදියේදී.
Data source එක text data වලින් සමන්විත නම් සහ text manipulations අවශ්‍ය විටදී character streams භාවිතාකල හැකිය.

ජාවා වැඩසටහනක් තුල මෙම ස්ට්‍රීම් භාවිතා වන්නේ කේසේදැයි අපි දැන් බලමු.

මුලින්ම බලමු character stream කියවීමට FileReader යොදාගන්නා අයුරු.

/**      
*class  : CharOperations
*Author : Kanishka Dilshan      
*Purpose: Showing how to use character streams
*Blog   : http://javaxclass.blogspot.com      
*/ 


import java.io.*;

public class CharOperations{
 public static void main(String args[]){
  FileReader fileRdr=null;
  FileWriter fileWr=null;
  try{
   fileRdr=new FileReader("myCharFile.txt");
   fileWr=new FileWriter("newCharFile.txt");
   int tmp;
   while((tmp=fileRdr.read())!=-1){
    fileWr.write(tmp);
   }
  }catch(FileNotFoundException e){
   System.err.println("File NOt Found : " + e.getMessage());
  }catch(IOException e){
   System.err.println("IO Exception : " + e.getMessage());
  }finally {
   try{
    if(fileRdr!=null){
     fileRdr.close();
    }
      }catch(IOException e){}
   try{   
    if(fileWr!=null){
     fileWr.close();
    }
   }catch(IOException e){}
  }
 }
}

පැහැදිලි කිරීම:

FileReader සහ FileWriter යනු පිලිවෙලින් myCharFile.txt සහ newCharFile.txt ට ලිවීමට තෝරාගත් Stream classes වේ. ඒවායින් සාදාගත් fileRdr සහ fileWr objects යොදාගෙන source file එකෙන් කියවීම සහ destination file එකට ලිවීම සිදුකෙරේ. මේවා character streams නිසා කියවීම සහ ලිවීම සිදුකරනුයේ character ආකාරයට ය. while loop එක තුලදී සිදුකෙරෙනුයේ input stream එකෙන් character by character කියවා output stream එකට character by character ලිවීමයි.

එහිදී while loop එකේ condition එක වශයෙන් යොදා ඇත්තේ කියවන ලද character එකෙහි integer අගය -1 ට සමානදැයි බැලීමයි. එම කියවන ලද අගය -1 නම් එයින් සඳහන් වනුයේ අප සිටින්නේ EOF(End of the file) හි බවය(ෆයිල් එකෙහි අවසානයේ බවය). මේවා try block එකක් තුල යෙදීමට හේතුව ස්ට්‍රීම් සමග ගනුදෙනු කිරීමේදී පැනනැගිය හැකි exception හසුකර ගැනීමයි.(Exception පිලිබඳ මීට පෙර සාකච්ඡා කර තිබේ). අවසානයේ open කරගන්නා ලද ස්ට්‍රීම් වසාදැමීම සිදුකර ඇත.( line 29 සහ line 34) මෙසේ ස්ට්‍රීම් close කිරීම අනිවාර්යයෙන්ම කල යුත්තකි. නැතහොත් අප ලියන වැඩසටහන් වල resource leaks ඇතිවීමට හේතුවේ. එය වැඩසටහනක ඇති විශාල ගැටලුවකි.

ලිපිය දීර්ඝ වන නිසා Byte streams පිලිබඳ වැඩිදුර තොරතුරු අපි ඊලඟ පාඩමෙන් කතාකරමු.

Java සමග Software Design Patterns (4 කොටස | Proxy Pattern)

2010-10-08T00:13:00.001+05:30

බොහෝ පරිගණක වැඩසටහන් සැලසුම් කිරීමේදී අපට පද්ධතියෙන් පරිභාහිර සම්පත්(resources) අප සැලසුම් කරන වැඩසටහන තුල භාවිතයට ගැනීමට සිදුවේ. උදාහරණ වශයෙන් ජාල සම්බන්දතා(network connections), files, පරිගණකයේ සසම්භාවී මතකය තුල පවතින විශාල වස්තුවක්(a large object in memory) හෝ සම්පත් අපතේ යෑම නිසා duplicate කල නොහැකි අනෙකුත් ඕනෑම resource එකක් සැලකිය හැකියි.

මෙවැනි අවස්ථාවලදී අප සකස්කරන සැලසුම අසාර්ථක එකක් වුවහොත් එය කෙලවර වන්නේ අධික ලෙස bandwidth එක භාවිතා කරන හෝ පරිගණක මතකය අපතේ යවන හෝ කාර්‍යක්ෂමතාව අතින් ඉතාම අඩු මට්ටමක පරිගණක වැඩසටහනකින්. ප්‍රොක්සි (proxy design pattern) යනු මෙවැනි අවස්ථාවන්හිදී සාර්ථකව apply කල හැකි design pattern එකකි.

මෙහිදී සිදුකරනුයේ අදාල resource එක ප්‍රවේශය කිරීම(access) සඳහා interface එකක් සැකසීමයි. පහත ඉදිරිපත් කර ඇති class diagram එක මගින් මෙහි ක්‍රියාකාරීත්වය වටහාගැනීම පහසුය.

අපි දැන් ඉහත model එක ජාවාතුල ක්‍රියාවට නංවන අන්දම බලමු.

ProxyTest.java

/**      
*class  : ProxyTest
*Author : Kanishka Dilshan      
*Purpose: Showing how to implement Proxy design pattern 
*Blog   : http://javaxclass.blogspot.com      
*/ 

interface Subject {
 void doAction();
}

class RealSubject implements Subject{
 
 public RealSubject(){
  //init resources
 }
 
 public void doAction(){
  //do something
 }
 
 private void someInternalProcess(){
  /*do some internal process related to 
   *the external resource
   */
 }
}

class Proxy implements Subject{
 private Subject subj=null;
 
 public Proxy(){
  //init initial attributes
 }
 
 public void doAction(){
  //handle the RealSubject
  if(subj==null){
   subj=new RealSubject();
  }
  subj.doAction();
 }
 
}

public class ProxyTest {
 public static void main(String args[]){
  Subject subj1=new Proxy();
  Subject subj2=new Proxy();
  
  subj1.doAction();
  //this initializes the resource
  subj2.doAction();
  //this also initializes the resource
  subj1.doAction();
  //this time it will not initializes the resource
 }
}

ඉහත class diagram එක implement කරන අන්දම වටහා ගැනීමට සහ Proxy හි මූලධර්මය වටහාගැනීමට අදාල ජාවා කේතය ප්‍රමාණවත් වුවද ප්‍රායෝගික වශයෙන් Proxy pattern එක කිසියම් ගැටලුවකට apply කරන අන්දම වටහාගැනීමට අපි පහත උදාහරණය සලකා බලමු.

ගැටලුව:
URL එක දෙනලද(http://sites.google.com/site/ansisliit/Home/MyData.dat) data file එකක් proxy design pattern එක යොදා view කරවීමට අදාල UML design එක සහ එය ජාවා යොදාගෙන implement කරන්න.

පිළිතුර:

RemoteFile.java

/**     
*class  : ProxyExampleTest  
*Author : Kanishka Dilshan     
*Purpose: Showing how to implement Proxy design pattern
*Blog   : http://javaxclass.blogspot.com     
*/ 
public interface RemoteFile {
 void viewFile();
}

RealRemoteFile.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;

public class RealRemoteFile implements RemoteFile {
 private String fileContent;
 private URL url;
 
 public RealRemoteFile(String u){
  try {
   url=new URL(u);
  } catch (MalformedURLException e) {
   System.err.println("Invalid URL!");
  }
  fileContent="";
  
  loadResource();
 }

 @Override
 public void viewFile() {
  System.out.println("Displaying the remote file...\n");
  System.out.println(fileContent);
 }
 
 private void loadResource(){
  System.out.println("Loading Remote Resource");
  try {
   URLConnection conn=url.openConnection();
   conn.setDoOutput(false); //read only
   InputStreamReader isr=new InputStreamReader(conn.getInputStream());
   BufferedReader br=new BufferedReader(isr);
   String tempLine;
   while((tempLine=br.readLine())!= null){
    fileContent+=tempLine+"\n";
   }
  } catch (IOException e) {
   System.err.println("Cannot open the location "+ e.getMessage());
  }
 }
}

ProxyRemoteFile.java

public class ProxyRemoteFile implements RemoteFile{
 RemoteFile rmtFile=null;
 String rmtFilePath;
 
 public ProxyRemoteFile(String url){
  rmtFilePath=url;
 }

 @Override
 public void viewFile() {
  long st1,st2;
  st1=System.nanoTime();
  if(rmtFile==null){
   rmtFile=new RealRemoteFile(rmtFilePath);
  }
  rmtFile.viewFile();
  st2=System.nanoTime();
  long timeDiff=st2-st1;
  double timeAmt=timeDiff*10e-12;
  System.out.println("Time taken to view : "+ timeAmt+ " s");  
 }
}

ProxyExampleTest.java

public class ProxyExampleTest {
 public static void main(String args[]){
  String location="http://sites.google.com/site/ansisliit/Home/MyData.dat";
  RemoteFile rFile=new ProxyRemoteFile(location);
  rFile.viewFile();
  //view same file again
  System.out.println("\nView same file again\n");
  rFile.viewFile();
 }
}

output:

පැහැදිලි කිරීම;

මුල් වතාවේ viewFile() method එක call කල විට එය view වීම සඳහා තත්පර 0.0387 ක් ගතවී ඇති බවත් නැවත වතාවක් එකම RemoteFile object එක සඳහා එම viewFile() method එක call කල විට ගතවී ඇත්තේ ඉතාමත්ම සුළු කාලයක් එනම් තත්පර 1.3641*10-6 ක් බවත් ඔබට පෙනෙනවා ඇති.

අප විසින් සාර්ථකව Proxy design pattern එක මෙම ගැටලුවට ආදේශ කල නිසා එකම resource එක නැවත නැවතත් ප්‍රවේශනය වීම වැළකී තිබේ.

ඔබට අවශ්‍ය නම් මේ සඳහා අදාල java කේත eclipse project එකක් ලෙස භාගත කරගත හැක.

(9.52 KB)

Java සමග Software Design Patterns (3 කොටස | Facade Pattern)

2010-10-07T00:11:00.002+05:30

ෆැෂාඩ් | Facade යනු structural ආකාරයේ design pattern එකකි. මෙමගින් කිසියම් සංකීර්ණ උප පද්ධතියක(sub system) lower level classes invoke කිරීම මගින් යම් කාර්‍යයක් සිදුකිරගැනීම සඳහා higher level interface එකක් සපයනු ලබයි. මෙලෙය fachade pattern එක යොදමින් කිසියම් පද්ධතියක් සැලසුම් කිරීම නිසා එම පද්ධතියේ coupling යන ගුණය අඩුවීම සිදුවේ එනම් එම පද්ධතියේ ස්ථායීතාවය කෙරෙහි එය සුභදායක ලෙස බලපායි. මීට අමතරව coupling ගුණය අඩුවීම යම් පද්ධතියක කාර්‍යක්ෂමතාවය වැඩිවීම පිනිසද හේතුවේ. යම් system එකකට facade pattern එක apply කල පසු එතුල පවතින සංකීර්ණ sub system එකක් කිසියම් client class කිහිපයක් මගින් access කරනුයේ facade එක හරහාවේ. එමගින් ඉතා විශාල වාසි එම පද්ධතියට අත්වේ. ඉන් එක් වාසියක් නම් client ගේ වෙනසක් නොවන පරිදි සංකීර්ණ sub system එක තුල වෙනස්කම් සිදුලහැකි වීමයි. එමගින් අප විසින් සැලසුම් කරන පද්ධතිය අවුල් ජාලයක් වීම වලකනු ලබයි.

Facade හි ව්‍යුහය

මෙම pattern එක තවදුරටත් වටහා ගැනීම පහසුවීම සඳහා අපි දැන් Facade එක apply කිරීමට පෙර class diagram එකක් සහ Facade design pattern එක apply කිරීමෙන් පසුව ලැබෙන විසඳුමකට අදාල class diagrams සලකා බලමු.

Facade යෙදීමට පෙර

Facade යෙදූ පසු

2වන class diagram එක අධ්‍යයනය කිරීමේදී coupling ගුණාංගය විශාල ලෙස අඩුවී ඇති බව ඔබට වැටහෙනවා ඇති.
අපි මීට පෙර සාකච්ඡා කල Adapter design pattern එක සහ Facade එක මගින් කෙරෙනුයේ classes wrap කිරීමකි. Facade pattern එකේදී වඩා සංකීර්ණ interface එකක් ලැබේ. අපි ඉදිරි පාඩම් වලදී තවත් design pattern පිලිබඳ අධ්‍යයනය කරමු.

Java සමග Software Design Patterns (2 කොටස | Adapter Pattern)

2010-10-06T17:08:00.001+05:30

Adapter නම් design pattern එක structural ආකාරයේ pattern එකකි. ලියන ලද කිසියම් program code එකක් දැනට පවතින වෙනත් නොගැලපෙන(incompatible) code-base එකකට(උදා: google maps API, twitter API) සම්බන්ද කිරීමේදී මෙම design pattern එක apply කල හැකිය. මෙහිදී සිදුකරනුයේ විධිමත් ක්‍රමයකට අපේ program එකට පරිභාහිර code-base එක call කිරීමට class structure එකක් සෑදීමයි. සාමාන්‍යයෙන් අප විසින් සකසන මෙම class තුලදී process එකක් නොපවතී ඒ වෙනුවට එම class මගින් සිදුකරනුයේ අදාලා කාර්‍යය සිදුකරගැනීම පිනිස පවතින code-base එක call කිරීමයි.

අපි දැන් බලමු adapter pattern එක සඳහා අදාල class diagram එක

ඔබට UML පිළිබඳ යම් අවබෝධයක් ඇත්නම් ඉහත class diagram එක මගින් adapter pattern එකෙහි ව්‍යුහය පිලිබඳ මනා වැටහීමක් ලැබෙනු ඇත. ඔබට UML(Unified Modeling Language) පිළිබඳ අවබෝධයක් නොමැතිනම් මෙම tutorial එක භාගත කරගෙන හොඳින් අධ්‍යයනය කරන්න. ඉන්පසු ඔබට ඉතා පහසුවෙන් මෙම UML diagram එක සහ ඉදිරි පාඩම් වලදී ඉදිරිපත් කෙරෙන UML diagrams වටහාගත හැකිවනු ඇත.

මෙය තවදුරටත් වටහාගැනීම පිනිස මෙම pattern එක ජාවා තුල implement කරන ආකාරය සලකා බලමු.

/**     
*class  : AdapterTest  
*Author : Kanishka Dilshan     
*Purpose: Showing how to implement Adapter design pattern
*Blog   : http://javaxclass.blogspot.com     
*/ 


interface Adapter {
 void operation();
}

class ConcreteAdapter implements Adapter {
 private Adaptee adaptee ;
 
 public ConcreteAdapter(){
  adaptee=new Adaptee();
 }
 
 public void operation(){
  adaptee.specialOperation();
 }
}

class Adaptee {
 //this is the external codebase
 void specialOperation(){
  System.out.println("Special operation was launched!");
 }
}

//test class
public class AdapterTest{
 public static void main(String args[]){
  ConcreteAdapter ca=new ConcreteAdapter();
  ca.operation();
 }
}

මෙම pattern එක වඩාත් හොඳින් තහවුරු කරගැනීම සඳහා ගැටලුවක් සාකච්ඡා කරමු. මෙම ගැටලුව උපුටාගත්තේ ශ්‍රීලංකා තොරතුරු තාක්ෂණ ආයතයනයේ software engineering II සඳහා ලබාදුන් tutorial එකකිනි.

ගැටලුව:

You have developed a set of classes that draws graphs.

Here the base class is the Chart Class. You need to develop a PieChart class. There is an existing PieChart class called PieChartGraph (See below). You want to connect your code base to this new Class. Briefly describe how an appropriate design pattern can be used for this purpose.

පිලිතුර:

abstract class Chart {
 abstract protected void display();
 abstract protected void refresh();
 abstract protected void addData();
}

class XYScatter extends Chart {
 public void display(){
  System.out.println("Displaying XYScatter..");
 }
 
 public void refresh(){
  System.out.println("Refreshing XYScatter..");
 }
 
 public void addData(){
  System.out.println("Adding data to the XYScatter..");
 }
}

class LineGraph extends Chart {
 public void display(){
  System.out.println("Displaying LineGraph..");
 }
 
 public void refresh(){
  System.out.println("Refreshing LineGraph..");
 }
 
 public void addData(){
  System.out.println("Adding data to the LineGraph..");
 }
}

class BarGraph extends Chart {
 public void display(){
  System.out.println("Displaying BarGraph..");
 }
 
 public void refresh(){
  System.out.println("Refreshing BarGraph..");
 }
 
 public void addData(){
  System.out.println("Adding data to the BarGraph..");
 }
}

class PieChart extends Chart {
 
 private PieChartGraph pcg;
 
 public PieChart(){
  pcg=new PieChartGraph();
 }

 public void display(){
  System.out.println("Displaying PieChart..");
  pcg.show();
 }
 
 public void refresh(){
  System.out.println("Refreshing PieChart..");
 }
 
 public void addData(){
  System.out.println("Adding data to the PieChart..");
 }
}

class PieChartGraph{

 public void dataseriesX(){
  
 } 
 
 public void dataseriesY(){
  
 }
 
 public void show(){
  System.out.println("Showing PieChartGraph..");
 }
 
 public void redraw(){
  System.out.println("Refreshing PieChartGraph..");
 }
}

public class Answer {
 public static void main(String args[]){
  PieChart pc=new PieChart();
  pc.display();
 }
}

Java සමග Software Design Patterns (1 කොටස)

2010-10-06T03:04:00.001+05:30

කිසියම් පරිගණක භාෂාවක් යොදාගෙන මෘදුකාංග නිපදවීමේදී අප විසින් කිසියම් සැලසුමක් මුලින් සකස් කල යුතු වනවා. මෙහිදී අදාල සැලැස්ම ඉතා හොඳ එකක් වීම ඉතා වැදගත්. හොඳ මෘදුකාංග සැලසුමක් නිසා කේතකරණය මෙන්ම මෘදුකාංගයේ නව යාවත් කාලීන කිරීම් පුලුල් කිරීම් ආදිය පහසු වීම සිදුවනවා.
හොඳ design එකක් සාදාගැනීම සඳහා භාවිතාකරන එක තාක්ෂණයක් තමයි software design patterns කියල කියන්නෙ. කිසියම් මෘදුකාංගයක් සැලකීමේදී එහි design pattern 1කට වැඩි සංබ්‍යාවක් තිබීමට පුලුවන්.
software design pattern සඳහා වන Wikipedia හි අර්ථ දැක්වීම

"A general reusable solution to a commonly occurring problem in software design"

සරළව විස්තර කරන්නේ නම්. design pattern එකක් යනු විවිධ අවස්ථාවන් සඳහා යොදාගත හැකිවන පටිදි කිසියම් ගැටලුවක් විසඳන ආකාරයයි. එම නිසා ඕනෑම software pattern එකක් සැලකූ විට ඒය design pattern එකක් නොවිය හැකියි.
උදා: algorithm(sorting,encrypting,compressing..etc) සහ data structures(queues, linked lists, stacks...etc) යන ඒවා design patterns ලෙස නොසැලකේ.

පහත දැක්වෙන ආකාරයට design patterns වර්ග කල හැකිය

creational design

object සෑදීම විධිමත් ලෙස කලමනාකරණය කිරීමට යොදාගැනේ

structural design

විධිමත් ලෙස objects එකලස් කිරීම සඳහා යොදාගැනේ

behavioral design patterns

flow control සහ algorithms කලමණාකරනය කිරීම සඳහා යොදාගැනේ

අපි දැන් බලමු singleton design pattern එක පිලිබඳව.

Singleton Design Pattern

මෙය creational pattern ආකාරයට අයත් වේ. සාමාන්‍යයෙන් class එකක් සැලකූ විට object 1ක් හෝ ඊට වැඩි ගනණක් සෑදිය හැකිය. class එකකින් instance එකක් පමණක් ලබාගන්නා අන්දම මෙමගින් පැහැදිලි කෙරේ.

class structure

මෙහිදී Singleton class එක සඳහා subclasses නොමැති නම් Singleton constructor එක private ලෙස දැක්විය යුතුය.

මෙහිදී Singleton එක access කල හැක්කේ getInstance() static method එක හරහා වේ. එනම් Singleton එකෙන් object create කිරීම කල හැක්කේ getInstance() method එක හරහා පමණි.

Sample Code:

/**     
*class  : Singleton  
*Author : Kanishka Dilshan     
*Purpose: Showing how to implement Singleton design pattern
*Blog   : http://javaxclass.blogspot.com     
*/ 

class Singleton {
 private static Singleton instance=null;
 
 protected Singleton(){
  
 }
 
 public static Singleton getInstance(){
  if(instance==null){
   instance=new Singleton();
  }
  return instance;
 }
}

දැන් අපි බලමු Singleton design pattern එක යොදාගෙන සරල වැඩසටහනක් ලියන අයුරු.

/**     
*class  : PrinterSingleton  
*Author : Kanishka Dilshan     
*Purpose: Showing how to use Singleton design pattern
*Blog   : http://javaxclass.blogspot.com     
*/ 

class PrinterSingleton {
 private static PrinterSingleton instance=null;
 int jobsCount;
 private PrinterSingleton(){
  jobsCount=0;
 }
 
 public static PrinterSingleton getInstance(){
  if(instance==null){
   instance=new PrinterSingleton();
  }
  return instance;
 }
 
 public void addNewJob(){
  jobsCount++;
 }
 
 public int getJobsCount(){
  return jobsCount;
 }
}


public class SingletonTest {
 public static void main(String args[]){
  PrinterSingleton p1=PrinterSingleton.getInstance();
  PrinterSingleton p2=PrinterSingleton.getInstance();
  
  p1.addNewJob();
  p1.addNewJob();
  p1.addNewJob();
  
  System.out.println("p1 job count "+p1.getJobsCount());
  System.out.println("p2 job count "+p2.getJobsCount());
  
  if(p1.equals(p2)){
   System.out.println("p1 and p2 are same object");
  }
 }
}

output:

Singleton design pattern එක වැඩිදියුණු කරමින් Coupleton design එකක්(exactly 2 instances) implement කරන අයුරු මීලඟට බලමු.

/**     
*class  : CoupletonTest, Coupleton  
*Author : Kanishka Dilshan     
*Purpose: Showing how to implement coupleton design pattern
*Blog   : http://javaxclass.blogspot.com     
*/

class Coupleton{
 private static Coupleton _instance1=null;
 private static Coupleton _instance2=null;
 private String ins_name;
 private Coupleton(String insName){
  this.ins_name=insName;
 }
 
 public static Coupleton getInstance(int instanceNo,String ins_name){
  if(instanceNo==1){
   if(_instance1==null){
    _instance1=new Coupleton(ins_name);
   }
   return _instance1;
  }else if(instanceNo==2){
   if(_instance2==null){
    _instance2=new Coupleton(ins_name);
   }
   return _instance2;  
  }else{
   return null;
  }
 }
 
 public String getInsName(){
  return ins_name;
 }
 
}

public class CoupletonTest{
 public static void main(String args[]){
  Coupleton c1=Coupleton.getInstance(1,"My Coupleton1");
  Coupleton c2=Coupleton.getInstance(2,"My Coupleton2");
  Coupleton c3=Coupleton.getInstance(1,"My CoupletonX");
  Coupleton c4=Coupleton.getInstance(2,"My CoupletonY");
  System.out.println("c1 instance name : "+c1.getInsName());
  System.out.println("c2 instance name : "+c2.getInsName());
  System.out.println("c3 instance name : "+c3.getInsName());
  System.out.println("c4 instance name : "+c4.getInsName());
 }
}

output:

අපි ඉදිරි පාඩම් වලදී තවත් design patterns පිලිබඳ සාකච්ඡා කරමු.

ජාවා යොදාගෙන බහුකාර්‍ය වැඩසටහන් ලිවීම (Java Threads) II

2010-09-11T13:56:00.002+05:30

අපි මීට පෙර පාඩමේදී සාකච්ඡා කලා Threads හා සම්බන්ද මූලිකම මූලධර්ම පිලිබඳව. අපි මෙම පාඩමෙන් බලමු Threads යොදාගෙන වැඩසටහන් ලියන ආකාරය.

Threads යොදාගෙන ජාවා වැඩසටහන් ලිවීමේදී ඉතා වැදගත් වන methods කිහිපයක් තිබෙනවා අපි මුලින්ම එම methds පිලිබඳ සලකා බලමු.
ඕනෑම Thread එකක් සැලකීමේදී එය පවත්නා තත්වයන් කිහිපයක් ඇත. පහත Thread state diagram එක මගින් එම අවස්ථා පිලිබඳ සහ thread එකක හැසිරීම පිලිබඳ අධ්‍යයනය කරමු.

Fig 1.0 Thread State Diagram

Method Name	Description
Thread.sleep()	දෙන ලද කාලයක් සඳහා අවශ්‍ය thread එකක් නවතා දැමිය හැක (pause). syntax: sleep(long milliseconds) sleep(long ms,long nanosec) eg: try{ Thread.sleep(1000); }catch(InterruptedException e){ System.err.println("Operation was Interrupted!"); }
Thread.yield()	අනෙකුත් threads සඳහා execute වීමට ඉඩ ලබාදේ. Thread synchronization පිළිබඳ සාකච්ඡා කිරීමේදී මේ ගැන වැඩිදුරටත් අධ්‍යයනය කරමු.
Thread.start()	අදාල Thread එක ආරම්භ කෙරේ. එනම් thread එක runnable state එකට පත්කරයි.
Thread.isAlive()	දෙන ලද thread එකක් ජීවී තත්වයේ පවතීදැයි පරීක්ශා කෙරේ. Thread එක ජීවී තත්වයේ පවතී නම් true ලෙසටද නැතහොත් false ලෙසටද return කෙරේ. Thread එකක් live තත්වයේ පැවතීමට නම් එය start වී තිබීම හා එය dead state එකේ නොතිබීම අනිවාර්‍ය වේ.
Thread.activeCount()	Active threads ප්‍රමාණය return කරයි.
Thread.enumurate()	මේ වන විට active තත්වයේ පවතින සියලු threads දෙන ලද array එකකට fill කිරීම සිදුකරයි.
Thread.currentThread()	Current thread එක return කරයි.
Thread.dumpStack()	ජාවා වැඩසටහන් debug කිරීමේදී වැදගත් වේ.
Thread.setPriority()	කිසියම් Thread එකකට ලබාදෙන priority එක int value එකක් ලෙස ලබාදේ. (1 සිට 10 දක්වා)
Thread.getId()	දෙනලද thread එකක් හඳුනාගැනීම සඳහා ලැබී ඇති ID එක long value එකක් ලෙස return කරයි.
Thread.setDaemon()	කිසියම් thread එකක් daemon ස්වභාවයට පත් කරයි. Daemon thread එකක් යනු user defined threads සඳහා සහය දැක්වීම සඳහා පසුබිමින් ධාවනය වන(run) threads වේ. JVM එකේ Garbage collector එක මීට උදාහරණයකි. මෙම method එක මගින් අප විසින් ලියන ලද කිසියම් thread එකක් daemon nature එකට පත්කල හැක. සාමාන්‍යයෙන් daemon thread එකකට ලැබෙනුයේ low priority එකකි. නමුත් අපට අවශ්‍ය නම් daemon threads සඳහා වැඩි priority එකක් ලබාදිය හැක. මෙහිදී විශේෂයෙන් සැලකිය යුතු කාරණය වන්නේ ඕනෑම daemon thred එකක් ආරම්භ වීමෙන් පසු එහි daemon ස්වභාවය වෙනස් කල නොහැකිය යන්නයි. නමුත් එහි priority එක වෙනස් කල හැක. eg: MyThread mt=new MyThread(); mt.setDaemon(true); mt.start();
Thread.run()	Thread එකක වැදගත්ම method එකක් ලෙස සැලකිය හැක. ඕනෑම thread එකක මෙම method එක override කර තිබිය යුතුය. start() method එක call කිරීමෙන් පසු execute කිරීමට පටන්ගන්නේ මෙම run() method එක තුල ඇති විධානයන් වේ.
Thread.destroy()	කිසිඳු cleanup එකකින් තොරව දෙනලද thread එකක් destroy කරදමයි. මෙම method එක deadlocks ඇතිවීමට හේතුවන නිසා මෙය deprecated method එකක් ලෙස දක්වා ඇත. Deadlocks පිලිබඳ ඉදිරි පාඩමකදී සාකච්ඡා කෙරේ.
Thread.stop()	කිසියම් thread එකක් stop කිරීමට යොදාගැනේ. මෙයද unsafe operation එකක් ලෙස සැලකේ. එම නිසා මෙය depricated method එකක් ලෙස දක්වා ඇත. Thread එකක් නැවැත්වීම සඳහා stop method එක භාවිතා නොකර වෙනත් technique එකක් භාවිතා කර ආරක්ශිත ආකාරයකට threads නවතා දමන අයුරු අපි ඉදිරියේදී සාකච්ඡා කරමු.

ජාවා භාවිතයෙන් thread create කරන අයුරු ආදර්ශනය කිරීමට ලියන ලද පහත සරල වැඩසටහන හොඳින් අධ්‍යයනය කරන්න.

ThreadLauncher.java

/**     
*class  : ThreadLauncher     
*Author : Kanishka Dilshan     
*Purpose: Showing how to create threads in Java 
*Blog   : http://javaxclass.blogspot.com     
*/ 

class ThreadLauncher{
 public static void main(String args[]){
  MyThread mt1=new MyThread("motor1");
  MyThread mt2=new MyThread("motor2");
  mt1.start();
  mt2.start();
 }
}

class MyThread extends Thread{
 String name;
 public MyThread(String name){
  this.name=name;
 }
 
 public void run(){
  System.out.println("Thread : "+name+" started!");
  for(int i=0;i<5;i++){
   System.out.println("I am "+name+ " Thread.");
   try{
    this.sleep(1000);
   }catch(InterruptedException e){
    System.err.println("Thread was interrupted! "+ e.getMessage());
   }
  }
  System.out.println("Thread "+name+" is going to die!");
 }
}

Code 1.0

Output:

Fig 2.0 Output of code 1.0

Threaded program එකක out put එක ඉහත පරිදි වේ. mt1 හා mt2 යනු threads 2යි. අපි එම වැඩසටහනම mt1 හා mt2 යනු runnable නොවන objects ලෙස සකස් කලහොත් output එක පහත පරිදි වේ.

ඔබට threads පිලිබඳ යම් අවබෝධයක් දැන් ලැබී තිබිය යුතුය. අපි ඉදි පාඩම් වලින් තවදුරටත් threads පිලිබඳ සාකච්ඡා කරමු.

ජාවා යොදාගෙන බහුකාර්‍ය වැඩසටහන් ලිවීම (Java Threads) I

2010-09-10T09:13:00.001+05:30

පරිගණක වැඩසටහනක් සැලසුම් කිරීමේදී එය මගින් යම් යම් ක්‍රියාවන්(methods) එකවිට(parallel) සිදුකලයුතු අවස්ථා අපට මුණගැසේ. Multitasking සඳහා උදාහරණයක් ලෙස web browser එකක tabs කිහිපයක් එකවිට load වීම ගත හැකිය. එවැනි අවස්ථාවන් ක්‍රියාවට නැංවීම (implement) සඳහා multitasking සංකල්පය භාවිතයට ගත හැකිය.

Multitasking වැඩසටහන්හි පහත අයුරින් ප්‍රධාන ආකාර 2ක් දැකිය හැකිය.

* Process Based

මෙහිදී සිදුවනුයේ පරිගණකයේ වැඩසටහන් කීපයක් සමගාමීව ක්‍රියාකිරීමෙන් අදාල ප්‍රතිඵලය ලබාදීමයි. process අතර සන්නිවේදනය(දත්ත හුවමාරුව) පහසු නොවේ. ඒ සඳහා pipes, files, sockets, shared memory ආදී විවිධ උපක්‍රම යොදාගැනීමට සිදුවේ.

* Thread Based

මෙහිදී සිදුවනුයේ එක් වැඩසටහනක් මගින් කාර්‍යයන් කිහිපයක් සමගාමීව සිදුකර අදාල ප්‍රතිඵලය ලබාදීමයි. මෙහිදී අදාල වැඩසටහන තුල Threads ලෙසින් පවතින කාර්‍යයන් කිහිපය කලමණාකරණය කිරීම මගින් ප්‍රතිඵලය ලබාගැනේ. සියලුම threads මගින් එකම address space එක share කරගන්නා නිසා threads අතර සන්නිවේදනය සාපේක්ෂව පහසුය.

අපි මෙහිදී සලකනුයේ Java යොදාගෙන multitasking සිදුකිරීමයි. මුලින් සඳහන් කල multitasking අකාරය හෙවත් process based multitasking ජාවාහි පාලනයෙන් ඔබ්බෙන් පවතින නිසා ජාවාතුල multitasking සිදුකරනුයේ threads යොදාගැනීමෙනි. Process based multitasking සිදුකිරීම C/C++ වැනි භාෂා යොදාගැනීමෙන් සිදුකල හැක.

ඕනෑම ජාවා වැඩසටහනක මුලින්ම ආරම්භ වන thread එක වනුයේ main thread එකයි.

ජාවා තුල මූලිකව threads ප්‍රභේද 2ක් පවතී. එනම් Thread class එක සහ Runnable interface එකයි. එම නිසා ජාවාහි Threads සෑදිය හැකි මූලිකම ක්‍රම දෙක වනුයේ

java.lang.Thread class එක Extend කර run() method එක override කිරීම
java.lang.Runnable interface එක implement කර run() method එක implement කිරීම.

Note : extend කිරීම සහ interfaces පිලිබඳ පෙර පාඩම් නැවත මතක් කරගැනීමට අවශ්‍ය නම් පහත සබැඳි භාවිතා කරන්න.

ජාවා interface සංකල්පය සහ එහි යෙදීම්
ජාවා වස්තු පාදක ක්‍රමලේඛනය VI (Inheritance) :: 1 කොටස

Thread class එක extend කිරීම

TestThread.java 

class TestThread{
 public static void main(String args[]){
  MyTask mt1=new MyTask();
  mt1.start(); //start the thread
 }
}

class MyTask extends Thread {

 public void run(){
  //do some task
 }
}

Runnable interface එක implement කිරීම
TestThreadRunnable.java

class TestThreadRunnable{
 public static void main(String args[]){
  Thread t1=new Thread(new MyTask());
  t1.start(); //start the thread
 }
}

class MyTask implements Runnable {

 public void run(){
  //do some task
 }
}

අපි ඊලඟ පාඩමෙන් threads පිලිබඳ තවදුරටත් හදාරමු.

Errors සහ Exceptions කලමනාකරණය කිරීම (Exception Handling)

2010-08-23T15:30:00.001+05:30

කිසියම් වැඩසටහනක් 100% ක්ම දෝශ රහිතව ලිවීම ඉතාම අසීරු කාරණයකි. වැඩසටහනේ විශාලත්වය වැඩිවත්ම මෙහි අසීරුතාව සීඝ්‍රයෙන් වැඩිවේ. Program එක සාර්ථකව compile වීම යනු එම වැඩසටහන දෝශරහිත යයි සැලකීමට සාධකයක් නොවේ. Program එකෙහි logical errors තිබිය හැක. logical errors යනු වැඩසටහන නියමාකාර ලෙස ක්‍රියානොකිරීමට(අපේක්ෂා කල පරිදි ක්‍රියා නොකිරීමට) හේතුපාදක වන කාරණයකි.

ජාවා වැඩසටහනක ඇතිවිය හැකි errors ආකාර දෙකකි.

Compile-time errors
Run-time errors

සියලුම syntax errors හෙවත් භාශාවේ කාරක රීති වලට පටහැනි අවස්ථා Compile-time errors ලෙස සැලකේ. මෙහිදී ජාවා compiler එක .java file එක මගින් .class file එක නොසාදයි. එනම් වැඩසටහන compile නොකෙරේ.

*Compile-time errors සඳහා උදාහරණ.

ඉහත වැඩසටහනේ 3 වන line එකෙහි ඇති statement එක semicolon ";" එකකින් අවසන් කර නැත එය syntax error එකකි. එමනිසා එය compile කිරීමේදී පහත දෝශය පෙන්වයි.

* Run-time errors සඳහා උදාහරණ

මෙහිදී program එක සාර්ථකව compile වුවද එය run කිරීමට යාමේදී විවිධ ගැටලු ඇතිවේ.

නිඛිල සංඛ්‍යා 0න් බෙදිම
Array එකක සීමාවෙන් පිට element එකක් access කිරීමට යාම
කිසියම් array එකක් තුලට නොගැලපෙන data type එකකින් යුතු අගයක් ඇතුලු කිරීම
null object එකක attribute හෝ methods භාවිතා කිරීම(access)

මේ සඳහා තවත් උදාහරණ රාශියක් ඇත.

දැන් අපි Run-time erors සඳහා උදාහරණ කිරිපයක් බලමු.

*Division by zero

class Runtime1{
 public static void main(String args[]){
  int a=5;
  int b=6;
  int c=10;
  int res=c/(b-a-1);
  System.out.println(res);
 }
}

මෙම වැඩසටහන සාර්ථකව compile වුවද run වීමේදී පහත දෝශය පෙන්වයි. එයට හේතුව line 6 දී (b-a-1) කොටසෙහි අගය 0 වීමයි.

* Array index out of bounds

class Runtime2{
 public static void main(String args[]){
  int arr[]=new int[5];
  int i=arr[10];
 }
}

මෙය run වීමේදී පහත දෝශය පැන නගී

දැන් අපි Run-time errors පිලිබඳ පුලුල්ව සාකච්ඡා කරමු.
Run-time errors වර්ග 2කි

Errors
Exceptions

අපි මුල්ම පාඩම් වලදී ඉගෙනගත්තා ජාවා තුල සියලුම දේවල් class ලෙස සලකන බව. ඒ අනුව Errors හා Exception සඳහාද ජාවා තුල class 2ක් තිබෙනවා.

Error class

මෙම ආකාරයේ errors හඳුන්වන්නේ abnormal errors හෙවත් අස්වාභාවික errors ලෙසින්. වැඩසටහනක් ලිවීමේදී අප එම වැඩසටහන තුලින් සාමාන්‍යයෙන් මෙම ආකාරයේ errors අපේක්ෂා කරන්නේ නෑ එනම් ඒවා handle කිරීමට යන්නේ නෑ.

මේ සඳහා උදාහරණ.

Virtual machine එකේ දෝශ
ThreadDeath errors

Exception class

ජාවා වැඩසටහන් තුල Error handle කරනවා යනු මෙම exceptions නියමාකාරයෙන් handle කිරීමයි. මෙහි වැදගත්කම වනුයේ run-time එකේදී කලින් අපේක්ෂා කල errors ඇතිවුවහොත් program එක terminate වීම හෝ වැරදි ප්‍රතිඵලයක් ලබාදීමෙන් වලක්වා ගැනීමයි.

බහුල වශයෙන් හටහන්නා Exception කිහිපයකට උදාහරණ

ArithmeticException
ArrayIndexOutOfBoundsException
IOException
FileNotFoundException
NumberFormatException
StringOutOfBoundsException

දැන් අපි බලමු ක්‍රමලේඛයක් තුලදී Exception handle කරන්නේ කියලා.
මේ සඳහා විධි 2ක් තිබෙනවා.

1) Throw Out (Ignore)

මෙහිදී යම් අපේක්ෂා කල Exception එකක් හටගතහොත් එය ඉවත දැමීම නොහොත් නොසලකා හැරීම සිදුකෙරෙනවා. ඇතැම් අවස්ථා වලදී මෙම ක්‍රමය යොදාගත්තත් මෙය සුදුසුම ක්‍රමය නොවේ.

දැන් අපි බලමු මෙම ක්‍රමය භාවිතා කරන අයුරු.

Syntax:

    methodName throws ExceptionName{
        ..method body
    }

උදා:

import java.io.*;

class ExceptionEx1{
 public static void main(String args[]) throws IOException{
  InputStreamReader isr=new InputStreamReader(System.in);
  BufferedReader br=new BufferedReader(isr);
  System.out.print("Enter your name : ");
  String name=br.readLine();
 }
}

2) Catch and handle

සලකනු ලබන code segment එකක් තුල යම් අපේක්ෂිත Exception එකක් පැනනැගුනහොත් සිදුකලයුතු ක්‍රියාමාර්ගය පිලිබඳ මෙහිදී සඳහන් කෙරේ ජාවා වැඩසටහනක Exception handle කිරීම සඳහා මෙම ක්‍රමය ඉතාම සුදුසු වේ.

Syntax:

        try{
            ..................
            ...code segment...
            ..................
        }catch(ExceptionName1 exObj){
            ..................
            ..handling error1..
            ..................
        }catch(ExceptionName2 exObj){
            ..................
            ..handling error2..
            ..................
        }catch(ExceptionNamen exObj){
            ..................
            ..handling errorn.
            ..................
        }finally{
            ..................
            ..final action....
            ..................
        }

උදා:

import java.io.*;

class ExceptionEx2{
 public static void main(String args[]) {
  int age=0;
  InputStreamReader isr=new InputStreamReader(System.in);
  BufferedReader br=new BufferedReader(isr);
  System.out.print("Enter your age : ");
  try{
   String ageStr=br.readLine(); 
   age=Integer.parseInt(ageStr);
  }catch(IOException ex1){
   System.out.println("I/O Error! "+ ex1.getMessage());
  }catch(NumberFormatException ex2){
   System.out.println("Invalid number format! "+ ex2.getMessage());
  }
 }
}

output:

Errors catch කිරීමේදී ඒවා අපේක්ශිත අනුපිලිවෙලට සිදුකලයුතු බව මතකතබා ගත යුතුය. මෙහිදී exceptions ඇතිවිය හැකි අනුපිළිවෙල මෙන්ම class hierarchy එකද වැදගත් වේ. class hierarchy එකේ පහලින් ඇති errors මුලින් catch කර ඉහල ඇති ඒවා පසුව catch කිරීම සිදුකලයුතුය. class hierarcy එක බලාගැනීමට java documentation එක පරිශීලනය කලයුතුවේ.

finally block එක පිලිබඳව

මෙතුල අන්තර්ගත කරන code segments අනිවාර්‍යයෙන්ම execute කිරීම සිදුවේ(Exception එකක් හටගත්තත් නැතත්). finally statement එක යෙදෙන අවස්ථා සඳහා උදාහරණ ලෙස open කරන ලද stream එකක් close කිරීම වැනි අවස්ථා දැක්විය හැකිය.

Exception class එකෙහි ඇති getMessage() method එක පිලිබඳව
මෙමගින් Exception එකට අදාල වැඩිදුර තොරතුරු String එකක් ලෙස return කරයි.

අපි දැන් බලමු අපිවිසින් අපේම(our own) Exception සාදන ආකාරය සහ ඒවා throw කරන්නේ කවර ආකාරයෙන්ද කියලා.
මෙහිදී මූලිකවම සිදුකරන්නේ Exception නම් predefined class එක extend කරමින් නව class එකක් සෑදීමයි.
උදා: OwnExceptionDemo.java

/**     
*class  : OwnExceptionDemo     
*Author : Kanishka Dilshan     
*Purpose: Demonstrate howto write custom exceptions   
*Blog   : http://javaxclass.blogspot.com     
*/ 

class Printer{
 /*assumption: 
  *printing 1 page will decrease the ink level by 1
  */
 int inkLevel;//minimum=0
 int pages;
 
 public Printer(int p,int inkLevel){
  pages=p;
  this.inkLevel=inkLevel;
 }

 public void print(){
  try{
   if(inkLevel==0){
    throw new EmptyCartridgeException();
   }else if(pages==0){
    throw new NoPagesException();
   }else{
    pages-=1;
    inkLevel-=1;
    System.out.println("Page completed.");
   }
  }catch(EmptyCartridgeException ecEx){
   System.err.println(ecEx.getMessage());
  }catch(NoPagesException npEx){
   System.err.println(npEx.getMessage());
  }
 }
}

class NoPagesException extends Exception{
 NoPagesException(){
  super("No pages in the paper tray!");
 }
} 

class EmptyCartridgeException extends Exception{
 EmptyCartridgeException(){
  super("Cartridge is empty. Please refill it");
 }
}

class OwnExceptionDemo{
 public static void main(String args[]){
  //creating Printer object and and calling print() method
  System.out.println("---------p1 Printer object---------");
     Printer p1=new Printer(5,100);
  for(int i=0;i<8;i++) //this will cause NoPagesException
   p1.print();

  System.out.println("\n---------p2 Printer object---------");
  Printer p2=new Printer(5,4);
  for(int i=0;i<5;i++) //this will cause EmptyCartridgeException
   p2.print();
 }
}

මෙම වැඩසටහනෙහි output එක පහත පරිදි වේ.

දැන් ඔබට Error handling පිලිබඳව යම් වැටහීමක් ඇතැයි සිතමි. වැඩිදුරටත් අභ්‍යාසයේ යෙදීමෙන් තවදුරටත් එය තහවුරු කරගැනීමට උත්සාහ ගන්න. ගැටලු සහගත තැන් ඇත්නම් ඒවා ඉදිරිපත් කරන්න.

මීලඟ පාඩමෙන් අපි Threads පිලිබඳ අධ්‍යයනය කරමු.

GUI සැකසීම සඳහා Basic Layouts යොදාගන්නා අයුරු

2010-08-11T15:40:00.002+05:30

අපි මෙම පාඩමෙන් සාකච්ඡා කරන්න යන්නේ ජාවා වැඩසටහන් සඳහා අතුරුමුහුනත් සැකසීමේදී components සුදුසු පරිදි ස්ථානගත කිරීම සඳහා layouts යොදාගන්නා ආකාරයයි. මෙම layouts java.awt පැකේජයේ අන්තර්ගත වනවා. අප මෙම පාඩමේදී මූලික වශයෙන් පහත දැක්වෙන layouts භාවිතා කරන අයුරු සලකා බලමු.

FlowLayout
BorderLayout
GridLayout

අපි මුලින්ම බලමු ජාවා අතුරුමුහුණතකට Layout manager එකක් set කරන්නේ කොහොමද කියලා.

syntax:

void setLayout(LayoutManager layoutObj);

උදා:

this.setLayout(new FlowLayout());

දැන් අපි ඉහත සඳහන් කල layouts විස්තරාත්මකව සලකා බලමු

FlowLayout

Panel class එකෙහි සහ එහි සියලුම child classes (උදා:Applet,JApplet,JPannel,.. ) වල default layout එක වන්නේ මෙයයි. සාමාන්‍යයෙන් components place(ස්ථානගත) කරනුයේ වමේ සිට දකුණට සහ උඩ සිට පහලට යන ආකාරයෙනි(left to right and top to bottom).

constructor:

FlowLayout(int align, int hgap, int vgap);

align: මෙමගින් සඳහන් කරනුයේ components ස්ථානගත කරනුයේ මොන පැත්තෙන් ආරම්භ වන පරිදිද යන්නයි

FlowLayout.LEFT
FlowLayout.CENTER
FlowLayout.RIGHT

hgap, vgap : මෙමහින් සඳහන් කරනුයේ components අතර horizontal gap එක සහ vertical gap එකයි මෙය pixels වලින් ලබාදිය යුතුය.

දැන් අපි FlowLayout එක යොදාගෙන සරල චිත්‍රකමුහුනතක් (GUI )සකසන අයුරු බලමු.

Code:

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

public class FlowLayoutDemo extends JFrame{

 public FlowLayoutDemo(){
  setTitle("FlowLayoutDemo Demo");  
  JPanel myPanel=new JPanel();
  myPanel.setLayout(new FlowLayout(FlowLayout.CENTER,5,5));
  //creating JButton objects
  JButton btn1=new JButton("Component1");
  JButton btn2=new JButton("Component2");
  JButton btn3=new JButton("Component3");
  JButton btn4=new JButton("Component4");
  JButton btn5=new JButton("Component5");
  JButton btn6=new JButton("Component6");
  //adding JButton objects to the panel
  myPanel.add(btn1);
  myPanel.add(btn2);
  myPanel.add(btn3);
  myPanel.add(btn4);
  myPanel.add(btn5);
  myPanel.add(btn6);
  this.add(myPanel);
  this.setSize(492,100);
  this.setDefaultCloseOperation(3);
  this.setVisible(true);
 }

 public static void main(String args[]){
  new FlowLayoutDemo();
 }
}

BorderLayout

Window සහ එහි sub class සඳහා default layout එක වේ. මෙහිදී container එක කලාප 5 කට බෙදනු ලැබේ ඒවා නම්

North
South
East
West
Center

components place කරනුයේ මෙම කලාප 5 ට වේ.

Constructor:

BorderLayout(int hgap, int vgap)

දැන් අපි BorderLayout එක යොදාගෙන සරල චිත්‍රකමුහුනතක් (GUI )සකසන අයුරු බලමු.

Code:

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

public class BorderLayoutDemo extends JFrame{

 public BorderLayoutDemo(){
  setTitle("BorderLayout Demo");  
  JPanel myPanel=new JPanel();
  myPanel.setLayout(new BorderLayout(5,5));
  //creating JButton objects
  JButton btn1=new JButton("North");
  JButton btn2=new JButton("East");
  JButton btn3=new JButton("South");
  JButton btn4=new JButton("West");
  JButton btn5=new JButton("Center");
  //adding JButton objects to the panel
  myPanel.add(btn1,BorderLayout.NORTH);
  myPanel.add(btn2,BorderLayout.EAST);
  myPanel.add(btn3,BorderLayout.SOUTH);
  myPanel.add(btn4,BorderLayout.WEST);
  myPanel.add(btn5,BorderLayout.CENTER);

  this.add(myPanel);
  this.pack();
  this.setDefaultCloseOperation(3);
  this.setVisible(true);
 }

 public static void main(String args[]){
  new BorderLayoutDemo();
 }
}

output:

GridLayout

මෙම layout එක බොහෝ දුරට FlowLayout එකට සමානය නමුත් components place කරනුයේ සමාන cell sizes ඇති virtual grid එකක් තුලටය. මෙහිදී අදාල component එකෙහි preffered size එක නොසලකා හැරේ.

Constructor:

GridLayout(int rows, int cols, int hgap, int vgap) ;

rows, cols : මෙමගින් දැක්වෙන්නේ components add කරනු ලබන virtual grid එකෙහි rows සහ columns ප්‍රමාණයයි.

hgap, vgap : මෙමහින් සඳහන් කරනුයේ components අතර horizontal gap එක සහ vertical gap එකයි මෙය pixels වලින් ලබාදිය යුතුය.
Code:

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

public class GridLayoutDemo extends JFrame{

 public GridLayoutDemo(){
  setTitle("GridLayoutDemo Demo");  
  JPanel myPanel=new JPanel();
  myPanel.setLayout(new GridLayout(2,3,5,5));
  //creating JButton objects
  JButton btn1=new JButton("Component1");
  JButton btn2=new JButton("Component2");
  JButton btn3=new JButton("Component3");
  JButton btn4=new JButton("Component4");
  JButton btn5=new JButton("Component5");
  JButton btn6=new JButton("Component6");
  //adding JButton objects to the panel
  myPanel.add(btn1);
  myPanel.add(btn2);
  myPanel.add(btn3);
  myPanel.add(btn4);
  myPanel.add(btn5);
  myPanel.add(btn6);

  this.add(myPanel);
  this.pack();
  this.setDefaultCloseOperation(3);
  this.setVisible(true);
 }

 public static void main(String args[]){
  new GridLayoutDemo();
 }
}

output:

අපි ඉහත සාකච්ඡා කල layout managers කිහිපය GUI සෑදීමේදී බහුල වශයෙන් යෙදේ.

වඩාත් සංකීර්ණ GUI සෑදීම
මෙහිදී සිදු කෙරෙනුයේ Layouts කිහිපයක් සංයුක්ත කොට කොට භාවිතා කිරීමය. Panel objects කිහිපක් සුදුසු පරිදි යෙදවීමෙන් අපට වඩාත් සංකීර්ණ GUI සකසාගත හැකිය.
දැන් අපි Windows calculator එකෙහි අනුරුවක් අප ඉගෙනගත් LayoutManagers යොදාගෙන සෑදීමට උත්සාහ කරමු.
Output:

code:

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

public class ComplexGUIDemo extends JFrame{

 public ComplexGUIDemo(){
  //this.setLayout(new GridLayout(3,1));
  this.setLayout(new FlowLayout(FlowLayout.RIGHT));
  //main panels
  JPanel txtPanel=new JPanel();
  JPanel numPanel1=new JPanel();
  JPanel numPanel2=new JPanel();
  //sub panels of numPanel2
  JPanel numPanel2Sub1=new JPanel();
  JPanel numPanel2Sub2=new JPanel();
  
  JTextField textBox=new JTextField("0",33);
  textBox.setHorizontalAlignment(JTextField.RIGHT);
  txtPanel.setLayout(new GridLayout(1,1));
  txtPanel.add(textBox);
  
  numPanel1.setLayout(new FlowLayout(FlowLayout.RIGHT));
  JButton btnbacksp=new JButton("Backspace");
  JButton btnce=new JButton("CE");
  JButton btnc=new JButton("C");
  numPanel1.add(btnbacksp);
  numPanel1.add(btnce);
  numPanel1.add(btnc);
  
  numPanel2Sub1.setLayout(new GridLayout(4,1,5,5));
  JButton btnMC=new JButton("MC");
  JButton btnMR=new JButton("MR");
  JButton btnMS=new JButton("MS");
  JButton btnMPl=new JButton("M+");
  numPanel2Sub1.add(btnMC);
  numPanel2Sub1.add(btnMR);
  numPanel2Sub1.add(btnMS);
  numPanel2Sub1.add(btnMPl);
  
  numPanel2Sub2.setLayout(new GridLayout(4,5,5,5));
  JButton btn7=new JButton("7");
  JButton btn8=new JButton("8");
  JButton btn9=new JButton("9");
  
  JButton btndv=new JButton("/");
  JButton btnsqrt=new JButton("sqrt");
  numPanel2Sub2.add(btn7);
  numPanel2Sub2.add(btn8);
  numPanel2Sub2.add(btn9);
  numPanel2Sub2.add(btndv);
  numPanel2Sub2.add(btnsqrt);
  
  JButton btn4=new JButton("4");
  JButton btn5=new JButton("5");
  JButton btn6=new JButton("6");
  
  JButton btnmul=new JButton("*");
  JButton btnperc=new JButton("%");
  numPanel2Sub2.add(btn4);
  numPanel2Sub2.add(btn5);
  numPanel2Sub2.add(btn6);
  numPanel2Sub2.add(btnmul);
  numPanel2Sub2.add(btnperc);
  
  JButton btn1=new JButton("1");
  JButton btn2=new JButton("2");
  JButton btn3=new JButton("3");
  
  JButton btnmin=new JButton("-");
  JButton btn1bx=new JButton("1/x");
  numPanel2Sub2.add(btn1);
  numPanel2Sub2.add(btn2);
  numPanel2Sub2.add(btn3);
  numPanel2Sub2.add(btnmin);
  numPanel2Sub2.add(btn1bx);
  
  JButton btn0=new JButton("0");
  JButton btnPM=new JButton("+/-");
  JButton btnpt=new JButton(".");
  
  JButton btnpl=new JButton("+");
  JButton btneq=new JButton("=");
  numPanel2Sub2.add(btn0);
  numPanel2Sub2.add(btnPM);
  numPanel2Sub2.add(btnpt);
  numPanel2Sub2.add(btnpl);
  numPanel2Sub2.add(btneq);
  
  numPanel2.setLayout(new FlowLayout());
  numPanel2.add(numPanel2Sub1);
  numPanel2.add(numPanel2Sub2);
  
  this.add(txtPanel);
  this.add(numPanel1);
  this.add(numPanel2);
  
  this.setTitle("My Calculator");
  this.setDefaultCloseOperation(3);
  this.setVisible(true);
  this.setSize(390,235);
 }

 public static void main(String args[]){
  new ComplexGUIDemo();
 }
}

GUI සම්බන්ද තවත් කරුණු අපි ඉදිරි පාඩම්වලදී සාකච්ඡා කරමු.

මෙම පාඩමට සම්බන්ද source codes බාගත කරගැනීම සඳහා සඳහා පහත ලින්ක් එක භාවිතා කරන්න.

Java වැඩසටහන් සඳහා User Interfaces සැකසීම :: Swing පැකේජය හැඳින්වීම III කොටස

2010-07-31T10:32:00.001+05:30

JRadioButton

විකල්ප කිහිපයක් දී ඇති විටදී ඉන් එක් විකල්පයක් තෝරාගැනීමට අවකාශ සැලසීමට මෙම component එක යොදාගත හැක. උදාහරණයක් පහත ඉදිරිපත් කර ඇත. Mr,Mrs,Ms,Dr යන විකල්ප වලින් එකක් පමණක් තෝරාගැනීමට මෙහිදී සිදුවේ. මෙම පාඩමෙන් සිදුකෙරෙන්නේ JRadioButton එකක් සාදාගන්නා ආකාරය පමණි. මේවායේ event handling සිදුකිරීම ඉදිරි පාඩම් වලදී සාකච්ඡා කෙරේ.

JRadioButtonDemo.java

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

public class JRadioButtonDemo extends JFrame{
 
 public JRadioButtonDemo(){
   setTitle("JRadioButton Demo");
   setLayout(new FlowLayout(FlowLayout.LEADING  ));
   setSize(300,300);
   JRadioButton jrb_mr=new JRadioButton("Mr");
   JRadioButton jrb_mrs=new JRadioButton("Mrs");
   JRadioButton jrb_ms=new JRadioButton("Ms");
   JRadioButton jrb_dr=new JRadioButton("Dr");
   //grouping
   ButtonGroup btnGroup=new ButtonGroup();
   btnGroup.add(jrb_mr);
   btnGroup.add(jrb_mrs);
   btnGroup.add(jrb_ms);
   btnGroup.add(jrb_dr);
   //add them to the JFrame
   add(jrb_mr);
   add(jrb_mrs);
   add(jrb_ms);
   add(jrb_dr);
   setVisible(true);
 }

 public static void main(String args[]){
  new JRadioButtonDemo();
 }
}

Output:

line14:

මෙහිදී අපි සාදාගත් JRadioButton ටික group කිරීම සිදුකෙරේ. මේවා group නොකලහොත් Mr, Mrs, Ms, Dr යන විකල්පයන්ගෙන් එකක් හෝ කිහිපයක් තේරීම සිදුකල හැකිය. නමුත් JRadioButton යෙදීමේ අරමුණ මෙය නොවන නිසා සාමාන්‍යයෙන් JRadioButtons group කිරීම සිදුවේ.

JList

කිසියම් elements ප්‍රමාණයක් පහත ආකාරයට දැක්වීමට JList නම් swing component එක භාවිතාකෙරේ.

උදා: JListDemo.java

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

public class JListDemo extends JFrame{
 
 public JListDemo(){
   setTitle("JList Demo");
   setLayout(new FlowLayout(FlowLayout.LEADING  ));
   setSize(300,300);
   
   DefaultListModel dlm=new DefaultListModel();
   JList countries=new JList(dlm);
   dlm.addElement("Sri Lanka");
   dlm.addElement("India");
   dlm.addElement("Japan");
   dlm.addElement("Usa");
   dlm.addElement("UK");
   
   add(countries); 
   setVisible(true);
 }
   
   public static void main(String args[]){
  new JListDemo();
   } 
}

JList එක construct කරගැනීමට පෙර DefaultListModel එකක් සාදාගැනීම කල යුතුයි. පසුව අපි සාදාගත් JList එකට දත්ත add කිරීම්ට JList එක clear කිරීමට, JList එකෙන් elements ඉවත් කිරීම මෙම DefaultListModel object එක හරහා සිදුවේ.Line11 දී මෙම DefaultListModel object එකක් සාදාගෙන ඇත.

Line12: මෙහිදී අපි සාදාගත් DefaultListModel object එක සහ JList එක සම්බන්ද කිරීම සිදුකෙරේ.

දැන් අපි JList එක හා සම්බන්ද වැදගත් method කිහිපයක් සලකා බලමු.

JList Methods	විස්තරය
int getSelectedIndex()	user විසින් list එකීහි මේ වනවිට select කර ඇති item එකෙහි index එක ලබාදේ.
void setSelectedIndex()	Program එක තුලින් list එකෙහි item එකක් select කර ඇති ලෙසට දක්වයි.
Object getSelectedValue()	user විසින් list එකීහි මේ වනවිට select කර ඇති item එක ලබාදේ
boolean isSelectedIndex(int idx)	ලබාදෙන int value එකක් select වී ඇති item එකේ index value එක නම් true ලෙසටද නැතිනම් false ලෙසටද return කරයි
setModel(ListModel model)	සකස් කරගත් ListModel object එකක් JList එක හා සම්බන්ද කිරීමට යොදාගැනේ
DefaultListModel Methods	විස්තරය
void add(int index, Object element)	ලබාදෙන index අගයකට(location එකකට) item එකක් ඇතුලු කිරීම සිදුකරයි
void addElement(Object obj)	list එකේ අගට item එකක් ඇතුලු කිරීම සිදුකරයි
int capacity()	දැනට list එකේ capacity එක නොහොත් items ගනණ ලබාදේ
void clear()	list එකේ ඇති සියලු items clear කිරීම සිදුකරයි.
boolean contains(Object obj)	ලබදෙන Object එකක් list එක තුල අන්තර්ගත වේනම් true ලෙසද නැත්නම් false ලෙසටද ලබාදේ.
Object elementAt(int index)	ලබාදෙන index එකක ඇති value එක ලබාදේ
boolean isEmpty()	list එක empty නම් true ලෙසටද නැත්නම් false ලෙසටද ලබාදේ
Object remove(int index)	ලබාදෙන index එකක ඇති item එක ඉවත්කරයි
void removeAllElements()	list එක තුල ඇති සියලු items ඉවත් කරයි

JList එකට අදාල documentation එක කියවීම සඳහා මෙම ලින්ක් එකෙන් යන්න.
DefaultListModel එකට අදාල documentation එක කියවීම සඳහා මෙම ලින්ක් එකෙන් යන්න.

JList එකට scroll bar යෙදීමට අවශ්‍ය නම් JScrollPane එකක් යොදාගත හැකිය. එය සිදුකරන අයුරු පහත දැක්වේ.

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

public class JListDemo extends JFrame{
 
 public JListDemo(){
   setTitle("JList Demo");
   setLayout(new FlowLayout(FlowLayout.LEADING  ));
   setSize(300,300);
   
   DefaultListModel dlm=new DefaultListModel();
   JList countries=new JList(dlm);  
   
   JScrollPane scrollP=new JScrollPane(countries);
   scrollP.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);

   dlm.addElement("Sri Lanka");
   dlm.addElement("India");
   dlm.addElement("Japan");
   dlm.addElement("Usa");
   dlm.addElement("Canada");
   dlm.addElement("Australlia");
   dlm.addElement("Italy");
   dlm.addElement("South Affrica");
   dlm.addElement("Thailand");
   
   add(scrollP); 
   setVisible(true);
 }
   
   public static void main(String args[]){
  new JListDemo();
   } 
}

Output:

පහත ජාවා ඇප්ලට් එක භාවිතයෙන් ඔබට ඉහත සඳහන් කල methods හි ක්‍රියාකාරීත්වය පහසුවෙන් වටහාගත හැකිවෙතැයි සිතමි.

පාඩමේ භාවිතා කර ඇති මූලාශ්‍ර කේත(source codes) බාගත කරගැනීම සඳහා පහත ලින්ක් එක භාවිතා කරන්න.

Java වැඩසටහන් සඳහා User Interfaces සැකසීම :: Swing පැකේජය හැඳින්වීම II කොටස

2010-07-23T21:55:00.000+05:30

අපි ඉහත කලින් පාඩමේදී සාකච්ඡා කලේ JLabel, JButton හා JTextField පිලිබඳවයි. මෙම පාඩමෙන් තවත් swing components කිහිපයක් පිලිබඳවා සාකච්ඡා කරමු.

JTextArea

මෙය JTextField සඳහා බොහෝ සමාන වුවද මෙහි lines කිහිපයකින් යුතු user inputs ගත හැක. එනම් address එකක් හෝ කිසියම් description එකක් ගැනීමේදී මෙය භාවිතා කල හැක.

JTextArea(int rows, int columns)
JTextArea(String text)
JTextArea(String text, int rows, int columns)

උදා;

අපිට අවශ්‍ය නම් මෙම JTextArea සඳහා scrollbar යෙදිය හැක. මේ සඳහා කල යුත්තේ JScrollPane එකක් තුලට JTextArea එක දැමීමයි. මෙය සිදුකරන අයුරු පහත දැක්වේ.

import javax.swing.*;
import java.awt.*;
class JTextAreaDemo extends JFrame{

 public JTextAreaDemo(){
  setTitle("JTextArea Demo");
  JTextArea jtxt=new JTextArea(10,20);
  JScrollPane scrollpane=new JScrollPane(jtxt);
  
  setLayout(new FlowLayout());
  setSize(300,300);
  setVisible(true);
  add(new JLabel("Description :"));
  add(scrollpane);
 }
 
 public static void main(String args[]){
  new JTextAreaDemo();
 }
}

Output:

JScrollPane එකෙහි constructor එකට(line 8) JTextArea object එක වන jtxt object එක ලබාදීම මගින් scrollpane එකට textarea එක ඇතුලුකිරීම සිදුකර ඇත.

JTextArea එකෙහි method ලෙස getText(),setText() බහුලව යෙදේ.

JTextArea එකට අදාල documentation එක කියවීම සඳහා මෙම ලින්ක් එකෙන් යන්න.

JCheckBox

විකල්ප 1ක් හෝ කීපයක් තේරීමට ඉඩලබාදිය යුතුවිට මෙය භාවිතා කෙරේ.

isSelected()method එක භාවිතා කර යම් CheckBox එකක් select කර ඇත්දැයි පරීක්ෂා කල හැක. Event handling පාඩමේදී JCheckBox පිලිබඳ වැඩිදුරටත් සාකච්ඡා කෙරේ.
JCheckBox එකට අදාල documentation එක කියවීම සඳහා මෙම ලින්ක් එකෙන් යන්න.

Java වැඩසටහන් සඳහා User Interfaces සැකසීම :: Swing පැකේජය හැඳින්වීම I කොටස

2010-07-23T12:55:00.001+05:30

අතුරු මුහුණත්(Graphical User Interfaces) යනු යම් පරිගණක වැඩසටහනක් භාවිතා කිරීම පහසු කරවන්නක්. සාමාන්‍ය පරිගණක පරිශීලකයෙක් නම් මේ වකවානුවේ බොහෝ දුරට භාවිතා කරනුයේ මෙවැනි වැඩසටහන්. ජාවා පරිගණක භාෂාව යොදාගෙන මෙවැනි GUI සහිත වැඩසටහන් සැකසීමට විශේෂ පහසුකම් ලබාදී තිබෙනවා. මේ සඳහා යොදාගත හැකි ප්‍රධාන ජාවා පැකේජ 2ක තමයි

AWT (Abstract Window Toolkit)
Swing

විශේෂ හේතූන් කිහිපයක් නිසා Swing පැකේජය භාවිතා කිරීම ප්‍රයෝජනවත් වනවා. ඉන් ප්‍රධානම හේතුව වන්නේ swing පැකේජය pure Java වලින් ලියැවුනු එකක් වීම. එම නිසා සුවිශේෂ වාසි කිහිපයක් අදාල වැඩසටහනට ලැබෙනවා. මීට අමතරව AWT සහය දක්වන සියලුම පහසුකම් සඳහා swing ද සහය දක්වනවා. AWT හි නොමැති පහසුකම් ගනණාවක්ද swing හි අඩංගු වනවා.

AWT සහ Swing හි වාසි අවාසි පිලිබඳ වැඩි විස්තර කියවීම සඳහා මෙම ලින්ක් එක භාවිතා කරන්න.

අපි මෙම පාඩම් මාලාවේදී වැඩිදුර සාකච්ඡා කිරීමට බලාපොරොත්තු වන්නේ Swing පැකේජය පිලිබඳවයි. NetBeans වැනි IDE එකක් යොදාගෙන ඉතා පහසුවෙන් GUI (අතුරු මුහුනත්) සාදාගත හැකිවුවද මෙය නවකයින්ගේ දැණුම මොට කරදැමීමට එය හේතුවන බව මගේ අදහසයි. එම නිසා මුලදී Notepad හෝ Notepad++ වැනි text editor භාවිතා කර GUI සඳහා අදාල කේත ලිවීමෙන් ඒ සම්බන්ද හොඳ අවබෝධයක් ලබාගෙන පසුව ක්‍රමලේඛන කටයුතු පහසු කරගැනීමට NetBeans භාවිතාකිරීම වරදක් නැහැ.

දැන් අපි බලමු swing components කිහිපයක විස්තර කිහිපයක්.

JLabel

jLabel එක වැදගත් වනුයේ user ට යම් විස්තරයක් පෙන්වීමේදීය.
jLabel එකක් සාදාගැනීම.
Constructors

JLabel(String text)
JLabel(Icon ico)
JLabel(Strnig text,Icon ico,int align)

note : align සඳහා දියහැකි අගයන්

JLabel.LEFT
JLabel.CENTER
JLabel.RIGHT
JLabel.LEADING

ඉහත constructors යොදාගෙන JLabel 3ක් සාදන ආකාරය දැන් අපි බලමු.
Constructor 1

JLabel lbl1=new JLabel("Sri Lanka");

Constructor 2

ImageIcon ico=new ImageIcon("sriLanka.png");
JLabel lbl2=new JLabel(ico);

Constructor 3

JLabel lbl3=new JLabel("Sri Lanka",ico,JLabel.LEFT);

දැන් අපි බලමු ඉහත Label 3ක්. යොදාගෙන සාදන ලද සරළ GUI එකක් සඳහා කේතය.
Note: පහත කේතයේ ඇති සියලු කොටස් ඉදිරියේදී සාකච්ඡා කෙරේ එබැවින් එහි JLabel සම්බන්ද කේත කොටස් පමණක් මෙහිදී අධ්‍යයනය කරන්න.
SwingDemo.java

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

class SwingDemo extends JFrame{
 public SwingDemo(){
  setTitle("Swing Demo");
  setLayout(new GridLayout(3,1));
  JLabel lbl1=new JLabel("Sri Lanka");
  ImageIcon ico=new ImageIcon("sriLanka.png");
  JLabel lbl2=new JLabel(ico);
  JLabel lbl3=new JLabel("Sri Lanka",ico,JLabel.LEFT);
  add(lbl1);
  add(lbl2);
  add(lbl3);
  setSize(300,300);
  setVisible(true);  
 }

 public static void main(String args[]){
  new SwingDemo();
 }
}

Output:

JLabel class එකෙහි methods

setText(String txt) ->JLabel එකෙට text එකක් ලබා දීමට .
getText() JLabel ->එකෙහි දැනට ඇති text එක ලබාගැනීමට.

JLabel එකට අදාල documentation එක කියවීම සඳහා මෙම ලින්ක් එකෙන් යන්න.

JButton

කිසියම් විධානයක් user ගේ අනුදැනුම මත ක්‍රියාත්මක කරවීම සඳහා යොදාගැනේ. මෙය Swing components අතුරින් බහුල වශයෙන් යෙදෙන component එකකි.
Constructors

JButton(String text)
JButton(String text,Icon ico)

උදා:

Code:

ImageIcon ico=new ImageIcon("icon5.jpg");
  JButton button2=new JButton("Show Details",ico);
  add(button1);
  JLabel lbl1=new JLabel("");
  add(lbl1);
  add(button2);

JButton එකට අදාල documentation එක කියවීම සඳහා මෙම ලින්ක් එකෙන් යන්න.

JTextField

User ගෙන් කිසියම් text input එකක් ලබාගැනීම සඳහා භාවිතා කෙරේ. (උදා: user name, age )
Constructors

JTextField()
JTextField(String text)
JTextField(int Columns)
JTextField(String text,int Columns)

උදා:

Methods:
getText() user විසින් textbox එකට ඇතුලුකල text එක ලබාගැනීමට
setText(String str) textbox එකට text එකක් set කිරීම සඳහා

JTextField එකට අදාල documentation එක කියවීම සඳහා මෙම ලින්ක් එකෙන් යන්න.

අපි ඊලඟ පාඩමෙන් අනෙකුත් swing components පිලිබඳ සාකච්ඡා කරමු.

ජාවා interface සංකල්පය සහ එහි යෙදීම්

2010-07-16T23:31:00.000+05:30

Interface එකක් කිව්වාම එකපාරටම මතක් වෙන්නෙ GUI එකක් නැත්නම් web form එකක් නේ. නමුත් මෙම පාඩමේදී අපි සලකා බලන්නේ වස්තු පාදක සංකල්පයක් වන interface සංකල්පය පිලිබඳවයි. මෙම සංකල්පයත් ජාවා ක්‍රමලේඛනයේ යෙදීමේදී බහුල වශයෙන් භාවිතා වන්නක්. මෙම පාඩමේදී පෙර පාඩම වන "ජාවා තුල Abstract Classes යොදාගන්නා අයුරු" යන පාඩමේදී උගත් කරුණු වැදගත් වන නිසා අවශ්‍ය නම් නැවත එය අධ්‍යයනය කරන්න.

interface එකක ඇති ප්‍රධාන ලක්ෂණ ගැන අපි සලකා බලමු.

interface එකක් යනු සම්පූර්ණයෙන්ම abstract class එකකි.

interface එකක ඇති methods සියල්ලම අර්ථදක්වා(define) ඇත්තේ method body එකකින් තොරවය(මෙයට හේතුව interface එක fully abstract වීමයි. එමනිසා මෙහි methods සියල්ලක්ම abstract වේ)

interface එකක් තුල class variables (උදා : private int age;) පැවතිය නොහැක. නමුත් final attributes පැවතිය හැක(උදා: private final SIZE=512;)

මීලඟට අපි සලකා බලමු ලියන ලද interface එකක් භාවිතා කිරීමේදී සැලකිය යුතු කරුණු.

class එකකට අවශ්‍ය නම් interface එකකට වැඩි ප්‍රමාණයක් භාවිතා කල හැක. එනම් class එකකට අවශ්‍ය නම් interface එකකට වැඩි ප්‍රමාණයක් implement කල හැක. මේ සඳහා implement keyword එක භාවිතාවේ.

යම් class එකක් interface එකක් implement කර ඇත්නම් එම interface එකෙහි ඇති සියලුම methods override කිරීම අනිවාර්‍යයෙන්ම කල යුතුය.

class එක abstract නම් එසේ අවශ්‍ය නොවේ.

class වලදී මෙන් inheritance සංකල්පය interface සඳහාද භාවිතා කල හැක. එනම් interface එකකදී වෙනත් interface එකක් extend කල හැක.

multiple inheritance නම් සංකල්පය C++ වලදී මෙන් java තුලදී කිරීමට ඉඩදී නොමැති වුවද, මෙම interface සංකල්පය යොදාගෙන එම ක්‍රියාවලිය ඉටුකරගත හැක.

අපි දැන් බලමු interface එකක් ලිවීම සඳහා භාවිතා වන syntax එක

interface MyInterface {
 
 final int VAL=512;
 
 void myMethod1();
 int myMethod2();
 ......................
 ...................... 
}

දැන් අපි බලමු interface සංකල්පයේ යෙදීම් ආදර්ශනය කිරීමට ලියන ලද සරල වැඩසටහනක්

/**    
*class  : CarControllerDemo    
*Author : Kanishka Dilshan    
*Purpose: Describe interface concept in Java  
*Blog   : http://javaxclass.blogspot.com    
*/ 

interface CarController{
 final float MAX_SPEED=320f;
 
 void accelerate(); //accelerate the car
 void applyBreak(); //apply breaks
}

class BMW implements CarController{
 private String model;
 private float speed;
 
 public BMW(String model){
  this.model=model;
  speed=0f;
 }
 public void accelerate(){
 //implementing accelerate() method in the interface
  if(speed < MAX_SPEED)
   speed+=15;
 }
 
 public void applyBreak(){
 //implementing applyBreak() method in the interface
  if(!((speed-20) < 0))
   speed-=20;
  else
   speed=0;   
 }
 
 public void showDetails(){
  System.out.println("Car model : "+model);
  System.out.println("Speed     : "+speed);
 }
}

//another car called Nissan implements CarController interface
class Nissan implements CarController{
 private String model;
 private float speed;
 
 public Nissan(String model){
  this.model=model;
  speed=0f;
 }
 public void accelerate(){
 //implementing accelerate() method in the interface
  if(speed < MAX_SPEED)
   speed+=15;
 }
 
 public void applyBreak(){
 //implementing applyBreak() method in the interface
  if(!((speed-25) < 0))
   speed-=25;
  else
   speed=0;
 }
 
 public void showDetails(){
  System.out.println("Car model : "+model);
  System.out.println("Speed     : "+speed);
 }
}


public class CarControllerDemo{
 public static void main(String args[]){
  //creating BMW car object
  BMW car1=new BMW("BMW M6");
  Nissan car2=new Nissan("Altima Sedan");
  
  //accelerate car1 twice
  car1.accelerate();
  car1.accelerate();
  //applyBreak() for car1
  car1.applyBreak();
  car1.showDetails();
  
  //accelerate car2 4 times
  car2.accelerate();
  car2.accelerate();   
  car2.accelerate();
  car2.accelerate(); 
  //applyBreak() for car2
  car2.applyBreak();  
  car2.showDetails();
 }
}

Output:

පැහැදිලි කිරීම:
ඉහත උදාහරණයේ Line8 සිට Line13 දක්වා ඇත්තේ define කරන ලද interface එකයි. BMW සහ Nissan යන class තුලදී implement කර ඇත්තේ එම interface එක තුල ඇති accelerate() සහ applybreak() යන methods දෙකයි. මීට පෙර පාඩම් වලදී උගත් සිද්ධාන්ත භාවිතා කරමින් ඉහත කේතයේ අනෙකුත් කොටස් අවබෝධ කිරීම ඔබගේ කාර්‍යයකි.

ජාවා ක්‍රමලේඛන භාෂාව යොදාගෙන වැඩසටහන් ලිවීමේදී පහත අවස්ථා වලදී මෙම interface භාවිතය ප්‍රායෝගිකව දැකගත හැකිය.

Event handling
Database connectivity

මෙම පාඩමත් සමග ජාවා වල මූලික OOP සංකල්ප කොටස අවසන් වේ. ඉදිරි පාඩම් වලදී ජාවහි අතුරු මුහුණත් සැකසීම පිලිබඳ අධ්‍යයනය කරමු.

ජාවා තුල Abstract Classes යොදාගන්නා අයුරු

2010-07-10T19:15:00.001+05:30

වස්තු පාදක(OO) ජාවා වැඩසටහන් ලිවීමේදී බහුල වශයෙන් යෙදෙන සංකල්පයක් තමයි abstraction කියන්නේ මේ සඳහා ජාවා පරිගණක භාෂාව තුල පහසුකම් සපයාතිබෙනවා.

අපි මුලින්ම බලමු abstract class එකක ලක්ෂණ මොනවාද කියල.

Abstract class වලින් කිසිවිටෙකත් objects සෑදිය නොහැක.

Abstract class එකක් extend කර(inherit කර) පසුව සාදනු ලබන class වලට හොඳ පදනමක් සැපයීම.

Generic (පොදු) ස්වභාවයකින් යුතුවීම. එනම් abstract class එකෙහි child class වලට පොදු ලක්ෂණ එතුල කැටිවී තිබීම(උදාහරණය මගින් විස්තර කර ඇත.)

Parent class එකෙහි Abstract methods ඇත්න්නම් එහි sub class නොහොත් child classes වලදී එම abstract methods අනිවාර්‍යයෙන්ම override කල යුතුය(override කරනවා යන්නෙහි සරල අදහස නම් අදාල abstract method එකෙහි body එක implement කල යුතු බවයි)

දැන් අපි උදාහරණය බලමු

class : AbstractDemo.java

/**   
*class  : AbstractDemo   
*Author : Kanishka Dilshan   
*Purpose: Describe abstract concept in Java 
*Blog   : http://javaxclass.blogspot.com   
*/   

abstract class Shape{
 protected int color;
 protected Point pos; //position
 
 public void setColor(int color){
  this.color=color;
 }
 
 public int getColor(){
  return color;
 }
 
 public void setPos(Point p){
  pos=p;
 }
 
 public Point getPos(){
  return pos;
 }
 
 abstract public float getArea();
  /* This method is defined as abstract since
     it cannot be implemented since Shape is a  
     common class(abstract class) */
}

class Rectangle extends Shape {
 /*since this clsaa inherits Shape class
  *the getArea() method must be overrided
  */
  //thease are properties specific to a Rectangle
  private float width,height;
  
  public Rectangle(float w,float h,Point p,int col){
  super.color=col;
  super.pos=p;
  this.width=w;
  this.height=h;
  }
  
  public float getArea(){
  return (width*height);
  } 
}

class Circle extends Shape {
 /*since this clsaa inherits Shape class
  *the getArea() method must be overrided
  */
  private float radius;
  
  public Circle(float rad,Point p,int col){
  super.color=col;
  super.pos=p;  
  this.radius=rad;
  }
  
  public float getArea(){
  return (float)(Math.PI*Math.pow(radius,2));
  }   
}

class Point{
 //class definition for represent a Point
 protected int xPos;
 protected int yPos;
 public Point(int x,int y){
  xPos=x;
  yPos=y;
 }
 
 public int getX(){
  return xPos;
 } 
 
 public int getY(){
  return yPos;
 }
}


public class AbstractDemo{
 //main method
 public static void main(String args[]){
  Rectangle rect1=new Rectangle(12.0f,7.5f,new Point(10,-3),255);
  Circle c1=new Circle(4.3f,new Point(3,8),100);
  
  //let's prnint object details for rect1
  println("rect1 belongs to    : "+ rect1.getClass().toString());
  println("colour val of rect1 : "+ rect1.getColor());
  println("x position of rect1 : "+ rect1.getPos().getX());
  println("y position of rect1 : "+ rect1.getPos().getY());
  println("area of rect1       : "+ rect1.getArea() );
  
  println("-----------------------------------------");
  //let's prnint object details for c1
  println("c1 belongs to       : "+ c1.getClass().toString());
  println("colour val of c1    : "+ c1.getColor());
  println("x position of c1    : "+ c1.getPos().getX());
  println("y position of c1    : "+ c1.getPos().getY());
  println("area of c1          : "+ c1.getArea() );
 }
 
 public static void println(Object o){
  System.out.println(o);
 }

}

output :

අපි දැන් ඉහත code එක විස්තරාත්මකව අධ්‍යයනය කරමු
අපි abstract class එක ලෙස මෙහිදී යොදාගෙන තිබෙන්නේ Shape නම් class එකයි. එයට හේතුව වනුයේ Circle සහ Rectangle යන class දෙකටම පොදු ලක්ෂණ Shape තුල අන්තර්ගත වන නිසයි.

Line 28

abstract public float getArea();

මෙහි getArea() නම් method එක abstract ලෙස සටහන් කර ඇත්තේ එය Shape හි sub classes වලට (specific) අනන්‍ය නිසා Shape class එක තුල implement කල නොහැකි නිසාය.

Line 48 - 50

public float getArea(){
  return (width*height);
  }

මෙහිදී Rectangle class එකෙහි super class එක වන Shape class එකෙහි ඇති abstract method එක implement කර ඇත. super class එකෙහි abstract method යම් ප්‍රමාණයක් ඇත්නම් ඒ සියල්ලම එහි subclasses වලදී implement කිරීම අනිවාර්‍ය වේ.
මෙම පාඩමෙන් අප ලබාගත් දැණුම මීලඟ පාඩම වන interfaces පාඩමේදී අත්‍යාවශ්‍ය වන නිසා මෙය හොඳින් අධ්‍යයනය කරන්න.

මෙහි ගැටලු සහගත තැනක් වේ නම් email එකක් මගින් දන්වන්න නැත්නම් comment එකක් ලෙස හෝ ඉදිරිපත් කරන්න.

පාඩමේ භාවිතා කර ඇති මූලාශ්‍ර කේත(source codes) බාගත කරගැනීම සඳහා පහත ලින්ක් එක භාවිතා කරන්න.

ජාවා තුල Inner Classes හි භාවිතය

2010-07-03T00:02:00.000+05:30

අපි අද පාඩමෙන් කතාකරන්න යන්නේ ජාවා inner classes පිලිබඳවයි. පරිගණක භාෂාවක් ලෙසට ජාවා වැනි භාෂාවක් හොඳින් අධ්‍යයනය කිරීම ඉතාම වැදගත්. ඒ මොකද, OOP සංකල්ප පැහැදිලිව අවබෝධ කරගැනීමට ජාවා අධ්‍යයනය මහත් රුකුලක් වන නිසා.
අපි දැන් සරළ රූප සටහනක් මගින් මෙම inner class සංකල්පය අවබෝධ කරගනිමු.

දැන් අපි ඉහත රූපසටහන විස්තරාත්මකව අධ්‍යයනය කරමු.
class B යනු class A හි inner class එකකි එනම් මෙහිදී class B හි outer class එක වන්නේ class A වෙයි. එමෙන්ම class C ද class A හි inner class එකකි. class D යනු class C හි ද inner class එකකි. එනම් class D හි outer class එක වන්නේ class C ය, class C හි outer class එක class A ය. දැන් ඔබට මෙහිදී සිදුවන්නේ කුමක්ද යන්න පැහැදිලි ඇතැයි සිතමි. outer class සහ inner class ගැන පැහැදිලි දල අවබෝධයක් පාඩමේ පහත කොටසට අවශ්‍ය නිසා මෙහිදී එය පැහැදිලි කරගන්න.

අපි දැන් බලමු inner classes වල ප්‍රධාන ලක්ෂණ මොනවාද කියලා.

► Outer class වලට ඒවායේ inner classes import කිරීමකින් තොරව භාවිතා කල හැකිය. උදා : ඉහත සටහනේ class A ට ඕනෑම විටක class B භාවිතා කල හැකිය(objects සෑදිය හැකිය)

► නමුත් inner classes භාවිතා කල හැක්කේ ඒවායේ outer class වලට පමනි. ඉන් පරිභාහිර කිසිඳු class එකකට සෘජුව අදාල inner classes භාවිතා කල නොහැක. උදා : class A ට පරිබාහිර වෙනත් කිසිඳු class එකකට class B access කල නොහැක.

►Inner class එකක් යනු එහි outer class එකෙහි member කෙනෙක් ලෙස සැලකිය හැක.

►Inner class එකකට එහි outer class එකෙහි ඕනෑම attributes හෝ methods සෘජුව access කල හැක.

►නමුත් Outer class එකකට එහි inner classes වල attributes හෝ methods සෘජුව access කල නොහැක. එම inner class වලින් object සෑදීමෙන් අනතුරුව ඒ හරහා එම methods සහ attribute access කල හැක.

inner classes ආදර්ශනය කිරීමට ලියන ලද පහත වැඩසටහන සැලකිල්ලෙන් අධ්‍යයනය කරන්න.

/**  
*class  : InnerClsDemo  
*Author : Kanishka Dilshan  
*Purpose: Demonstrate how inner classes are manipulated
*Blog   : http://javaxclass.blogspot.com  
*/  

public class InnerClsDemo{
 public static void main(String args[]){
  Report rpt1=new Report("Sri Lanka","I love my country","End of the DOC");
  rpt1.print();
 }
}

class Report {
 String headerTxt;
 String bodyTxt;
 String footerTxt;
 
 public Report(String h,String b,String f){
  headerTxt=h;
  bodyTxt=b;
  footerTxt=f;
 }
 
 public void print(){
  Header h=new Header();
  Body b=new Body();
  Footer f=new Footer();
  h.print();
  b.print();
  f.print();
 }
 
 //inner class 1: Header
 class Header{
  public void print(){
   System.out.println("-----------------------------");
   System.out.println("------This is The Header-----");
   System.out.println("\t"+headerTxt);
   System.out.println("-----------------------------");   
  }
 }
 //inner class 2: Body
 class Body{
  public void print(){
   System.out.println("-                           -");
   System.out.println("-                           -");
   System.out.println("------This is The Body-------");   
   System.out.println("\t"+bodyTxt);   
   System.out.println("-                           -");   
  }
 }
 //inner class 3: Footer
 class Footer{
  public void print(){
   System.out.println("------This is The Footer-----");
   System.out.println("\t"+footerTxt);
   System.out.println("-----------------------------");       
  }
 } 
}

output:

අපි ඉහත ඉගෙනගත් inner classes මූලධර්ම මගින් ඔබට ඉහත වැඩසටහන පැහැදිලි කරගත හැකිය.

inner classes compile කිරීමෙන් අනතුරුව file system එකේ තැන්පත් වන ආකාරය දැන් බලමු.

outer class එක වන Report class එක Report.class ලෙස පවතින බව ඔබට පෙනෙනවා ඇති. එම Report නම් outer class එකෙහි inner classes වන Header , Body සහ Footer classes පිලිවෙලින් Report$Header.class , Report$Body.class සහ Report$Footer.class ලෙස පවතින බවත් පෙනෙනවා ඇති. එනම් inner class එකට අදාල class file එකට නම ලැබී ඇත්තේ එහි outer class එකට ඇති සම්බන්දය විද්‍යාමන කරවමිනි.
(OuterClassName$InnerClassName.class)

මීලඟ පාඩමෙන් අපි ජාවා interface පිලිබඳව සාකච්ඡා කරමු.

ජාවා static members කියන්නේ මොනවාද? මොකටද යොදාගන්නේ?

2010-06-23T20:16:00.000+05:30

Static කියන්නේ ස්ථිතික කියන එකනේ සරලව කිව්වොත් පැතිරීයන ස්වභාවය නැති කියන එක ඉතින් මේ ස්ථිතික ස්වභාවය ජාවා වැඩසටහන් වලට ලබාදීමට තමයි මෙම static ලක්ෂණය ජාවා වලට හඳුන්වාදී තිබෙන්නේ. මේ සඳහා static නම් keyword එක භාවිතා වනවා. සාමාන්‍යයෙන් static modifier එක යොදා ඇති fields බැඳී තිබෙන්නේ class එක සමගයි. static members වර්ග දෙකක් තිබෙනවා ඒ තමයි

Class variables
Class methods

අපි දැන් class variables ගැන බලමු. ඔබ දන්නවා සමාන්‍ය instance variable නම් object එකකට එක බැගින් තිබෙනවා. උදාහරණයක් ලෙස Student class එකේ studentName එක instance variable එකක්. එනිසා එය Student object එකකට අනන්‍ය(unique) ලෙස පවතිනවා. සරලව කිව්වොත් සෑම object එකකටම studentName කියල වෙන වෙනම instance පවතිනවා. නමුත් කිසියම් static variable එකක් නැත්නම් class variable එකක් Student class එකේ තියනවා නම් සෑම object එකකටම එක බැගින් static members නෑ. එකම memory location එකක ඇති variable එකක් ලෙසටයි පවතින්නේ. සෑම object එකක්ම එය share කරගැනීම සිදුවෙනවා. එනම් object 1000ක් තිබුනොත් instance variable නම් 1000ක් පවතිනවා නමුත් static variable නම් පවතින්නේ එකම එකයි. පහත ඉදිරිපත්කර ඇති උදාහරණය අධ්‍යයනය කිරීමෙන් ඔබට මේ ගැන අවබෝධ කරගැනීමට පහසු වේවි.

උදාහරණයට කලින් static methods නැතහොත් class methods ගැනත් බලලම ඉඳිමු. static methods පොදුවේ භාවිතා වන්නේ class එකෙන් objects සෑදීමෙන් තොරව අදාල method එක භාවිතා කිරීමටයි. class එකක් තුල ඇති static variable හි අගයන් පිටතට ගැනීමට(access කිරීමට) මෙම static methods භාවිතා කලයුතු වනවා. මෙම static methods invoke(call) කිරීම සිදුවන්නේ class එකේ නම හරහායි.

දැන් අපි static සංකල්පය යොදාගැනීමට භාවිතා කරන syntax ගැන අධ්‍යයනය කරමු.

Syntax 1 : Declaring a static variable

[access modifier] static [datatype] [variable__name] ;

ex: private static int studID;
Syntax 2 : Declaring a static method

[access modifier] static [datatype] [method__name]()

ex: public static int getSum()

දැන් අපි උදාහරණය බලමු

/** 
*class  : StaticDemo 
*Author : Kanishka Dilshan 
*Purpose: introduce static keyword in Java 
*Blog   : http://javaxclass.blogspot.com 
*/ 

class Student {
 private String name;
 private int studId;
 private static int numberOfStudents;

 public Student(String name){
  this.name=name;
  //generate a new ID and increment the total value by 1
  studId=1000+(numberOfStudents++);
 }
 
 public static int getNumberOfStuds(){
  return numberOfStudents;
 }
 
 public void showStudDetails(){
  System.out.println("Name : " + name);
  System.out.println("stID : " + studId);
 }
}


public class StaticDemo{
 public static void main(String args[]){
  Student std1=new Student("Sajith");
  Student std2=new Student("Kanishka");
  Student std3=new Student("Ravindu");
  Student std4=new Student("Sathiranga");

  std1.showStudDetails();
  std2.showStudDetails();
  std3.showStudDetails();
  std4.showStudDetails();
  System.out.println("Total students : " + Student.getNumberOfStuds());
  
 }
}

ප්‍රතිඵලය:

පැහැදිලි කිරීම:
මෙහි name හා studId යන ඒවා instance variable වේ. numberOfStudents යන්න static variable එකකි. student ලා කීයක් ඉන්නවද කියන තමයි numberOfStudents එකේ තබාගන්නේ එය object එකින් එකට වෙනස් වන අගයක් නොවේ. එනිසයි අපි numberOfStudents යන්න static ලෙස යොදාගෙන තිබෙන්නේ. තවද මෙහි showStudDetails() යන method එකත් static මොකද එයත් object එකින් එකට වෙනස් වන්නේ නැහැ අනික එම method එක numberOfStudents නම් static variable එකත් access කරනවා. එම නිසා එය static විය යුතුයි. එමනිසා class එකේ නමයොදාගෙන call කිරීම කලහැකියි 41 වන පේලියේදී ඔබට මෙය දැකගත හැකියි.
තවත් OOP සංකල්ප අපි ඉදිරි පාඩමකදී සාකච්ඡා කරමු.

ජාවාහි එන Wrapper classes යනු මොනවාද..?

2010-06-18T11:09:00.001+05:30

ඔබ දන්නවා ජාවා වැඩසටහන තිබෙනවා මූලික දත්ත ආකාර(primitive data types) 8ක්. ජාවාහි සෑම තැනකටම පොදු ඔබ්ජෙක්ට් ඔරියන්ටඩ් ගතිය මෙම primitive data types තුල නැති බව බැලූ බැල්මටම පෙනෙනවා. මෙම wrapper classes නිර්මාණය කර ඇත්තේ මෙම primitive data type 8 සඳහා objects සෑදීමේ හැකියාව ලබාදීමටයි. එම නිසා ජාවා 1.0 සංස්කරණයේ සිටම මෙම primitive data types 8 සඳහා wrapper class 8ක් පැමිණෙනවා මේවා java.lang පැකේජයේ අන්තර්ගත වන නිසා වැඩසටහනකට විශේෂයෙන් import කිරීමට අවශ්‍ය නැහැ.

මෙම wrapper classes යොදාගෙන ජාවාහි ඉතා වැදගත් කාර්‍යභාරයක් කරගැනීමට පුලුවන්. data types convert කිරීම මෙවායේ සුලභ යෙදීමක්. මීට අමතරව එම දත්ත ආකාරය ගැන වැඩි විස්තර මෙම wrapper classes යොදාගනිමින් අපට ලබාගන්නටද පුලුවන්.

Primitive type	Wrapper class
boolean	Boolean
char	Character
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double

අපි දැන් බලමු wrapper class යොදගෙන ලියන ලද සරල වැඩසටහනක්.

public class Wrapper{
 public static void main(String args[]){
  Integer num1=new Integer(23);
  Integer num2=new Integer(34);
  Integer tot1=new Integer(num1+num2);
  Integer tot2=num1+num2;
  
  System.out.println("tot1 : " + tot2);
  System.out.println("tot2 : " + tot1);
 }
}

ඉහත වැඩසටහන නිරීක්ෂණයෙන් ඔබට පෙනෙනවා ඇති ක්‍රම 2කකට අපි num1 හා num2 හි එකතුව ලබාගෙන තිබෙනවා. ජාවා 1.5 න් පසු සංස්කරණ වලදී නම් මෙම 2 ක්‍රම 2ම දෝශ රහිතයි නමුත් ඊට පෙර සංස්කරණයන්හි 2වන ක්‍රමය එනම් 6 වන පේලියේ ඇති ක්‍රමය දෝශ සහගතයි. Integer class type එක ඇති ඔබ්ජෙක්ට් එකකට int primitive type එකක් assign කිරීම ඇත්තටම වරදක්. නමුත් ජාවා 1.5න් පසු සංස්කරණ වලදී එලෙස assign කර ඇති අගය සුදුසු wrapper class type එකට convert කිරීමෙන් අනතුරුවයි assign කිරීම සිදුකරන්නේ. මෙය autoboxing ලෙසත් හඳුන්වනවා.

දැන් අපි බලමු මෙම wrapper classes භාවිතාකර data types convert කරන ආකාරය. මේ සඳහා ලියන ලද සරළ ජාවා වැඩසටහන බලමු.

public class Wrapper{
 public static void main(String args[]){
  String str1="23.44";
  String str2="44.76";
  float val1=Float.parseFloat(str1);
  float val2=Float.parseFloat(str2);

  System.out.println("str1 \t => " + str1);
  System.out.println("str2 \t => " + str2);
  System.out.println("String Data\t=> "+str1+str2);
  System.out.print("float  Data\t=> ");
  System.out.println(val1+val2);
 }
}

line 5 හා line6 දී සිදුකර ඇත්තේ str1 හා str2 යන String data val1 හා val2 ලෙස float ඩේටා බවට පත්කිරීමයි. ඒ ආකාරයට wrapper class අටේම ඇති parseXXX methods (parseInt(),parseFloat(),parseDouble()...) දත්ත භාවිතා කර අපිට අවශ්‍ය data type වලට convert කරගන්න පුලුවන්.

දැන් අපි wrapper classes භාවිතා කර යම් data type එකකට දැරිය හැකි උපරිම හා අවම අගයන් ලබාගැනීමට වැඩසටහනක් ලියමු.

public class Wrapper{
 public static void main(String args[]){
  
  System.out.println("Byte wrapper"+"\t_______________");
  System.out.println("Max value : "+Byte.MAX_VALUE);
  System.out.println("Min value : "+Byte.MIN_VALUE);
  System.out.println();

  System.out.println("Integer wrapper"+"\t_______________");
  System.out.println("Max value : "+Integer.MAX_VALUE);
  System.out.println("Min value : "+Integer.MIN_VALUE);  
  System.out.println();

  System.out.println("Long wrapper"+"\t_______________");
  System.out.println("Max value : "+Long.MAX_VALUE);
  System.out.println("Min value : "+Long.MIN_VALUE); 
  System.out.println();
  
  System.out.println("Float wrapper"+"\t_______________");
  System.out.println("Max value : "+Float.MAX_VALUE);
  System.out.println("Min value : "+Float.MIN_VALUE); 
  System.out.println(); 
  
  System.out.println("Double wrapper"+"\t_______________");
  System.out.println("Max value : "+Double.MAX_VALUE);
  System.out.println("Min value : "+Double.MIN_VALUE); 
  System.out.println();
 }
}

ප්‍රථිඵලය:

Source: Java Documentation

ජාවා වැඩසටහනකින් Keyboard Inputs ලබාගන්නා අයුරු :: (Accessing the standard input stream)

2010-06-17T15:33:00.001+05:30

ජාවා භාවිත යෙදුම්(Java Aplications) Desktop applications හා Console applications වශයෙන් මූලික ආකාර 2ක් තිබෙනවා . Desktop applications සඳහා textbox වැනි component භාවිතාකර user inputs ලබාගන්න පුලුවන් මේ සඳහා awt හා swing ලෙස ජාවා පැකේජ 2ක් හඳුන්වාදී තිබෙනවා. නමුත් console application යනු console එක(windows වලදී command prompt එක) ක්‍රියාකරන ආකාරය අනුව කොන්සෝල් එකෙදී inputs ලබාගැනීමට වන්නේ keyboad එක මගින් ලබාදෙන string එකක් වශයෙන්. අපි අද පාඩමෙන් අධ්‍යයනය කරන්නේ කොන්සෝල් එක මගින් user input එකක් ලබාගන්නා අයුරුයි.

keyboard එකකින් ලබාදෙන දත්ත ජාවා තුලදී stream එකක් ලෙස සලකනවා. ඒ විතරක් නොවෙයි file data සහ network connection යනාදියත් ජාවා තුලදී stream එකක් ලෙස සලකනවා. ජාවා තුල භාවිතාවන මූලිකම stream වර්ග 2 තමයි byte streams සහ character streams.

අපි දැන් සරළ ජාවා වැඩසටහනක් මගින් බලමු ජාවා වලදී stream යොදාගෙන keyboard input එකක් ලබාගන්නා ආකාරය.

KeybIn.java

import java.io.*;

public class KeybIn{ 
 public static void main(String args[]) throws IOException{
  String name;
  InputStreamReader myIsr=new InputStreamReader(System.in);
  BufferedReader myBr=new BufferedReader(myIsr);
  
  System.out.print("What is your name : " );
  name=myBr.readLine();
  
  System.out.println("Your name is : "+ name);
  
 }
}

දැන් අපි ඉහත වැඩසටහන අධ්‍යයනය කරමු.
Line1 : මෙම වගන්තිය මගින් සිදුකරනුයේ IO නම් ජාවා පැකේජ් එකේ තිබෙන ඕනෑම class එකක් හෝ සියල්ල අපගේ වැඩසටහන තුලදී භාවිතා විය හැකිය යන්න සඳහන් කිරීමයි.

Line4 : main method එකෙහි throws IOException යන්නෙන් විධාන කරන්නේ input හෝ output exception එකක්(දෝශයක් යයි කියමු) පැමිණියහොත් එය නොසලකා හරින්න(ignore) යන්නයි.

Line6 : මෙහිදී සිදුකරන්නේ System.in නොහොත් standard input stream එකෙන් දත්ත bytes වශයෙන් කියවා characters බවට පත්කලහැකි object එකක් සෑදීමයි. සාමාන්‍යයෙන් standard input stream එක යනු keyboad input strem එකයි.

Line7 : මෙහිදී සිදුකරන්නේ ඉහත සාදන ලද InputStremaReader object එක මගින් එකතුකරන ලද characters එකතු කර තනි පේලියක් සෑදිය හැකි BufferedReader object එකක් සෑදීමයි.

Line10 : මෙහිදී කොන්සෝල් එකෙන් string එකක් read කිරීම සිදුකරනවා.

ඉහත ආකාරයේ ව්‍යුහයක් යොදාගනිමින් ජාවා තුලදී key board input එකක් ලබාගන්න පුලුවන්.
ප්‍රතිඵලය :

ජාවා වස්තු පාදක ක්‍රමලේඛනය VI (Inheritance) :: 1 කොටස

2010-06-12T15:54:00.002+05:30

Inheritance යනු ජාවාහි එන ප්‍රභල සංකල්පයක්. එමෙන්ම වස්තු පාදක වැඩසටහන් (OOP programs) ලිවීමේදී මෙය බොහෝ විට භාවිතා වනවා. C++ වැනි අනෙකුත් OOP සඳහා සහය දක්වන පරිගණක භාෂා වලත් මෙම සංකල්පය සඳහා සහය දැක්වුවද C++ හා Java අතර inheritance හිදී යම් වෙනස්කම් පවතිනවා.

දැම් අපි බලමු මොකක්ද මේ inheritance ක්‍රියාවලිය කියල, Inheritance යනු යම් class එකකකින් සාදන ලද වස්තුන්(objects) වෙනත් class එකකට අයත් objects වල ගුණාංගයන්ද අයත් කර ගැනීමේදී සිදුකරන ක්‍රියාවලියයි. එම නිසා මෙහිදී අදාල ලක්ෂණ අත් කරගත් class එක සහ ලක්ෂණ අත් කරගැනීමට බඳුන් වූ class එක සඳහා පොදු ලක්ෂණ එකක් හෝ කිහිපයක් පවතිනවා. අදාල ලක්ෂණ අත් කරගත් class එක child class එක නොහොත් sub class එක ලෙසත් ලක්ෂණ අත් කරගැනීමට බඳුන් වූ class එක parent class එක නොහොත් super class එක ලෙසත් හැඳින්වෙනවා. මෙම ක්‍රියාවලියේදී extends නම් ජාවා keyword එක භාවිතා වනවා. යම් class එකක් Inherite කිරීමෙන් සාදන ලද නව class එක එහි parent class එකෙහි attributes සහ behaviour යනාදිය උකහා ගන්නා නිසා මෙහිදී ඉබේම software re-usability නම් සංකල්පයද ක්‍රියාත්මක වනවා. නමුත් inherite කිරීමෙන් සාදාගන්නා ලද නව class එකෙහි එහි parent class එකේ නොමැති attributes සහ behaviours අන්තර්ගත වීමට පුලුවන්.

ජාවා තුල inheritance සංකල්පය ක්‍රියාවට නැංවීමේදී දැන ගතයුතු කරුණු.

► අලුතින් සාදන සෑම class එකක්ම අනිවාර්‍යයෙන්ම වෙනත් class එකක් extend (inherit) කල යුතුය.
► extend කරන්නේ කුමන class එකක්ද යන්න විශේෂයෙන් සඳහන් කර නැති විට Object යන class එක inherit වීම සිදුවේ. Object යනු ජාවා class hierarchy එකේ උඩින්ම ඇති super class එකයි.
► inherit කිරීමකදී කිසිවිටෙකත් constructors උකහා ගැනීම සිදුනොවේ. සියලුම constructors එය define කරන ලද class එක සඳහා වීශේෂ වේ. (constructor පිලිබඳ අපි මීට පෙර පාඩමකින් සාකච්ඡා කර තිබේ එම පාඩම සඳහා මෙතන click කරන්න)
► යම්කිසි sub class එකක් construct වීමේදී එම class එකෙහි super class එකෙහි constructor එක මුලින්ම call වීම සිදුවේ.
► ජාවාහිදී ඕනෑම class එකකට තිබිය හැක්කේ එක් parent class එකක් පමණි. එනම් multiple inheritance සඳහා ජාවා සහය නොදක්වයි. එමනිසා multiple inheritance මගින් සිදුවන කාර්‍යය ජාවාහිදී සිදුකරන්නේ interfaces භාවිතයෙනි. අපි ඉදිරි පාඩමකින් ජාවා interfaces පිලිබඳ අධ්‍යයනය කරමු. ජාවා multiple inheritance සඳහා සහාය නොදැක්වුවද C++ වලදී නම් multiple inheritance සඳහා ඉඩකඩ සලසා තිබේ.

Syntax for extending/inheriting a class

class SubClassName extends SuperClassName

දැන් අපි මෙම inheritance සංකල්පය හොඳින් වටහා ගැනීම සඳහා සරල ජාවා වැඩසටහනක් ලියමු.
එම ජාවා වැඩසටහන සඳහා අපි පහත hierarchy එක භාවිතා කරමු.

Cube.java

/**
 *class  : Cube
 *Author : Kanishka Dilshan
 *Purpose: Demonstrate inheritance in Java
 *Blog   : http://javaxclass.blogspot.com
 */


class Cube {
 protected int length;
 protected int width;
 protected int height;
 
 public Cube(int l,int w,int h){
  length=l;
  width=w;
  height=h;
 }
 
 public void setLength(int l){
  length=l; 
 }
 
 public void setWidth(int w){
  width=w; 
 } 
 
 public void setHeight(int h){
  width=h; 
 }
 
 public int getVolume(){
  return(length*width*height);
 }

 public void showInfo(){
  System.out.println("Length \t:"+this.length);
  System.out.println("Width  \t:"+this.width);
  System.out.println("Height \t:"+this.height);
  System.out.println("Volume \t:"+getVolume());
 }
}

ColorCube.java

/**
 *class  : ColorCube
 *Author : Kanishka Dilshan
 *Purpose: Demonstrate inheritance in Java
 *Blog   : http://javaxclass.blogspot.com
 */

class ColorCube extends Cube {
 String color;
 
 public ColorCube(int l,int w,int h,String color){
  //constructing the parent
  super(l,w,h);
  this.color=color;
 }
 
 public void setColor(String color){
  this.color=color;
 }
 
 public void showInfo(){
  super.showInfo();
  System.out.println("Color \t:"+this.color);
 }
}

InheritanceDemo.java

/**
 *class  : InheritanceDemo
 *Author : Kanishka Dilshan
 *Purpose: Demonstrate inheritance in Java
 *Blog   : http://javaxclass.blogspot.com
 */

class InheritanceDemo {
 public static void main(String args[]){
  Cube cube1=new Cube(3,7,5);
  ColorCube ccb1=new ColorCube(2,9,4,"Blue");
  
  cube1.showInfo();
  System.out.println("_____________________________");
  ccb1.showInfo();
  
  System.out.println("\nMaking changes to cube objects....");
  cube1.setWidth(8);
  ccb1.setColor("Yellow");
  ccb1.setHeight(6); //this methods is inherited by the Cube class
  System.out.println("New info. of modified objects\n");  
  cube1.showInfo();
  System.out.println("_____________________________");
  ccb1.showInfo();  
 }
}

Output :

ඉහත ජාවා වැඩසටහන අධ්‍යයනයෙන් ඔබට inheritance පිලිබඳ තවදුරටත් වටහාගත හැකිවනු ඇත.එහි class variables සඳහා protected access එකක් ලබාදීමෙන් සිදුකරන්නේ එම data members සඳහා ප්‍රවේශවීම(access) අදාල class එක තුලදී සහ එහි sub classes වලට පමණක් සීමා කිරීමයි.

දැන් අපි Inheritance හිදී සිදුවන ක්‍රියාවලිය සියුම්ව වටහා ගැනීමට සුදුසු ජාවා වැඩසටහනක් අධ්‍යයනය කරමු.
InherianceStudy.java

/**
 *class  : InherianceStudy
 *Author : Kanishka Dilshan
 *Purpose: Demonstrate inheritance in Java
 *Blog   : http://javaxclass.blogspot.com
 */

class Parent {
 protected int i,j;
 
 public Parent(){
  System.out.println("Using the default constructor of Parent class..");
  i=0;
  j=0;
 }
 
 public Parent(int i,int j){
  System.out.println("Using the integer constructor of Parent class..");
  this.i=i;
  this.j=j;
 }
 
 public void showMessage(String msg){
  System.out.println("A message from Parent class..");
  System.out.println("Message : "+msg);
 }
}

class Child extends Parent {
 protected String text;
 
 public Child(){
  System.out.println("Using the default constructor of Child class..");
 }
 
 public Child(int i,int j,String t){
  super(i,j);
  System.out.println("Using the integer constructor of Child class..");
  this.text=t;
 }
 
 public void showMessage(){
  showMessage("Java programming is very interesting!!");
  System.out.println("A message from Child class..");
  System.out.println("Message : "+text);
 }
}

class InherianceStudy {
 public static void main(String args[]){
  System.out.println("Creating Parent objects...");
  System.out.println("_________________________________________________\n");
  Parent p1=new Parent();
  Parent p2=new Parent(2,5);
  System.out.println("\nCreating Child objects...");
  System.out.println("_________________________________________________\n");
 
  Child c1=new Child();
  Child c2=new Child(3,-1,"Java is owned by Sun Microsystems");
  System.out.println("\nShowing messages..");
  System.out.println("_________________________________________________\n");
  c2.showMessage();
 }
}

Output:

ඉහත ජාවා කේතය දී ඇති ප්‍රතිඵලය සමග සැසඳීමෙන් ඔබට Inheritance සංකල්පය ගැන හොඳ අවබෝධයක් ලබා ගැනීමට පුලුවන්. Sub class එකකින් object එකක් සාදන සෑම විටම එහි super class එකත් construct වීම සිදුවන බව දැන් ඔබට වටහා ගත හැකිවිය යුතුයි.

මෙම පාඩමේ උදාහරණ download කරගැනීමට පහත Link එක භාවිතා කරන්න.

ජාවා වස්තු පාදක ක්‍රමලේඛනය V (Data Encapsulation/ Data Hiding)

2010-06-03T19:31:00.002+05:30

data සහ methods තනි ඒකකයකට සංක්ෂිප්ත කිරීම data encapsulation ලෙස හඳුන්වන්න පුලුවන්. මෙහි තනි ඒකකය ලෙස දක්වා ඇත්තේ ජාවා class එකකි. ජාවා class එකක ඉතාම සිත් ගන්නා සුලු ලක්ෂණයක් ලෙසටද data encapsulation දැක්විය හැකියි. මෙහිදී සිදුකරන්නේ පිටතින් දත්ත සඳහා සෘජුව පිවිසීමට(access) ඉඩ නොදී methods භාවිතා කොට ඒ සඳහා අතුරු මුහුනතක් සැකසීමයි. data hiding ලෙස හැඳින්වෙන්නේද මෙම සංකල්පයමයි. මෙම සංකල්පය ක්‍රියාවට නංවන ලද object එකක් අපට black box එකක් ලෙස හැඳින්විය හැකි අතර මෙහිදී එහි අභ්‍යන්තර ක්‍රියාවලිය ගැන සවිස්තර අවබෝධයක් නැතිව එහි සපයා ඇති methods ගැන පමණක් අවබෝධයක් ලබාගැනීමෙන් පසු අදාල කාර්‍ය කිරීමට හැකිය.

Data Encapsulation සංකල්පය ක්‍රියාවට නැංවීම සඳහා අනුගමනය කලයුතු නීතිරීති.

1 ) Encapsulate කරන ලද object එකක අභ්‍යන්තර දත්ත(internal data) කිසි විටෙකත් වෙනත් පරිභාහිර object එකක් මහින් සෘජුව මෙහෙයවීම වැළැක්විය යුතුය.
2 ) දත්ත මෙහෙයවීම(manipulate) සඳහා accessor methods හා mutator methods භාවිතා කල යුතුය.

Accessor Methods - අභ්‍යන්තර දත්ත වලට අදාල අගයන් පිටතට ලබාදීමට යොදාගනී. එමෙන්ම අභ්‍යන්තර දත්ත(internal data) ප්‍රදර්ශනය කිරීමක් වැනි ක්‍රියාවලටද යොදාගනී. සාමාන්‍යයෙන් accessor method එකක නම ආරම්භ වනුයේ get යන උපසර්ගයෙනි(prefix).

උදා : getUserName(); , showErr();

Mutator Methods - අභ්‍යන්තර දත්ත සඳහා අගයන් සෙට් කිරීම මෙම methods භාවිතයෙන් සිදුකෙරේ. මෙහිදී නව දත්ත වල වලංගු භාවය(validity) සහ සම්පූර්ණත්වය (integrity) සහතික කල හැකිය. සාමාන්‍යයෙන් mutator method එකක නම ආරම්භ වනුයේ set යන උපසර්ගයෙනි(prefix).

උදා : setWallpaper(String imagePath);

දැන් අපි data encapsulation/data hiding සංකල්පය හොඳින් අවබෝධ කරගැනීම සඳහා උදාහරණයක් බලමු.

Cylinder.java

/**
 *Author : Kanishka Dilshan
 *Purpose: Demonstrate encapsulation in Java
 *Blog   : http://javaxclass.blogspot.com
 */

public class Cylinder{
 //radius and height are private members
  
 private double radius,height;
 
 public Cylinder(double rad,double ht){
  radius=rad;
  height=ht;
 }
 
 //mutator methods
 public void setRadius(double rad){
  radius=rad;
 }
 
 public void setHeight(double ht){
  height=ht;
 }
 
 //accessor methods
 public double getVolume(){
  return (Math.PI*radius*radius*height);
 }
 
 public double getSurface(){
  return (2*Math.PI*radius*(height+radius));
 }
}

දැන් අපි ඉහත Cylinder class එක භාවිතා කිරීමට සරළ වැඩසටහනක් ලියමු.
EncapDemo.java

public class EncapDemo{
 public static void main(String args[]){
  Cylinder c1=new Cylinder(4.23,12.56);
  //invoking accessor methods
  double surf1=c1.getSurface();
  double vol1=c1.getVolume();
  System.out.println("Volume of c1  : " + vol1 );
  System.out.println("Surface of c1 : " + surf1 );
  
  //invoking mutator methods
  System.out.println("Modifying the cylinder object..");
  c1.setRadius(23.11);
  c1.setHeight(5.46);
  double surf2=c1.getSurface();
  double vol2=c1.getVolume();  
  System.out.println("Volume of c1  : " + vol2 );
  System.out.println("Surface of c1 : " + surf2 );  
  
 }
}

Output :

Cylinder class එකෙහි data members සියල්ලම private ලෙසද පිටතින් invoke කරන methods සියල්ලම public ලෙසටද යොදා ඇත. එනිසා මෙහිදි Cylinder object එකක internal data භාහිරින් access(ප්‍රවේශනය) කල නොහැක. තවද අදාල දත්ත මෙහෙයවීම සඳහා accessor සහ mutator methods යොදා ඇත. එමනිසා මෙම Cylinder class එක encapsulate කරන ලද ඒකකයකි.

ජාවා වැඩසටහනකට Command Line Arguments ලබාගන්නා ආකාරය.

2010-05-25T17:46:00.003+05:30

ජාවා වැඩසටහනක් ක්‍රියාත්මක කරවන(Execute) අවස්ථාවේම එයට යම් දත්තයක් හෝ කිහිපයක් ලබාදීමට Command Line Arguments භාවිතා කල හැක. උදාහ‍රණයක් ලෙස copy file1 file2 යන විධානයේ file1 හා file2 ලෙසට අපිවිසින් දත්තයන් දෙකක් ලබාදී ඇත copy utility එක සඳහා එම file1 file2 command line argument 2කි. එම විධානය ක්‍රියාත්මක කල විට copy utility එක විසින් අදාල arguments 2 වැඩසටහන තුලට ලබාගෙන අදාල කාර්‍යය ඉටුක‍රනු ලබයි. අපි දැන් බලමු ජාවා වැඩසටහනකින් කොහොමද මෙවැනි හැකියාවක් ලබාදෙන්නේ කියලා.

අපි ජාවා වැඩසටහන ආරම්භයේදී ලබා දෙන arguments තැන්පත් වී තිබෙන්නේ public static void main(String args[]) හි සඳහන් කරන ලද args[] නම් array එක තුලයි. එනම් main method එකෙන් parameter එකක් ලෙස ලබාදුන් array එක තුලයි. මෙය args ලෙසින්ම නම් වීම අත්‍යාවශ්‍ය නොවේ. නමුත් එය String type එකෙන් තිබීම අනිවාර්‍ය වේ. ඔබට arrays ගැන ගැටලුවක් ඇත්නම් arrays සම්බන්ද පාඩම බලන්න.

example01:

class CommandLineDemo{
 public static void main(String args[]){
  String argument1=args[0];
  String argument2=args[1];
  String argument3=args[2];
  System.out.println("Argument 1 : "+argument1);
  System.out.println("Argument 2 : "+argument2);
  System.out.println("Argument 3 : "+argument3);
 }
}

Output:

අපි මෙහිදී Java C++ C# Perl ලෙසින් argument 4ක් දී තිබුනද console එකෙහි පෙන්වා ඇත්තේ Java C++ C# arguments 3 පමණි. අපි access ක‍ර ඇත්තේ args[] හි 0,1,2 යන elements 3 පමණි. යම්හෙයකින් අපි args හි අඩංගු නැති element එකක් access කලහොත් ArrayIndexOutOfBoundsException එකක් ලැබෙනු ඇත. එනම් program එකෙහි run time error එකක් ඇතිවනු ඇත. Error Control ගැන කෙරෙන පාඩමේදී අපි Exception ගැන විස්ත‍රාත්මකව ඉගෙන ගනිමු. අපි ඉහත වැඩසටහනේ එවැනි error එකක් ලැබෙන අවස්ථාවක් ගැන බලමු.

අපි arguments ලෙස ලබා දී ඇත්තේ Java හා C++ පමණි නමුත් අප වැඩසටහන තුලදී args[] හි 3වන element එකද access කෙරේ(2nd index). එමනිසා මෙහිදී ඉහත සඳහන් කල ආකාරයේ exception එකක් (මෙහිදී නම් run time error) ලැබේ.

අපි දැන් ඉහත ආකාරයේ දෝශ මගහැරවීමට සුදුසු පියව‍රක් යොදා එම වැඩසටහනම වැඩිදියුණු (modify) ක‍රමු.

example02:

class CommandLineDemo{
 public static void main(String args[]){
  try{
   String argument1=args[0];
   String argument2=args[1];
   String argument3=args[2];
   System.out.println("Argument 1 : "+argument1);
   System.out.println("Argument 2 : "+argument2);
   System.out.println("Argument 3 : "+argument3);
  }catch(ArrayIndexOutOfBoundsException ex){
   System.out.println("Incorect usage!");
   System.out.println("You must provide minimum of 3 numbers!");
   System.out.println("Invalid index =  " + ex.getMessage());
   
  }
 }
}

Exception handle කිරීම ගැන අපි ඉදිරි පාඩමකින් විස්ත‍රාත්මකව සාකච්ඡා ක‍රමු. මෙම පාඩමේ මූලික අරමුණ Command Line Arguments භාවිතා ක‍රන ආකාරය හැදෑරීමයි. මෙහිදී මතක තබාගත යුතු කාරණාව වන්නේ args[] array එක String type එකෙන් ඇති බවයි එමනිසා අපි ගණිතමය දත්තයන් arguments ලෙස ගන්නා විට ඒවා සුදුසු types වලට convert කිරීමට සිදුවනවා.

අපි දැන් ප්‍රායෝගික උදාහරණ කිරිපයක් බලමු.
Example03:

class CLADemo1{
 public static void main(String args[]){
  try{
   String name=args[0];
   float price=Float.parseFloat(args[1]);
   float VAT=Float.parseFloat(args[2]);
   float Total=price+VAT;
   System.out.println(name +" :  " + Total);
  }catch(ArrayIndexOutOfBoundsException e){
   System.out.println("Incorrect usage!");
  }catch(NumberFormatException e){
   System.out.println("Invalid number " + e.getMessage());
  }
 }
}

Output 01:

මෙහිදී numbers convert ක‍රන විට ලබාදී ඇති number format එක දෝශ සහගත නම් එයද handle කිරීමට NumberFormatExcption එකක්ද program එක තුලදී catch ක‍ර ඇත. පහත රූපයෙන් එවැනි exception එකක් මතුවූ විට අප විසින් පෙන්වන දෝශ පණිවුඩය දැක්වේ.

මෙම පාඩමේ උදාහරණ download කරගැනීමට පහත Link එක භාවිතා කරන්න.

OOP සඳහා අභ්‍යාස II කොටස

2010-05-23T12:16:00.000+05:30

අපි කලින් පාඩමෙන් ස‍රල OOP සඳහා උදාහ‍රණ දෙකක් සාකච්ඡා කලා. අපි මේ පාඩමේදී බලමු මදක් සංකීර්ණ OOP examples කිහිපයක්. අපි මෙතෙක් උගත් Object Oriented සංකල්ප වලින් පමණක් උදාහ‍රණ සපයා ඇති ඇතිබව සලකන්න. අපි ඉදිරියේදී ජාවාහි තවත් වැදගත් Object Oriented සංකල්ප සාකච්ඡා ක‍රමු. එහිදී ඒවාට අදාල උදාහ‍රණ සුදුසු ප‍රිදි ඉදිරිපත් කෙරෙනු ඇත.
අපි මෙහිදී objects අත‍ර සම්බන්දතාවයක් පෙන්විය හැකි උදාහ‍රණයක් සලකා බලමු. objects ලෙස Point හා Line (ලක්ෂ්‍යයක් හා සරල රේඛාවක්) ගනිමු. මෙහිදී අපි එක එකක් class සඳහා වෙන වෙනම java file ලියා තිබෙනවා. පාඩම අවසානයේ එම මූලාශ්‍ර කේත අමුණා තිබෙනවා.

Point.java

/**
 *Class Name : Point
 *Author     : Kanishka Dilshan
 *Bolg       : http://javaxclass.blogspot.com
 *Purpose    : Demonstrate relationships between objects
 */
public class Point {
 private int x,y;
 
 public Point(int x,int y){
  this.x=x;
  this.y=y;
 }
 
 public void setX(int x){
  this.x=x;
 }
 
 public void setY(int y){
  this.y=y;
 }
 
 public int getX(){
  return x;
 }
 
 public int getY(){
  return y;
 }
 
 public double distance(){
  //calculate and return distance from the origin
  double dis=Math.sqrt(Math.sqrt(Math.pow(x,2)+Math.pow(y,2)));
  return dis;
 }
 
}

දැන් ඔබට Point class එකේ ජාවා කේතය කියවා අවබෝධ ක‍රගැනීමට හැකිවිය යුතුය. ගැටලුවක් ඇත්නම් පෙර OOP පාඩම් නැවත කියවා බලන්න.Math.pow() හා Math.sqrt() යනු ජාවාහි inbuilt methods ය. pow() method එක මගින් යම් සංඛ්‍යාවක බලයක්ද sqrt() method එක මගින් යම් සංඛ්‍යාවක වර්ගමූලයද ලබාදේ.
දැන් අපි අපි ඉහත ලියන ලද Point class එක සම්බන්ද ක‍රගෙන Line (ස‍රල රේඛාවක්) සඳහා class එකක් ලියමු. source code එක කියවීමේදී statements වලට අදාලව යොදා ඇති comments ද කියවන්න. එමගින්ද අදාල කොටස ගැන හොඳ අවබෝධයක් ලබාගත හැකිවේවි.
Line.java

/**
 *Class Name : Line
 *Author     : Kanishka Dilshan
 *Bolg       : http://javaxclass.blogspot.com
 *Purpose    : Demonstrate relationships between objects
 */
public class Line {
 private Point p1,p2;
 /**
  *p1 and p2 are Point objects
  *we have already created the Point class
  */
  public Line(Point p1,Point p2){
  this.p1=p1;
  this.p2=p2;
  }
  
  public double getLength(){
  int x1=p1.getX();
  int x2=p2.getX();
  int y1=p1.getY();
  int y2=p2.getY();
  double len=Math.sqrt(Math.pow((x1-x2),2)+Math.pow((y1-y2),2));
  return len;
  }
  
  public void showDetails(){
  System.out.println("x1 : " + p1.getX() + " y1 : " + p1.getY());
  System.out.println("x2 : " + p2.getX() + " y2 : " + p2.getY());
  System.out.println("----------------------------------------");
  }
 
}

ඔබ දකින්නට ඇති Line class එකේ 8 වන පේලියේදී අපි p1 හා p2 ලෙසින් Point object 2ක් සාදාගෙන තිබෙනවා. එම Point type එක වනුයේ අපි ඉහතින් සකස්ක‍ර ගත් Point class එකයි.
අපි Line class එකේ constructor එකේදී (13පේලිය) Point parameters 2ක් ගෙන තිබෙනවා.අපි දැන් ඉහත class 2ම යෙදෙන ප‍රිදි ජාවා වැඩසටහනක් ලියමු.

/**
 *Class Name : Line
 *Author     : Kanishka Dilshan
 *Bolg       : http://javaxclass.blogspot.com
 *Purpose    : Demonstrate howto use above classes
 */
public class OOPDemo {
 public static void main(String args[]){
  //create 2 Point objects (p1 and p2)
  Point pnt1=new Point(3,4);
  Point pnt2=new Point(-2,7);
  System.out.println("x position of p1    : " + pnt1.getX());
  System.out.println("y position of p1    : " + pnt1.getY());
  System.out.println("distance frm Origin : " + pnt1.distance());
  System.out.println("----------------------------------------");
  
  //creating a Line object;
  Line ln1=new Line(pnt1,pnt2);
  //show details of ln1
  System.out.println("Details of the line object");
  ln1.showDetails();
  double lineLen=ln1.getLength();
  System.out.println("length of line : " + lineLen);
 }
}

Output :

අපි ඉහත වැඩසටහනේ main method එකේදී සිදුක‍ර ඇත්තේ අප විසින් ලියූ Point class එක සහ Line class එක භාවිතා ක‍ර objects සෑදීමයි. pnt1 හා pnt2 ලෙසින් Point object 2ක් සාදා ඉන් pnt1 එකෙහි details console එකෙහි print ක‍ර එම pnt1 හා pnt2 objects arguments ලෙස භාවිතා ක‍රමින් Line object එක සාදා තිබෙන බව ඔබට වැටහෙනවා ඇති.
ඉහත Point හා Line class 2 යොදාගනිමින් සාදා ඇති පහත ඇප්ලටය භාවිතා ක‍රමින් එම objects වල හැසිරීම ප‍රීක්ෂා ක‍ර බලන්න. එම Java Applet එකෙහි source code එකද මම පහත ඉදිරිපත් ක‍ර ඇති link එකෙන් download ක‍රගන්න පුලුවන්.
ජාවා ඇප්ලට් ගැන අපි ඉදිරි පාඩම් පෙලකින් දීර්ඝව සාකච්ඡා ක‍රමු. මෙහිදී අප උගත් දෑ ආදර්ශනය කිරීමට පමණක් පහත ජාවා applet එක ලියා ඇති බව සලකන්න

මෙම පාඩමේ ඉදිරිපත් ක‍ර ඇති මූලාශ්‍ර කේත භාගත ක‍රගැනීමට පහත link එක භාවිතා ක‍රන්න.

ඉහත Java Applet එකෙහි source code එක download ක‍රගැනීමට පහත link එක භාවිතා ක‍රන්න.

OOP සඳහා අභ්‍යාස I

2010-05-22T18:15:00.000+05:30

අපි මීට පෙර පාඩම් වලදී ඉගෙනගත් Java OOP සංකල්ප තවත් හොඳින් අවබෝධ කරගැනීම සඳහා අපි අභ්‍යාස කිහිපයක් සාකච්ඡා කරමු. මෙහිදී මම හැකිතාක් ප්‍රායෝගික උදාහරණ ඉදිරිපත් කිරීමට බලාපොරොත්තු වනවා. අභ්‍යාසයේ යෙදෙන තරමට අපිට ජාවා වල සංකල්ප අවබෝධ කරගැනීමට පහසුයි.
අපි මුලින්ම ස‍රල උදාහ‍රණයකින් පටන්ගනිමු. මෙහිදී ඉදිරිපත් ක‍ර ඇති කේතයන් ඔබ ඉගෙනගත් OOP concept සමග ගලපමින් අවබෝධ ක‍රගැනීමට උත්සාහ ක‍රන්න.
Exercise1

/**
 *Author : Kanishka Dilshan
 *Blog   : http://javaxclass.blogspot.com
 *Purpose: Demonstrate some applications of OOP
 */

class Car {
 private String model,color;
 private int enginePower,speed;
 
 public Car(String model,String color,int enginePower){
  this.model=model;
  this.color=color;
  this.enginePower=enginePower;
  speed=0;
 }
 
 public void accelerate(){
  //let's assume the maximum speed is 320
  if(speed < 320){
   speed+=10; //increment speed by 10
  }
 }
 public void applyBreaks(){
  if(speed > 10){
   speed-=10; //decrement speed by 10
  }
 }
 public void changeColor(String NewColor){
  this.color=NewColor;
 }
 public void showDetails(){
  System.out.println("----------------------------------");
  System.out.println("Car Model    : " + model);
  System.out.println("Engine Power : " + enginePower);
  System.out.println("Color        : " + color);
  System.out.println("Current Speed: " + speed);
  System.out.println("----------------------------------");
 }
 public String getModel(){
  return model;
 }
}

public class Exercise1{
 public static void main(String args[]){
  //create a new Car object
  Car c1=new Car("Audi A4","Blue",2000);
  //accelerate the car
  for(int i=0;i < 120;i++){
   c1.accelerate();
  }
  //show details of the car
  c1.showDetails();
  //apply breaks on the car(3 times)
  c1.applyBreaks();
  c1.applyBreaks();
  c1.applyBreaks();
  //change color 
  c1.changeColor("Black");
  //show details of the car again
  c1.showDetails();
  
  //create another car object
  Car c2=new Car("Mazda 3 Sedan","Red",1800);
  //.......................
 }
}

Output :

දැන් අපි ඉහත ලියන ලද ජාවා වැඩසටහන විස්ත‍රාත්මක වශයෙන් සාකච්ඡා ක‍රමු.

Line 07 මගින් Car class එකේ ආරම්භය සනිටුහන් කෙරෙනවා. එහි සියලුම class variables වලට යොදා ඇත්තේ private modifier එක බව ඔබට පෙනෙනවා ඇති.(line 8,line 9). අපි access modifiers ගැන සාකච්ඡා ක‍රද්දී ඔබට මතක ඇති මම එහිදී සඳහන් කලා instance variables,private ලෙසත් methods , public ලෙසත් යෙදීම හොඳ වස්තු පාදක ක්‍රමලේඛනයක ලක්ෂණයක් බව.

ඉන්පසුව ඇත්තේ constructor එකයි (line 11) එහිදී අපි speed එක 0 ලෙසත් අනෙකුත් class variables සඳහා constructor එකෙන් ලබාගන්නා parameters ද ආදේශ ක‍ර තිබෙනවා. මෙහිදී constructor එකේ parameter එකක් ලෙස speed එක ගෙන නැහැ. නමුත් constructor එක තුලදී speed variable එක සුදුසු value එකක් යොදා initialize ක‍ර තිබෙනවා.

ඉන්පසු ඇත්තේ methods ය. අපි methods පාඩමේදී ලබාගත් දැණුම භාවිතයෙන් ඔබට මෙය පහසුවෙන් අවබෝධ ක‍රගත හැකිවිය යුතුය.

Car class එක ලියා අවසන්වූ පසු main method එක අයත් Exercise1 class එක ආරම්භවේ. මෙහිදී අප සකස්ක‍රගත් Car class එක භාවිතා ක‍ර object සාදා ඒවා භාවිතා කිරීම සිදු කෙරේ. ජාවා වැඩසටහන තුල යොදා ඇති comments වලින්ද එහිදී සිදුවන්නේ කුමක්ද යන්න තේරුම් ගැනීමට හැක.

Exercise2

/**
 *Class Name : Excerice2java
 *Author     : Kanishka Dilshan
 *Blog       : http://javaxclass.blogspot.com
 *Purpose    : Demonstrate some applications of OOP
 */
class Line {
 private int x1,y1,x2,y2;
 
 public Line(int x1,int y1,int x2,int y2){
  this.x1=x1;
  this.y1=y1;
  this.x2=x2;
  this.y2=y2;
 }
 
 public double getLength(){
  double length=Math.sqrt(Math.pow((x1-x2),2)+Math.pow((y1-y2),2));
  return length;
 }
}

public class Exercise2{
 public static void main(String args[]){
  Line line1=new Line(-3,6,10,8);
  double len=line1.getLength();
  System.out.println(len);
 }
}

අපි ඊලඟ පාඩමෙන් මීට වඩා සංකීර්ණ උදාහ‍රණ කිහිපයක් බලමු.
මෙම පාඩමේ ඉදිරිපත් ක‍ර ඇති මූලාශ්‍ර කේත භාගත ක‍රගැනීමට පහත link එක භාවිතා ක‍රන්න.