if else ගැන දැනගන්න පෙර දැනගතයුතු operators

11 වන පාඩම(if else ගැන දැනගන්න පෙර  දැනගතයුතු operators)

මෙන්න මේ operator ටික බලන්න.මේව පවිච්චි කරන විදිය ඉදිරියෙදි කියන්නම් if-else condition ගැන කියනකොට.

== මේකෙන්  කරන්නෙ වැලියු 2ක් සමානද කියල හොයනෙක.

!= මේකෙන්  කරන්නෙ වැලියු 2ක් අසමානද කියල හොයනෙක.

> මේකෙන්  කරන්නෙ වැලියු 2න් එකක් අනෙකට වඩා විශාලද  කියල හොයනෙක

>= මේකෙන්  කරන්නෙ වැලියු 2න් එකක් අනෙකට වඩා විශාල හෝ සමානද කියල හොයනෙක

< ,<= කියන විදියටත් යොදාගන්න පුලුවන්.

&& මේක උදව් වෙනව condition 2ක් හෝ වැඩිගානක් තියනකොට ඒ සියල්ල සත්‍යද බලන්න.

|| මේක උදව් වෙනව condition 2ක් හෝ වැඩිගානක් තියනකොට ඒ සියල්ලෙන් එකක් හෝ  වැඩිගානක් සත්‍යද  බලන්න.

| කියනෙකත් || වගෙ පෙනුනට මේක වෙනස් || වලින් .ඒ වගෙම & කියනෙකත් && වලින් වෙනස්.දැනට මෙහෙම එකක් තියනව කියල දැනගන්නකො.

ඒ වගෙම ! එකෙන් නැත යන අදහස දෙනව.

මේ ටික තමයි ජාවා වල ගොඩක් වැඩියෙන්ම පාවිච්චි  වෙන්නෙ condition check කරනකොට.

If-else, while loops,for loops කියනේවත් එක්ක මේ operators ගොඩක් සම්බන්දයි.

ඊලග පාඩම් වලදි  බලමු ඒ ගැන එකින් එක.

.

ඉන්පුට් ගන්න ක්‍රම (තෙවන කොටස)

10 වන පාඩම(input read from user)(තෙවන කොටස)

මෙන්න මේකටත් ඉන්පුට් දෙන්න ඕනි විදිය උත්සහ  කරල බලන්න.

String name=s.next();

            int i=s.nextInt();

            System.out.println("fname is: "+name);

            System.out.println("int : "+i);

Nalaka

123

කියල දෙන්නත් පුලුවන්. 

Nalaka 123

 කියල දෙන්නත් පුලුවන්.

Nalaka senarathna

123 

කියල දෙන්න බෑ. මොකද පලවෙනි line එකේ space එකෙන් පස්සෙ කොටස i  වලට assign වෙනව.

මේවත් උත්සහ කරල බලන්න.

double d=s.nextDouble();

double dd=s.nextInt();

double ddd=s.nextLong();

මේ විදියට ඉන්පුට් දෙනකොට දෙවන ,තෙවන අවස්තාවල int,long වල පරාසයේ අගයන් තමයි දෙන්න ඕනි.casting බැලුවනම් මේ විදියට long,int වලටත් ඉන්පුට් ගන්න හැටි අවබෝද වෙයි.

char c1=s.next().charAt(0);

මේ විදියට පුලුවන් character read කරන්න.

 දැන් arithmetic ඔපරේෂන් කරල බලන්න මේ දැනුමෙන්.

ස්ට්‍රින්ග් read කරනවිට වෙන වැරදි.

9 වන පාඩම(input read from user)(දෙවන කොටස)

දැන් වැදගත්ම කොටස.

ඔයාල කලින් lesson එකේ පලවෙනි ප්‍රෝග්‍රෑම් එකට මෙහෙම ඉන්පුට් දීල බලන්න.

nalaka

123

456.23

56

false

දැන් nalaka 123 456.23 56 false එක පෙලට ටයිප් කරල enter key ප්‍රෙස් කරන්න.

එකම අවුට්පුට් එක ලැබෙයි.මේක වැදගත් වෙන්නෙ ප්‍රෝග්‍රෑම් competition වලදි.ඒවගෙදි එයාල කියනව input එක දෙන විදිය.ඒ වගෙම output එක දෙන්න ඕනි විදියත් කියනව,ඒ වගෙ programe කරනකොට මේ ටික හොඳට

අවබෝධ කරගෙන තියනවනම් ලේසි වෙයි.

දැන් බලමු s.nextLine(); මෙතඩ් එක ගැන.

import java.util.Scanner;

public class ReadFromUser

 {

            public static void main(String[] args)

            {         

            Scanner s=new Scanner(System.in);

            //int j=s.nextInt();

            String fullname=s.nextLine();

            int i=s.nextInt();

           

            //System.out.println("int : "+j);

            System.out.println("full name is: "+fullname);

            System.out.println("int : "+i);

            }

}දැන් comment දාල තියෙද්දි මුලින්ම රන් කරන්න.

