ජාවා ලෝකය. Powered by Blogger.

Friday, February 10, 2017

String එකක ඇති අකුරු ප්‍රමාණය ගණනය කිරීම.


String එකක ඇති අකුරු ප්‍රමාණය ගණනය කිරීම සදහා අපට

String.length(); යන්න භාවිතා කල හැක.

මෙහි String යන්නට අපට අකුරු ප්‍රමාණය ගණනය කිරීමට අවශ්‍ය String එක යෙදිය යුතුය.

තවද මෙහිදී ලැබෙන්නේ  අපට int එකකි.




Tuesday, August 16, 2016

User Input ලබාදීම (Scanner class එක භාවිතය)



අද කියලා දෙන්න යන්නේ ජාවා ක්‍රමලේඛන භාෂාව තුල user input භාවිතා කරන ආකාරයයි. මුලින්ම අපි බලමු මොකක්ද මේ user input එකක් කියන්නේ කියලා.

හිතන්න අපි මෙච්චර කල් කරපු පාඩම් වලදී කලේ ක්‍රමලේඛනය ලිවීමේදී ලියන ලද විචල්‍යයක් භාවිතයෙන් යම් කිසි ප්‍රතිපලයක් output එකක් ලෙස ලබාගැනීම. දැන් අපි කියලා දෙන්න යන user input එක නිසා ඉදිරියට කරන පාඩම් වලදී යම් කිසි විචල්‍යයකට කලින් අගයක් ලබා නොදී එම වැඩ සටහන ක්‍රියාත්මක වන විටදීම එයට අගයක් ලබාදීමට පුළුවන්.

මේ විදිහට user input ලබාදෙන ක්‍රම කීපයක්ම ජාවා වල තිබෙනවා. අද අපි බලමු java හි util package එකේ ඇති Scanner class එක භාවිතා කරමින් User Input ලබාදෙන ආකාරය. තවද මෙය ජාවා වල භාවිතා වන object oriented කොටසට අයත් වෙනවා.  

පහත උදාහරණය බලන්න. මෙහිදී ඔබගේ නම Enter your name here යනුවෙන් ඔබේ නම අසන අතර ඉන් පසුව නම ඇතුලත් කල විට HELLO යනුවෙන් ඔබව අමතයි.

මෙහි Class Name එක UserInput වන අතර x නමින් string (Variable)එකක් යොදාගෙන ඇත.

 import java.util.Scanner;  
 public class UserInput {  
   public static void main(String args[]) {  
     Scanner myScanner = new Scanner(System.in);  
     String x;  
     System.out.print("" + "Enter your name here: ");  
     x = myScanner.nextLine();  
     System.out.println("HELLO, " + x);  
   }  
 }  

මෙසේ user input එකක් භාවිතයෙදී import java.util.Scanner; යන කොටස අනිවාර්යෙන්ම යෙදිය යුතුය.  මෙහිදී සිදු කරන්නේ util package එකෙ ඇති  Scanner class එක අපගේ ජාවා වැඩසටහන තුලට import කරගැනීමයි. ඉන්පසුව එම Scanner class එක භාවිතා කොටගෙන object එකක් සාදාගැනීම සිදුකරනු ලබනවා. ඉන්පසුව එම සාදාගත් object එකට System.in ලෙස parameter එකක් pass කිරීම සිදුකරනු ලබනවා.
Scanner myScanner = new Scanner(System.in);
මෙහිදී  myScanner යනු අප සාදාගත් object එකේ නමයි.   තවද Scanner එක භාවිතා කොට  String එකක් input  එක ලෙස   ලබා ගත යුතු නම්  next()  හෝ nextLine() යන  method  දෙකෙන් එකක් භාවිත කල යුතුය. අප මෙහිදී භාවිතා කොට ඇත්තේ nextLine() යන method එකයි.

පහත ඇනිමේෂන් එකේ තිබෙන්නේ මෙම වැඩසටහන ක්‍රියාත්මක වන ආකාරයයි.


තවද අපි මේ ආකාරයට input කරනු ලබන්නේ integer එකක් නම් nextLine() වෙනුවට nexInt() භාවිතාකල යුතු අතර double එකක් භාවිතා කරයි නම් nextDouble() යන්න භාවිතා කල යුතුය.(ඉදිරි පාඩම් වලදී මෙය තවත් අවබෝධ වේවි.) පහත තිබෙන්නේ ඒ විදිහට Scanner class එක තුල භාවිතා කල හැකි method list එකයි.


Method Description
void close() Closes the scanner object.
Pattern delimiter() Returns the Pattern the Scanner object is currently using to match delimiters.
String findInLine(Pattern pattern) This method returns a String object that satisfies the Pattern object specified as method argument.
String findInLine(String pattern) Attempts to find the next occurrence of a pattern constructed from the specified string, ignoring delimiters.
String findWithinHorizon(Pattern pattern, int horizon) Attempts to find the next occurrence of the specified pattern.
String findWithinHorizon(String pattern, int horizon) This method simply attempts to find the next occurrence of a pattern input ignoring delimiter
boolean hasNext() Returns true if this scanner has another token in its input.
boolean hasNext(Pattern pattern) Returns true if the next complete token matches the specified pattern.
boolean hasNext(String pattern) Returns true if the next token matches the pattern constructed from the specified string.
boolean hasNextBigDecimal() Returns true if the next token in this scanner's input can be interpreted as a BigDecimal using the nextBigDecimal() method.
boolean hasNextBigInteger() Returns true if the next token in this scanner's input can be interpreted as a BigInteger in the default radix using the nextBigInteger() method.
boolean hasNextBigInteger(int radix) Returns true if the next token in this scanner's input can be interpreted as a BigInteger in the specified radix using the nextBigInteger() method.
boolean hasNextBoolean() This method checks if the Scanner object has boolean data type on its buffer.
boolean hasNextByte() This method returns true if the next byte on the scanner buffer can be translated to byte data type otherwise false.
boolean hasNextByte(int radix) Returns true if the next token in this scanner's input can be interpreted as a byte value in the specified radix using the nextByte() method.
boolean hasNextDouble() Returns true if the next token in this scanner's input can be interpreted as a double value using the nextDouble() method.
boolean hasNextFloat() Returns true if the next token in this scanner's input can be interpreted as a float value using the nextFloat() method.
boolean hasNextInt() Returns true if the next token in this scanner's input can be interpreted as an int value in the default radix using the nextInt() method.
boolean hasNextInt(int radix) This method returns boolean, true if  the token can be interpreted as int data type with respect to the radix used by the scanner object otherwise false.
boolean hasNextLine() This method returns a boolean data type which corresponds to the existence of new line on the String tokens which the Scanner object holds.
boolean hasNextLong() Returns true if the next token in this scanner's input can be interpreted as a long value in the default radix using the nextLong() method.
boolean hasNextLong(int radix) Returns true if the next token in this scanner's input can be interpreted as a long value in the specified radix using the nextLong() method.
boolean hasNextShort() Returns true if the next token in this scanner's input can be interpreted as a short value in the default radix using the nextShort() method.
boolean hasNextShort(int radix) This method returns boolean, true if  the token can be interpreted as short data type with respect to the radix used by the scanner object otherwise false.
IOException ioException() Returns the IOException last thrown by this Scanner's underlying Readable.
Locale locale() This method returns a Locale which the Scanner class is using.
MatchResult match() This method returns a MatchResult object which corresponds to the result of the last operation by the scanner object.
String next() Finds and returns the next complete token from this scanner.
String next(Pattern pattern) Returns the next token if it matches the specified pattern.
String next(String pattern) Returns the next token if it matches the pattern constructed from the specified string.
BigDecimal nextBigDecimal() Scans the next token of the input as a BigDecimal.
BigInteger nextBigInteger() Scans the next token of the input as a BigInteger.
BigInteger nextBigInteger(int radix) Scans the next token of the input as a BigInteger.
boolean nextBoolean() Scans the next token of the input into a boolean value and returns that value.
byte nextByte() Scans the next token of the input as a byte.
byte nextByte(int radix) Scans the next token of the input as a byte.
double nextDouble() Scans the next token of the input as a double.
float nextFloat() Scans the next token of the input as a float.
int nextInt() Scans the next token of the input as an int.
int nextInt(int radix) Scans the next token of the input as an int.
String nextLine() Advances this scanner past the current line and returns the input that was skipped.
long nextLong() Scans the next token of the input as a long.
long nextLong(int radix) Scans the next token of the input as a long.
short nextShort() Scans the next token of the input as a short.
short nextShort(int radix) Scans the next token of the input as a short.
int radix() Returns this scanner's default radix.
void remove() The remove operation is not supported by this implementation of Iterator.
Scanner reset() Resets this scanner.
Scanner skip(Pattern pattern) Skips input that matches the specified pattern, ignoring delimiters.
Scanner skip(String pattern) Skips input that matches a pattern constructed from the specified string.
String toString() Returns the string representation of this Scanner.
Scanner useDelimiter(Pattern pattern) Sets this scanner's delimiting pattern to the specified pattern.
Scanner useDelimiter(String pattern) Sets this scanner's delimiting pattern to a pattern constructed from the specified String.
Scanner useLocale(Locale locale) Sets this scanner's locale to the specified locale.
Scanner useRadix(int radix) Sets this scanner's default radix to the specified radix.

