Java Data Type

welcome Boys and Girls, මහින්ද මහත්තයගෙන් අවසරයි Voldemort in pisu kannah version 😂😂 ආවා ආවා අදත් ආවා එදත් සිංහයා අදත් සිංහයා Voldemort ඔයාලව හොයාගෙන, හොයගෙන හොයාගෙන 😂😍

අන්තිමට දාපු Post එකේදි අපි කතා කරලා ඉවර කලේ Java Variables ගැනනේ.අද අපි කතා කරන්න යන්නේ, Data Type ගැන. කලින් Post එකේ කතා කරපු Java Variables කියල කියන්නේ විශේශිකරණය කරපු වූ Data Type ඒම නැත්නම් Java වල තියන Pre-Defined data Type වලට. මතකයි නෙහ් ඒ ටික 😁, 

Variable වල ප්‍රදාන Data Type දෙකටම අයිති වෙන කොටස් තියෙයි, අපි බලමුකො ඉස්සරහට ප්‍රදාන Data Type දෙක මොනාද කියලා.

Data type ප්‍රාධාන වර්ග දෙකකට බෙදෙනවා,

1. Primitive Data Type

සිංහලෙන් කියනව නම් ප්‍රාතමික දත්ත වර්ග. එහෙම කිව්වට තේරෙන්නේ නෑනේ, නෙහ් ? ප්‍රදාන වශයෙන් Single Characters හා Numeric තමයි Primitive Data Type එකට එන්නේ.

Primitive Data Type එකට එන්නේ, Byte(-128 සිට 127  දක්වා පූර්ණ සංඛ්‍යා), Shorts(-32,728 සිට 32,727 දක්වා පූර්ණ සංඛ්‍යා ගබඩා කරනවා), integer(in t- 2,147,483,648 සිට 2,147,483,647 සංඛ්‍යා), Long(-9,223,372,036,854,775,008 සිට 9,223,372,036,854,775,007 සංඛ්‍යා), float(දශම 6-7 ත් අතර අංක), double(දශම 15 ක් වෙනකම් Digits), Boolean (True/ False, Value ) and characters (Single Characters/ Letters හෝ ASCII Values)

2. Non-Primitive Data Types

ප්‍රාතමිකව නොවන දත්ත වර්ග, මේකට එන්නේ Strings, Arrays and Classes (මේකේ Strings කියන්නේ Text ක්ප්ටස් වලට කියලා ඔයාලා දන්නවනේ, Arrays හා Classes කියන්නෙ Java කරගෙන යද්දී ඉස්සරහට හම්බ වෙන ලොකුම ලොකු ලෙසන්ස් දෙකක්, අපි ලෙසටම පැහැදිලි කරගමු එදාට මේ දෙක ගැන) 

Primitive Data types

Primitive Data Types වල Specify කරන්නේ size එක හා Variable Value එකේ Type එක, ඒ ඒ Type හා ඒ ඒ Size අනුව තමා Data Type වලට නම වැටිලා තියෙන්නේ. ඒ වගේම මේක Display කරන්න වෙන Additional Methods නෑ. 

Data Type	Size	Description
byte	1 byte	Stores whole numbers from -128 to 127
short	2 bytes	Stores whole numbers from -32,768 to 32,767
int	4 bytes	Stores whole numbers from -2,147,483,648 to 2,147,483,647
long	8 bytes	Stores whole numbers from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
float	4 bytes	Stores fractional numbers. Sufficient for storing 6 to 7 decimal digits
double	8 bytes	Stores fractional numbers. Sufficient for storing 15 decimal digits
boolean	1 bit	Stores true or false values
char	2 bytes	Stores a single character/letter or ASCII values

Byte Data Type

Short data type

int data type

මේ විදියටම දිගටම ඔයාට Check කරගෙන යන්න පුලුවන්, ඒ වගේම මේ Range එකේ නොවන Number එකක් දැම්මම Program එක Compile නොවෙන හැටිත් ඔයාට බලාගන්න පුලුවන්

