Friday, January 20, 2012

java - keywords (still under construction)

ජාවා keywords ගැන තමයි අද කතා කරන්නේ.
හරියටම keywords මෙච්චරක් තියනවා කියන්න විදියක් නෑ. හැබයි පොදුවේ ගත්තොත් keywords 50 -60 ත් (50 in Java 1.5) අතර ප්‍රමාණයක් තමයි තියෙන්නේ. පහල තියන list එකේ තියනවා keywords ටික. මෙතන ඔක්කොම keywords තියනවා කියන එක නම් මම gurantee කරන්නෑ.
මේ එකින් එක ගැන විස්තර කරන්න නම් අමාරුයි. මම කියන්නම් class වලට, methods  වලට හා වලට කරන්න පුලුවන් ගැන. පස්සේ වෙලාව තිබුනොත් අනික් ගැනත් ලියන්නම්
  1. abstract
  2. continue
  3. for
  4. new
  5. switch
  6. assert
  7. default
  8. goto
  9. package
  10. synchronized
  11. boolean
  12. do
  13. if
  14. private
  15. this
  16. break
  17. double
  18. implements
  19. protected
  20. throw
  21. byte
  22. else
  23. import
  24. public
  25. throws
  26. case
  27. enum
  28. instanceof
  29. return
  30. transient
  31. catch
  32. extends
  33. int
  34. short
  35. try
  36. char
  37. final
  38. interface
  39. static
  40. void
  41. class
  42. finally
  43. long
  44. strictfp
  45. volatile
  46. const
  47. float
  48. native
  49. super
  50. while

අපි මුලින්ම බලමු  class වලට use කරන්න පුලුවන් keywords මොනවාද කියලා.
එහෙම keywords 5ක් තියනවා
ඒ keywords 5 කොටස් දෙකකට බෙදන්න පුලුවන්.
1. access modifiers
2. non-access modifiers

access modifiers යටතේ තියෙන්නේ keywords දෙකයි.
public, default

non-access modifiersයටතේ තුනක් තියනවා
strictfp, final, abstract

public, default කියන keywords දෙක ගැනනම් ආයි කතාකරන්න ඕනේ නෑ. ඒ දෙක ගැන java - access modifiers http://alokayasoya.blogspot.com/#!/2012/01/java-access-modifiers.html එකේ ලියලා ඇති.

මුලින්ම බලමු strictfp කියන keyword එක ගැන. මේක classes වලට වගේම methods වලටත් use කරන්න පුලුවන්. මේ keyword එක use කලාම JVM එක floating point values handle කරන්නේ IEEE-754 floating-point specification එකට අදාලව තමයි.

Tuesday, January 17, 2012

Eyes wants to sleep

My eyes need to sleep coz it was so hard to looking at monitor for about 10 hours @ work and now @ home. But still heart wants to wait to see someone online

Sunday, January 15, 2012

ලමැදේ හුස්මක් පවා

වැසිදාක තුරු යාය පීරා
අතුරාන පිණි සිත සීරා
දෑස හමුවේම උතුරාන දුටුවා එදා
හාද වී රෑ පුරා

ලමැදේ හුස්මක් පවා
ආලේ කලා ආසයි කියා

වැසිදාක තුරු යාය පීරා
අතුරාන පිණි සිත සීරා
ආයාචනා සීතේ ගලා
ආශා මවා මාගේ වෙලා
ආවා සිත දා පාවිලා
රෑ විලා.........
රෑ හීන පාසා වෑහේවි ආශා
මා හා....

ලමැදේ හුස්මක් පවා
ආලේ කලා ආසයි කියා

මේ චෝදනා දෑසේ පුරා
ආවා සොයා යායේ සරා
නාඩා දෑස හා
යාවෙනා
මේ හීන සේනා ආයේම ඕනා
මා හා.....

ලමැදේ හුස්මක් පවා
ආලේ කලා ආසයි කියා

සඳ පාන සඳ රේණු නාවා
හිත මාගේ සබකෝල වීලා
මගේ තුරුලේම
කොඳුරාන නොකියූ කතා
දෑස පියවී ගියා......

ලමැදේ හුස්මක් පවා
ආලේ කලා ආසයි කියා

Java - Simple console chat app

මෙන්න මචං මගේ ගානේ ජාවා වලට කැමති කට්ටියට සරල Chat application එකක්. කට්ටියට පොඩි පොඩි changes ටිකක් කරලා පට්ට chat එකක් හදා ගන්න මේක උදව්වක් වෙයි කියලා හිතනවා.
මෙන්න server එකේ code එක.

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author Thusitha
 */