ඊලග පාඩමෙන් නැවත හමුවෙමු.

Sunday, August 7, 2016

Variables හා Data Types



අප මෙම පාඩමේදී බලමු ඕනෑම පරිගණක ක්‍රමලේඛන භාෂාවක ප්‍රධාන සංකල්පයක් වන විචල්‍යයන් හෙවත් Variable පිලිබදව.

අප මුලින්ම Variable එකක් කියන්නේ මොකක්ද කියලා සරලව අවබෝධ කරගමු. මතකද පාසලේදී මේ වගේ සමීකරණ විසදුවා.

Y = X + 5

මෙහිදී අපට X සදහා විවිධ අගයන් ආදේශ කිරීමෙන් Y සදහා අගයන් ලබාගන්න පුළුවන්. මෙන්න මේ වගේ.

X = 3 විට Y = 8 ,
X = 1.5 විට Y = 6.5 ,
X = -2.5 විට Y = 2.5 ,

මෙහිදී X අපි විචල්‍යයක් හෙවත් Variable එකක් ලෙස හදුන්වනු ලබනවා. පරිගණක වැඩසටහනක් ලිවීමේදී මේ ආකාරයේ Variables යොදාගනු ලබන්නේ එම වැඩසටහනක් ක්‍රියාත්මක වන විට පරිගනකයේ Ram මතකය එක තුල දත්ත ගබඩා කිරීම සදහා යම් ඉඩක් වෙන් කරගැනීමටය. මෙය අපි Data Store කිරීම ලෙස හදුන්වනු ලබනවා. දැන් අපි පොඩ්ඩක් බලමු පරිගණකය තුල Data Store කරගනු ලබන ආකාරය.

පරිගණකය තුල Data Store කිරීම

පරිගණකය තුල දත්ත ගබඩා කිරීම සිදුවන්නේ 2 පාදයේ සංඛ්‍යා වලිනි. එනම් 0 1 යන සංඛ්‍යා භාවිතයෙනි. මෙහිදී Data Store කරන කුඩාම ඒකකය bit ලෙස හදුන්වනු ලබනවා.
  • 8 bit = 1 byte
  • 1024 bytes = 1 kilo byte (KB)
  • 1024 KB = 1 mega byte (MB)
  • 1024 MB = 1 giga byte (GB)
  • 1024 GB = 1 tera byte(TB)
 මේ 2016 වර්ෂය නිසා සමහර විට ඔබේ RAM එක 2 GB, 4 GB, 8 GB, 16GB වෙන්න පුළුවන්.

අපට කුඩා  Data ප්‍රමාණයක් පරිගණකයේ RAM මතකයන් තුල Store කරගැනීමට කුඩා ඉඩ ප්‍රමාණයකුත්,
විශාල Data ප්‍රමාණයක් පරිගණකයේ RAM මතකයන් තුල Store කරගැනීමට විශාල ඉඩ ප්‍රමාණයකුත් යොදාගනු ලබනවා. මෙසේ පරිගණකයේ RAM මතකය අවශ්‍ය ප්‍රමාණයට වෙන් කරගැනීම සදහා අපි Data Type යොදාගනු ලබනවා.

Data Types හදුනාගනිමු


ඉහත රුපයේ දක්වෙන්නේ Data Type වර්ගීකරණය සිදුකරනු ලබන ආකාරයයි. මුලින්ම Data Types Primitive හා  Non-Primitive යනුවෙන් කොටස් දෙකකට වෙන් කරන්න පුළුවන්. ඔය String, Array වගේ ඒවා අයිති වෙන්නේ Non-Primitive කියන කොටසට. පහත දැක්වෙන්නේ ජාවා හි භාවිතා කරන Primitive Data Types පිළිබද විස්තරයි.

Data TypeRAM එකේ වෙන් කර ගන්නා ඉඩගබඩා කල හැකි දත්ත පරාසය
byte8 bits-128 සිට 127 දක්වා
short16 bits-32,768 සිට 32,767 දක්වා
int32 bits-231 සිට 231-1 දක්වා
long64 bits-263 සිට 263-1 දක්වා
float32 bitsදශමස්ථාන 6 කට නිවැරදිව සංඛ්‍යාවක් රදවන්න පුලුවන්
double64 bitsදශමස්ථාන 15 කට නිවැරදිව සංඛ්‍යාවක් රදවන්න පුලුවන්
char16 bits'\u0000' (හෝ 0) සහ '\uffff' (හෝ 65,535 ඇතුලත්ව) අතර ඇති ඕනෑම UNICODE සංඛේතයක්.
boolean1 bittrue හෝ false (සත්‍ය වශයෙන් 1 හෝ 0) අගයන් 2න් එකක්

 ඊට පසුව අපි කතා කරමු ජාවා වලදී මෙම Variables සටහන් කරගනු ලබන ආකාරය හෙවත් Variable Declaration ගැන

Variable Declaration

ජාවා වල යම් Variable එකක් Declare කිරීමේදී ඒ සදහා සම්මත ක්‍රමයක් හෙවත් Syntax එකක් තිබෙනවා. පහත තිබෙන්නේ ජාවා හි භාවිතා කරන Variable Declaration Syntax එක.
 <data_type> <identifier>;  
මෙහිදී <data_type> එක යනු ඉහතදී හදුන්වා දුන් Data Type එකයි. <identifier> එක යනු Variable එක සදහා යොදාගනු ලබන සංකේතයයි. මෙය හරියට අපි මුලදී භාවිතා කලා X , Y වගේ එකක්. අපට identifier එකක් ලෙස අකුරු පමණක් නොව වචනද භාවිතා කරන්න පුළුවන්.
උදාහරණයක් ලෙස num1 කියන එක identifier එකක් ලෙස භාවිතා කර int එකක් Declare කරමු.
 int num1;  
ඉදිරි පාඩම් වලදී මේ විදිහට Variable Declare කරන ආකාරය වැඩි දුරටත් සලකා බලමු. 

Saturday, August 6, 2016

print හා println භාවිතය විසදුම් - 1



අප මෙහිදී print හා println භාවිතයෙන් අභ්‍යාස - 1 පාඩමේ විසදුම් පිලිබදව සාකච්ඡා කරමු. මෙතනදී සාකච්ඡා කරන්නේ ආදර්ශ විසදුම් බැවින් ඔබගේ ජාවා වැඩසටහන් වලින් මේවා වෙනස් වීමටද පුළුවන.


1. පහත output එක java statement එකක් පමණක් භාවිතයෙන් ලබාගන්න.

Hello Sri Lanka

විසදුම :- මෙය ඉතාමත් පහසුය. මෙහිදී භාවිතා කරන්නේ පළමු ජාවා වැඩසටහනයි. මෙහිදී අපට print හෝ println යන method දෙකෙන් ඕන එකක් භාවිතා කිරීමට පුළුවන.

 public class Answer11{  
   public static void main(String args[]){  
     System.out.print("Hello Sri Lanka");  
   }  
 }  

2. පහත output එක java statement දෙකක් පමණක් භාවිතයෙන් ලබාගන්න.

Sri Lanka

විසදුම :- මෙහිදී අනිවාර්යෙන්ම පළමු java statement එක ලෙස print භාවිතා කල යුතුය. දෙවන java statement එක සදහා print හෝ println භාවිතා කල හැක.


 public class Answer12{  
   public static void main(String args[]){  
     System.out.print("Sri ");  
     System.out.print("Lanka");  
   }  
 }  