Java Numbers

Primitive numbers කොටස් දෙකකට බෙදනවා.

Integer Types

මේ Type එක Store කරන්නේ දශම නොවන ධන හෝ සෘණ පූර්ණ සංඛ්‍යා, එතකොට මේ කොටසට අයිති වෙන ඒවා වෙන්නේ Bytes, Shorts, int සහා Longs. ඔයාලට උඩ වගුව දැක්කම පැහැදිලි වෙනවා ඇති ඒ ඒ අදාල Range එකේ Values වලට අපිට Int ම විතරක් නෙවී Byte, Shorts ඒමත් Use කරන්න පුළුවන්, අපි Normally Use කරන Range එකේ 99% ක්ම Int වල Range එකේ තියන නිසා int කියලා අපි ඔක්කොටෝම Use කරනවා.

Floating Point Types 

Fractional Parts හා Decimal Numbers Store කරන්න තමා මේ Variable Type එක Use කරන්නේ, Floating Numbers වර්ග දෙකයි. එකක් Float, අනික Double. මෙතනදි කියන්න තියෙන්නෙත් උඩ කියපු දේම තමා. අපි Decimal හැම Value එකකටම අපි Double Use කලාට Float කියලත් Use කරන්න පුලුවන් අදාල Range එකට වෙනකන්. අපි Use කරන Range එක ඇතුලට කෝකටත් තයිලේ කියලා Double කියන එක හැම Range එකටම Suitable නිසා අපි හැම එකටම ඒක දානවා Float නොදා.

එතකොට උඩ පත හෑල්ලේ Summary එක තමා, කොච්චර Numeric Types තිබ්බත් අපි Numbers  වලට int use කරනවා, Decimals වලට Double Use කරනවා. ඒක ඒම උනාට උඩ ටිකත් Memory ට දාගන්න හීන් සැරේ. 

උඩ පැහැදිලි කරපු හැම Data Type එකකම Syntax එක එන්නේ Variable වල Syntax එක ආපු විදියටමයි. Display කරන්න Use කරන්නෙත් println method එකමයි, කලින්ම කිව්වනේ වෙන්ස Methods නෑ කියලා. 

මෙහෙම දෙයක් තියෙයි. මෙතනදී Decimal Point එකෙන් පස්සෙ තියන Numbers වලින් Indicate වෙන්නේ ඒ Decimal Number එකේ නිරවද්‍යතාවය, මං මේ කියන්න උත්සහා කරන දේ ඔයාලට තේරෙනව නේද, 0.1 කියනවට වඩා 0.10 කියන එක අමතර එජක දශ්මස්තානයකට නිවැරදී, (7 වසර ගණිතය) මං මේ කියන්න උත්සහා කරන්නෙ මේකයි, Floating Numbers කියන්නේ උපරිමේ Decimal points 8 කට යන දශම කියල උඩ වගුවේත් ඊට උඩ චේදෙත් මම වෙන වෙනම Mention කලා, ඒ වගේම Double කියන්නේ දශමස්තාන 16 ක් දක්වා යන දශම සංඛ්‍යා කියලත් කිව්වා, දැන් ඔයාලට තේරෙන්න ඕන මම කියන එක,

Index1= 0.1

Float index1=0.10000000

Double index1=0.1000000000000000

දැන් තේරෙනවනේ කෝකද නිරවද්‍යතාව (අපි Java වලදී Precision කියල කියනවා) වැඩිම කියල. ඒක නිසා අනික් Numeric වගේ නෙවී Decimals වලදී Double Use කරන එක Safe වැඩී.

Java Boolean data type 

මේ Boolean data type එකේ Key Word  එක Boolean, ඒ වගේම Store කරගන්න පුලුවන් Value වෙන්නේ True හෝ False විතරයි.