public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(12345);
            while (true) {
                Socket incoming = serverSocket.accept();
                Runnable r = new ThreadedServer(incoming);
                Thread t = new Thread(r);
                t.start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class ThreadedServer implements Runnable {
    private Socket incoming;
    private Scanner type = new Scanner(System.in);
    private Scanner reader;
    private PrintWriter writer;
    public ThreadedServer(Socket i) throws IOException {
        incoming = i;
        reader = new Scanner(incoming.getInputStream());
        new Thread(new Runnable() {
            public void run() {
                try {
                    InputStream inStream = incoming.getInputStream();
                    while (incoming.isConnected()) {
                        while (reader.hasNext()) {
                            System.out.println(reader.nextLine());
                        }
                    }
                } catch (IOException ex) {
                    Logger.getLogger(ThreadedServer.class.getName()).log(Level.SEVERE, null, ex);
                }
                try {
                    Thread.currentThread().sleep(1000);
                } catch (InterruptedException ex) {
                    Logger.getLogger(ThreadedServer.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }).start();
        new Thread(new Runnable() {
            public void run() {
                try {
                    OutputStream outStream = incoming.getOutputStream();
                    writer = new PrintWriter(outStream, true);
                    while (incoming.isConnected()) {
                        writer.println(type.nextLine());
                    }
                } catch (IOException ex) {
                    Logger.getLogger(ThreadedServer.class.getName()).log(Level.SEVERE, null, ex);
                }
                try {
                    Thread.currentThread().sleep(1000);
                } catch (InterruptedException ex) {
                    Logger.getLogger(ThreadedServer.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }).start();
    }
    public void run() {
    }
}
මුලින්ම මේ code එක notepad file එකට copy කරලා Server.java කියලා java file විදියට save කරගන්න. ඊට පස්සේ පහල තියන code එක වෙන notepad file එකකට  copy කරලා Client.java විදියට save කරගන්න. අන්තිමට files දෙකම compile කරගන්න.

මෙන්න client එකේ code එක.
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
*
* @author Thusitha
*/

class Client {
    private Scanner clientReader;
    private Socket s;
    private PrintWriter clientwriter;
    private Scanner clientType = new Scanner(System.in);
    public Client() {
        try {
            s = new Socket("localhost", 12345);
            clientReader = new Scanner(s.getInputStream());
            new Thread(new Runnable() {
                public void run() {
                    while (s.isConnected()) {
                        while (clientReader.hasNext()) {
                            System.out.println(clientReader.nextLine());
                        }
                    }
                    try {
                        Thread.currentThread().sleep(1000);
                    } catch (InterruptedException ex) {
                        Logger.getLogger(ThreadedServer.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }
            }).start();
            new Thread(new Runnable() {
                public void run() {
                    try {
                        OutputStream outStream = s.getOutputStream();
                        clientwriter = new PrintWriter(outStream, true);
                        while (s.isConnected()) {
                            clientwriter.println(clientType.nextLine());
                        }
                    } catch (IOException ex) {
                        Logger.getLogger(ThreadedServer.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    try {
                        Thread.currentThread().sleep(1000);
                    } catch (InterruptedException ex) {
                        Logger.getLogger(ThreadedServer.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }
            }).start();
        } catch (UnknownHostException ex) {
            Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    public static void main(String[] args) throws Exception {
        new Client();
    }
}

දැන් අපිට මේක test කරන්න පුලුවන්. මුලින්ම Server.java file එක run කරන්න. ඊට පස්සේ අලුතෙන් command prompt එකක් open කරලා Client.java file එක run කරන්න. දැන් මොනවා හරි type (ටයිප්) කරලා Enter ඔබලා බලන්න. ටයිප් කරන ටික අනික් command prompt එකේ පේනවා.

එහෙනම් කට්ටියට ජය වේවා

Java - Simple Port Scanner

 අද මම කියලා දෙන්න යන්නේ ජාවා වලින් සරල පෝර්ට් ස්කෑනර් PORT SCANNER එකක් හදා ගන්න විදිය. (මම මේක හදලා තියෙන්නෙ ඔක්කොම port(පෝර්ට්) එ කියන්නේ port (පෝර්ට්) 65536 ම ස්කෑන් කරන්න විදියට. කැමති කට්ටිය ඕනේ විදියට වෙනස් කරගන්න. )
මුලින්ම පහල තියන code එක notepad එකට paste කරගන්න. ඊට පස්සේ ඒ ෆයිල් එක TestScanner.java කියලා save(සේව්) කරගන්න. File type(ෆයිල් ටයිප්) එක විදියට All Files දෙන්න.
ඊට පස්සේ ඒ ෆයිල් එක compile කරලා run කරන්න.ජාවා ෆයිල් එකක් compile කරලා run කරන විදිය මම කලින් එකක කියලා දුන්නා ;)(මොකක් හරි අවුලක් තියනවනම් අහන්න )

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

/**
*
* @author Thusitha
*/
public class TestScanner {

public static void main(String[] args) {
while (true) {
try {
System.out.println("Press 1 to find the IP Address of a host");
System.out.println("Press 2 to run the port scan");
System.out.println("Press 3 to exit");
BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));
String command = consoleReader.readLine();
if (command.equalsIgnoreCase("1")) {
System.out.println("please enter hostname");
String hostName = consoleReader.readLine();
System.out.println("Trying to find the IPAddresses of " + hostName);
getIPAddress(hostName);
} else if (command.equalsIgnoreCase("2")) {
System.out.println("please enter hostname");
String hostName = consoleReader.readLine();
System.out.println("Trying to find the open ports in " + hostName + ". This make take several minutes");
portScan(hostName);
} else if (command.equalsIgnoreCase("3")) {
System.exit(0);
} else {
command = consoleReader.readLine();
}
} catch (IOException ex) {
ex.printStackTrace();
}
}

}

public static void portScan(String host) {
for (int i = 0; i < 65536; i++) {
try {
Socket socket = new Socket(host, i);
System.out.println("A server is listening on port " + i);
socket.close();
} catch (UnknownHostException ex) {
} catch (IOException ex) {
}
}
}

public static void getIPAddress(String host) throws UnknownHostException {
InetAddress[] hostAddress = InetAddress.getAllByName(host);
for (int i = 1; i < hostAddress.length; i++) {
System.out.println(hostAddress[i]);
}
}
}

Saturday, January 14, 2012

මගේ හිත

ජීවිතේ හරිම පුදුමයි.
අපි හිතන්නේවත් නැති වෙලාවට
හිතන්නේවත් නැති විදියට
සමහරුන් අපේ හිතේ ලැඟුම් ගන්නවා.
ඔවුන් අපේ ජීවිතේ පුදුම විදියට වෙනස් කරනවා

එහෙම උනාම,
අනික් අය මොනවා කිවුවත්
තමන්ගේ හිතට දැනෙනදේ
කාටවත් ප්‍රතික්ෂේප කරන්න බෑ.

මොකද අපේ හිත දන්නවා
ඔවුන් අපේ ජීවිතයට කොතරම් වැදගත්ද කියන එක


Java - Network programming - 2

කට්ටියට දැන් Network programming ගැන normal idea එකක් තියනවා නේ. එහෙනම් මම පොඩි Server කෑල්ලක් හදන හැටි කියල දෙන්නම්. මම දැන් හදන්නේ TCP පාවිච්චි කරලා. ඊළඟ එකෙන් UDP server එකක් හදන හැටි බලමු.

මම කලින් thread එකෙ කිව්වා වගේ TCP server හදන්න අපි පාවිච්චි කරන්න ඕනේ ServerSocket කියන එක. එකේ ඇතුලට අපි listen කරන් ඉන්න port එක දෙන්න ඔනේ.
e.g. - new ServerSocket(20000);

මෙන්න code එක

class SimpleTCPServer{
public static void main(String[] args) {
try {
ServerSocket s=new ServerSocket(20000);
} catch (IOException ex) {
System.out.println(ex);
}
}
}

මේ එක complile කරලා run කලාට මොකුත් වෙන්නෑ.
කට්ටියට මුලින්ම කියනන් අමතක උනා. Command prompt ගිහින් netstat -ao ගහලා දැනට machine එක listen කරන් ඉන්න port numbers ටික ඉස්සල්ලා බලාගන්න.

මෙන්න මම ගත්ත screen shot එකක්

කට්ටියට පේනවා ඇතිනේ TCP යටතේ 20000 කියන port එකේ මොකුත් නෑ.

දැන් අපි හදාගත්ත ServerSoocket එකට කියනන් ඕනේ listen කරන්න කියලා. ඒකට අපි use කරන්නේ accept() කියන method එක. එතකොට වෙන්නේ Serversocket එක කව්රු හරි ඒකට connect වෙන්න හදනවද කියල බලන් ඉන්න එක. හරියට අපි telephone එක ring වෙනවද කියලා අහන් ඉන්නවා වගේ වැඩක් තමයි මෙතනදී වෙන්නේ.
කව්රු හරි connect උනොත් එහෙම ඒ connect වෙච්ච එකත් එක්ක talk කරන්න මූ අපිට random socket එකක් හදලා දෙනවා.එතකොට ඒ හැදෙන socket එක හරහා ඔනේ වැඩ කරගතෑකි.

මෙන්න code එක

class SimpleTCPServer{
public static void main(String[] args) {
try {
ServerSocket s=new ServerSocket(20000);
s.accept();
} catch (IOException ex) {
System.out.println(ex);
}
}
}

මෙන්න මේ code එක compile කරලා run කරලා බලන්න. ඊට පස්සේ ආපහු command prompt එකට ගිහින් netstat -ao ගහලා check කරලා බලන්න.
මෙන්න මගේ screenshot එක




ඔන්න දැන් අපි server listen කරන් ඉන්න part එක හදලා ඉවරයි. මේක හරහා කොහොමද වැඩ කරන්නේ කියන එක ඉස්සරහට කියලා දෙන්නම්.
කට්ටියට තේරුන්නැති දෙයක් තියනවනම් pm කරන්න.
ජය වේවා

කට්ට්යට මොනවා හරි තේරුනානම් සන්තෝසයි

Friday, January 13, 2012

Life

Some times in life we will miss some people from our lives. They can't be replace by anyone. So don't wait until you are too late. Go and express your self to them.

Java - mysql + java with netbeans - part 2

මෙන්න කලින් දවසේ post එකේ ඉතුරු ටික. මම හිතන්වා කට්ටියම mysql server එක install කරගෙන ඇති කියලා. එහෙම install කරලා නැති කට්ටිය WAMP හරි XAMPP හරි install කරගන්න.පහල තියන links වලින් ඒ දෙක download කරගනන් පුලුවන්.

WAMP
XAMPP

මම use කරන්නේ WAMP එක.install කරලා WAMP එක run කරගන්න. එතකොට පහල පිංතූරයේ තියනවා වගෙ notification area එකේ icon එකක් පෙන්නයි. ඒක උඩ click කරනකොට එන menu එකෙන් phpMyAdmin කියන එක select කරන්න.

එතකොට web browser එක හරහා phpMyAadmin open වෙනවා. එතන තියන create new database හරහා school කියලා database එකක් හදා ගන්න.

පහල තියනවා table එකට අදාල SQL code එක.

CREATE TABLE student (
  sid varchar(10) NOT NULL,
  fname varchar(30) NOT NULL,
  lname varchar(50) NOT NULL,
  dob date NOT NULL,
  address varchar(500) NOT NULL,
  tel varchar(10) DEFAULT NULL,
  PRIMARY KEY (sid)
);

දැන් netbeans open කරගෙන අපි කලින් හදාගත්ත project එක open කරගන්න. menubar එකේ windows යටතේ තියන services  යන එක click කරන්න.

services එකේ තියන database කියන එක උඩ right click කරලා new connection කියන එක කරන්න.
එන windows එකේ Driver යටතේ තියන drop down menu එකෙන් mysql කියන එක select කරන්න.

next button එක click කරලා එන  menu එකේ අදාල details fill කරන්න. JDBC URL එක අගට database එකේ නම type කරන්න.

එතකොට දැන් services කියන එකේ අලුතෙන් හදාගත්ත connection එක පෙන්නනවා


දැන් අපි බලමු netbeans හරහා කොහොමද table එකක් create කරගන්නේ කියලා.
services එකෙන් schhol/tables කියන එක උඩ right click කරලා create table කියන එක select කරන්න.
පහල පිංතූරේ තියන විදියට student table එක හදාගන්න.

ඔන්න දැන් අපි database එක සහ table එකක් හදාගෙන ඉවරයි.

දැන් අපි බලමු අපි කලින් හදාගත්ත DatabaseConnection class එක වැඩ කරනවාද කියලා.
ඒ සඳහා ඊයේ අපි හදාගත්ත class එකේ main method එකක් හදලා පහල තියන code එක ගහලා කරලා run බලන්න.

package db;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
 *
 * @author Thusitha
 */
public class DatabaseConnection {
    public static Connection createConnection(String userName, String password, String datbaseName) throws SQLException {
        DriverManager.registerDriver(new com.mysql.jdbc.Driver());
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/"+datbaseName, userName, password);
        return connection;
    }
   
    public static void main(String[] args) {
        try {
            Connection myConncetion = createConnection("root", "123", "school");
            System.out.println(myConncetion.isClosed());
        } catch (SQLException ex) {
            Logger.getLogger(DatabaseConnection.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

run කරන්න class එක උඩ right click කරලා run this file කියන එක select කරන්න.

run කලාම output එක විදියට false කියලා print වෙනවනම් අපේ method එක හරියට වැඩ කරනවා.


දැන්නම් හොඳ ගනං මේක type කරලා. ඉතුරු ටික ඊළඟ post එකෙන් බලාපොරොත්තු වන්න.

Thursday, January 12, 2012

ජීවිතේ ... සුන්දරද මෙතරම් ...

සුවඳ දැනී දැනෙනවා
උදා හිරු එළියේ
අලුත් ඉරක්දෝ මේ
හිතට ගලනවා හීන බිඳු බිඳු
හීන් පිනි හුළගේ
හිනස්සා හිත ගැඟුම්
සුවඳ දැනී දැනෙනනවා

ඊයේ නොදුටුව ලස්සන ලෝකය අද කොයින්දෝ
හෙමිහිට ඇවිදින් මිදුල දිගේ මට තුරුළු වෙනවා
ජීවිතේ ... සුන්දරද මෙතරම් ...
සුවද දැනී දැනෙනවා

රෑන රෑන එන පාට පාට සමනළයෝ
පේන පේන මල සිපගන්නෝ ..
ආදරේ ....
ඔච්චම් කර කර හංකිති කවනා ආදරේ...
බලාපොරොත්තුව දෝත දරා
මග බලා ඉඳි ඔබ එනතුරා
ආයේ හෙට දවසක් තියේද අද වාගේ
ජීවිතේ සුන්දරද මෙතරම්..
සුවඳ දැනී දැනෙනවා

free counters
Free counters

Java - mysql + java with netbeans

මම අද සරල වැඩසටහන් යටතේ කියලා දෙන්නේ Netbeans පාවිච්චි කරලා අපේ ජාවා program එක සහ MySQL ඩේටාබේස් එකක් connect කරගන්න විදිය.
දැන් සමහර කට්ටිය බලනවා ඇති මොකද්ද මේ Netbeans කියන්නේ කියලා. Netbeans කියන්නේ ජාවා program හදන්න අපිට ඉතාමත් පහසුවෙන් පාවිච්චි කරන්න පුලුවන් IDE (Integrated development environment) එකක්. මේක අපිට free download කරගන්න පුලුවන්.
මේක තාම install කරගෙන නැති කට්ටිය පහල තියන link (ලින්ක්) එකට ගිහින් download කරගන්න පුලුවන්. එහෙම කරගෙන install කරගන්න.
http://netbeans.org/
දැන් netbeans open කරගෙන File ------> New project කියන එක select කරන්න. එතකොට අලුතෙන් window එකක් open වේවි.

ඒකෙන් ජාවා කියන එක යටතේ තියන Java Application කියන එක select කරලා next කියන එක ඔබන්න. project නමට තමන් කැමති නමක් දෙන්න පුලුවන්. ඊට පස්සේ finish කියන එක ඔබන්න.

දැන් කට්ටියට මෙන්න මේ වගේ තමයි screen එක පේන්නේ. Librares කියන එක උඩ right click කරලා add library කියන එක select කරන්න. එතකොට අලුතෙන් window එකක් open වේවි. ඒකෙන් MYSQL JDBC DRIVER කියන එක select කරලා add library කියන button එක ඔබන්න.

දැන් අපි අලුතෙන් ජාවා class එකක් හදන්න යන්නේ. ඒකට source packages කියන එක උඩ roght click කරන්න. එතකොට එන menu එකෙන් new කියන එක select කලාම තවත් menu එක්ක එයි. අන්න ඒ menu එකෙන් java Class කියන එක select කරන්න. එකට DatabaseConnection කියන නම මම පාවිචිචි කරනවා. කැමති නමක් දෙන්න පුලුවන්.
package එකටත් තමන් කැමති නමක් දෙන්න පුලුවන්. මම ඒකට db කියලා දෙනවා.

class එකට අදාල code එක ගහලා ඉවර උනාම class එක පහල තියන එක තමයි තියෙන්න ඔනේ.

public class DatabaseConnection {
    public static Connection createConnection(String userName, String password, String datbaseName) throws SQLException {
        DriverManager.registerDriver(new com.mysql.jdbc.Driver());
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/"+datbaseName, userName, password);
        return connection;
    }
}

ඔන්න අපි දැන් mysql database  එකත් එක්ක ගණුදෙනු කරන්න ඕනේවෙන connect එකක් හදාගන්න ඔනේ method එක නම් හදලා ඉවරයි.
දැන් තියෙනෙන් මෙන්න මේ method එක අපිට ඕනේ තැනකින් call කරන එක තමයි. එහෙම call කරනකොට අපේ databse එකේ නමයි, username එකයි, password එකයි pass කරන්න ඔනේ.
එතකොට අපිට database එකත් එක්ක coonection එකක් හදලා දෙනවා. ඒ හැදෙන connection එකත් එක්ක database එක manipulate කරන්නේ කොහොමද කියන එක වෙන දවසක බලමු.

Java - Network programming -1

මම කට්ටියට ජාවා වලින් Network programming කරන්න කියලා දෙන්න හිතුවා.
මේ යටතේ ජාවා වලින් සිම්පල් chat එකක ඉඳන් proxy server එකක් උනත් හදන්න වැඩිය අමාරුවක් නෑ. මම වෙලාව තියන විදියට කට්ටියට කියල දෙන්න try කරන්නම්. පුලුවන් කට්ටිය sup එක දෙන්න.
ජාවා වල Network programming කරන්න පාවිච්චි කරන ගොඩක් classes තියෙන්නේ java.net කියන package එකේ.
කට්ටියම දන්නවා ඇතිනේ අපි ගොඩක් වෙලාවට network program කරන්න පාවිච්චි කරන්නේ එක්කෝ TCP එහෙම නැත්නම් UDP[/color].
අපිට listen කරන්න TCP server එකක් හදන්න ඔනේ නම් අපි ServerSocket එකක් පාවිච්චි කරන්න ඕනේ. TCP client කෙනෙක් හදන්න පාවිච්චි කරන්නේ Socket කියන එක.

SeverSocket server = new ServerSocket(20000);

මෙතන 20000 කියලා දීලා තියෙන්නේ server එක connection වලට listen කරන් ඉන්න port number එක.අපිට එතනට 1 ඉඳන් 65536 වෙනකම් ඔනේ number එකක් දෙන්න පුලුවන්. හැබැයි ගොඩක් වෙලාවට කියන්නේ 2000 වැඩි එකක් පාවිච්චි කරන්න කියලා. ඒකට හේතුව අපි use කරන ගොඩක් applications 1 - 2000 අතර port use කරනවා.

Socket client = new Socket("localhost",20000);

locahost කියලා දීලා තියෙන්නේ අපි connect කරන pc එකේ ip address එක. eg. "192.245.3.4" මෙතන 20000 කියලා දීලා තියෙන්නේ server එක listen කරන් ඉන්න port number එක.
UDP වලදී Server එකක් හදන්නයි Client කෙනෙක් හදන්නයි දෙකටම පාවිච්චි කරන්නේ DatagramSocket කියන එක.

DatagramSocket udpServer = new DatagramSocket(20000);
DatagramSocket udpClient = new DatagramSocket();
මේවා පාවිච්චි කරන විදිය මම ඉස්සරහට කියලා දෙන්නම්

Wednesday, January 11, 2012

Java - Method

අද අපි බලමු ජාවා වල තියන methods ගැන.
මම මුලින්ම කියලා දෙන්නම් මොකද්ද method එකක් කියන්නේ කියලා.

අපි සරල උදාහරණයක් ලෙස වාහන නිපදවන කර්මාන්ත ශාලවක් ගමු.මේ කර්මාන්ත ශාලාවේ එක එක ජාතියෙ machines ගොඩක් තියනවා. සමහර machine වලින් වාහනයට අදාල engine එක සෙට් කරනවා, තවත් එකකින් paint ගානවා, තවත් එකකින් tyres සෙට් කරනවා.....................
අපි අපේ ජාවා class එක කර්මාන්ත ශාලාවක් කියලා සැලකුවොත් methods කියන්නේ ඒකේ තියන machines වගේ තමයි. සරලව කිවුවොත් අපෙ කර්මාන්ත ශාලාවට අදාල එක එක process කරන්නේ මෙන්න මේ methods හරහා තමයි.

දැන් අපි බලමු කොහොමද ජාවාවල methid එකක් ලියන්නේ කියන එක.
පහල තියෙන්නේ සරල ජාවා method එකක්. මේ එකෙන් වෙන්නේ අපි මොකක් හරි සංඛය්‍යා දෙකක් දුන්නාම පළමු සංඛය්‍යාව දෙවන සංඛය්‍යාවෙන් බෙදලා උත්තරය ලබාදෙන එක.

public double divider(double no1, double no2) throws ArithmeticException{
 return no1/no2;
}

දැන් අපි බලමු method එකේ තියන එක එක කොටස් ගැන.

1. (must have) මුලින්ම තියෙන්නේ access modifier එක. මම කලින් පාඩමක කිව්වා වගේ මේ access modifier එක මත තමයි මේ methid එක පාවිච්චි කරන්න පුලුවන් කාටද (ඒ කියන්නේ මොන මොන class/ methods වලටද කියන එක) තීරණය වෙන්නේ.

2. (must have) දෙවෙනියට තියෙන්නේ return type එක. මේකෙන් කියන්නේ methid එක execute වෙලා අවසන් වුනාම return කරන answer එක මොන data type එකට අදාල answer එකක්ද කියන එක. මොකක් හරි method එකකින් උත්තරයක් වෙන්නැත්නම් අපිට void කියන keyword එක පාවිච්චි කරන්න පුලුවන්. ( මේ මම කතා කරන්නේ imparetive programming ගැන, හැබැයි functional programming වලනම් ඔනේම methid එකක් ගත්තොත් ඒකෙන් අනිවාර්යයෙන් මොකක් හරි උත්තරයක් return කරන්න ඔනේ. ඒවා ගැන විස්තර පස්සේ කතා කරමු )
දැන් මේ method එකේ return type එක double. අපි method එකකට return type එකක් සඳහන් කලොත් එක අවසානයේ return කියන keyword එක සහ සඳහන් කරපු datatype එකට අදාලා දෙයක් තියෙන්නම ඔනේ.
අපිට method එකකින් අපිට කැමති data type එකක් return කරන්න පුලුවන්. ( we can return any data type from an method. it can be either a primitive data type or object type or even null )

3. (must have) ඊළඟට තියෙනේ method එකේ නම. methods එකිනෙක වෙන්කරලා හඳුනාගන්නේ මෙන්න මේ නමින් තමයි. එකම නම තියන methods එකට වඩා වැඩි ගනනක් තියෙන්න පුලුවන් (overloading, overridding ). ඒවා ගැන වෙනම පාඩමකින් බලමු.
method එකේ නම විදියට අපිට කැමති නමක් දෙන්න පුලුවන්. හැබැයි මම කලින් පාඩමක කියලා දුන්න විදියට නම සඳහන් වෙන්න ඔනේ. ඒ කියන්නේ method එකේ නම අනිවාර්යයෙන්ම පටන් ගන්න ඔනේ ඉංග්‍රීසි අකුරකින් හරි '_' sign එකෙන් හරි '$' sign එකෙන් විතරයි. number එකකින් methdod name එකක් පටන් ගන්න බෑ. method name එකේ ඉතුරු කොටසට අපිට numbers, alphabet characters, '_', '$' වලින් කැමති සංකලනයක් තෝරාගන්න පුලුවන්.

4. (optional) හතර වෙනියට තියෙන්නේ parametr/argument list එක. එකේ අපිට කැමති තරමක් arguments/parameters පාවිච්චි කරන්න පුලුවන්. කැමතිනම් parameter/argument list එකක් යොදා නොගන්නත් පුලුවන්. e.g. (String name, int age), (int no1, int no2), () .............

5. (optional) මේකෙන් කියන්නේ method එක execute වෙනකොට විසිවෙන්න පුලුවන් exceptions මොනවාද කියන එක.

6. (must have if ther is you declare a return type ) 2 point එකේ සඳහන් කලා වගේ method එකේ return type එකක් තියනවානම් මොකද්ද අන්තිමට return කරන answer එක.

අම්බෝ දැන්නම් සිංහලෙන් කොටන්න (type) ගිහින් අත රිදෙනවෝ. ඊළඟ පාඩමින් හමුවන තෙක් ජය වේවා !!....................

Java - simple virus

මේක හෙනම සරල වැඩක්. මේකේදී වෙන්නේ අපි Folder or File එකක් හදනවා. හැබැයි ඒක delete කලාට delete වෙන්නෑ. (ඇත්තටම delete උනාට අයි අයි ඒක හැදෙනවා)
class SimpleVirus {
    public static void main(String[] args) {
        while (true) {
            File file=new File("C:\\abc"); // methana hadanne folder ekak.මෙතනට එකේ තියන කැමති Folder එකක නමක් දෙන්න පුලුවන්
            //File file=new File("D:\\New Folder\\abc.bat"); // methana hadanne folder ekak.
            file.mkdir();
            //file.createNewFile();
           
        }
    }
}
මේ code එක notepad එකේ type කරලා SimpleVirus.java (save type එක - All files) විදියට save කරන්න. ඊට පස්සේ CMD එකට ගිහින් javac SimpleVirus.java කියල type කරලා compile කරගන්න. ඊට පස්සේ CMD java SimpleVirus කියලා type කරන්න.

NOTE - (මේ program එක නවත්තන්න ඕනේ උනාම Ctrl + C ඔබන්න)

Monday, January 9, 2012

Java - Get System properties

මම අද පොඩ්ඩක් වෙනස් මාතෘකාවක් ගැන කතා කරන්න හිතුවා. ජාවා මුල ඉඳන් කියලා දෙන එකට අමතරව තමයි post මේ එක ලියන්නේ.
මේක යටතේ මම කතා කරන්නේ ජාවා භාවිතා කරලා කොහොමද පොඩි පොඩි programs හදා ගන්නේ කියන එක.
ඒක යටතේ මම මුලින්ම කියල දෙන්නම් ජාවා වලින් කොහොමද අපේ computer එකේ sysrem properties ගන්නේ කියලා.
මේ code එකෙන් Computer එකේ ඔක්කොම System properties අපේ file එකකට write කරගන්න පුලුවන්.
මෙන්න code එක. මේ code එක notepad එකේ ගහලා මම කලින් post එකේ කියලා දුන්නා වගේ compile කරලා run කරලා බලන්න.

import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
 *
 * @author Thusitha
 */
public class GetDetails {
    public static void main(String[] args) {
        PrintWriter writer = null;
        try {
            writer = new PrintWriter("details.txt"); // මේ file එකට තමයි විස්තර ටික write වෙන්නේ. මෙතනට කැමති නමක් දෙන්න පුලුවන්
            Properties systemProps = System.getProperties();
            Set<Entry<Object, Object>> sets = systemProps.entrySet();
            writer.println("System properties");
            writer.println();
            for (Entry<Object, Object> entry : sets) {
                writer.println(entry.getKey() + " - " + entry.getValue());
                writer.println();
                writer.flush();
            }
        } catch (FileNotFoundException ex) {
            Logger.getLogger(GetDetails.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            writer.close();
        }
    }
}

Sunday, January 8, 2012

when I saw this girl.

I have found the english translation of this nice hindi song. 


when I saw this girl, she seemed to me like...
like a blooming rose;
like a poet's dream;
like a glowing ray of light;
like a deer in the forest;
like a moonlit night;
like a soft word;
like a candle burning in the temple.
 
when I saw this girl, she seemed to me like...
like the beauty od the morning;
like winter sunshine;
like a note from the lute;
like the essence of all color;
like a twisting vine;
like the play of waves;
like a cool scented wind.
 
when I saw this girl, she seemed to me like...
like a dancing feather;
like a silken thread;
like a fairy melody;
like the fire of sandalwood;
like the sixteen (traditional) ornaments of beauty;
like a refreshing mist;
like a slowly growing feeling of intoxication.
 
when I saw this girl, she seemed to me like...
 

ඔබ හිතට ඇවිත් හෙමි හෙමිහිට

මේ දවස් වල මට නිතරම කියවෙන සින්ඳුවක්. පට්ටම තේරුමක් තියනවා.

ඔබ නැතුව ඉන්න බැරි තරමට
ඔබ හිතට ඇවිත් හෙමි හෙමිහිට
ඔබ නොදැක ඉන්න බැරි තරමට
නෙත ඔබව සොයනවා දවසෙම

මේ සීතල හිම ගිරි අරණේ
මට හමු වූ වනපස කුසුමේ
පෙති මත සතපා රැගෙන යන්න මා 
කුසුම් නිම්නයේ මාලතියේ

මේ ජීවන අවපස අහසේ
ඔබ පුරපස සඳ වී පිපුණේ
ඔබේ රැසින් මා දවාලන්න රෑ
ළය මත සනහා රාජිනියේ

Java - access modifiers

අද අපි බලමු ජාවා වල තියන access modifiers මොනවද කියලා.
තියෙන්නේ මොනවද කියන්න කලින් access modifiers එකක් කියන්නේ මොකද්ද කියලා සමහර අයට ප්‍රශ්නයක් ඇති.
access modifiers එකක් කියන්නේ ජාවා program එකක තියන class, variables, methods enums, etc.. වගේ ඒවා access කිරීම පාලනය කරන්න පාවිච්චි කරන්න පුලුවන් key words වගයක්.
ජාවා වල access modifires 4ක් පාව්ච්චි වෙනවා.
1. private
private කියන්නේ private තමයි ඉතින්. private එකෙන් modify කලොත් ඒක access කරන්න පුලුවන් ඒ class එකෙන්ම විතරයි.වෙන classes, method වලට තවත් class එකක තියන private access modifier එකෙන් modify කරපු ඒවා මොකක්වත් access කරන්න බෑ.

2. protected
මේකෙන් modify කලොත් එකම package එකේ ඕනේම class එකකට සහ එක extend කරන වෙනත් package වල තියන ඕනේම class වලට access කරන්න පුලුවන්.

3. default
මේ default කියල type කරන්නෑ. වෙන මොකුත් access modifier එකක් දාලා නැත්නම් තියෙන්නේ default access modifier එක තමයි.
එතකොට එකම package එකේ තියන ඕනේම class එකකට මේක access කරන්න පුලුවන්.

4. public
වචනයෙන්ම තේරෙනවානේ. ඔනේම package එකක තියන ඔනේම class එකකට access කරන්න පුලුවන්.

Java - Abstract class vs. Interface

මම අද කියන්නේ abstract class එකක් සහ interface එකක් අතර වෙනස.
abstract class එකක් ගත්තොත් එකේ abstract methods වගේම non-abstract methods තියෙන්න පුලුවන්.කට්ටිය දැන් හිතන්නේ මොන මේ abstract method කියන්නේ කියලා. මෙහෙමයි සරලවම කිවුවොත් abstract method එකකින් කියන්නේ මෙන්න මෙහෙම method එකක් තියනවා ඒක උඹට පාවිච්චි කරන්න ඔනේ නම් උබට ඔනේ විදියට code කරගනින් වගේ වැඩක්.
abstract method එකක method body එකක් නෑ.
e.g
[code]public Sound getSound(Bird bird);
public void getNumber(int no);
e.g abstract class
[code]abstract class BirdAbstract{
   abstract public Sound getSound(Bird bird); // abstract method
   public void getBirdCount(){ // non abstract method // no compile error
       // something here
       return something
   }
}
interface එකේ තියන වෙනස තමයි මේකේ තියන හැම method එකක්ම අපි abstract දැම්මත් නැතත් implicitly abstract method

inetface Birdinterface{
   public Sound getSound(Bird bird); // abstract method no CE
   abstract public void doSomething(); // abstract method no CE
   public void getBirdCount(){ // non abstract method // this is a CE interface can't have non abstract methods
       // something here
       return something
   }
}
අපි interface එකක් හරි abstract class එකක් extend/implement කලොත් ඒවගේ තියන ඔක්කොම abstract method අපේ පළවෙනි concreat class( abstract නොවන )  එකේදි අනිවා override කරන්න ඔනේ.

Saturday, January 7, 2012

Java Fundementals

මම අද කතා කරන්නේ ජාවා වල මූලිකම දේවල් ගැන.ඒ යටතේ මම
1.OO concepts
2.class
3.packages
කියන ඒවා ගැන කියල දෙන්නම්.

1. OO (Object Orientation)[/color]
අපි මුලින්ම බලමු Object oriented program එකක් කියන්නේ මොකද්ද කියලා.ඉස්සර තිබ්බේ structured program ඒ කියන්නේ එ program execute වෙන්නේ පේලියෙන් පේලියට (line by line). පළවෙනි පේලිය execute උනාට පස්සේ ඊළඟ පේලිය execute වෙනවා.ඔය structure එක වෙනස් කරන්න මාරම ගේමක් දෙන්න උනා.
ඊට පස්සේ තමයි මේ OOP කියන concept එක ආවේ. ඒකෙදී සරලව කිව්වොත් වෙන්නේ අපේ program එක object ගනනාවක එකතුවක් විදියට තමයි වැඩ කරන්නේ. එක වෙන්නේ object අතර වෙන interaction වලින්.එක object එකක් තව object එකක තියන method එකක්  call කරනවා. ඒ object එක වෙන object එකක method එකක් call කරනවා.ඔන්න ඔහොම තමයි වැඩේ වෙන්නේ.
හැම object එකටම පොදු කරුණු 3ක් තියනවා
1. Identifier නමක් තියනවා අඳුර ගන්න - name of the object.
2. States ඌට අදාල ලක්ෂණ තියනවා - instance variables in that object.
3. Behaviors ඌට කරන්න පුලුවන් වැඩ තියනවා - methods of that object.
OOP වල තියන මූලිකම කරුණු තමයි
1. Abstraction[/color] - මේ කියන්නේ අපි පාවිච්චි කරන කෙනාට/එකාට පෙන්වන්නේ අවශ‍යම දේවල් විතරයි. අපි ඌට සංකීරණ දේවල් කියන්න යන් නෑ. (Abstraction means to show only the necessary details to the client of the object.)
 2. Encapsulation - මේකෙන් කියන්නේ හංඟනවා වගේ දෙයක්.අපි මොකක් හරි හෙනම පට්ට algorithm එකක් ලිව්වා කියලා හිතපන් කෝ. මේක හැමොටම පාවිච්චි කරන්න ඔනේ. හබැයි අපි කැමති නැ අනික් උන් අපි මේක හදලා තියෙන්නේ කොහොමද කියලා දැන ගන්නවාට. එතකොට අපි කරන්නේ අපේ මේ algorithm එක ලියලා ඒක use කරන්න විදියක් දෙනවා. හැබැයි ඒක වෙන්නේ කොහොමද කියලා අනික් අයට දන ගන්න විදියක් නෑ. මේක ගොඩක් වෙලාවට කරන්නේ private variables හා getters and setters වලින් තමයි.
3. Inheritance - මේකනම් කට්ටියට තේරෙනවා ඇති. අම්මාගේ තාත්තගේ ලක්ෂණ ළමයින්ට ලැබෙනවා. ඒවගේ තමයි super class වල attributes, sub class වලට ලැබෙනවා
4. Polymorphism - එකම දේ ක්‍රම ගණනාවකින් තියෙන්න පුලුවන්. මේක යටතේ method overloading, overriding, dynamic method binding කියන ඒවා තියනවා.

2. class
object එකක් කියලා කියන්නේ class එකකින් අපි හදන instance එකක්. එතකොට කට්ටියට එන ප්‍රශ්නේ තමයි මොකද්ද යකෝ class එකක් කියන්නේ කියලා.class එකක් කියන්නේ සරලවම කිවුවොත් හරියට අච්චුවක් වගේ.
අපි බ්ලොක්ගලක් object එකක් කියලා සැලකුවොත් බ්ලොක්ගල් හදන machine එක තමයි අපේ class එක වෙන්නේ. ඒ අච්චුවෙන් අපිට ඕනේ තරම් බ්ලොක්ගල් හදන්න පුලුවන්.හැබැයි ඒ හැම එකක්ම එකම වගේ.
class එකක structure එක තියෙන්නේ මෙහෙමයි.PIC
P - package declaration - මේ file එක තියෙන්නේ මොන folder එකේද
I - import statements - අපේ program එක run කරන්න ඕනේ වෙන අනික් class, methods තියෙන්නේ කොහෙද කියන එක
C - 'class' keyword + class body.
package test; // MyFileReader කියන class එක තියෙන්නේ test කියන folder එක ඇතුලේ
import java.io.BufferedReader; 
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
//BufferedReader,File,FileReader, etc..class තියෙන්නේ IO කියන package එක ඇතුලේ

class MyFileReader {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader(new File("abc.txt")));
        while (reader.ready()) {
            System.out.println(reader.readLine());
        }
        reader.close();
    }
}
interface එකක් කියනේ class එකකට වඩා ටිකක් වෙනස් දෙයක්. එකකින් අපි බලාපොරොත්තු වෙන්නේ යම්කිසි දෙයකට අනිවාර්යෙන්ම තියෙන්න ඕනේ මොනවාද කියන එක enforce කරනවා.කට්ටියට එහෙම කිවුවාම තේරුණාද මන්දා... හ්ම්........... අපි මෙහෙම හිතමුකෝ.
කුරුල්ලෝ වර්ග ගොඩක් ඉන්නවා. ඒ හැම කුරුල්ලාටම කෑගහන්න පුලුවන්. හබැයි එක එක කුරුල්ලා කෑගහන විදිය වෙනස්. ඒ කියන්නේ අපි කුරුල්ලෝ කෑගහන්නේ makeSound() කියන methos එකෙන් නම් ඒ method එකේ implementation එක කුරුල්ලා අනුව වෙනස් වෙන්න ඕනේ.හැබැයි හැම එකාටම මොකක් හරි කෑගහන්න විදියක් තියෙන්න ඔනේ.ඒ කියන්නේ හැම එකාටම makeSound() කියන method එක තියෙන්න ඔනේ. අන්න ඒ වගේ වෙලාවක අපිට interface එකක් පාවිච්චි කරන්න පුලුවන්.
interface BirdSound{
  public void makeSound();
}
class Kaputa implements BirdSound{
  public void makeSound(){
    System.out.println("Kaak kaak");
  }
}
class Kowula implements BirdSound{
  public void makeSound(){
    System.out.println("Koho koho");
  }
}