3. පහත output එක java statement තුනක් පමණක් භාවිතයෙන් ලබාගන්න.

I
Love
Sri Lanka

විසදුම :- මෙහිදී අපට println method එක භාවිතා කල java statement තුනක් භාවිතා කල හැක.


 public class Answer13{  
   public static void main(String args[]){  
     System.out.println("I");  
     System.out.println("Love");  
     System.out.println("Sri Lanka");  
   }  
 }  

4. පහත output එක java statement එකක් පමණක් භාවිතයෙන් ලබාගන්න.

Here
we will learn
about the statement
in Java

විසදුම :- මෙහිදී අපට println හෝ print method භාවිතා කල හැක. මෙහිදී අලුත් line එකකට යාම සදහා හොදා ගන්නේ string එක ඉදිරියෙන් \n යන පදය ඇතුලත් කිරීමයි. තවද string දෙකක් එකට සම්බන්ධ කිරීම සදහා ධන ලකුණ භාවිතා කර ඇත.


 public class Answer14{  
   public static void main(String args[]){  
     System.out.print("Here" + "\nwe will learn" + "\nabout the statement" + "\nin Java");  
   }  
 }  

5. පහත output එක 24 භාවිතා නොකොට java statement එකක් පමණක් භාවිතයෙන් ලබාගන්න.

30 - 6 = 24

විසදුම :- මෙහිදීද print හෝ println යන method දෙකෙන් ඕනෑම එකක් භාවිතා කල හැකි. මෙහි ඇති විශේෂත්වය වන්නේ output එක ලෙස යොදාගනු ලබන දෙය number එකක් ලෙස හා string එකක් ලෙස ඇතුලත් කරන ආකාරයයි.
 

 public class Answer15{  
   public static void main(String args[]){  
     System.out.print("30 - 6 = " + (30-6));  
   }  
 }  

6. පහත output එක 15, 9, 36 හෝ 4 භාවිතා නොකොට java statement හතරක් පමණක් භාවිතයෙන් ලබාගන්න.

12 + 3 = 15
12 - 3 = 9
12 x 3 = 36
12 / 3 = 4

විසදුම :- මෙහිදී යොදාගත යුතු වන්නේ println යන method එකයි. තවද මෙහිදී maths operators කිහිපයක් භාවිතා කලයුතු අතර ඒවා අපි ඉදිරියේදී වැඩිදුර ඉගනගනිමු. මෙහිදී යොදාගනු ලබන්නේ පහත සදහන්
maths operators කීපයයි.

එකතු කිරීම සදහා   +
අඩු කිරීම සදහා       -
ගුණ කිරීම සදහා     *
බෙදීම සදහා           /

 public class Answer16{  
   public static void main(String args[]){  
     System.out.println("12 + 3 = " + (12 + 3));  
     System.out.println("12 - 3 = " + (12 - 3));  
     System.out.println("12 x 3 = " + (12 * 3));  
     System.out.println("12 / 3 = " + (12 / 3));  
   }  
 }  

7. පහත output එක 15, 9, 36 හෝ 4 භාවිතා නොකොට java statement එකක් පමණක් භාවිතයෙන් ලබාගන්න.

12 + 3 = 15
12 - 3 = 9
12 x 3 = 36
12 / 3 = 4

විසදුම :- මෙහිදී අපට println හෝ print method යන දෙකෙන් ඕනෑම එකක් යොදා ගත හැකි අතර \n භාවිතයෙන් output එක සකස් කරගනු ලබයි.

 
 public class Answer17{  
   public static void main(String args[]){  
     System.out.print("12 + 3 = " + (12 + 3) + "\n12 - 3 = " + (12 - 3) + "\n12 x 3 = " + (12 * 3) + "\n12 / 3 = " + (12 / 3));  
   }  
 }  

ඊලග පාඩමෙන් අපි Variables හා Data Types ගැන අධ්‍යනය කරමු.



Friday, August 5, 2016

print හා println භාවිතයෙන් අභ්‍යාස - 1




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

1. පහත output එක java statement එකක් පමණක් භාවිතයෙන් ලබාගන්න.

Hello Sri Lanka

2. පහත output එක java statement දෙකක් පමණක් භාවිතයෙන් ලබාගන්න.

Sri Lanka

3. පහත output එක java statement තුනක් පමණක් භාවිතයෙන් ලබාගන්න.

I
Love
Sri Lanka

4. පහත output එක java statement එකක් පමණක් භාවිතයෙන් ලබාගන්න.

Here
we will learn
about the statement
in Java

5. පහත output එක 24 භාවිතා නොකොට java statement එකක් පමණක් භාවිතයෙන් ලබාගන්න.

30 - 6 = 24

6. පහත output එක 15, 9, 36 හෝ 4 භාවිතා නොකොට java statement හතරක් පමණක් භාවිතයෙන් ලබාගන්න.

12 + 3 = 15
12 - 3 = 9
12 x 3 = 36
12 / 3 = 4

7. පහත output එක 15, 9, 36 හෝ 4 භාවිතා නොකොට java statement එකක් පමණක් භාවිතයෙන් ලබාගන්න.

12 + 3 = 15
12 - 3 = 9
12 x 3 = 36
12 / 3 = 4

අපි ඊලග පාඩමෙන් මේ ගැටළු විසදගන්නා ආකාරය ගැන සාකච්ඡා කරමු. පහත button  එක click කර ඊලග පාඩම සදහා යොමු වන්න.


print හා println හදුනාගනිමු.



ඔන්න අපි අපේ පළමු ජාවා වැඩසටහන ලියල එක Run කරගෙනත් ඉවරයි. ඒ විතරක් නෙවෙයි එම වැඩසටහන ක්‍රියාත්මක වන ආකාරය ගැන කතා කරලත් ඉවරයි.

එකේදී අපි කලේ යම් කිසි Output එකක් CMD එක මත දර්ශනය කරගැනීම. මෙතනදී අපි යොදාගත්තේ print කියන method එක.

අපි ඉස්සෙල්ලා පාඩමේ දී කතා කලා print( ) කියන method එකේ වරහන තුලට යම් කිසි දෙයක් ඇතුල් කළාම ඒ ඇතුල් කරපු දෙය CMD එක තුලින් බලන්න පුලුවන් කියලා.

හරි දැන් එහෙනම් පොඩ්ඩක් හිතන්න Hello World කියන වචනය වෙනුවට JAVA කියන වචනේ Output එකක් විදිහට ලබාගන්න හැටි.

මේකට කරන්න තියෙන්නේ පොඩි දෙයයි. System.out.print("Hello World"); වෙනුවට System.out.print("JAVA"); කියන එක ලබාදෙන්න. එතකොට අපේ වැඩසටහන මෙන්න මේ වගේ වේවි.

 public class HelloWorld{  
      public static void main(String args[]){  
           System.out.print("JAVA");  
      }  
 }   

හරි දැන් අපි ඊලගට බලමු string එකක් වෙනුවට number එකක් ලබාදීලා. මෙතනදී " " යොදා ගැනීම අත්‍යවශ්‍ය වෙන්නේ නෑ.

 public class HelloWorld{  
      public static void main(String args[]){  
           System.out.print(25);  
      }  
 }  

දැන් ඔබට 25 යනුවෙන් output එකක් ලැබිලා ඇති. දැන් අපි බලමු 25 වෙනුවට 25 + 5 යනුවෙන් ලබා දීලා.

 public class HelloWorld{  
      public static void main(String args[]){  
           System.out.print(25 + 5);  
      }  
 }   

මෙහි ඇති + ලකුණ වැනි ඒවා අපි Arithmetic operators ලෙස හදුන්වනු ලබනවා. එකෙදී ඔබට 30 යනුවෙන් Output එකක් ලැබිලා ඇති. දැන් අපි බලමු 25 + 5 කියන එකම output එකක් විදිහට ලබාගන්නා හැටි.

 public class HelloWorld{  
      public static void main(String args[]){  
           System.out.print("25 + 5");  
      }  
 }   

හරි දැන් 25 + 5 යනුවෙන් output එකක් ලැබිලා ඇති. දැන් අපි පොඩ්ඩක් හිතමු. System.out.print( ); කියන statement එක තුන් වතාවක් ඇතුල් කලා කියලා මෙන්න මේ විදිහට

 public class HelloWorld{  
      public static void main(String args[]){  
           System.out.print("Welcome");  
           System.out.print("Java lokaya");  
           System.out.print("Sri lanka");  
      }  
 }   