Input එක nalaka senarathna

23

එතකොට output එක මේක එයි.

full name is: nalaka senarathna

int : 23

දැන් comment අයින් කරල  රන් කරන්න.

Input එක ,

23

nalaka senarathna

එතකොට output එක මේක එයි.

Exception in thread "main" java.util.InputMismatchException

        at java.util.Scanner.throwFor(Unknown Source)

        at java.util.Scanner.next(Unknown Source)

        at java.util.Scanner.nextInt(Unknown Source)

        at java.util.Scanner.nextInt(Unknown Source)

        at ReadFromUser.main(ReadFromUser.java:9)

මෙතනදි මේ අව්ල වෙන්නෙ 23 දීල එන්ටර් කරන නිසා.එතනදි read කරන්න ඉල්ලන්නෙ int  අගයක්.

23

56

ඉන්පුට් එක දෙන්න  දැන් පෙනෙයි මොකක්ද වෙලා තියෙන්නෙ කියල.

int : 23

full name is:

int : 23

කියල ආවද.

දැන් මෙහෙම කරන්න

23 nalaka senarathna

56

පේනවද දැන් අනෙක් අගය දෙන්න පුලුවන් වෙනව .

දැන් output එක එයි

int : 23

full name is: nalaka senarathna

int : 56

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

                       int j=s.nextInt();

                       s.nextLine();

                       String fullname=s.nextLine();

                       int i=s.nextInt();

                       System.out.println("int : "+j);

                       System.out.println("full name is: "+fullname);

                       System.out.println("int : "+i);

දැන් මන් highlight කරල තියන ස්ටේට්මන්ට් එක යොදල ඉන්පුට් දෙන්න.මතක තියාගන්න මේ වෙනස කරන්නෙ එන්ටර් කර කර ඉන්පුට් දෙන්න  ඕනි වෙලාවට.

23

nalaka senarathna

56

මේකෙදි කලින් වගේ error මැසේජ්  එකක් පෙන්නන එකක් නෑ.මෙතනදි අපි පලවෙනි ඉන්පුට් එක දීල space තියල  පහත විදියට ඉන්පුට් දෙන්න.

23 456 jkl

nalaka senarathna

56

ඒකෙදිත්

23

nalaka senarathna

56

අවුට්පුට් එක එයි 456 jkl කියන කොටස discard වෙලා.දැන් තේරෙනවනේද හොඳට.

Enter කර කර ඉන්පුට් දෙනකොට මේ ගැන මතක තිබුනොත් වරදින්න තියන ඉඩකඩ  අඩුවෙයි.

මුලින්ම ඉන්ට්,ලෝන්ග් වගෙ අගයන් read කරල  String රීඩ් කරන්න යනකොට s.nextLine(); කියන මෙතඩ් එකෙන්  මේ ගැන අවදානය දෙන්න.

user ඉන්පුට් ගන්නකොට වරදින තැන්

8 වන පාඩම(input read from user)

Data ටයිප්ස් වල වැලියු user කෙනෙක්ගෙන් read කරන්න තමයි දැන් ලෑස්තිවෙන්නෙ.

ඊට කලින් data ටයිප් එකක් තියනව දැනගන්න.ඒ තමයි Boolean ගැන.මේව define කරන්නෙ මෙහෙම.

boolean b=true;

boolean c=false;

මේ බූලියන් ටයිප්  එකේ තියෙන්නෙ වැලියු 2යි.එක්කො true,නැත්නම් false.

හරි දැන් lesson එකට යමු.

මෙතනදි කරන්නෙ userගෙන් වැලියු read කරනෙක.මන්  කලින් කිව්ව වගේ මේකටත් package එකක් ඉම්පොර්ට් කරගන්න වෙනව.මෙතනදි අපිට Scanner ක්ලාස් එක ඕනි වෙනව.ඒක තියෙන්නෙ util package එකේ.

import java.util.Scanner; මේ විදියට තමයි ඉම්පෝර්ට් කරගන්නෙ.දැන් බලමු කෝඩ් එක.වැදගත්ම දෙයක් මෙතනදි මතක තියාගන්න.මුල්ම පාරට කෝඩ් එක රන් කරනකොට කමෙන්ට් දාල තියල රන් කරන්න.ඒ ඇයි කියල මන් කියන්නම්.

import java.util.Scanner;

public class ReadFromUser

 {

            public static void main(String[] args)

            {         

            Scanner s=new Scanner(System.in);

            String name=s.next();

            //String fullname=s.nextLine();

            long l=s.nextLong();

            float f=s.nextFloat();

            int i=s.nextInt();

            boolean b=s.nextBoolean();

           

            System.out.println("fname is: "+name);

            //System.out.println("full name is: "+fullname);

            System.out.println("long : "+l);

            System.out.println("float : "+f);

            System.out.println("int : "+i);

            System.out.println("bool : "+b);

            }

}

