Tuesday, May 25, 2010

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

ජාවා වැඩසටහනක් ක්‍රියාත්මක කරවන(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 එක භාවිතා කරන්න.

Sunday, May 23, 2010

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

අපි කලින් පාඩමෙන් ස‍රල 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 එක භාවිතා ක‍රන්න.

Saturday, May 22, 2010

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

අපි මීට පෙර පාඩම් වලදී ඉගෙනගත් 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 එක භාවිතා ක‍රන්න.

ජාවා වස්තු පාදක ක්‍රමලේඛනය IV (Access Modifiers)

මීට පෙර පාඩමෙන් අපි සාකච්ඡා කලේ methods ගැනයි. අපි එහිදී access modifiers සඳහා සුලු හැඳින්වීමක් දුන්නා. අපි මෙම පාඩමෙන් modifiers ගැන විස්ත‍ර සහිතව අධ්‍යයනය කරමු. Inheritance , Encapsulation වැනි OOP Concept ක්‍රියාවට නැංවීම (implement) සඳහා access modifiers ඉතා වැදගත් මෙහෙව‍රක් ඉටුක‍රනවා. අපි පහත වගුව තුලින් access modifiers ගැන අධ්‍යයනයක යෙදෙමු.
Access modifier this(class) subclass package general
public
protected
X
X
default
X
X
private
X
X
X

දැන් අපි මේ පිලිබඳව විස්ත‍රාත්මකව බලමු.
■ public
මෙලෙස declare ක‍රන ලද members සඳහා ජාවා වැඩසටහන තුල එය අයත් object එක refer ක‍රන ඕනෑම තැනකදී ලඟා විය හැක.  

■ protected
මේ අයුරින් declare ක‍රන ලද methods හා variables භාවිතා කල හැක්කේ එම class එකෙහි sub class / child class වලට පමණි. මෙය Inheritance පාඩමේදී වඩාත් පැහැදිලි වනු ඇත.

■ default
යම් member කෙනෙක් සඳහා කිසිඳු modifier එකක් යොදා නොමැති විට එයට යෙදෙනුයේ default modifier එකයි.default members භාවිතා කල හැක්කේ එම class එක තුලදී සහ එම class එක අයත් package එක තුලදී පමණි.

■ private
සියලු private members access කල හැක්කේ එය අයත් class එක තුලදීම පමණි. 

සැයු: සාමාන්‍යයෙන් Object Oriented ක්‍රමලේඛනයක් ලිවීමේදී අනුගමනය කරන දෙයක් තමයි data නොහොත් instance variables, private ලෙස declare කිරීම සහ methods , public ලෙස declare කිරීම.public data භාවිතා කිරීම හොඳ වස්තු පාදක ක්‍රමලේඛනයක ලක්ෂණයක් නොවේ!.

දැන් අපි private සහ public modifiers ගැන අධ්‍යයනය කිරීම සඳහා ස‍රල ජාවා වැඩසටහනක් ලියමු.
මේ සඳහා අපි Employee කෙනෙකු උදාහ‍රණයට ගනිමු.
Employee.java

class Employee {
 //instance variables
 public String Name; // Name is a public member
 private float HourlyRate; //private member
 private float HoursWorked; //private member
 
 //constructor
 public Employee(String name,float hr,float hw){
  Name=name;
  HourlyRate=hr;
  HoursWorked=hw;
 }
 
 //public method
 public void setHourlyRate(float hr){
  HourlyRate=hr;
 }
 //private method
 private float getTotalSal(){
  return (HourlyRate*HoursWorked);
 }
 //public method
 public void showDetails(){
  System.out.println("Employee Name : " + Name);
  System.out.println("Total Salary  : " + getTotalSal() );
  System.out.println("-----------------------------------------");
 }
}//end of the Employee class
■දැන් අපි Employee class එක යොදාගෙන පහත කේතය execute ක‍ර ලැබෙන ප්‍රතිඵලය කුමක්දැයි බලමු.
Employee emp1=new Employee("Prasanna",2300.75f,40.0f);
  emp1.showDetails();
  emp1.Name="Nimal"; //access the public variable of emp1
  emp1.showDetails();
1 සහ 2 පේලි
මෙහිදී Employee object එකක් සාදා මුලින්ම එහි public member කෙනෙකු වන showDetails() method එක invoke ක‍රයි.
3 පේලිය
මෙහිදී ඉහත සාදාගත් emp1 object එකට අයත් public member වන Name විචල්‍යය access ක‍ර එහි name එක Nimal ලෙසට වෙනස් ක‍රනු ලැබේ.
4 පේලිය
මෙහිදී නැවතත් emp1 object එකෙහි showDetails() method එක invoke ක‍රයි. දැන් console එකෙහි දිස්විය යුත්තේ Name එක Nimal ලෙසටය.


Output:

මීලඟට private modifier එක අධ්‍යයනය කිරීමට පහත කේතය execute ක‍රමු.
Employee emp1=new Employee("Prasanna",2300.75f,40.0f);
  emp1.HourlyRate=1500.00f;
මෙහිදී emp1 ගේ private modifier එකක් වන HourlyRate විචල්‍යය අපි access කිරීමට යයි. එම නිසා මෙහිදී compile කිරීමේදී පහත දෝශ පණිවුඩය පෙන්වයි.
අපට නිවැරදිව HourlyRate එක වෙනස් කිරීමට කලයුතු වන්නේ අප Employee class එකෙහි අන්තර්ගත කොට ඇති setHourlyRate() නම් public method එක භාවිතා කිරීමයි. මේ සඳහා කේතය පහත පරිදි වේ.
Employee emp1=new Employee("Prasanna",2300.75f,40.0f);
  emp1.showDetails(); // before changing the HourlyRate
  emp1.setHourlyRate(1500.00f);
  emp1.showDetails(); // after changing the HourlyRate
Output:
මේ ආකාරයෙන්ම Employee class එකට අයත් getTotalSal() නම් private method එක class එක තුලදීම භාවිතා ක‍ර තිබෙන ආකාරය line 25 දෙස බලන විට ඔබට පෙනී යනු ඇත. 
අනෙක් access modifiers පිලිබඳව අපි ඉදිරියේදී සාකච්ඡා ක‍රන OO Concept වලදී පුලුල්ව අධ්‍යයනය කිරීමට පුලුවන්.
මම මේ සඳහා යොදාගත් උදාහරණ භාගත කර ගැනීමට පහත සබැඳිය භාවිතා ක‍රන්න. 
Download The Source Code

Thursday, May 20, 2010

ජාවා වස්තු පාදක ක්‍රමලේඛනය III (Methods)

Methods

 
Method එකක් යනු function/procedure සඳහා ලබාදී ඇති OOP term එකයි.
methods වල වැදගත්කම් කිහිපයක් බලමු.


 


►වැඩසටහනක් modules වලට කැඩීමේදී උපයෝගී ක‍රගනී.
►Code reusability සංකල්පය එනම් කේත නැවත නැවත, අදාල ස්ථානයන්හිදී භාවිතා කිරීමට යොදාගත හැක.
►Method එකක් ක්‍රියාත්මක(execute) වනුයේ එය call කල විට පමණි
(explicitly invoked).



Method Declaration 
Method එකක් සෑම විටම පැවතිය යුත්තේ class එකක් තුලයි. method එකක් declare කිරීමෙන් පසු අපට අවශ්‍ය විටක එය invoke කල හැකිය. එතෙක් එය තුල ඇති උපදෙස් ක්‍රියාත්මක නොවේ. පහත syntax එකට අනුව method එකක් declare කිරීම සිදුකෙරේ.
Syntax:
modifiers  returnType methodName (parameter-list) {
    /*
    * Method body (block)
    */
    return expression;
}
 දැන් අපි method header එක පිලිබඳව සලකමු.

■ modifiers
මෙයට method scope යයිද කියනවා. මෙමගින් method එක access කිරීම පිලිබඳ තීරණ ගනු ලබනවා.
මෙම access modifiers වනුයේ public, private, protected, default/friendly යන ඒවායි.මේවා ගැන සවිස්ත‍ර වශයෙන් අපි ඉදිරියේදී සාකච්ඡා ක‍රමු.


■ returnType
method එකෙන් එය call කල ස්ථානයට යවන(return) පණිවුඩය කුමන දත්ත ආකාරයක් ඇති එකක්ද යන්න මෙමගින් සඳහන් කෙරේ.


■ method එක invoke ක‍රනවිට method එකට ලබාදෙන දත්ත parameter-list එක තුල අන්තර්ගත වේ.


■ method body
method එකෙන් සිදුක‍රන කාර්යයට අදාල කේත මෙතුල අඩංගුවේ.


■ return expression
method එකෙන් එය call කල ස්ථානයට පණිවුඩය යැවීම මෙමගින් සිදුකෙරේ. මෙම statement එක execute වී අවසන් වූ වහාම method එකෙහි execute වීම අවසන්වේ.


Note :  සෑම method එකක්ම values return කිරීම අනිවාර්‍ය නොවේ. මෙසේ values return නොක‍රන method වලදී modifier එක ලෙස void යන්න භාවිතාවේ.


Method invoke/call කිරීම
මෙය method එක සඳහා values pass කිරීම ලෙසද හඳුනවනු ලැබේ. 
syntax:
methodName(argument-list)
argument-list එකෙහි ඇති arguments හ‍රියටම method එකේ parameter-list එකෙහි ඇති parameters වලට අනුරූප විය යුතුය.
variable pass ක‍රන්නේ නම් මෙම arguments අගයන් සහිත තාත්ත්වික විචල්‍යයන්(real variables) විය යුතුය. මේ නිසා මෙම arguments pass කිරීමට පෙර එම variables initialize ක‍ර තිබිය යුතුය.


class එක තුලදී method call කිරීම 
මෙහිදී කෙලින්ම method එකේ නම භාවිතාක‍රමින් invoke කල හැක. අවශ්‍ය නම් this keyword එකද භාවිතාකල හැකිය.
methodName()
//or
this.methodName()
class එකෙන් පිටතදී method call කිරීම
මෙහිදී method එක අයත් object එකේ නමද යොදාගැනේ
objectName.methodName()
static method එකක් නම්
static keyword එක ගැන අපි ඉදිරි පාඩමකදී විස්ත‍රාත්මකව බලමු. දැනට static method එකක් call ක‍රන ආකාරය මතක තබා ගන්න. 
className.methodName()
ex:
Math.random();
දැන් අපි බලමු methods පවතින ස‍රල ආකාර මොනවාද කියලා

►return type එකක් පවතින සහ parameters නැති
උදා:
int getName(){
 return name;
}
►return type එකක් පවතින සහ parameters ඇති
int sum(int i,int j){
 return(i+j);
}
►return type එකක් නොපවතින(void)  සහ parameters නැති
void showDetails(){
 System.out.println("Name: " + this.name);
}
►return type එකක් නොපවතින(void)  සහ parameters ඇති
void showMax(int a, int b){
 if(a>b)
  System.out.println(a);
 else
  System.out.println(b);
}
මෙම ආකාරවලට අමත‍රව methods පැවතිය හැකි තවත් ආකාර කිහිපයක් පවතිනවා. අපි ඒවා වෙනමම පාඩමකදී සාකච්ඡා ක‍රමු.

දැන් අපි method හි ක්‍රියාකාරීත්වය තවත් හොඳින් අවබෝධ ක‍රගැනීම සඳහා ජාවා වැඩසටහනක් ලියමු.
මේ සඳහා කලින් පාඩමේදී ගත් උදාහ‍රණයම methods යොදා දීර්ඝ ක‍රමු.
Circle.java
class Circle {
 int x,y,radius;
 //Constructor 1
 public Circle(int x,int y,int r){
  this.x = x;
  this.y = y;
  radius= r;
 }
 //Constructor 2
 public Circle(int x,int y){
  this.x = x;
  this.y = y;
  radius=1;
 }

 //Method 1
 public float getArea(){
  return (3.14f*radius*radius);
 }
 //method 2
 public void setRadius(int r){
  radius=r;
 }
 //method 3
 public void showDetails(){
  System.out.println("Position x=" +x+" y="+y  );
  System.out.println("Radious : " + radius );
  System.out.println("Area    : " + getArea() );
 } 
}
දැන් බලමු එම circle class එකෙන් සාදන object වලට අයත් methods භාවිතා ක‍රන ආකාරය.
මේ සඳහා ලියන ලද සරල java වැඩසටහනක් පහත දැක්වේ.
CircleDemo.java
public class CircleDemo {
 public static void main(String srgs[]){
  /*create a circle object 
   *x=12 , y=34 , radius=4
   */
  Circle c1=new Circle(12,34,4);
  float c1_area=c1.getArea();
  System.out.println("Area of c1 : " + c1_area);
  
  //change the radius of c1
  c1.setRadius(6);
  //invoke the showDetails method of c1
  c1.showDetails();

 } 
}
Output :
මෙම පාඩමෙන් ලබාගත් දැණුම උපයෝගී ක‍රගනිමින් ඉහත වැඩසටහන ක්‍රියාත්මක වන ආකාරය දැන් ඔබට තේරුම් ගත හැකිය. ගැටලු වෙතොත් comment එකක් ලෙස හෝ ඉදිරිපත් ක‍රන්න.
අපි මීලඟ පාඩමෙන් access modifiers ගැන සාකච්ඡා ක‍රමු.

Wednesday, May 19, 2010

ජාවා වස්තු පාදක ක්‍රමලේඛනය III (Constructors)

  • Constructors
constructor මගින් සිදුක‍රනුයේ එය අයත් class එකට අදාලව සාදන object එක initialize කිරීමයි. දැනටමත් ඔබ දන්නවා class එකකින් කොහොමද object එකක් සාදාගන්නේ කියලා.(පසුගිය පාඩම). මේ සඳහා new keyword එක භාවිතාවන බවත් ඔබ දන්නවා ඇති.
 

අපි බලමු constructor එකක ලක්ෂණ මොනවාද කියලා. 
  • ►constructor එකක නම එය අයත් class එකේම නම වනවා. උදා: Radio class එකේ constructor එකේ නමත් Radio ම වනවා.
  • ►arguments එකක් හෝ කිහිපයක් තිබිය හැකියි. උදා : Radio(String band,float frequency)
  • ►return values ගැන කිසිඳු සඳහනක් නොමැත. (methods ගැන සාකච්ඡා කිරීමේදී return values ගැන බලමු)
  • ►constructor එකක් හෝ කීපයක් පැවතිය හැකිය.
constructors එකක කාර්‍ය භාරය කුමක්ද?
  •  local variable වල ආරම්භක අගය සැකසීම.(initialize)
  • කීප ආකාරයකට object එක සෑදීමට යොදාගත හැකිවීම 
Syntax:

public ConstructorName(argument-list){
 //constructor body
}
උදාහ‍රණයක් ලෙසට අපි Circle එකක් ගනිමු.

Circle.java
class Circle {
 int x,y,radius;
 //Constructor 1
 public Circle(int x,int y,int r){
  this.x = x;
  this.y = y;
  radius= r;
 }
 //Constructor 2
 public Circle(int x,int y){
  this.x = x;
  this.y = y;
  radius=1;
 }
}
දැන් අපි බලමු Circle class එකෙන් Circle object එකක් සෑදීමේදී constructor එක වැදගත් වන ආකාරය. අපි ඉහත class එකේ අන්තර්ගත ක‍රන ලද constructor භාවිතාක‍ර object 2ක් සාදමු.
//using constructor 1
  Circle c1=new Circle(12,34,7);
  //using constructor 2
  Circle c2=new Circle(14,47);
c1 object එක සෑදීමේදී යෙදෙන්නේ constructor 1 එකයි. එම constructor එකෙහිදී සිදුවන්නේ x,y හා r ලෙසින් arguments 3ක් ලබාගෙන c1 object එකෙහි class variables ලෙස පවතින x, y, හා radius variables initialize කිරීමයි.
c2 object එක සෑදීමේදී යෙදෙන්නේ constructor 2 එකයි. එහිදී arguments ලෙස ලබා ගනුයේ x හා y පමණි. radius එක 1 ලෙසට initialize කිරීම මෙම constructor එකෙන් සිදුක‍රයි. එනම් මෙම constructor එක(constructor 2) භාවිතයෙන් සාදන සෑම object එකකම radius එකෙහි initial value එක 1 වේ.


දැන් අපි බලමු this keyword එකෙහි භාවිතය පිලිබඳව
this keyword එක භාවිතා වන්නේ කිසියම් object instance එකකට අයත් දෑ එම object එක තුලදී refer කිරීමටයි.
මෙහිදී this keyword එක භාවිතා වන්නේ class variables හා arguments refer කිරීමේදී ඇතිවන ගැටලුවෙන් මිදීමටයි. class variables යනු සමස්ථ class එකටම බලපවත්වන ලෙස පවතින variables ය. ඉහත Circle class එකෙහි x, y හා radius යනු Circle class එකෙහි class variables වේ. constructor 1 හි තවත් x හා y ලෙසින් arguments 2ක් ගෙන ඇති බව ඔබට පෙනෙනවා ඇත. එම නමුත් එක x හා y විචල්‍යයන් බලපවත්වනුයේ/වලංගු වනුයේ constructor body එක තුලදී පමණි. this.x ලෙසින් අප refer ක‍රනුයේ class object එකට අයත් x අගයයි. අනෙක් x එක argument එකයි. එනම් this.x = x යන්නෙහි අර්ථය වන්නේ argument එකක් ලෙස සපයන x හි අගය object එකට අයත් x වෙත ලබාදීමයි.

Sunday, May 16, 2010

Java වස්තු පාදක ක්‍රමලේඛනය II (objects)

  • Objects
සැයු: මෙම පාඩම කලින් පාඩම(Java classes) සමග සම්බන්ද බව සලකන්න. 

Object එකක් යනු data සහ method වල එකතුවක් ලෙස හඳුන්වන්න පුලුවන්. සැබෑ ලෝකයේ වස්තූන් Java තුල නිරූපණය ක‍රන්නේ objects භාවිතයෙන්. classes තමයි object එකේ design එක පිලිබඳ තීරණය ක‍රන්නේ.
class එක භාවිත ක‍ර objects සෑදූ පසු ඒවා එක එකක් වෙන වෙනම පරිගණකයේ ප්‍රධාන මතකයේ(RAM) තැන්පත් වීම සිදුවනවා. ඉන්පසු අදාල කාර්යය ඉටුකර ගැනීම සඳහා අපට ඒවා යොදාගන්න පුලුවන්.


අපි බලමු පසුගිය පාඩමේදී අපි යොදාගත් Radio class එක භාවිතයෙන් objects සකසා ගන්නා ආකාරය.
ඔබගේ පහසුව සඳහා මම Radio class එකේ කේතය නැවත මෙම පාඩමේ ඉදිරිපත් ක‍රනවා.

Radio class 
class Radio {
 //Attributes Declarations
 String Band;
 int Volume;
 float Frequency;
 
 //Constructors
 public Radio(){
  Band="FM";
  Volume=13;
  Frequency=90.5f;
 }
 
 //Methods
 public void tuneUp(){
  if(Frequency < 108.0 )
   Frequency=Frequency+1;
 }
 
 public void tuneDown(){
  if(Frequency > 88.0 )
   Frequency=Frequency-1;
 }
 
 public void increaseVol(){
  if(Volume < 48 )
   Volume=Volume+2;
 }
 
 public void decreaseVol(){
  if(Volume > 2 )
   Volume=Volume-2;
 }
}
අපි දැන් බලමු class එකකින් objects සාදාගැනීමට අදාල Java syntax මොනවාද කියලා.උදාහ‍රණ සඳහා ඉහත Radio class එකම යොදා ගනිමු.

class එකකින් object එකක් සාදා ගැනීම සඳහා new Keyword එක භාවිතා කෙරෙනවා.
Syntax 01:
ClassType ObjectName;
ObjectName=new ClassType(); //default constructor
//or 
ClassType ObjectName;
ObjectName=new ClassType(parameter-list);
Example :
Radio rad1;
rad1=new Radio();

Syntax 02:
ClassType ObjectName=new ClassType();
//or
ClassType ObjectName=new ClassType(parameter-list);
Example :
Radio rad1=new Radio();


දැන් අපි බලමු අපි සකසාගත් object එක පරිගණකයේ ප්‍රධාන මතකයේ(RAM) තැන්පත් වීම සිදුවන්නේ කොහොමද කියලා.
මුනින්ම new keyword එක ගැන බලමු.
new keyword එක මගින් සිදුවන්නේ දී ඇති class type එකෙන් object එකක් RAM එක තුල සාදා එයට reference එකක් (යොමුවක්) අදාල variable එක වෙත යැවීමයි. 
ඉහත උදාහ‍රණය අනුව ගතහොත්,unique(අනන්‍ය) Radio object එකක් RAM එක තුල සාදා එයට reference එකක් rad1 නමැති variable එකට assign කිරීම සිදුක‍රයි.
මෙහිදී ඔබ තේරුම් ගත යුතු කරුණ වන්නේ ඇති Java හි භාවිතා වන variable දරාගෙන(hold) සිටින්නේ object එකක් නොව object එක සඳහා reference එකකි. තව දුරටත් පැහැදිලි ක‍රන්නේ නම් Java variable එකක් තුල ඇත්තේ object එක RAM එක තුල පවතින ස්ථානයට අදාල memory address එකකි. memory address එකක් සඳහා උදාහ‍රණ : Ox23FF50 එනම් object එක හඳුනා ගැනෙනුයේ අදාල memory address එකෙනි.

දැන් අපි බලමු object එක කොහොමද RAM එක තුල තිබෙන්නේ කියලා.
object එකක් RAM එකේ heap නමැති විශේෂ කලාපය තුල විසිරී පවතිනවා. ඉහත rad1 නමැති object එක සෑදීමෙන් පසුව rad1 object එක RAM එකේ පවතින ආකාරය පහත දැක්වෙන සටහන අනුව බලමු.

දැන් object එකක් RAM එකේ තිබෙන ආකාරය ගැන පැහැදිලි ඇතියි සිතනවා.
ඔබ දකින්න ඇති rad2 කියලා තිබුන Radio object එකේ තිබුනෙ null කියලා value එකක්. null කියන්නේ Java තුල භාවිතාවන literal value එකක් ඇතැම් තැන් වල manifest constant එකක් කියලත් හඳුන්වනවා.නමුත් මෙය ජාවා keyword එකක් නොවෙයි.
හොඳයි මොකක්ද මේ null value එකෙන් වෙන්නෙ.?
මෙමගින් object එකක් memory location එකක් refer නොක‍රන බව එනම් එය අභිශුන්‍ය බව දක්වනවා. rad2 යනු null object එකක් නිසා එය කිසිදු memory location එකක් සමග බැඳී නැහැ කිව්වොත් නිවැරදියි.


ජාවා ප‍රිගණක භාෂාවේ ඇති සුවිශේෂ වාසියක් වන්නේ සාදන ලද objects සඳහා වෙන් ක‍රන ලද memory ප්‍රමාණයන් නැවත නිදහස් කිරීම සඳහා වෙහෙස වීමට අවශ්‍ය නොවීමයි. එය සිදුකිරීම සඳහා JVM එක මගින් ක්‍රියාත්මක වන සුවිශේෂ thread එකක් වන "Garbage Collector" බැඳී සිටිනවා. අපගේ වැඩසටන මගින් සකසන ලද කිසියම් object එකක් තවදුරටත් භාවිතා නොවන තත්වයට පත්වූ විට "Garbage Collector" විසින් එම object එක සඳහා වෙන් ක‍රන ලද memory ප්‍රමාණය නිදහස් කිරීම සිදුක‍රනවා.
මෙහි ඇති වාසිය ස‍රළ ජාවා වැඩසටහන් වලදී එත‍රම් නොපෙනුනද සංකීර්ණ data structures භාවිතාවන වැඩසටහන් වලදී හොඳින් කැපී පෙනෙනවා. C/C++ යොදාගෙන එවැනි වැඩසටහන් ලිවීමේදී අනිවාර්‍යයෙන්ම වෙන්ක‍රන ලද (allocate) memory ප්‍රමාණය තව දුරටත් අවශ්‍ය නොවන තත්වයට පත්වූ විට release කල යුතුයි. එසේ release නොකිරීම නිසා ඇතිවන තත්වය "memory leak" එකක් ලෙස හැඳින්වේ. එය ප‍රිගණක වැඩසටහනක ඇති දෝෂ තත්වයකි.

ක්‍රියාකාරී ජාවා වැඩසටහනක process එකට අදාල heap කොටස ගැන පහත රූප සටහන ආධාරයෙන් නිරීක්ෂණය කරන්න. 
 
අපි ඊලඟ පාඩමෙන් constructors සහ methods ගැන අධ්‍යයනය කරමු.
objects ගැන මට කියවන්න ලැබුනු ඉතාම හොඳ පාඩමක් තියනවා. මේ ලින්ක් එකෙන් ගිහින් ඒකත් කියවලා බලන්න.

Friday, May 14, 2010

Java වස්තු පාදක ක්‍රමලේඛනය I

ප‍රිගණක ක්‍රමලේඛනයේදී භාවිතා වන මූලික ආකාර දෙකක් තමයි
  1. Structural/Procedural
  2. Object-Oriented
structural ආකාරය භාවිතාවන ප‍රිගණක භාෂා වලට උදාහ‍රණ වශයෙන් C,Pascal,FORTRAN,COBOL වැනි ප‍රිගණක භාෂා ඉදිරිපත් ක‍රන්න පුලුවන්. මෙම භාෂා යොදාගෙන යම් ගැටලුවක් විසඳීමේදී එම ගැටලුව විසඳීමට අදාල පියව‍ර(steps) පිලිඹඳ තදින් සැලකිලිමත් වියයුතුයි. මේ සඳහා බොහෝවිට ඇල්ගොරිතමයන් භාවිතාවෙනවා. මෙම පියව‍රයන්හිදී සුදුසු data structures භාවිතා කිරීමද සිදුවනවා.
object-oriented ආකාරය භාවිතාවන ප‍රිගණක භාෂා වලට උදාහ‍රණ වශයෙන් Java,C++,Smalltalk හදුන්වන්න පුලුවන් මෙම භාෂාවන් යොදාගෙන ගැටලු විසඳීමේදී තදින් සැලකිලිමත් වනුයේ වස්තූන්(entities/objects) පිලිඹදවයි. එහිදී එක් එක් වස්තුවට තිබිය යුතු ක්‍රියාකාරීත්වය(functionality) සහ වස්තූන් අත‍ර සම්බන්දතාවය යන කරුණු මූලික වශයෙන්ම සැලකිල්ලට ගනු ලබනවා. මෙහිදී ගැටලුව විසඳීමේ පියව‍ර තීරණය ක‍රණු ලබන්නේ object නොහොත් entity එකේ සැලැස්මයි(design).
 

මෙම අදහස ලඝු කොට දක්වන්නේ නම්::> structural ආකාරයට ප‍රිගණක වැඩසටහන් සැකසීමේදී step එක අනුව data structures සැලසුම් කෙරෙනවා. object-oriented ආකාරයට ප‍රිගණක වැඩසටහන් සැකසීමේදී object එකට අනුව step (පියව‍ර) තීරණය වෙනවා. 

ඉහත මූලික ආකාර 2 ට අමත‍රව functional,visual,4GL සහ තවත් ආකාර කිහිපයක් භාවිතා වනවා. නමුත් අප සාකච්ඡා ක‍රන්නේ object-oriented ආකාරය පිලිඹදවයි. වැඩි විස්ත‍ර සඳහා

object-oriented (වස්තු පාදක) සංකල්පය තවදුරටත් පැහැදිලි ක‍රගැනීම සඳහා අපි ප්‍රායෝගික උදාහරණයක් දෙසට හැරෙමු. අපි කවුරුත් දන්නා මෙහෙයුම් පද්ධති දෙකක් වන DOS සහ Windows පිලිඹද සලකා බලමු. DOS මෙහෙයුම් පද්ධතිය භාවිතා ක‍රණුයේ procedural/structured (පටිපාටිගත) ආකාරයක්. අපිට යම්තැනක ඇති file එකක් copy කිරීමට අවශ්‍ය වූයේ නම් අපි කරන්නේ copy srcfile destfile ආකාරයේ විධානයක් භාවිතාකිරීමයි. නමුත් windows මෙහෙයුම් පද්ධතියේදී අපි ක‍රන්නේ file එක ඇති ස්ථානයට ගොස්, එය මත right click කොට ලැබෙන popup මෙනුවෙන් copy select කොට paste කිරීමට අවශ්‍ය ස්ථානය ක‍රා එලඹ එය paste ක‍රගැනීමයි. .මෙය සැබෑ ලෝකයේදී file එකක් සමග ගනුදෙනු ක‍රන ආකාරයට බොහෝ සමාන හෙයින් මෙහිදී සැබෑවටම file එකක් ලෙස භාවිතා ක‍රන ආකාරයක් user ට හැඟීයනවා.

අපි බලමු OOP වල ඇති වාසි.
  1. අතිරික්ත වශයෙන් කේත ලිවීම වලකාලීමට හැකිය.(eliminate redundant code)
  2. කාලය ඉතිරික‍ර ගත හැකිය.
  3. නිරෝධනයකින්(interference) තොරව  වස්තුන් ගණනාවක් පහසුවෙන් එකව‍ර පැවතිය හැකිය.
  4. ලියල ලද වැඩසටහන හෝ මොඩියුලය යාවත්කාලීන කිරීම පහසුය(easy upgrading)
  5. ව්‍යාපෘති පාදක වැඩසටහන් වලදී මෘදුකාංගය කොටස් වලට බෙදීමට පහසුය
OOP වල භාවිත යෙදුම් (applications)
  • Real-time systems
  • Object oriented databases
  • Artificial intelligences 
  • Expert systems
  • Neural networks & Parallel programming
  • Decision support and office automation systems
  • CAD/CAM Systems
OOP හි මූලික සංකල්ප
  • Classes and Objects
  • Data encapsulation
  • Data abstraction
  • Interfaces
  • Packages
  • Inheritance
  • Polymorphism
  • Message communication
  • Dynamic binding
අපි මේ එක එකක් ගැන ඉදිරි පාඩම් වලදී පිලිවෙලින් සාකච්ඡා ක‍රමු.

Classes සහ Objects

  • Classes
ස‍රලවම කිව්වොත් class එකක් යනු object එකක සැලැස්ම වගේ දෙයක්(blue print/prototype). object එකක ලක්ෂණ, ක්‍රියාකාරීත්වය යනාදිය සියල්ල තීරණය කරණු ලබන්නේ class එක විසින්. objects නිමවීමට classes යොදාගන්නවා යන්න දැන් ඔබට පැහැදිලි ඇති. එකම class එකකින් objects අවශ්‍ය තරමක් සැකසිය හැකියි.
class එක සැලසුම් කිරීමේදී එහි object එකට අදාල පහත අංග ඇතුල් කෙරෙනවා.

  1. attributes/properties/state (වස්තුවට අදාලවන ලක්ෂණ) උදා : වර්ණය, දිග, ප‍රිමාව...
  2. constructors (class එක මගින් object එක සෑදීමේදී object එකේ attributes(ලක්ෂණ) මොනවාදැයි ලබාදීමට භාවිතකෙරේ.)
  3. methods වස්තුවේ ක්‍රියාකාරීත්වය කුමන ආකාරයෙන් වියයුතු දැයි විස්තර කෙරෙන කොටස. ඇතැම් ප‍රිගණක භාෂාවල functions,procedures ලෙසද මෙම කොටස හැඳින්වේ.
අපි class එකකට උදාහ‍රණයක් ලෙස Radio එකක් ගනිමු. 
දැන් බලමු radio එකේ attributes සහ methods මොනවාද කියලා.
ඕනෑම radio එකකට තියෙනවා band එකක්(ත‍රංග කලාපයක්), ඒවගේම volume(ශබ්ද ප්‍රමාණයක්), සුස‍ර ක‍රන ලද සංඛ්‍යාතයක් (frequency) මේවා සියල්ල අපට radio එකේ attributes/properties ලෙස සලකන්න පුලුවන්.

ඔබ දන්නවා radio එකක් factory එකෙන් පිටවෙනකොට එයට කිසියම් පෙර සකසන ලද වින්‍යාසයක් (configuration) තිබෙනවා ඒකිව්වෙ ඇතැම් radio එකක  frequency එක 88.0MHz ලෙසද තවක් එකක 108.0MHz ලෙසද සැකසී එනවා. volume එකත්, band එකටත් මේ කතාව පොදුයි. මෙන්න මේක OOP වලදී ඉටුක‍රගැනීමට තමයි constructor එකක් භාවිතා ක‍රන්නේ. 

මීලඟට radio එකක methods හඳුනා ගනිමු. ඒ කිව්වේ radio එකෙ ක්‍රියාකාරීත්වයට බලපාන දේවල්. උදාහ‍රණයක් විදියට radio එක සුස‍ර කිරීම(tune) සලකමු. මෙහිදී ඉදිරියට සුස‍ර කිරීම සහ පිටුපසට සුස‍ර කිරීම යනාදී වශයෙන් methods දෙකක් අපට හඳුනා ගන්න පුලුවන් tuneUp සහ tuneDown වශයෙන් අපි ඒවා නම් ක‍රමු. volume එකටත් එලෙසටම increaseVol සහ decreaseVol ලෙස methods 2ක් ගනිමු.   
මේ ආකාරයට ඕනෑම object එකක methods සහ attributes හදුනා ගත හැකියි.
දැන් අපි බලමු මෙම class එකට අයිති attributes සහ methods රූපිකව පෙන්වන්නේ කෙසේද කියලා.

දැන් අපි බලමු ඉහත class එක ජාවා තුලදී නිර්මාණය ක‍රගන්නේ කෙසේද කියලා.

class ClassName {
    [Attribute Declarations]*
    [Constructors]*
    [Method Declarations]*
}
 * යන්නෙන් අර්ථවත් කරන්නේ එකක් හෝ ඊට වැඩි ගණනක් තිබිය හැකිය යන්නයි.
අපි මේ සඳහා ජාවා කේතයක් ලියමු.
class Radio {
 //Attributes Declarations
 String Band;
 int Volume;
 float Frequency;
 
 //Constructors
 public Radio(){
  Band="FM";
  Volume=13;
  Frequency=90.5f;
 }
 
 //Method Declarations
 public void tuneUp(){
  if(Frequency < 108.0 )
   Frequency=Frequency+1;
 }
 
 public void tuneDown(){
  if(Frequency > 88.0 )
   Frequency=Frequency-1;
 }
 
 public void increaseVol(){
  if(Volume < 48 )
   Volume=Volume+2;
 }
 
 public void decreaseVol(){
  if(Volume > 2 )
   Volume=Volume-2;
 }
}

දැන් පේලියෙන් පේලිය ගෙන මෙහි ක්‍රියාකාරීත්වය බලමු.
3,4,5 පේලි වලින් සිදුක‍රන්නේ class එකට අයත් attributes declare ක‍රගැනීමයි.


8,9,10,11,12 පේලි අයත්වන්නේ constructor එකටයි. මෙමගින් මෙම class එක භාවිතා ක‍ර සාදාගන්නා object එකෙහි attributes/properties සඳහා අගයන්(values) initialize කිරීම සිදුක‍රනවා. අපි ඉදිරියේදී constructors පිලිඹද තවදුරටත් සාකච්ඡා කිරීමට බලාපොරොත්තු වෙනවා. 


15 වන පේලියේ සිට පහලට class එකට අයත් methods පිලිබඳ විස්ත‍ර කිරීම සිදුකෙරෙනවා. මෙහිදී භාවිතාවී ඇති සෑම method නමකම මුලට public void ලෙසින් යෙදීමට හේතුව අපි ඉදිරියේදී සාකච්ඡා ක‍රන method සම්බන්ඳ පාඩමේදී බලමු. 

මෙම පාඩමෙදී class එකක් තුල attributes,constructors හා methods යෙදෙන ආකාරය දැනගැනීම ප්‍රමාණවත්.

අපි ඊලඟ පාඩමෙන් object, constructors හා methods පිලිබඳව බලමු.
ඔබට classes හා objects පිලිබඳ sun tutorial එකෙන් බැලීමට අවශ්‍ය නම් මෙම link එක භාවිතා ක‍රන්න.

Wednesday, May 12, 2010

ජාවා තුල Arrays භාවිතය II (2D Arrays)

බොහෝ විට 1-dimentional arrays භාවිතා වුවද 2-dimentional arrays ද වැදගත්වන අවස්ථා බොහොමයකි. උදා matrix සම්බන්ඳ ගණනය කිරීම් වලදී. table එකක් වැනි යමක් නිරූපණය කිරීම‍ටද 2D arrays භාවිතා කල හැක.අපි මීට පෙර පාඩමෙන් arrays පිලිබඳ මූලික සංකල්ප 2D arrays වෙතද වලංගුවේ. අපි පහත රූප සටහන තුලින් බලමු ජාවා 2D array එකක් ප‍රිගණකයේ ප්‍රධාන මතකය තුල තැන්පත් ක‍රවන ආකාරය.
 ජාවා තුල 2D arrays නිර්මාණය කිරීමේ ආකාර කිහිපයක් පවතී.

Syntax  01: 
DataType arayName[][]=new DataType[ROWS][COLUMNS];
ex :
float weight[][]=new float[5][3];
Syntax  02: 
DataType arrayName[][]={ {row_1_val_1,row_1_val_2,...,row_1_val_n},
    {row_2_val_1,row_2_val_2,...,row_2_val_n},
    {row_3_val_1,row_3_val_2,...,row_3_val_n},
    {row_n_val_1,row_n_val_2,...,row_n_val_n}};
අපි දැන් බලමු ඉහත array එක ජාවා තුලින් නිර්මාණය කිරීමට ස‍රළ වැඩසටහනක්.
class Arrays2D {
 public static void main(String args[]){
  int array2D[][]={ {11,82,54,78,-1,91} ,
      {65,-9,45,65,95,25} ,
      {91,0,98,78,58,65}  ,
      {46,65,22,96,-5,34} };
  //accessing array elements
  for(int row=0;row < array2D.length;row++){
   for(int col=0;col < array2D[row].length;col++){
    //System.out.print("Row : " + row + " Column : " + col );
    //System.out.println(" Value : " + array2D[row][col]);
    System.out.print(array2D[row][col]+ "\t");
   }
   System.out.println();
  }     
 }
}

output :
 මේ සංකල්පයම භාවිතාක‍රමින් 3-dimensional arrays එකක් වුනත් හදාගන්න පුලුවන්. පහත ඉදිරිපත් ක‍ර ඇති නිදසුන බලන්න.  
class Array3D {
 public static void main(String args[]){
  //defining a 3D array 
  float arrXD[][][]=new float[4][7][8];
  for(int i=0;i < arrXD.length;i++){
   for(int j=0;j < arrXD[i].length;j++){
    for(int k=0;k < arrXD[i][j].length;k++){
     //filling the 3D with random values
     arrXD[i][j][k]=(float)Math.random();
     //printing stored values
     System.out.println(arrXD[i][j][k]);
    }
   }
  } 
 }
}
හොඳයි, අපි මීලඟ පාඩමේ සිට ජාවා ප‍රිගණක භාශාවේ ඉතාම වැදගත් කොටසක් වන වස්තු පාදක ක්‍රම ලේඛනය (Object Oriented Programming) පිලිබඳව අධ්‍යයනය ක‍රමු.

Tuesday, May 4, 2010

ජාවා තුල Arrays භාවිතය I

Array එකක් යනු ස‍රළම ආකාරයේ දත්ත ව්‍යුහයක් (Data Structure) ලෙස දක්වන්න පුලුවන්. අපි මීට පෙර විචල්‍යයන්(variables) ගැන කතා කලා. Array එකක් යනු එකම දත්ත ආකාරයක්(data type) ඇති විචල්‍යයන් සමූහයක්. මෙහිදී array එකකට නිශ්චිත විශාලත්වක් ඇතිබව විශේෂයෙන් සඳහන් කල යුතුයි.

Array එක සමන්විත වන variables, elements යනුවෙන් හඳුන්වනවා. Array එක තුල element එකක් හඳුනා ගැනීමට භාවිතා වන්නේ index එකයි. index එකෙහි ආරම්භක අගය 0 වනවා. අපි පහත සටහන ආධාරයෙන් array එකක ව්‍යුහය පිලිඹඳ අධ්‍යයනය කරමු.


 ArrayNum යනු array එක සඳහා දී ඇති නමයි. 0 වන index එක ලෙස 23 ද, අවසාන index එක (5) ලෙස 8 ද මම මෙහිදී ආදේශ ක‍ර තිබෙනවා. Array එකේ size එක (length) ලෙස 6 පවතිනවා(මුලු elements ගණන).  
ArrNum යන්න RAM එකෙහි ස්ථාපනය වී ඇති array එකට pointer එකක් හා සමානයි. නමුත් java pointer arithmetic සඳහා සහාය නොදක්වන බව මතක තබාගත යුතුයි.

අපි දැන් බලමු ජාවා වල array එකක් create ක‍රගත හැකි ආකාර.
syntax for creating arrays:
method 01
DataType ArrayName[];
ArrayName=new DataType[SIZE];
Ex :
int MyArray[];
MyArray=new int[5];


method 02
DataType ArrayName[]=new DataType[SIZE];
Ex :
int MyArray[]=new int[5];

method 03
DataType ArrayName[]={value1,value2,value3,value_n};
Ex :
int MyArray[]={23,45,67,23,-32,66};

method 01 හා method 02 භාවිත ක‍ර arrays සෑදීමේදී array එකේ size එක(elements ගණන) ලබා දිය යුතු වුවත් method03 භාවිත කිරීමේදී එසේ අවශ්‍ය නෑ. Array එකක් සෑදු පසු එහි size එක පසුව වෙනස් කිරීම කල නොහැකියි. 


අපි දැන් බලමු සකසන ලද array එකකට values assign ක‍රන ආකාරය. 
example:
MyArray[0]=44;
MyArray[4]=68;
මෙහිදී අප සකසන ලද array එකේ උප‍රිම index එකට වඩා වැඩි අගයක් index ලෙස ලබා දුනහොත් ArrayIndexOutOfBoundsException එකක් ලබාදීම සිදුවනවා. අපි exception පිලිබ්ඳ ඉදිරි පාඩමකදී පුළුල්ව සාකච්ඡා ක‍රමු.

Java Arrays හා සම්බන්ඳ length property එක

ජාවාහි සෑම array එකකටම length නම් property එකක් තිබෙනවා. මෙමගින් අපිට array එකක size එක(number of elements) ලබාගන්න පුලුවන්. මෙම නිසා C/C++ වලදී array භාවිතාකිරීමට වඩා java තුලදී arrays භාවිතා කිරීම පහසු ක‍රනවා.
උදා : C වලදී function එකකට array එකක් pass ක‍රන විට එහි size එකත් වෙනම parameter එකක් මගින් pass කල යුතුවනවා. නමුත් ජාවා තුලදී length property එක මගින් size එක ලබාගත හැකිනිසා එසේ size එක වෙනම variable එකකින් pass කල යුතු නැහැ. array එක තුලින්ම එහි size එක ලබගන්න පුලුවන්. 



අපි දැන් ඉහත සටහනේ ඉදිරිපත් ක‍රඇති array එක ජවා තුල නිර්මාණය ක‍රගැනීම සඳහා සුදුසු කේතයක් ලියමු.
Code 01
int ArrNum[]={23,39,14,25,23,8};
Code 02
int ArrNum[]=new int[6];
ArrNum[0]=23;
ArrNum[1]=39;
ArrNum[2]=14;
ArrNum[3]=25;
ArrNum[4]=23;
ArrNum[5]=8;
දැන් අපි බලමු ඉහත සකස් ක‍රගත් Array එකෙහි values පරිශීලනය(access) ක‍රන ආකාරය.
Access values one by one:
int value_at_index_4 = ArrNum[4];
int value_at_index_1 = ArrNum[1];
Access values using a for loop:
for(int i=0;i < ArrNum.length ; i++){
 int value_at_index_i=ArrNum[i];
 System.out.println(value_at_index_i);
}
Access values using a for-each loop:
for(int elem:ArrNum){
 int value_at_index_i=elem;
 System.out.println(value_at_index_i);
}
Access values using a while loop:
int i=0;
while( i < ArrNum.length ){
 int value_at_index_i=ArrNum[i];
 System.out.println(value_at_index_i);
 i++;
}
පහත ජාවා applet එක භාවිතා ක‍ර array එකක් ක්‍රියා කරන අයුරු අධ්‍යයනය කරන්න.

Monday, May 3, 2010

ජාවා Jump Statements සහ loops සඳහා අභ්‍යාස.

ජාවා සඳහා jump statement 3 ක් සහය දක්වනවා.  මේවා වැදගත් වනුයේ අපට කිසියම් control structure එකක් පාලනය කිරීමට අවශ්‍ය විටදීයි. උදාහ‍රණයක් ලෙස සැලකුවහොත් අපට කිසියම් loop එකක මැදදී එය නැවැත්වීමට අවශ්‍ය වුවහොත් අපට මෙම jumping statements යොදාගන්න පුලුවන්.
  • break
  • continue
  • return
break
example :
class BreakDemo {
 public static void main(String args[]){
  for(int i=0;i<10;i++){
   if(i==5){
    break; //if i is equal to 5 terminate the loop
   }
   System.out.print(i + " " );
  }
 }
}

output :

මෙහිදී සිදුවන්නේ ක්‍රමයෙන් වැඩිවිගෙන යන i අගය 5 ට සමාන වූ විගස loop එක නැවැත්වීමයි. break keyword එකෙන් විධාන ක‍රනුයේ loop එකෙන් පිටතට යෑමටයි. එනම් loop එක නැවැත්වීමයි.

continue
class ContinueDemo {
 public static void main(String args[]){
  for(int i=0;i<10;i++){
   if(i==5){
    continue;//if i is equal to 5  ignore i and continue
   }
   System.out.print(i + " " );
  }
 }
}
output :

මෙහිදී සිදුවන්නේ ක්‍රමයෙන් වැඩිවිගෙන යන i අගය 5 ට සමාන වූ විට continue keyword එකට යටින් ඇති කිසිදු statement එකක් execute නොක‍ර loop එකෙහි ඊලග step එකට පැනීමයි. එනම් i හි අගය 6 ට අදාල iteration එක පටන් ගැනීමයි. මෙහිදී 5 යන අගය console එකෙහි මුද්‍රණය නොවීමට හේතුව දැන් ඔබට වටහා ගත හැකිවිය යුතුය.

return 
මෙම keyword එක පිලිඹඳ අපි method සම්බන්ද පාඩමේදී සවිස්ත‍රාත්මකව සාකච්ඡා ක‍රමු. 


loops සඳහා අභ්‍යාස
 පහත රටාවන් ලබාගැනීමට  loops යොදාගන්න.


class Pattern01{
 public static void main(String args[]){
  for(int i=0;i<10;i++){
   for(int j=0;j<10;j++){
    System.out.print("#");
   }
   System.out.println();
  }
 }
}


class Pattern03{
 public static void main(String args[]){
  for(int i=0;i<10;i++){
   for(int j=10-i;j>0;j--){
    System.out.print("#");
   }
   System.out.println();
  }
 }
}


class Pattern04{
 public static void main(String args[]){
  for(int i=0;i<10;i++){
   for(int j=10-i;j>0;j--){
    System.out.print(" ");
   }   
   for(int j=0;j<=i;j++){
    System.out.print("#");
   }
   System.out.println();
  }
 }
}


class Pattern05{
 public static void main(String args[]){
  for(int i=0;i<10;i++){
   for(int j=10-i;j>0;j--){
    System.out.print(" ");
   }   
   for(int j=1;j<=i*2-1;j++){
    System.out.print("#");
   }
   System.out.println();
  }
 }
}


class Pattern06{
 public static void main(String args[]){
  for(int i=0;i<10;i++){
   for(int j=10-i;j>0;j--){
    System.out.print(" ");
   }   
   for(int j=0;j<10;j++){
    System.out.print("#");
   }
   System.out.println();
  }
 }
}


class Pattern05{
 public static void main(String args[]){
  for(int i=0;i<5;i++){
   for(int j=5-i;j>0;j--){
    System.out.print(" ");
   }   
   for(int j=1;j<=i*2-1;j++){
    System.out.print(j);
   }
   System.out.println();
  }
 }
}
class Pattern08{
 public static void main(String args[]){
  for(int i=1;i<10;i++){
   for(int j=1;j<10;j++){
    System.out.print(i*j + "\t" );
   }
   System.out.println();
  }
 }
}
අපි ඊලඟ පාඩමෙන්  Java arrays පිලිඹඳ අධ්‍යයනය කරමු.

Sunday, May 2, 2010

ජාවා Iterations (loops)

අපි මේ පාඩමෙන් සාකච්ඡා ක‍රන්න යන්නේ ජාවාහි ඉතාම වැදගත් කොටසක් ගැන. එනම් Iterations (නැවත නැවත සිදුකිරීම්) ජාවා වලදී පමණක් නොවෙයි ඕනෑම ක්‍රමලේඛන භාෂාවකදී Iterations හෙවත් loops ඉතා වැදගත් වනවා.
Iterations භාවිතා වන අවස්ථා වලට උදාහ‍රණ:

  • කිසියම් array එකක් තුල ඇති elements (අවයව) එකින් එක පිලිවෙලින් පරීක්ෂා කිරීම.
  • විවිධ ඇල්ගොරිතම් (algorithm) නිර්මාණයේදී.
  • කිසියම් දත්ත සමූහයක් විශ්ලේෂණය කිරීමේදී
අපි දැන් බලමු ජාවාතුල භාවිතාවන looping structures මොනවාද කියලා.
  • while
  • do - while
  • for
  • for - each
while Loop
 syntax:
while(expression){
 //do something
}
මෙහිදී expression එක true ලෙස පවතින තාක් loop එක ක්‍රියාත්මක වීම සිදුවේ (නැවත නැවත සිදුවේ). අපි දැන් while loop එක ක්‍රියාත්මක වන අන්දම විස්තරාත්මකව බලමු.
මෙහිදී expression එකෙහි boolean අගය පරීක්ෂා කිරීම සිදුවනවා. එය false නම් while එක ඇතුලේ ඇති statement එක execute කිරීම සිදුනොක‍ර කෙලින්ම loop එකෙන් පිටතට යාම සිදුක‍රනවා. එය true නම් while loop එක ඇතුලේ ඇති statement execute ක‍ර අවසානයේ නැවත expression එක පරීක්ෂා ක‍රනවා. මේ ආකාරයට දිගින් දිගටම මෙය සිදුවනවා. සාමාන්‍යයෙන් while loop එකක් යොදාගන්නේ loop එක කොපමණ වාර ගණනක් ක්‍රියාත්මක විය යුතුද යන්න කලින් අනුමාන කල නොහැකි අවස්ථා වලදීය.
අපි ස‍රල ජාවා වැඩසටහනකින් බලමු while iteration එකක් ක්‍රියා කරන ආකාරය.
ex :
class WhileDemo {
 public static void main(String args[]){
  int val=(int)(Math.random()*10);
  while(val !=5){
   System.out.println(val);
   val=(int)(Math.random()*10);
  }
 }
}

output :

මෙහිදී සසම්භාවී ලෙස 0 සිට 9 තෙක් පූර්ණ සංඛ්‍යා උත්පාදනය කොට ලැබුනු සංඛ්‍යාව 5 නම් loop එක නැවැත්වීම සිදුක‍රනවා. මෙහිදී අපිට 5 කීවෙනි සංඛ්‍යාව ලෙස ලැබේදැයි කිව නොහැකියි. එමනිසා මෙවැනි අවස්ථාවකදී while loop එක උපයෝගී ක‍රගැනීම පහසුයි. ඉහත උදාහ‍රණයේ 2,6,9,0,8,0,8,6,2 යන සංඛ්‍යා පිලිවෙලින් ලැබී අවසානයේ ලැබී ඇත්තේ 5 යි. එමනිසා while loop එක නැවතීම සිදුවී තිබෙනවා.

do - while loop
 syntax:
 

do{
 //do some thing
}while(expression);

මෙහිදි expression එක ප‍රීක්ෂා කිරීම සිදුක‍රන්නේ statements execute කිරීමෙන් පසුවයි.

example :

class DoWhileDemo {
 public static void main(String args[]){
  int val=(int)(Math.random()*10);
  do{
   System.out.println(val);
   val=(int)(Math.random()*10);
  }while(val !=5);
 }
}
output :


මෙහිදී generate ක‍රන ලද සංඛ්‍යාව 5 ට අසමානද යන්න ප‍රීක්ෂා ක‍රනුයේ loop එක අවසානයේ දිය. console එකෙහි මුලින් 5 print වීම‍ට හේතුව මෙයයි.

for loop
 syntax:
for(initialization ; Expression ; UpdateStatement ){
 //do something
}

example :

int tot=0;
for(int i=1;i<=30;i++){
 tot+=i;
}

සාමාන්‍යයෙන් for loop එකක් භාවිතා ක‍රන්නේ loop එක ක්‍රියාත්මක වන වාර ගණන දන්නා විටදීය.

for - each loop
syntax :
for(element : array ){
 //do something
}

මෙහිදී දෙනලද array එකක් තුල ඇති සියලු අවයව (elements) එකින් එක ලබාගැනීම කලහැකියි. දී ඇති element නම් variable එක තුලට සෑම iteration එකක දීම value ලබාදීම සිදුක‍රනවා. අපි ස‍රළ ජාවා වැඩසටහනක් තුලින් බලමු for - each iteration එක ක්‍රියා කරන ආකාරය.

example :


class ForEachDemo{
 public static void main(String args[]){
  int arr[]={33,45,67,78,56};
  int tot=0;
  for(int i:arr){
   System.out.println(i);
   tot=tot+i;
  }
  System.out.println("Sum : " + tot );
 }
}

output :

loop වල ක්‍රියාකාරීත්වය පෙන්වීම සඳහා ලියන ලද පහත ජාවා ඇප්ලටය භාවිතා කර බලන්න.

Saturday, May 1, 2010

ජාවා Selection Statements

ඕනැම ප‍රිගණක ක්‍රම ලේඛනයක් සාමාන්‍යයෙන් මූලික කොටස් 3 කින් සමන්විත වෙනවා
  1. Selection
  2. Sequence
  3. Iteration
අප මෙම පාඩමේදී සලකා බලන්නේ ජාවාහි selection භාවිතා වන්නේ කුමන ආකාරයෙන්ද යන්නයි. ජාවා තුල selection සඳහා සහය දැක්වීමට පහත සඳහන් විකල්ප 6 භාවිතා කරන්න පුලුවන්.
  • if 
  • if - else
  • Nested if
  • if - else - if
  • switch statement 
  • Ternary operator
if statement
syntax :
if (condition) {
   //Perform Task1
}

මෙහිදී සිදුවන්නේ condition යන්න true ලෙස පවතීනම් if code block එක තුල ඇති statements (Task1) execute කිරීමයි.

if - else statement
syntax :
if(condition){
 //Perform Task1
}else{
 //Perform Task2
}

මෙහිදී සිදුවන්නේ condition යන්න true ලෙස පවතීනම් if code block එක තුල ඇති statements (Task1) execute කිරීමයි. condition යන්න false ලෙස පවතීනම් else සඳහා අදාල  code block එක තුල ඇති statements (Task2) execute කිරීමයි.

Nested if statements

syntax :
if(condition1){
 if(condition2){
  //Peform Task1
 }else{
  //Peform Task2
 }
}else{
 //Peform Task3
}

මෙහිදී සිදුක‍ර ඇත්තේ if statement කිහිපයක් එකට ගොනු ක‍්ර දැක්වීමයි. condition1 තෘප්ත වේ නම් එම if block එක තුල ඇති ඊලග if statement එක execute වේ එනම් condition2 තෘප්ත වේනම් Task1 සිදුක‍රයි. condition2 යන්න තෘප්ත නොවේ නම් Task2 සිදුක‍රයි. යම් හෙයකින් condition1 තෘප්ත නොවේ නම්(false) Task3 සිදුක‍්රයි.
දැන් ඔබට පැහැදිලි වනවා ඇති Task1 සිදුවීමට නම් condition1 සහ condition2 යන දෙකම තෘප්ත විය යුතු බව. Task2 සිදුවීමට condition1 තෘප්ත වීම ප්‍රමාණවත්ය. condition1 තෘප්ත නොවීම සිදුවුවහොත් Task3 අනිවාර්‍යයෙන්ම සිදුවනු ඇත.

if - else - if statements 

මෙහිදී අපට මුලින් ඇති if condition එක තෘප්ත නොවේ නම් තවත් if conditions කිහිපයක් යෙදිය හැක.
syntax:
 
if(condition1){
 //Perform Task1
}else if(condition2){
 //Perform Task2
}else if(condition3){
 //Perform Task3
}else{
 //Perform Task4
}

switch statement

ජාවා තුලදී switch statement එක සහය දක්වන්නේ int,byte,short,char සහ enumeration  data types සඳහා පමණයි.

ex:


class Case {
public static void main(String args[]){

 int week=3;
 String output;
 switch(week){
  case 1 : output="Sunday";break;
  case 2 : output="Monday";break;
  case 3 : output="Tuesday";break;
  case 4 : output="Wednesday";break;
  case 5 : output="Thursday";break;
  case 6 : output="Friday";break;
  case 7 : output="Saturday";break;
  default : output="Invalid day of week!";
 }//end of the switch statement
 
 System.out.println(output);
}
}

මෙහිදී break keyword එක යොදා තිබෙන්නේ condition එක තෘප්ත වූවිට switch block එකෙන් ඉවතට යාමටයි. default යටතේ දී ඇති statement එක execute වනුයේ ඉහත සඳහන් කිසිඳු case එකක් සමග දී ඇති values නොගැලපුනහොත් පමණි.


Ternary operator

syntax:


result=Condition ? valueA : valueB

මෙහිදී සිදුවන්නේ දී ඇති condition එක true නම් result සඳහා valueA ද නො එසේ නම් valueB ද assign කිරීමයි.

example :

int max;
int a=12 , b=54;
max = (a>b) ? a : b ;