මෙන්න මේ වගේ එකක් නේද ලැබුනේ

WelcomeJava lokayaSri lanka

මෙහෙම වෙන්නේ print කියන method එකේදී අන්තිමට අලුත් ලයින් එකට ගමන් නොකිරීමයි. මේ සදහා print method එක වෙනුවට println method එක භාවිතා කරන්න පුලුවන්. දැන් අපි print වෙනුවට println භාවිතා කරමු.

 public class HelloWorld{  
      public static void main(String args[]){  
           System.out.println("Welcome");  
           System.out.println("Java lokaya");  
           System.out.println("Sri lanka");  
      }  
 }   

එතකොට අපේ වැඩසටහන මෙන්න මේ වගේ තියෙවි. දැන් වැඩසටහන Run කලවිට

Welcome
Java lokaya
Sri lanka 

ලෙස ලැබේවි. මෙසේ සිදු වන්නේ println මගින් Output එක ලබා දීමෙන් අනතුරුව එය නව line එකකට ගමන් කිරීමයි.

ඊලගට අපි බලමු එක් statement එකක් පමණක් භාවිතා කරමින් ඉහත ආකාරයේ output එකක් ලබාගන්නා ආකාරය. මෙහිදී අපිට print හෝ println යන method දෙකෙන් ඕනෑම එකක් භාවිතා කරන්න පුලුවන්.

 public class HelloWorld{  
      public static void main(String args[]){  
           System.out.print("Welcome"+"\nJava lokaya"+"\nSri lanka");  
      }  
 }   

ඉස්සෙල්ලා වගේම output එකක් අවා නේද? මෙහිදී \n මගින් සිදු වන්නේ අලුත් ලයින් එකකට ගමන් කරවීමයි. තවද + ලකුණ string දෙකක් සම්බන්ධ කිරීමට යොදාගන්නවා.

අපි ඊලග පාඩමෙන් print හා println method භාවිතයෙන් අභ්‍යාස කිහිපයක් සලකා බලමු.



Thursday, August 4, 2016

මුල්ම ජාවා වැඩසටහනේ කොටස් අධ්‍යනය කරමු.




මේ පාඩමේ දී අපි කරන්න යන්නේ මුලින්ම අපි හදාගත්ත Hello World කියන වැඩසටහන විශ්ලේෂණය කරන්නයි. මුලින්නම අපි නිර්මාණය කරගත්ත වැඩසටහන ආපහු open කරගමු.


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


මුලින්ම බලමු ඔය  රෝස පාටින් වර්ණ ගන්වා ඇති කොටස class definition එක වශයෙන් හදුන්වනවා.තවත් දෙයක් තමයි ඕනෑම ජාවා වැඩසටහනක එක class definition එකක් හෝ අනිවර්යන්ම අවශ්‍ය වෙනවා .
 
ඊට අමතරව ඔය දම් පාටින් වර්ණ ගන්වා ඇති සගල වරහන මගින් class definition එකේ ආරම්භය සලකුණු කරනවා. ඔය තද නිල් පාටින් වර්ණ ගන්වා ඇති සගල වරහන class definition එකේ අවසානය සලකුණු කරනවා.

කහපාටින් වර්ණගන්වා ඇති කොටසට අපි කියනවා method definition එක කියලා. මේ main method එක ජාවා වැඩසටහනක තියෙන ප්‍රධාන කොටසක්. java virtual machine (JVM) එක මගින් ජාවා වැඩසටහන execute වෙන්න පටන්ගන්නේ මෙන්න මේ method definition එකෙන්.

ඊට පස්සේ බලමු. ඔය ලා කොළ පාටට පාට කරලා තියන සගල වරහනෙන් method definition එකේ ආරම්භය සලකුණු කරනවා. ඔය ලා නිල් පාටට තියන සගල වරහන method definition එකේ අවසානය සලකුණු කරනවා. මෙන්න මේ වරහන් දෙක තුල තමයි අපිට කරන්න ඕන දේ ලියන්න ඕනේ.

ඊට පස්සේ ඔය රතු පාටට වර්ණ ගන්වා තියන කොටස java statement එකක් කියලා හදුන්වනවා. තවත් දෙයක් තමයි.  මේ විදිහට ලියන java statement එකක් semicolon එකකින් අවසන් විය යුතුම වෙනවා. මොකද ඉවර වෙලා නැති statement එකක් පරිගණකයට තේරෙන්නේ නෑ. ඒ නිසා compile වීමේදී compile error එකක් ලබා දෙනවා.

මෙතනදී මෙතනදි කියන class එකේ තියෙන standard output stream (out) එකට අයත් PrintStream.print(java.lang.String) කියන method එක භාවිත කරල තමයි මේ අපේ වැඩේ කරගන්නේ. තවත් දෙයක් තමයි ඔය print() වරහන  තුලයමක් ලියලා තමයි අපිට ඕන දේ cmd එකේ දර්ශනය කරවා ගන්නේ.  ඒ යොදන දෙය string එකක් නම් අනිවාර්යෙන්ම double quotes (“ ”) තුල ලිවිය  යුතුම වෙනවා.
 
අපි මෙතන සිට අපි ලියපු ජාවා වැඩසටහනේ වචන ගැන අධ්‍යනය කරමු.

public

මුලින්ම අපි කතා කරමු public ගැන. public කියන එක අපි access modifier එකක් කියලා හදුන්වනු ලබනවා. ඒ විතරක් නෙවේ public කියන එක ජාවා වල භාවිතා වන keyword එකක් වෙනවා ජාවා වල මේ විදිහට access modifier හතරක් පමණ දකින්න පුළුවන්. ඒවානම්
  • private
  • default (මේ කියන්නේ access modifier එකක් භාවිතා නොකලොත් කියන එක)
  • protected
  • public
මේ වැඩසටහන භාවිතයෙන් නම් මේ එකින් එක ගැන විස්තර කරන්න බෑ.access modifier එකක් කියන්නේ සරලව මොකක්ද කියලා විතරක් කියන්නම්.

ඔයාලා ඕන කෙනෙක් facebook එක පාවිච්චි කරනවා ඇතිනේ.පොඩ්ඩක් හිතන්න facebook එකේ ඔයාලා දාන ඕනෑම පොස්ට් එකකට ඕන කෙනෙක්ට like කරන්න පුළුවන්. එත් ඔයාලා කවුරුහරි එක්ක චැට් කරන එකක් පිට කෙනෙක්ට බලන්න පුලුවන්ද? බෑ නේද? එක බලන්න පුළුවන් ඔයාටයි ඔයා චැට් කරන පුද්ගලයාටයි විත‍රයි. ඒ වගේම තමයි ඔයා පාරේ යද්දී හිතෙන දේවල් තව කාටවත් දැනගන්න දැනගන්න පුලුවන්ද? අන්න එකට තමයි මේ  access modifier කියන ඒවා යොදාගන්නේ. ඔය access modifier කියන ඒවා වැරදියට පාවිච්චි කලොත් හරියට ඔයාගේ facebook එකේ user name එකයි password එකයි profile picture එකට දැම්මා වගේ තියෙයි.


 access modifier ගැන ඔයිට වඩා කියන්න යන්නේ නෑ. අපි ඒ ගැන වැඩි විස්තර ඉදිරියට කතා කරමු.

class

දැන් අපි බලමු class කියන්නේ මොකක්ද කියලා. class කියන්නේ ජාවා වල භාවිතා කරන keyword එකක්. ඇත්තටම ජාවා වල මේ වගේ keyword 50 ක් විතර තියනවා. විවිද ක්‍රමලේඛන භාෂාවල විවිද keyword භාවිතා වෙනවා. තවද මේ keyword ඒ ඒ භාෂාවට අනන්‍ය වෙනවා. මෙන්න මෙතන තියනවා ජාවා වල භාවිතා වන keyword.



තව කියන්න ඕන දෙයක් තමයි මෙතන තියන සමහර keyword දැනට භාවිතා වන්නේ නෑ. සමහර keyword විවිද ජාවා සංස්කරණ වලදී මේ භාෂාවට එකතු වූ ඒවා.


මේ keyword විවිද අවස්ථාවලදී යොදා ගන්නා හැටි පසුව සාකච්චා කරමු. දැනට class එකක් කියන්නේ පන්තියක් වගේ කියලා හිතාගන්නකෝ.