අපි Scanner එකක් හරහා තමයි අපිට ඕන  වැලියු read කරන්නෙ.මෙතනදි මන් ඒක highlight කරල තියනව.string,int,long,float,char,Boolean,double read කරන මෙතඩ් තියනව.

අපි මුලින්ම space,enter කරනේව discard වෙනව.එක අකුරක් හරි ටයිප් කරාට පස්සෙ space,enter කරනේව input එකට බලපානව.

මුලින්ම read කරන්නෙ String එකක්.එතනදි අපිට keybord එකේ ඕනම character ටිකක් දෙන්න පුලුවන්.ඊට පස්සෙ enter key ප්‍රෙස්  කරන්න.මෙතනදි වැදගත්ම දේ තමයි character එක පෙලට ටයිප් කරන්න අතරමැද space නොතිය. Space තියල type කරොත් space වෙනකන් තියන String කොටස විතරයි assign වෙන්නෙ name කියන වේරියබල් එකට.අනෙක් කොටස discard වෙනව ආපහු user ගෙන් read karanne නැත්නම්.මේ කෝඩ් එකේදි ඊලගට read කරන්නෙ long වැලියු එකක්නෙ.එතකොට space එකෙන් පස්සෙ තියන String කොටස assign වෙනව l කියන වේරියබල් එකට.එතකොට exception එකක් වෙනව.ඒ නිසා space නැතුව තනි String එකක් දෙන්න.  මේ මෙතඩ් එක වැඩ කරන්නෙ ඒ විදියට.

import java.util.Scanner;

public class ReadFromUser

 {

            public static void main(String[] args)

            {         

            Scanner s=new Scanner(System.in);

            String name=s.next();

            String fullname=s.nextLine();

           

            System.out.println("fname is: "+name);

            System.out.println("full name is: "+fullname);

            }

}

දැන්   nm fg fgffgf fgfg කියල ඉන්පුට් එක දීල බලන්න.name එකට nm කියන  ටික assign වෙනව.අනෙක් සේරම fullname කියනෙකට.මේ s.nextLine() කියන මෙතඩ් එකේදි.enter key ප්‍රෙස් කරනකන් තියන වැලියු ටික assign වෙනව. String fullname=s.nextLine();කියන ස්ටේට්මන්ට් එක විතරක් පාවිච්චි කරල තේරුම්ගන්න මේ මෙතඩ් එක ගැන.

දැන් ඊලගට තියෙන්නෙ long read කරන මෙතඩ් එක.ඉන්පුට් දෙනකොට මේ ටයිප් වල පරාසය ගැන මතක් කරගන්න.පරාසයට අදාල නොවෙන ඒව assign  කරොත් exception ei.තව පාඩම් දෙක තුනක් ඉදිරියේදි exception ගැන කතාකරමු.

ඊලගට float,ඉන්ට් තියනව.මේ දෙක long read කරන මෙතඩ් එක වගේමනෙ.තේරුම්ගන්න ලේසියි.

ඊලගට තියෙන්නෙ boolean.මේ පාඩම පටන්ගන්නකොට මන් කිව්ව වගෙ ඒ සදහ දෙන්න පුලුවන් අගයන්  විතරක් දෙන්න මතක තියාගන්න.එක්කො true කියල ටයිප් කරල එන්ටර් කරන්න.නැත්නම් false දෙන්න.

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

ඊලග part එකේදි දාල තියන කමෙන්ට් අයින් කරල රන් කරනකොට  වෙන  දේ ගැන කියන්නම්.

හත්වන පාඩම.(BigInteger,BigDecimal)

මන් කිව්වනේද අර ලොන්ග්,ඩබල් කියන ප්‍රිමිටිවෙ ටයිප් වල පරාසයක් ගැන.ඒ වගේම

දැන් තමයි ඒ පරසයෙන් එහා තියන වැලියු එක්ක ඔපෙරේෂන් කරන වෙලාව.

මුලින්ම අපි පොඩ්ඩක් package ගැන බලමු.

 අපි ජාවා වල තියන package පාවිච්චි කරාම  අපිට ඒවගෙන් ගොඩක් ලේසියෙන් ප්‍රෝග්‍රෑම් එක කරගන්න පුලුවන් වෙනව.මේ package කියන්නෙ ජාවා වල pre programed class වල එකතුවක්.ඒ කියන්නෙ අපි මුල ඉදලම හැම කෝඩ් එකක්ම ලියන්න ඕනි නෑ මේ හන්ද.ඒ package වල තියන classes call කරල ඒවගෙ තිඅයන pre defined මෙතඩ් පාවිච්චි කරල  අපේ වැඩ ලේසි කරගන්නව.ඉතින් තේරෙනව නේද ඒ package import  කරන්න තමයි දැන් යන්නෙ කියල.