Boolean Values හුගක්ම අපි Use කරන්නේ,  Condition Testing වලට, ඒ කියන්නේ නැගෙනහිරින් ඉර පායයි කිව්වොත් ඒක True, අන්න ඒ වගේ සීන් වලට. මේ Condition Testing හා java එකිනෙකට Use වෙන විදිය බලමුකෝ අපි ඉස්සරහට. 

Characters

Characters(char) Data Type එක අපි Use අපි Use කරන්නේ Single Characters Store කරන්න. (‘A’ , ‘B’ වගේ) මේ Characters හැම වෙලේකම Code වලදී අපි Use කරන්නේSingle Quote(‘’) ඇතුලේ.

ඒ වගේම ඔයාට ASCII Value මතක නම් ඒවා Display කරන්නත් char Use කරන්න පුලුවන්.

String Data Type

String කියන Data Type එක නැත්නම් Use කරන්නේ Character කිහිපයක් එහෙම නැත්නම් Text එකක් Store කරන්න. Code කරද්දී String Value එකක් අපි Double Quote ඇතුලේ තමයි Use කරන්නේ.

Non-Primitive Data Type

Non-Primitive Data type නැත්නම් Reference Type කියලත් මේවට කියනවා. ඒකට හේතුව non-primitive data කියන්නේ objects කියලා අපි කියනවා. මේ Objects (මේ objects කියන කතාව පස්සට පැහැදිලි කරන්නම්, Java Objects කියන්නේ තනි Chapter එකක් )

Differences Non-Primitive and Primitive Data Types 

Primitive Types හැම එකක්ම Java වල කලින්ම Define කරලා තියෙයි( මතකනේ Primitive Data Type 8) ඒත් Non-Primitive data Types එකේ String හැරුනම වෙන එකක් වත් Java වල Define කරලා නෑ. ඒව අදාල වෙලේට Define කරලා අලුතෙන්ම හදාගන්නේ. 

Non-primitive type වලට තමන්ට උවමනා Operation එකක් කරගන්න Method Call කරන්න පුලුවන්(මේක ඉස්සරහට බලමු, දැනට නිකං මතක තියාගන්න). නමුත් Non Primitive වල Data Operations ටික කතා කරනවා, ඒ කතා කරන ටික ඇරුනම වෙන ඒව නෑ Non Primitive වලට.

Primitive Data වල Variable එකක් Null ව Define වෙන්නෑ කොයිම වෙලේක වත්, එයාට හැම වෙලේම Value එකක් එක්ක අපි Define කරන්නේ. ඒත් Non-primitive Data variables අපිට Null ව Define කරන්න පුලුවන්.

Primitive Data Type එකක Variable Name එක හැම වෙලේම Lower Case එකකින් Start වෙන්නේ, Non-primitive වලදී Variable Name එක Upper case එකකින් පටන් ගන්න ඕන(මේ දේවල් සම්මතයන්, මේව මේම නොකලාය කියලා ප්‍රෝගෑම් එක Run නොවී තියෙන්නෑ, හැබැයි ඔයාට Interview හෝ Exam එකකදී මේ විදියට නැතුව වැඩ කලොත් Program එක Run උනා කියලා නෑ. ලැබෙන්නේ ලකුණු විදියට Big Zero 🥴). 

Primitive data Type එකක Size එක Depend වෙන්නේ Data type එක මත(Byte (1 Byte),Short (2 byte),Int (4 byte),Long(byte 8),float(byte 4),double(byte 8),Boolean(1 bit),char(2 byte)). නමුත් Non primitive Types ඔක්කොම එකම Size. 

හරි, ඔන්න data Type ත් ඉවරයි, ඊලග දවසේ අපි කතා කරනවා වගේම කතා කරලා ඉවර කරනවා මේ වගේම ලොකු lesson එකක්, ඒ තමයි Java Operators.

අදට එහෙනම් මෙච්චරයි. Bye මගේ කොල්ලනේ කෙල්ලනේ 😁😽