HelloWorld

මෙතනදී HelloWorld කියන්නේ අපි භාවිතා කරන class එකේ නම. ඉස්සෙල්ලා පාඩමේදී අපි කිව්වා class එකේ නමයි ජාවා file එකේ නමයි සමාන වෙන්න ඕනේ කියලා. එහෙම වෙන්න ඕනේ class එක public class එකක් වුණාම. දැන් පොඩ්ඩක් බලන්න අපේ වැඩසටහනේ class එකේ  access modifier එක මකලා දාලා class එක එක නමකිනුත් ජාවා file එක තවත් නමකිනුත් save කරලා. වැඩසටහන compile වෙනවා නේද?

static

static කියන්නෙත් ජාවා වල භාවිතා වන keyword එකක්. මෙමගින් කියවෙන්නේ main method එක භාවිතා කළහැකි ආකාරයක් පිලිබදව. තවද method පිලිබදව කතා කරන විට static methods වගේම non static methods කියලත් වර්ගයක් තිබෙනවා. ඒ විතරක් නෙවේ non static method එකක් භාවිතා කරනවා නම් ඒ සදහා වෙනම ක්‍රමවේදයක් යොදාගනු ලබනවා. අපි ඉදිරියේදී මේ ගැන වැඩිදුරට සාකච්චා කරමු.

void

void කියන්නෙත් කලින් වගේම keyword එකක්. පොඩ්ඩක් keyword list එකේ බලන්නකෝ. void කියන keyword එක යොදාගනු ලබන්නේ යම් කිසි method එකක් හෝ function එකක් value return කිරීමක් සිදුනොකරන විටයි. තවද මේ void යන keyword එක එම function එකේ හෝ method එකේ නමට ඉදිරියෙන් යොදාගනු ලබනවා. විස්තරේ වැඩිය තේරුනේ නෑ නේද? මේ ගැන වැඩි විස්තර පසුව කතා කරමු.

main

main යනුවෙන් සටහන් කරන්නේ මෙම method එක මෙම වැඩසටහනේ මූලික නැත්නම් main method එක යනුවෙන් හැදින්වීමටයි.

String args[]

මෙහිදී මේ args යනුවෙන් ඇත්තේ args යන Array එක ගැනයි. මෙහි args යනු එම Array එකේ නම වෙනවා. තවද ජාවා වල Array එකක් සටහන් කිරීමේදී එම Array එකට පසුව කොටු වරහන් යොදා ගනු ලබනවා. අපි Array ගැන පස්සේ පාඩමකින් කතා කරමු.

String යනු එම Arrayඑකේ type එකයි.මේ String කියන එක ජාවා වල class එකක් වෙනවා. ඒ නිසාම මෙය සටහන් කිරීමේදී  කැපිටල්  S අකුර  භාවිතා  වෙනවා.

System.out

මෙය cmd එක මත යම් දෙයක් සටහන් කර ගැනීමට (පරිගණකය මගින් output එකක් ලබාගැනීමට) අවශ්‍ය වූ විට යොදා ගනු ලබනවා.

print

print යනු ජාවා වල method එකක් වෙනවා. තවද එය පරිගණකය මගින් ලබාදෙන output එක සකසා ගැනීමට භාවිතා කෙරෙනවා.

Thursday, July 28, 2016

මුල්ම ජාවා වැඩසටහන පරිඝනකයේ Run කරමු




ඔන්න මේ වෙද්දී මුල්ම ජාවා වැඩසටහන නිර්මාණය කරගෙන ඇති කියලා හිතනවා. ඒ පොස්ට් එක බලන්න බැරි වුනානම් මෙතැනින් ගිහිල්ලා බලලා ඉන්න.

අද කියලා දෙන්න යන්නේ අපි මුලින්ම හදාගත්ත ජාවා වැඩසටහන පරිඝනකයේ Run කරගන්න විදිහ. මුලින්ම මේකට ඔබගේ පරිඝනකයේ ජාවා ස්ථාපනය කරගෙන ඉන්න ඕනේ. ඒ විතරක් නෙවේ ස්ථිර ලෙස path set කරගනීමකුත් කරගෙන තිබෙන්න ඕනේ. ඒ දේවල් කරන්නේ කොහොමද කියලා දන්නේ නැත්නම් පහත ලින්ක් වලට ගිහිල්ලා ඒවා කරන හැටි බලලා ඉන්න.


හරි එහෙනම් දැන් වැඩේට බහිමු.  පළමු පියවර තමයි ඔබගේ පරිඝනකයේ CMD එක open කරගැනීම. (CMD එක ගැන දැනගන්න මෙතනින් යන්න.) ඊට පස්සේ කරන්න තියෙන්නේ ඔබ HelloWorld.java නමින් save කර ගත් file එක ඇති folder එක තුලට cmd එක ගෙන යාම. (ඒ සදහා cd හා dir command භාවිතා කරන්න.) හරි දැන් 

 javac HelloWorld.java 

කියලා ටයිප් කරන එකයි. මේ පියවරේදී වෙන්නේ අපි සකස් කරගත් ජාවා ෆයිල් එක පරිගණකය දන්නා භාෂාව බවට පත් වීම. එහෙම නැත්නම් compile කියන ක්‍රියාවලිය. (compile කියන්නේ මොකක්ද කියලා දන්නේ නැත්නම් මෙතනින් යන්න.) දැන් ඒ folder එක තුල  HelloWorld.class නමින් file එකක් හැදිලා ඇති. බොරුද කියලා folder එක ඇතුලට ගිහිල්ලා බලන්නකෝ.

මේ  compile ක්‍රියාවලිය හරියට සිද්ද වුනේ නැත්නම් ඔබ HelloWorld.java file එක සකස් කිරීමේදී යම් වැරැද්දක් සිදු කරලා තියෙන්නවා. ආපහු file එක text editor එක මගින් open කරගෙන බලන්න code එක හරියට ලියලා තියනවද කියලා. මේ විදිහට වෙන්න පුළුවන් වැරදි ගැන අපි ඉදිරියේදී කතා කරමු. මේ HelloWorld.class file එක අපේ පරිඝනකය  තුල Run කරන පුළුවන්. 

හරි දැන් file එක Run කරන හැටි බලමු. එකට කරන්න තියෙන්නේ මෙචරයි. ඔයාලගේ HelloWorld.class file එක තියන folder එක තුලම cmd එක තබාගෙන

 java HelloWorld

යනුවෙන් type කරන්න. (java <space>.class file එකේ නම) හරි දැන් ඔයාලට Hello World කියන එක CMD එක තුල දිස්වේවි. මෙන්න මේ ඇනිමේෂන් එකෙන් වැඩේ තවදුරටත් පැහැදිලි වේවි.

 
මෙන්න මේ විදිහට තමයි අපි මුලික පාඩම් කීපයේදී ජාවා file පරිඝනකය තුල Run කරනු බලන්නේ.

අපිට මේ විදිහට Hello World එක වෙනුවට විවිද වචන යොදා ගන්නත් පුළුවන් try කරලා බලන්න.
(උදාහරණයක් විදිහට ඔබගේ නම මේ විදිහට CMD එක තුලින් ගන්න try කරන්න.)
  

Tuesday, July 26, 2016

User Variables භාවිතයෙන් ස්ථීර ලෙස path set කිරීම




දැන් ඔන්න User Variables භාවිතයෙන් path set කරන්න තමයි යන්නේ. මෙතනදී සිද්ද වෙන්නේ ඔයාලගේ පරිඝනකයේ user account ඒ කියන්නේ ඔයාලගේ profile එකට විදිහට බලපාන විදිහට path set කිරීමයි.

දැන් ඉස්සෙල්ලා පාඩමේ කියලා දුන්න විදිහට ඔයාලගේ jdk folder එකේ bin folder එක තුලට යන්න.ඒ විදිහට ගිහිල්ලා address bar එක උඩ click කරලා path එක copy කරගන්න. ඒ විදිහට copy කරගත්තාම මේවගේ path එකක් ඔයාලට ලැබේවි.

C:\Program Files\Java\jdk1.8.0_101\bin