ඔයලට ඕනි විදියට  package හදන විදියත් ඉදිරියේදි බලමු.

සමහර input  ,user කෙනෙක්ගෙන් read කරගන්න.ප්‍රින්ට් එකක් දෙන්න.හැමදේකටම වගෙ මේ package

ඕනි වෙනව.

System.out.println(); අයත් වෙන්නෙ lang package එකට.මේක අමුතුවෙන් import කරන්න අවශ්‍ය නෑ.මේ package එක නිකන්ම import වෙනව අපි class එකක් හදනකොට.අනෙක් සමහර ඒවනම් import කරන්න වෙනව.

අපි user ගෙන් input read කරනකොට util package එක බාවිත කරනව.ඉදිරියේදි package ගොඩක් import 

කරන programe හමුවෙනව.

ඇයිද දන්නවද අපිට ඕනි වෙනකොට විතරක් import කරන්නෙ.සේරම එකපාර claas එක හදනකොට import උනොත් වෙන්නෙ නිරපරාදෙ අපි processing power එක,memory use කරනෙක වෙනව.ඒක වලක්වන්න තමයි ඕනි package එක ඕනි උනාම import කරන්නෙ.

package import කරන්කොට අපි class නේම් එකට උඩින් import කරන package එකේ ස්ටේට්මන්ට් එක ලියන්නෙ.අපිට එකපාර package ගනනාවක් උනත් import කරන්න පුලුවන්.

දැන් අපි BigInteger class එකෛ BigDecimal class එකයි import කරගමු.

import java.math.BigInteger;

import java.math.BigDecimal;

public class BIgNumber

 {

          public static void main(String[] args) 

          {

          BigInteger b= new BigInteger("133");

          BigInteger c=new BigInteger("6");

          BigInteger d1=b.add(c);

          //BigInteger d11=b.add(new BigInteger("6"));

          BigInteger d2=b.subtract(c);

          BigInteger d3=b.multiply(c);

          //BigInteger d33=b.multiply(new BigInteger("6"));

          BigInteger d4=b.divide(c);

          BigInteger d5=b.remainder(c);

          System.out.println(d1);

          System.out.println(d2);

          System.out.println(d3);

          System.out.println(d4);

          System.out.println(d5);

         

          BigDecimal e= new BigDecimal("12.9");

          BigDecimal f=new BigDecimal("4.3");

          BigDecimal g=e.divide(f);

          System.out.println(g);

          System.out.println(e.divide(f));

         

          }

}

මෙතන පොඩි ගනන් use කරාට ඔයාල ලොකු නම්බර් දල බලන්න 45645645456465456465 වගෙ. 

මෙන්න මන් import කරගත්ත  විදිය  hightlight කරල තියෙන්නෙ.java math package එකේ BigInteger class එකයි ,BigDeimal class එකයි.

class  එක සේව් කරල රන් කරම එන output බලන්න.comment දාල තියන ඒවගෙ comment අයින් කරල ඔපරේෂ්න් කරල බලන්න.

BigInteger  හදුන්වනකොට  ඒව define කරන විදිය තේරුම්ගන්න. පේනවද  "" පාවිච්චි කරල කියල හරියට String වල වගේ.මෙතනදි අපි දෙන වැලියු එකේ String එකක් තමයි use කරන්නෙ.මොකද String වලදි දිග length  එකක් පාවිච්චි කරන්න පුලුවන් නිසා.

BigInteger   class එකෙ pre defined මෙතඩ් ටිකක් තමයි add,subtract,multiply,divide,remainder කියන මෙතඩ්.

දශම ඕනි නම් අපි Use කරන්නෙ BigDecimal.

මේ BigDecimal වලදි පොඩි අව්ලක් තියනව. 16  ය 4.5 බෙදුවම 3.55555555555555..

එනවනෙ.එතකොට සමාවර්ත වෙනවනෙ.මේ BigDecimal වලදි මේ විදියට devide මෙතඩ්  එක පාවිච්චි කරාම අවුට්පුට් එක දෙන්නෙ නෑ.මෙහෙම බෙදනකොට දශම ස්තාන කීයක් ඕනිද කියල දුන්නොත් හරිනෙ.

BigDecimal e= new BigDecimal("123");
BigDecimal f=new BigDecimal(33);

System.out.println(e.divide(f,4,BigDecimal.ROUND_UP));

මෙන්න ට්‍රයි කරල බලන්න.මෙතනදි දශම ස්තාන 4 කට තමයි අගය ගන්නෙ.එහෙම ගන්නකොට එතනින් එහ අගයන් ටික අයින් වෙනවනෙ.එතනදි අපි ඊලග දශම සංක්‍යාවට round කරනව කියල තමයි මෙතනදි කියන්නෙ.

System.out.println(e.divide(f,4,BigDecimal.ROUND_DOWN));