වැඩේ කරන හැටි තේරුනේ නැත්නම් පහත ඇනිමේෂන් එක බලන්න.


 හරි දැන් ඊලග පියවර බලමු.
  • මුලින්ම ඔයාලගේ My Computer  වලට යන්න.
  • දැන් රයිට් ක්ලික් ක‍රලා Properties වලට යන්න.
  • ඊට පස්සේ ඕපන් වන වින්ඩෝ එකේ වම්  පැත්තේ ඇති  advanced system settings එකට යන්න.
  • ඊට පස්සේ එන වින්ඩෝ එකේ ඇති Environment Variable කියන button එක click කරන්න.
  • දැන් open වන ඩයලොග් බොක්ස් එකේ උඩ තියන New button එක click කරන්න.
  • ඊට පස්සේ එන ඩයලොග් බොක්ස් එකේ Variable name කියන තැනට path කියන එකත් Variable value කියන තැනට ඉස්සෙල්ලා copy කරගත් path එකත් ලබා දෙන්න.
  • දැන් සැම ඩයලොග් බොක්ස් එකක්ම OK කරමින් පස්සට එන්න.
වැඩේ හරියට තේරුනේ නැත්නම් පහත ඇති ඇනිමේෂන් එක බලන්න.



හරි දැන් අර ඉස්සෙල්ලා වගේ Command Prompt එක ඕපන් කරගෙන javac කියලා type කරලා Enter බලන්න. මෙන්න මේ වගේ එකක් ලැබේවි.


අපි ඊලග පාඩමෙන් බලමු System Variables භාවිතයෙන් path set කරන විදිහ. මේ විදිහට path set කලාම අපිට පරිඝනකයේ ඕනෑම user account එකකට ගිහිල්ලා ජාවා compile කරන්න වගේම class file  Ran කරන්නත් පුළුවන්.

Monday, July 25, 2016

වින්ඩෝස් මෙහෙයුම් පද්දතිය තුල ජාවා ස්ථාපනය කිරීම



අද අපිකතා කරමු වින්ඩෝස් මෙහෙයුම් පද්දතිය තුල ජාවා ස්ථාපනය කිරීම ගැන. ඊට ඉස්සෙල්ලාමේ පොස්ට් කියෙව්වේ නැත්නම් කියවලා ඉන්න කියලා මම ආරාධනා කරනවා. මොකද ජාවා ඉගනගන්න ඉස්සෙල්ලා මේ මුලික දැනුමත් තියන එක වටිනවා.

පරිඝණක ක්‍රමලේඛන භාෂාවක් යනු
ජාවා යනු කුමක්ද?

පලවෙනි දේ කියන්න ඕනේ මම මේ පාඩම සදහා භාවිතා කරන්නේ Windows 10 මෙහෙයුම් පද්දතිය. එත් මෙතන කතා කරන සියලු පියවර windows XP, 7, 8, 8.1 වගේ මෙහෙයුම් පද්දති සදහාත් ගැලපෙනවා.

ඉස්සෙල්ලා අපි බලමු අපේ පරිඝනකයේ ජාවා තියනවද නැද්ද කියලා හදුනා ගන්න විදිහ. මේකට කරන්න තියෙන්නේ පොඩි දෙයක්. ඔයාලගේ පරිඝනකයේ Command Prompt එක ඕපන් කරගෙන javac කියලා type කරලා Enter කරන්න. (Command Prompt එක මොකක්ද කියලා දන්නේ නැත්නම් මෙනතින් ගිහින් බලන්න.) මෙන්න මෙහෙම එකක් එනවනම් ඔබගේ පරිඝනකයේ ජාවා ස්ථාපනය කරලා නැහැ.


ජාවා ස්ථාපනය කරන්න ඉස්සෙල්ලා දැනගන්න ඕන පලවෙනි දේ තමයි තමන්ගේ මෙහෙයුම් පද්දතිය නැත්නම් Operating System  එක 32 bit එකක්ද 64 bit එකක්ද කියලා හොයාගන්න ඒකට පහත පියවර අනුගමනය කරන්න.

My Computer  වලට යන්න. දැන් රයිට් ක්ලික් ක‍රලා Properties වලට යන්න. දැන් ඔයාලට ඔයාලගේ Operating System එකේ bit version (x86 කියලා තියෙන්නේ 32 bit සදහාය.) බලාගන්න පුළුවන්.මෙන්න මේ ඇනිමේෂන් එකේ වැඩේ හරියටම කරන හැටි තියෙනවා.


දැන් ඉතින් ඔන්න ඒ වැඩෙත් හරි කියලා සිතනවා. මම මේ ලිපිය ලියන්නේ 2016 / 7 /25. මේ වෙනකොට Java 8 කියන සංස්කරණය එළිදක්වලා තියෙන්නේ. පහල button එක click කරලා ඔයලට Java SE Development Kit 8 එක ඩවුන්ලෝඩ් කරගන්න පුළුවන්. අනික මේ හැම දෙයක්ම දෙන්නේ නොමිලේ බව මතක තබා ගන්න.



 මම නම් ඩවුන්ලෝඩ් කලේ Java SE Development Kit 8u101 කියන සංස්කරණය. ඔයාලට කැමති සංස්කරණයක් ඩවුන්ලෝඩ් කර ගන්න. මේ විදිහට ඩවුන්ලෝඩ් කරද්දී තමන්ගේ මෙහෙයුම් පද්දතියේ bit අගය ගැනත් සැලකිලිමත් වෙන්න.

දැන් jdk එක ඩවුන්ලෝඩ් කරලා ඉවරයිනේ. දැන් මේ පහල ඇනිමේෂන් එකේ තියන විදිහට එක ඉන්ස්ටෝල් කරගන්න. එක ඉන්ස්ටෝල් කරන විදිහ ලොකුවට කියලා දෙන්න ඕනේ නෑ කියලා මම හිතනවා.





Sunday, July 24, 2016

ජාවා යනු කුමක්ද?




පරිඝණක ක්‍රමලේඛන භාෂාවක් යනු කුමක්ද කියලා හදුනාගත්ත අපි දැන් බලමු අපි ඉගන ගන්න යන මේ ජාවා කියන්නේ මොකක්ද කියලා. කවුරුහරි පලමු ලිපිය කියෙව්වේ නැත්නම් පහත ලින්ක් එකෙන් ඒ ලිපිය කියවලා ඉන්න.

පරිඝණක ක්‍රමලේඛන භාෂාවක් යනු

හරි දැන් අපි බලමු මේ Java කියන්නේ මොකක්ද කියලා.  සරලව කිව්වොත් ජාවා කියන්නේ පරිඝණක ක්‍රමලේඛන භාෂාවක්.  මෙය 1995 වර්ෂයේදී "සන් මයික්‍රෝසිස්ටම්ස්" (Sun Microsystems) නමැති ආයතනය විසින් හදුන්වාදෙන ලද්දක්. මෙය C සහ C++ යන පරිගණක ක්‍රමලේඛණ හාෂා වලට සමානකම් දැක්වුවද ඊට වඩා වැඩි පහසුකම් අන්තර්ගත වෙනවා.

ජේම්ස් ගොස්ලිං (James Gosling), මයික් ෂෙරිඩන් (Mike Sheridan) සහ පැට්‍රික් නෝටන් (Patrick Naughton) යන අය ඇතුලු "ග්‍රීන් ටීම්" (Green Team) නමින් හැන්දින්වු කන්ඩායම 1991 ජූනි මාසය පමන වන විට "Green Project" ව්‍යපෘතිය ආරම්භ කළා. ඔහුන්ගේ මූලික අරමුණ වුනේ low cost, Hardware Independent Language එකක් C++ උපයෝගී කරගෙන සංවර්ධනය කිරීමයි. තාක්ෂණික ගැටළු මත එය අසාර්ථක උනත්  "ඕක්"(oak) නමින් තවත් ක්‍රමලේඛන භාෂාවක් සංවර්ධනය වුනා. ජේම්ස් ගොස්ලිං ගේ කාර්යාලය ඉදිරිපිට තිබූ "ඕක්" ගසක් එයට හේතු වූ බව සඳහන් වේ.මේ විදිහට ජාවා සංවර්ධනය වුනේ C++ වල තිබුනු සමහර ගුණාංග ඉවත් කරලයී

1994දී World Wide Web concept එක පැමිණීමත් සමඟ Oak, Java ලෙස නම් කෙරුණා. එය එවකට ජනප්‍රිය පද්ධති වෙනුවෙන් වියදම් රහිත භාෂාවක් ලෙස ප්‍රචලිත වුනා. එය 2010 ජනවාරි 27 වන දින සිට ඔරකල් ආයතනය විසින් අත්පත් කරගන්නා ලද මෙය අද  වන විට පරිගනක යෙදවුම් මෘදුකාංග (Computer Application Software) සැකසීමේ සිට වෙබ් යෙදවුම් (Web Application) දියුණු කිරීම දක්වා වූ පුළුල් පරාසයක ව්‍යප්ත වී තිබෙනවා.

ජාවාවල විශේෂතා කීපයක් අපිට දැකගන්න පුළුවන්.

  • Java is Platform Independent 
  • Java is Object-Oriented
  • Java is easy to learn
  • Java is small
  • Java is secure
  • Java is portable
මේකේ තියන පලවෙනි දේ තමයි ජාවා Platform Independent කියන එක. ඒ කියන්නේ Platform එක මත රදා පවතින්නේ නෑ. අපිට ඕනෑම මෙහෙයුම් පද්දතියකදී ජාවා වැඩසටහනක් ක්‍රියාත්මක කරගන්න පුළුවන්.
මේ හේතුව නිසා අපිට අපේ පරිගණකයේ ජාවා ස්ථාපනය කරගන්න අවශ්‍ය වෙනවා. ඊලග පාඩමෙන් බලමු වින්ඩෝස් මෙහෙයුම් පද්දතිය තුල ජාවා ස්ථාපනය  කරගන්නේ කොහොමද කියලා.


පරිඝණක ක්‍රමලේඛන භාෂාවක් යනු





ලෝකයේ විවිද ජාතීන් තම අදහස් හුවමාරු කරගැනීම සදහා විවිද භාෂාවන් භාවිතා කරනු ලබනවා. මේ ආකාරයටම පරිඝනකත් තම සන්නිවේදනය සදහා එයටම ආවේනික වූ භාෂාවක් භාවිතා කරනු ලබනවා. මේ භාෂාව binary (දෙකේ පාදයේ සංඛ්‍යා) ලෙස හදුන්වනු ලබනවා. අපට binary තේරුම් ගන්න අමාරුයි වගේම පරිගණකයටත් අපේ භාෂාව තේරුම් ගන්න හැකියාවක් නැහැ.  මෙන්න මේ දුර්වලතාවය මග හරවා ගන්න තමයි පරිගණක ක්‍රමලේඛන භාෂාවක් හෙවත් Computer Programming Language එකක් භාවිතා කරනු ලබන්නේ.

පහත වගුවෙන් දැක්වෙන්නේ පරිඝණක ක්‍රමලේඛන භාෂා හා ඒවගේ නම් හැදුන හැටි ගැනයි.


මේවට අමතරව තවත් විශාල ප්‍රමාණයක් පරිගණක ක්‍රමලේඛන භාෂාවන් තිබෙනවා. හැබැයි මේ හැම භාෂාවකම key words, symbols සහ syntaxes කියලා දේවල් ටිකක් තියනවා. එපමණක් නොවෙයි ඒවා භාෂාවන්ගෙන් භාෂාවන්ට වෙනස් වෙනවා.

High Level & Low Level Programming languages

ලෝකයේ තිබෙන පරිගණක ක්‍රමලේඛන භාෂාවන් ප්‍රදාන වශයන් කොටස් දෙකකට වෙන් කරන්න පුළුවන්. ඒවානම්,

  • High Level Programming languages
  • Low Level Programming languages 
High Level Programming languages

යම්කිසි පරිගණක ක්‍රමලේඛන භාෂාවක පාවිච්චි වෙන වචන මිනිසා එදිෙනදා පාවිච්ච් කරන වචන වලට සමාන නම් ඒවා පාවිච්ච් කරන ආකාරෙයන් වාවහාරික භාෂා සමග ලොකු ගැටුමක් නැත්නම් එය High Level Programming languages එකක් ලෙස හැදින්වෙනවා. උදාහරණයක් ලෙස Java, Visual Basic, C++, VB.Net ගන්න පුළුවන්.

Low Level Programming languages

Low level languages වලට Machine code හා Assembler කියන වර්ග දෙක අයත් වෙනවා. අපි High Level Programming language එකක් භාවිතයන් වැඩසටහනක්  නිර්මාණය කලවිට එය ක්‍රියාවට නැංවීමේදී මුලින්ම එය  Machine code එකක් බවට හැරවෙනවා. 

Assembler language එක නිර්මාණය කර ඇත්තේ පරිඝනකයේ ඇති  Operating System එක සමග ක්‍රියා කිරීමටයි. Assembler language එක භාවිතයෙන් program ලිවීම අමාරු වුවත් කියාවට නැංවීෙම්දී ඉතා වේගවත්.

Low level Languages වල පාවිච්චි වෙන නියෝග නිකම්ම අකුරුවල එකතුවක් මිසක් අපිට හුරු පුරුදු ඉංගීසී වචන නෙමෙයි.  Low level Languages වලට උදාහරණ ලෙස Asm , mov , add , jnz,  dec යන ඒවා ගන්න පුළුවන්.

 

මේ රුපයෙන් දැක්වෙන්නේ මිනිසා High Level  languages භාවිතා කර ක්‍රමලේඛන ලිව්වත් ඒවා පරිඝනකය තේරුම් ගන්නේ Low level  Languages වලින් බවයි. දැන් ඉතින් අපි ලියන High Level languages Low level  Languages බවට පරිවර්තනය කිරීම සිදුකරන්න ඕනේ. 

 High Level  language එකක් Low level  Language එකක් බවට පරිවර්තනය කිරීම.


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


  • Compiler
  • Interpret 

Compiler

භාෂා පරිවර්තකෙයෝ වර්ග දකක් ඉන්නවා. එක වර්ගයකට කලින් කතාව ලියලා දුන්නහම ඒ ගොල්ලෝ කතාවේ වැරදි එහෙම  තියනව නම් ඒවා හදලා මුලු කතාවම වෙනත් භාෂාවකට හරවනවා. කතාව කරන කෙනාට තියන්නේ පරිවර්තනය කරපු කතාව කියවන එකයි.

Compiler කියන වර්ගෙය්දී ඉස්සෙල්ලාම එකකින් නියෝග මාලාව හෙවත් program එක ලියනවා. මේකට අපි source code එක කියලා කියනවා.  මෙහිදී සම්පූර්ණ program එකම Machine code  එකට හැරෙවනවා එහිදී program එෙක් ඇති සියලුම වැරදි ලැයිස්තුව අප ඉදිරිෙය් පෙන්වනවා. ඒ වැරදි නිවැරදි කරලා ආයෙමත් compile කලහම Compile වූ program එක ලැබනවා. දැන් අර මුල් source code එක නැතිව වුවත් අපිට program එක කියාත්මක කරලා අවශ දේ  ලබාගන්න පුලුවන්.

ඒත් යම් විදියකින් අපට අපි ලිව්ව program එෙක් යම් නියෝගයක් වෙනස් කිරීමට අවශ නම් ඒක compile කල program එක පාවිච්චි කරලා කරන්න බැහැ. ආයෙත් අපට source code එක ගන්න වෙනවා. ඒකේ  අවශ වෙනස්කම් කරලා ආයෙත් compile  කරලයි වෙනස් කරන ලද program එක පාවිච්චි කරන්න වෙන්නේ. 

උදාහරණ විදිහට අපිට Turbo Pascal, Turbo  C++ වගේ ඒවා ගන්න පුළුවන්.

 Interpret

හිතන්න භාෂා පරිවර්තනය කිරීෙම්දී බැරි වෙලාවත් කතාව කරන කෙනා කොලයක් බලන්නේ නැතිව එෙව්ලේ හිතලා කතා කරනවා කියල. එවැනි වෙලාවක පරිවර්තකයාට මුළු කථාවම පරිවර්තනය කිරීමක් ගැන හිතන්නවත් බැහැ. මොකද එහෙම මුළු කතාවම එවෙලෙම පරිවර්තනය කරන්න බැහැ. එතෙකොට කරන්න තියන්නේ කථිකයා කතාකරන පේලියෙන් පේලිය පරිවර්තකයා විසින් අවශ අනෙක් භාෂාවට පරිවර්තනය කිරීමයි. මේ වැඩේදී වැරදී අහුවෙන්නේ ඒ ඒ පේලිය කතා කරනකොටයි. 