මෙහෙමත් කරන්න පුලුවන්.

මේ BigInteger වලයි BigDecimal වලයි තව මෙතඩ් ගොඩක් තියනව.දැනට මේ ටික බලන්න.

System.out.println(e.equals(f));

මේකෙන් බලන්නෙ ඒ නම්බර් දෙක සමනද කියල.සමනයි නම් true නැත්නම්  false ප්‍රින්ට් වෙනව.

ඉස්සරහට String වල මෙතඩ් කරාම ඒවගෙ තියන සමහර  මෙතඩ් පවිච්චි කරන්න පුලුවන් මේ නම්බර් එක්ක.

ඔපරේෂන් ගැන තවත් විස්තර

හයවන පාඩම.

ඔපරේෂන් වල වැදගත් වෙන casting ගැන පොඩ්ඩක් බලමු.

 byte >short>int>long>float>double


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

ඒ උනාට පොඩි බාජනේ පිරෙනකන් විතරක් පුරවන්න පුලුවන් නේද.


ටිකක්මේ  වගෙ තම ඔය උඩින් තියන ටයිප් වැඩ කරන්නෙත්.
මෙතනදි වමේ ඉදන් දකුනට යන අවස්තාව ගමු.

වමට යනකොට තියන අයට දකුනෙ අයගෙ වැලියු assign කරන්න දෙනව.ඒත් ඒකෙ අනික්පැත්ත බෑ එහෙම assign කරන්න.
එහෙම කරන්න නම් cast කරන්න වෙනව.
double a=45.6;
byte s=(byte) a;
System.out.println(s);


int c=(int)a;
 System.out.println(c);


මතක තියාගන්න cast කරනකොට cast කරාම එන අගය අපි assign කරන වේරියබල් එකේ පරාසයේ තියනවද කියල.

System.out.println(Byte.MAX_VALUE);
  System.out.println(Short.MAX_VALUE);

මෙහෙම තමයි byte,short වල  max අගයන් ගන්නෙ.

බලන්න පහල කෝඩ් එක.
public class Opration
 {
public static void main(String[] args)
{

 double num1=123;
 double num2=5;
 double ans1;
 double ans2;
 double ans3;
 double ans4;
 ans1=num1+num2;
 ans2=num1*num2;
 ans3=num1/num2;
 ans4=num1%num2;
  System.out.println(ans1);
  System.out.println(ans2);
  System.out.println(ans3);
  System.out.println(ans4);
}
}
බලන්න මේ අවුට්පුට්ද ආවෙ කියල.අන්තිම ඔපෙරේෂන් එකේදි වෙන්නෙ බෙදුවම ඉතිරි අගය ගන්න එක.(remainder).
128.0
615.0
24.6
3.0

මේ වගෙ අනෙක් ටයිප් වලටත් ට්‍රයි කරල බලන්න.ඒවගෙ පරාසය අතුලෙ තියන, ඒ වගෙම ඒ ටයිප් එකට assign කරන්න පුලුවන් වැලියු එන විදියට ඔපෙරේෂන් කරන්න.එතනදි casting වැදගත් වෙයි.

ඔපරේෂන්

පස්වන පාඩම

// මේ  බැක් ස්ලෑශ් දෙකෙන් ජාවා වල කමෙන්ට් දාන්න පාවිච්චි කරනව.මේව රන් වෙනකොට මෙතන තියන //එව්වගෙ අවුට්පුට් පෙන්නන්නෙ   නෑ.


/*
මෙහෙම තමයි මල්ටිලයින්  දාන්න පාවිච්චි කරන විදිය.

*/


දැන් බලමු කොහොමද මේ int, long  වගේ ප්‍රිමිටිව්  ටයිප් එක්ක වැඩ කරන්නෙ කියල.

public class Opration
 {
public static void main(String[] args)
{
//single comment

/*
multiline
comment
*/

String fname="amal";
String lname="silva";
String full=fname+lname;
System.out.println("full name is: "+full);

int d=12;
int q=5;
int r1=d+q;
System.out.println("result is: "+r1);


 long l1=5;
 long l2=55;
 long r2=l1*l2;
 System.out.println("result is: "+r2);

 long r3=d-q;

 System.out.println("result is: "+r3);

 float n1=5623.12f;
 float n2=55623.45f;
 System.out.println("n2/n1 : "+n2/n1);
}
}
මගෙ ෆයිල් නේම් එක Operation.java
දැන් කම්පයිල් කරන්න.
javac Operation.java
දැන් රන් කරන්න.
java Operation

full name is: amalsilva
result is: 17
result is: 275
result is: 7
n2/n1 : 9.891919

මේව තමයි අවුට්පුට්.
 බලන්මෙන කොල පාටින්ත හයිලයිට්න කරපු තැන. ඉන්ට්  පාවිච්චි කරාට අව්ලක් නෑ assign වෙන්නෙ long එකකට නිසා.