මේ වගේමයි Interpreters එකත් පවිච්චි කරල High level language එකකින් ලිව්ව program එකක් Machine code එකට හැරවීෙම්දී වෙන්නෙත්. ඇත්තටම compiler එකේ වගේ  විශේෂයෙන් Translate  කිරීමක් කරන්න අපිට සිද්ද වෙන්නේ නැහැ. අපි High level language එකකින් program එක ලියලා ඒක ක්‍රියාත්මක කරනවිට පේලියෙන් පේලියෙන් Interpreter එක මගින් Machine code එකට හැරවෙන්නේ.  ඊලඟට ඒ හැරවුනු පේලිය ක්‍රියාවට නැංවෙනවා. මෙතනදී යම් පේළියක වැරැද්දක් තියනවනම් ඒ පේලිය ආවම තමයි ඒක දැනගන්න පුළුවන් වෙන්නේ. 

කාලෙකට ඉස්සෙල්ලා භාවිතයේ තිබූ “GW BASIC” කියන Language  එක Interpreters  වලට හොද උදාහරණයක්.

Compiler & Interpreters 

Compiler  එකකින් Translate කරද්දි ඒ වැඩේ කරන්න ඕන එක පාරක් විතරක් හන්දා කලායින් පස්සේ අපට ඕන වාර ගණනක් Compile  කල program  එක ක්‍රියාත්මක කරන්න පුලුවන්. මේ නිසාම මේ  ක්‍රමය වඩා වේගවත් වෙනවා.  ඒත් Interpreter එකකින් කරද්දී අපි program එක ක්‍රියාත්මක කරන වාරයක් වාරයක් ගනෙන් Interpreter වෙන නිසා මේ විදිය ටිකක් කාලය ගත වෙනවා.  අද කලේ භාවිතා වෙන වඩා දියුනු නවීන languages වල  (Visual Basic, Java) මේ ලක්ෂණ දෙකම තියෙනවා.





මොකක්ද මේ CMD



CMD හෙවත් Command Prompt එක කියන්නේ වින්ඩෝස් මෙහෙයුම් පද්දතියේ එන ඉතා බලවත් උපකරණයක්. අද මම ඔයාලට කියලා දෙන්න යන්නේ Java ඉගෙනගන්න ඉස්සෙල්ලා දැනගන්න ඕනේ CMD කෝඩ් කීපයක් ගැන. මීට අමතරව CMD එක ගැන තොරතුරු විශාල ප්‍රමාණයක් මේ ලිපිය අන්තිමට දාලා තියන ලින්ක් වලට ගිහිල්ලා බලා ගන්න පුළුවන්.

ඔන්න අපි එහෙනම් මුලින්ම CMD එක open කරගන්න ඕනේ. එකට පහත පියවර අනුගමනය කරන්න.

  • Windows Key  එක සමග  R කරන්න. ඊට පහත ආකාරයේ box එකක් දිස්වෙයි. 


  •  එහි CMD යනුවෙන් type කර Enter කරන්න. ඉන්පසුව පහත ආකාරයට Command Promptඑක දර්ශනය වේවි.

 දැන් බලන්න CMD එකේ මොකක්ද සටහන් වෙලා තියෙන්නේ කියලා.

C:\Users\Userගේ නම

මෙනන් මේ විදිහට path එකක් සටහන් වෙලා ඇති. දැන් අපි පියවරෙන් පියවර path එක වෙනස් කරගන්න හැටි බලමු.

Path එක පියවරක් පස්සට ගමු.

මේ සදහා cd.. යනුවෙන් type කර Enter කරන්න. එවිට පහත ආකාරයට path එක පියවරක් පස්සට එවි.


Folder එක තුල ඇති දේවල් මොනවාදැයි බැලීම.

 මේ සදහා dir කියන command එක type කරලා Enter කරන්න පුළුවන්. එවිට path එකේ අවසානයට ඇති folder එක තුල ඇති files හා folder මොනවාද කියලා බලාගන්න පුළුවන්.



අලුත් folder එකක් තුලට ගමන් කිරීම.

දැන් අපි බලමු path එකක් ඉස්සරට ගන්න විදිහ. මේ සදහා කරන්න තියෙන්නේ cd<space>floder එකේ නම සටහන් කර Enter කරන්න. එවිට ඔබට dir භාවිතයෙන් ලබාගත් folder ඇතුලට ගමන් කරන්න පුළුවන්.


 File එකක් open කිරීම.

dir භාවිතයෙන් ලබාගත් file එකක් open කිරීම සදහා file එකේ නම එක්ස්ටෙන්ෂන් එකත් සමග type කර Enter කරන්න. එවිට අදාල file එක open කිරීම සිදුකල හැක.  උදාහරණයක් ලෙස sinhala යනුවෙන් MP3 audio file එකක් තිබේ යයි සිතන්න. එවිට sinhala.mp3 යනුවෙන් සටහන් කර Enter කල හැක.

පාටිෂන් එක වෙනස් කිරීම.

දැන් සිතන්න ඔබට ඔබගේ D පාටිෂන් එකට CMD එක යොමු කරන්න අවශ්‍යයි කියලා. එවිට සිදු කරන්න තියෙන්නේ D: යනුවෙන් සටහන් කර Enter කිරීමයි.



කලින් භාවිතා කල command එකක් නැවත භාවිතා කිරීම.

සමහර අවස්ථා වලදී අපට කලින් භාවිතා කරන ලද command එකක් නැවත නැවත භාවිතා කරන්නට සිදුවෙනවා. ( උදාහරණයක් ලෙස dir command එක) මේ අවස්ථා වලදී එය නැවත නැවත type නොකර Up හා Down Arrow key භාවිතයෙන් එය සිදු කරගැනීමේ හැකියාව තිබෙනවා. තවද මෙය අපි ඉදිරියේදී කතා කරන ජාවා වැඩසටහනක් Run කරන ක්‍රියාවලියට ඉතා වැදගත් වෙනවා. 

CMD එක පිරිසිදු කිරීම.

දැන් command වලින් CMD එක පිරිල නම් ඒවා ටික පිරිසිදු කරගන්න cls යනුවෙන් type කර enter කරන්න.


ජාවාවැඩසටහන් Run කරන්නCMD එක ගැන මේ දැනුම හොදටම ඇති. දැන් පොරොන්දු වුනු විදිහට CMD එකෙන් ගන්න පුළුවන් වෙනත් වැඩ ගැන ලින්ක් ටිකක් දාන්නම්.


cmd එකෙන් වැඩගන්න හැටි 
සොයාගත නොහැකි ලෙස Folders සඟවන ආකාරය.(software භාවිත නොකර) 
Format  කරන්න බැරි Pen Drives ලේසියෙන්ම Format කරමු 
Virus වලින් සැඟවුන Folders ගොඩගන්න හැටි
Windows password reset කරන හැටි
පිංතූරයක් අස්සෙ files හංගමුද?

මෙන්න මෙතන CMD එක ගැන පාඩම් මාලාවක්ම තියෙනවා.

#sameera tutorial 47- command pormpt එකේ ඉතිහාසය ගැන ඉගෙන ගමු 
#sameera tutorial 48-hacking පාඩම් මලාව command prompt part 2
#sameera tutorial 49-hacking පාඩම් මලාව command prompt part 3
#sameera tutorial 51-hacking පාඩම් මලාව command prompt part 4
#sameera tutorial 52-hacking පාඩම් මලාව command pormpt part 5
#sameera tutorial 53-hacking පාඩම් මලාව command prompt part 6
#sameera tutorial 55- hacking පාඩම් මලාව command prompt part 7
#sameera tutorial 56 -hacking පාඩම් මලාව command prompt part 8
#sameera tutorial 57-hacking පාඩම් මලාව command prompt part 9
#sameera tutorial 61-hacking පාඩම් මලාව command prompt part 10
#sameera tutorials 63-hacking පාඩම් මලාව command prompt part 11
#sameera tutorials 69-hacking පාඩම් මලාව command prompt part 12
#sameera tutorials 70-hacking පාඩම් මාලාව command prompt part 13

මීට අමතරම තව ගොඩක් දේවල් CMD එක භාවිතයෙන් කරන්න පුළුවන්. ඒ ගැන ඔයාලා ලියපු පොස්ට් එහෙම තියනවනම් මෙතන කමෙන්ට් එකක් විදිහට දාලා යන්න.