int r4=l1+l2; මේක වැරදි.

මෙවගෙ අවුට්පුට් එකක් ගන්න ඕනිනම් cast කරන්න වෙනව මෙහෙම.
int r4=(int)(l1+l2); long එහෙමත් මෙහෙම cast කරන්න පුලුවන්.


float assign කරනකොට අගට f දාන්න ඕනි.

මේවත් ට්‍රයි කරල s3 අවුට්පුට් එක බලන්න.
String s1="my name\n is \t";
 String s2="nalaka";
 String s3=s1+s2;
 int age=23;
 s3=s3+"age is "+age;



String n="";
n=n+23;

n=23;

සිව්වන පාඩම 


වේරියබල්   ගැන තවදුරටත්.
අපි ස්ට්‍රින්ග් හදුන්වන කොට අනිවාර්යෙන්ම "" පාවිච්චි කරන්න ඕනි.

String firstOne="my name";
String second="my name";
මේ වගෙ වැලියු එකක් තව ස්ට්‍රින්ග් එකකට asign කරගන්නකොට මේ විදියට කරන්න.
String firstOne="my name";
String second=firstOne;
මෙතනදි දෙඅවන වේරියබල් එකට "my name" කියන වැලියු එක asign  වෙනව.
මුල් වේරියබල් එකට කිසිම බලපෑමක් නෑ මෙතනදි.


අපිට වේරියබල් දෙකක  වැලියු දෙකක් swap කරගන්නකොට මේ දැනුම වදගත් වෙනව.
හිතමු මෙහෙම.
String firstOne="my name";
String second="your name";
මේ වේරියන්බල් වල වැලියු මාරුකරනවනම් මෙහෙම කරන්න පුලුවන්.
String temp=firstOne;
firstOne=second;
second=temp;

ඔයාල මේ  ස්ටේට්මන්ට් මෛන් මෙතඩ් එකෙ ටයිප් කරල කම්පයිල් කරල රන් කරල බලන්න.
int ,double,long වගෙ අනෙක් ඒවත් මේ විදියට ස්වැප් කරන්න පුලුවන්.


ඉන්ටීජර් හදුන්වනකොට ඒවගෙ දශම සංක්‍යා එන වැලියු asign   නොවන විදියට වග බලගන්න.
ex:
int n=81/9.0;
int d=81/9;
int d=47/9;

මෙතනදි පලවන ස්ටේට්මන්ට් එක වැරදි.දෙවන විදිය හරි.තුන්වන විදියට අනුව  උත්තරෙ එන්නෙ 5.එතනදි වෙන්නෙ 45 බෙදපුවම assign වෙන්නෙ remainder එක ගත්තම එන අගය අඩු වෙලා.මේකට ජාවා වල casting වෙනව කියල කියනව.
මේ වගෙ පුන්චි වැරදි නොදැනුවත්වම වෙන බව මතක තියාගන්න.
long උනත් මේ වගෙ තමයි.

char හදුන්වනකොට ' ' තමයි පාවිච්චි වෙන්නෙ." " යෙදුවොත් වැරදි.


මේ සේරමත් එක්ක ගත්තම මේවගෙන් int,double,long ,float char කියන ඒව primitive types කියල  කියනව.reference type තමයි අනෙක් වර්ගය.ඒව ඉදිරියේදි බලමු.


දැන් int,double,long ,float කියන ඒවගෙ පරාසයක් තියනව කිව්වනෙ.ඒ පරාසයෙන් එහා වැලියු ඕනි උනොත් මොනාද කරන්නෙ කියල හිතෙනව ඇති.

ඒකට අපි පාවිච්චි කරන්නෙ
BigInteger සහ BigDecimal.ඒව අපි ඉදිරියෙදි කතාකරමු ඒව කොහොමද යොදාගන්නෙ කියල.

වේරියබල්

තෙවන පාඩම:කොහොමද variable එක්ක වැඩ කරන්නෙ.

අපි දන් බලමු මේ වේරියබල් ගැන.
String
char
int 
double
long
float

බලන්න පහලින් තියන ස්ටේට්මන්ට්.අකුරු වරද්දන්නැතුව මන් ටයිප් කරල තියන එව්වම ටයිප් කරන්න.
String name="aruna sanatha  ";
char cname='v';
int num=3256;
long num2=456123;
double num3=456.35;
float num4=456789.4562f;

මේව තමයි වැඩිපුර බාවිත වෙන ඒව.
මුලින්ම වේරියබල් ටයිප් එක .ඊලගට වේරියාබල් නේම් එක.
ඊලගට අපි ඒ වේරියබල් එකට  assign කරනව කියල තමයි = සයින් එකෙන් කියන්නෙ.
ඊලගට  assign කරන වැලියු එක.

ඉහත විදියට වගේම තව ක්‍රම දෙකක් තියනව වේරියබල් assign කරන.
1.
String name;
name="aruna sanatha";

char cname;
cname='v';

int num;
num=3256;

long num2;
num2=456123;

double num3;
num3=456.35;

float num4;
num4=456789.4562f;

2.

String name=new String("aruna sanatha  ");
int c=new Integer(2);
char cname=new Character('v');
long g=new Long(2);

මේ විදියට අනෙක්වත් ට්‍රයි කරන්න.

එකම නමින් වේරියබල් assign කරන්නෙපා.

ප්‍රින්ට් එකක් ගන්න පුලුවන් මේ විදියට.

System.out.println(num);

System.out.println(num2);

වදගත්ම දේ තමයි highlight කරල තියන ඒවගෙ පරාසය.
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
System.out.println(Float.MAX_VALUE);
System.out.println(Float.MIN_VALUE);

මේ ස්ටේට්මන්ට් වලින් බලාගන්න පුලවන් Integer,Float වල පරාසය.
public class PrintNum
 {
public static void main(String[] args)
{

System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
int c=123;

System.out.println(c);

}
}

මේක තමයි අවුට්පුට් එක.
2147483647
-2147483648
123

ජාවා කෝඩින් අරබමු

දෙවන පාඩම 

මුලින්ම බලමු කොහොමද ජාවා ෆයිල් එක සේව් කරගන්නෙ කියල.

මෙන්න සාම්පල් කෝඩ්  එක.

public class SayHello

 {

public static void main(String[] args) 

{

System.out.println("Hello");

}

}

මන් කොල පාටින් සිලෙක්ට් කරල තියන නමින්ම තමයි ජාවා ෆයිල් එක සේව් කරල තියෙන්නෙ.

ඒ කියන්නෙ SayHello.java තමයි ෆයිල් නේම් එක.පොඩ්ඩක් බලමුද මේ කෝඩ් එකේ තේරුම.

මෙතන .java කියන්නෙ ෆයිල් එක්ස්ටෙන්ශන් එක.ජාවා සේව් කරනකොට මේ විදියට සේව් කරන්න මතක තියාගන්න.

public-මෙකෙන් කියන්නෙ මේ ක්ලාස් එකට ඕනම ක්ලාස් එකක් මගින් ඇක්සස් වෙන්න පුලුවන් කියල.

main method එක තියන ක්ලාස් එක අනිවාර්යෙන් පබ්ලික් වෙන්න ඕනි.

class කියල කිව්වම ඊලගට ක්ලාස් නේම් එකක් තියෙන්න ඕනි.

ක්ලාස් නේම් එක අපිට කැමති නමක් යොදගන්න පුලුවන්.ඒත් ඒ නම 1-9 සහ ස්පෙශල් චැරැක්ටර් එකක් වෙන්න බෑ.

ඒත් _ සයින් එකෙන් නම පටන්ගන්න පුලුවන් කියලත් මතක තියාගන්න.

ඊලඟට තියෙන්නෙ  { සයින් එක.මේ විදියට ඕපන් කරාම අවසානයේ ක්ලෝස් කරන්නත් ඕන } මේ විදියට.

ඊලගට තියෙන්නෙ main method එක.කෙටියෙන් කිව්වොත් ඒ මෙතඩ් එකත් පබ්ලික් වෙන්න ඕනි.

ඒ වගේම static කියන්නේ අපිට ක්ලාස් එකේ ඉන්ස්ටන්ස් එකක් නැතුව මේක ඇතුලේ කෝඩ් එක රන් කරන්න පුලුවන් .මේකෙන් කිසිම වැලියු එකක් රිටන් කරන්නෙ නෑ( void).අපි මෙකෙදි ස්ට්‍රින්ග් ආර්ගියුමෙන්ට්ස් තමයි පාර්ස් කරන්නෙ.((String[] args) ). 

දැන් බලමු මොකක්ද මේ System.out.println("Hello");

මේක ජාවා ස්ටේට්මන්ට් එකක්.ස්ටේට්මන්ට් එකක් අවසන වෙන්නෙ සෙමි කෝලොන් එකෙන්.

මේ System.out.println(); කියන එකෙන් වෙන්නෙ ප්‍රින්ට් එකක් දෙන එක.ඇතුලෙ මොකුත්ම නැතුව ප්‍රින්ට් කරොත් ලයින් එකක් පහලට යනව.

System.out.print(); 

කියල කෝඩ් කරල බැලුවොත් පෙනෙයි ස්පේස් එකක් එහාට  යනව.

 System.out.print("Hello");

මේක මේන් මෙතඩ් එක ඇතුලෙ තියන කෝඩ්  එකට සමාන අවුට්පුට් එකක් දුන්නට වෙන්නෙ පොඩ්ඩක් වෙනස් විදියට.

" " පාවිච්චි කරල තියෙන්නෙ ස්ට්‍රින්ග් ප්‍රින්ට් කරන හන්ද.

මේව බලන්න අපි මෙ ප්‍රෝග්‍රෑම් එක රන් කරන විදිය බලමු.

 මුලින්ම notpad++ එකේ  මුලින් කිව්ව විදියට මෙ ප්‍රොග්‍රෑම් එක සේව් karanna.

දන් ස්ක්‍රීන් ශොට් එකෙ විදියට කොමාන්ඩ් ප්‍රොම්ට් එක ඔපන් කරන්න.

මුලින්ම 

javac SayHello.java

මෙහෙම ටයිප් කරල එන්ටර් කරාම එරර් එකක් ආවොත් කෝඩ් එකේ අව්ලක් වෙලා ඇති.අව්ලක් නැතිව කම්පයිල් කරගන්න හරියට සාම්පල් කෝඩ් එක බලල ට්‍රයි කරන්න.මෙතනදි වෙන්නෙ අපෙ ෆයිල් නේම් එකට අදාලව ක්ලාස් ෆයිල් එක හැදෙන එක. 

දැන් 

java SayHello කියල ටයිප් කරල එන්ට කී ප්‍රෙස් කරන්න.

දැන් පේනවද

Hello  කියල අවුට්පුට් එක ආව.

මෙතනදි වෙන්නෙ අපෙ ක්ලාස් ෆයිල් එක රන් වෙන එක.

main method  ඇතුලෙ පහල ස්ටේට්මන්ට් ට්‍රයි කරල බලන්න.

        public class SayHello
 {
public static void main(String[] args)
{
System.out.println("Hello "+" world");
System.out.println("1 "+" 2");
System.out.println(12);
System.out.println(1+2);
System.out.println(""+1+2);
System.out.println(1+2+"");
System.out.println(1+2*5);
System.out.println(12/5);
System.out.println(12/5.0);

System.out.print("hello ");
System.out.print("world ");

System.out.println("hello");
System.out.println("world");

}
}

හැම වෙලවෙම සේව් කරල තමයි කම්පයිල් කරන්න ඕනි.නැත්නම් එරර් පෙන්නයි.

බලන්න මේ විදියට අවුට්පුට් ආවද කියල.

Hello  world
1  2
12
3
12
3
11
2
2.4
hello world hello
world

මේ ස්ටේට්මන්ට් වෙනස් කර කර අවුට්පුට් එක්ක සසඳල බලන්න.මොකක්ද
System.out.print();
System.out.println(); කියන ස්ටේට්මන්ට් වල වෙනස තේරෙයි.

වැඩිදුරටත්
System.out.println("my name \n nalaka");
System.out.println("my name \n\n nalaka");
System.out.println('a')
System.out.println("my name \t nalaka");;

පලමු පාඩම 

මුලින්ම කල යුත්තේ ජාවා  ඉන්ස්ටෝල් කර ගැනීම.මේ ලින්ක් එකෙන් ඩ්වුන්ලෝඩ් කරගෙන ඉන්ස්ටෝල් කරගන්න.www.oracle.com

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

මෙම පාඩම් මාලාවේ මම පාවිච්චි කරන්නෙ නෝට්පෑඩ් ++ .Jdk එක ඉන්ස්ටෝල් කරගන නෝට්පෑඩ්++ එකත් ඩවුන්ලෝඩ් කරගන ඉන්ස්ටෝල් කරගන්න.
https://www.google.lk/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8&ved=0ahUKEwj-zImw_JjNAhWIOo8KHbW4A20QFggbMAA&url=https%3A%2F%2Fnotepad-plus-plus.org%2Fdownload%2F&usg=AFQjCNFCBJqyIc2YisTG74LS2eSZnUZ2Og&sig2=2p_a-LT7iupGlLI21lCEwQ



ඊලඟට ජාවා පාත් එක සෙට් කරන්න තියෙන්නෙ.
ඒකට my computer රයිට් ක්ලික් කරල properties   යන්න.ඒකෙ තියන
advance system setting යන්න.ඒකෙ තියන
environment variable යන්න.ඒකෙ තියන තොරතුරු වලට හානි නොවෙන විදියට අවසානයෙ සෙමි කෝලොන් එකක් දාලා ;  ජාවා බින්   එකේ පාත් එක දෙන්න.
පාත් එක හොයාගන්න ජාවා ඉන්ස්ටෝල් කරපු ෆෝල්ඩර් එක බලන්න.

ජාවා ඉන්ස්ටෝල් වෙලාද කියල දැනගන්න කමාන්ඩ් ප්‍රොම්ප්ට් එක ඔපන් කරල  javac කියල ටයිප් කරාම ලිස්ට් එකක් එයි.එහෙම එන්නෙ නැත්නම් ජාව ඉන්ස්ටෝල් කරනකොට මොකක් හරි අවුලක් වෙලා නම් අපහු ට්‍රයි කරල හරි ගියේ නැතොත් කියන්න.