Monday, June 7, 2021

Java Programming sinhala tutorial - Garbage Collection - Part 31

Garbage Collection

    JVM එක මගින් java class run කරන විට, එම class වලට අදාළ object JVM එක තුල නිර්මාණය වේ. මෙලෙස JVM එක තුල සියලු objects නිර්මාණය වන විට, එහි ඉඩ මදි වුවහොත්, JVM එක terminate වීම හෝ garbage collector  එක මගින් application එකෙහි භාවිතා නොකරන ( reference නොමැති ) objects delete කරයි. Daemon thread යනු background එකෙහි run වන low priority thread එකක් වන අතර garbage collector එක daemon thread එකකට හොද නිදසුනක් වේ.


   ඉහත උදාහරණයේදී for loop එක run වන විට object 10000 ක් නිර්මාණය වුවද එම object reference නැවත භාවිතා නොකරන නිසා JVM එකෙහි memory space මදි වූ විට garbage collector පවතින objects delete කර අලුතෙන් object නිර්මාණය කිරීමට space ලබා දේ. 


    ඉහත උදාහරණයේදී for loop එක run වන විට නිර්මාණය වන සෑම object එකකම reference, object array එක තුල ගබඩා කර ගන්නා නිසා එම object garbage collector ට delete කල නොහැක. එම නිසා OutOfMemoryError  එකක් ලැබේ.

    Garbage collector එකෙන් reference නොමැති object delete කිරීමට මොහොතකට පෙර finalize() method එක run කරයි. එය Object class එකේ පවතින method එකකි.


    object එකක් නිර්මාණය වන විට constructor එක run වන අතර delete වීමට මොහොතකට පෙර finalize() method එක runවේ.

System.gc() method හා Runtime.getRuntime().gc() method එක මගින් අපිට පුළුවන් garbage collector හට run වීම සදහා request කරන්න. මෙම methods මගින් garbage collector අනිවාර්යෙන්ම run කරන බව guarantee කල නොහැක.


    සාමාන්‍යයෙන්, විදි 4 ක් අනුව object එකක් garbage collector හට eligible විය හැක.

1. Reference variable එක null කිරීම.


2. Object reference එකට වෙනත් object එකක් reassign කිරීම.



3. Local scope එකක් ( method / block එකක් ) තුල object එක නිර්මාණය කිරීම.



4. Inland of isolation මගින්. - object අතර link තබා ගනිමින් object පද්ධතියක් නිර්මාණය කර එම පද්ධතියට අදාලව එක reference variable එකක් පමණක් තිබෙන අවස්ථාවක එම reference variable එක null කිරීම.


අපි ඊලග ලිපියෙන් Java ගැන තවත් විස්තර ඉගෙන ගනිමු.

- චමෝදි -

Thursday, May 13, 2021

Java Programming sinhala tutorial - Interface - Part 30

 Interface

    අද අපි interface කියන්නේ මොකද්ද කියලා බලමු. Class එකක වගේම, interface එකකත් variables හා methods අපිට නිර්මාණය කරන්න පුළුවන්. නමුත් interface එකක තිබෙන methods, abstract methods වෙනවා (method signature එක පමණයි , body එකක් නැ ). 
    Interface එකකින් class එක මගින් කුමක්ද විය යුත්තේ කියලා දක්වන අතර කොහොමද කරන්නේ කියලා නොදක්වයි. 


  • Interface එකක් declare කරන්න "Interface" keyword එක පාවිච්චි කරනවා.
  • Interface එකක methods implicitly public හා abstract වේ.
  • Interface එකක variables implicitly public, static  හා final වේ.
  • Interface එකක් implement කිරීම සදහා "implement"  keyword එක පාවිච්චි කරනවා.
  • Interface හි declare කර ඇති සියලු methods එම interface එක implement කල class එකෙහි override කල යුතු වේ. එම methods public කල යුතු වේ.
  • Interface හි declare කර ඇති සියලු methods එම interface එක implement කල class එකෙහි override නොකරයි නම් එම class එක abstract විය යුතු වේ.

  • Interface type එකෙන් reference නිර්මාණය කල හැකි අතර object නිර්මාණය කල නොහැක. Interface එකට super class එකක් ලෙස ක්‍රියා කල හැකි අතර interface type reference එකට sub  class refer කල හැක.

  • Class එකකට වෙනත් class එකක් පමණක් extends කල හැකි අතර interface කිහිපයක් implements කල හැක.

  •  Interface එකකට වෙනත් interface එකක් හෝ කිහිපයක් extends කල හැක.

  • Interface සදහා constructor නිර්මාණය කල නොහැක.
  • JDK 8 මගින් default method හා static method නිර්මාණය කිරීමට හැකියාව ලබා දී ඇත. Default method මගින් interface එක තුල body එකක් සහිත method නිර්මාණය කිරීමට ඉඩ ලබා දෙයි.

  • JDK 9 මගින් private method, static method හා  private static method නිර්මාණය කිරීමට හැකියාව ලබා දී ඇත. 
  • Interface total abstraction, multiple inheritance හා loose coupling සදහා උපකාරී වේ.

අපි ඊලග ලිපියෙන් Java ගැන තවත් විස්තර ඉගෙන ගනිමු.

- චමෝදි -

Sunday, April 11, 2021

Java Programming sinhala tutorial - Polymorphism - Part 29

Polymorphism

     Polymorphism යනු OOP concept වල පවතින වැදගත් ලක්ෂණයක්. එය අපිට ඉඩ දෙනවා යම් ක්‍රියාවක් වෙනස් ආකාරයන්ගෙන් සිදු කිරීමට. වෙනත් විදියකට කිව්වොත්, අපිට පුළුවන් එක interface එකක් define කරලා වෙනස් implementation සිදු කිරීමට. "poly" වචනයේ තේරුම විවිධ වන අතර "morphs" යනු ආකාරයන් වේ. ඒ නිසා එහි තේරුම විවිධ ආකාරයන් වේ.

    යම් පුද්ගලයෙක් එක විට පියෙක්, පුතෙක්, සේවකයෙක් වීම සාමාන්‍ය ජිවිතයේ මෙම concept එකට උදාහරණයක් විදියට කියන්න පුළුවන්.

    Polymorphism ආකාර 2 කට බෙදන්න පුළුවන්.
  1. Compile Time Polymorphism 
  2. Run Time Polymorphism  

Compile Time Polymorphism

    Static polymorphism ලෙසද මෙය හදුන්වනවා. Compile time polymorphism අපිට method overloading හා operator overloading මගින් සිදු කරන්න පුළුවන්. නමුත් operator overloading සදහා Java support නොකරන නිසා method overloading පමණක් භාවිතා කරයි.

    මෙහිදී එකම නමින් methods  නිර්මාණය කරන අතර ඒවායේ parameter list එක වෙනස් වේ.


Method Overloading 
  • Method overloading හිදී එකම නමින් methods  නිර්මාණය කරන අතර ඒවායේ parameter list එක වෙනස් කරනු ලබයි.
  • මෙහිදී return type එක මගින් පමණක් method overload කල නොහැකි අතර parameter list එක වෙනස් කරන අතර return type එක වෙනස් කරන්න පුළුවන්.
public int mA(int x) { return 100; }
public char mA(int x, int y) { return 'x'; }
  • අපිට static method ද  overload කල හැක. මෙහිදී ද static keyword එක මගින් පමණක් method overload කල නොහැකි අතර parameter list එක වෙනස් කල යුතු වේ.
public static int mA(int x) { return 100; }
public static char mA(int x, int y) { return 'x'; }

 

Run Time Polymorphism  

    Dynamic Method Dispatch ලෙසද මෙය හදුන්වන්න පුළුවන්. මෙහිදී overriding method එකට run time එකේදී call කරයි. Method overriding මගින් run time polymorphism ලබා ගනි. 

    මෙහිදී parent/ base  class එකෙහි  method, child/ derived class එහෙහිදී එම method name එකම, එම parameter list එකම සහිතව හා එහි access කල ආකාරයටම නිර්මාණය කිරීම method overriding වේ. මෙහිදී parent/ base  class එකෙහි  method එක hide වී child/ derived class එහෙහි method එක run වේ.


Method Overriding
  • Method overriding යනු parent/ base  class එකෙහි  method, child/ derived class එහෙහිදී එම method name එකම හා එම parameter list එකම සහිතව නිර්මාණය කිරීමය. 
  • මෙහිදී parent/ base  class එකෙහි  method එක hide වී child/ derived class එහෙහි method එක run වේ.
  • Overriding method එකෙහි access modifier, base class එකෙහි method එකෙහි access modifier එකට සමාන හෝ ඊට වඩා වැඩි විය යුතුය.
class Parent {
    protected void mA() {
        System.out.println("parent");
    }
}

class Child extends Parent {
    @Override
    public void mA() {
        System.out.println("child");
    }
}
  • private, final හා static method override කල නොහැක.
  • Overriding method එකෙහි return type එක සමාන හෝ derived type එක විය යුතුයි.
class Parent {
    Parent p;
    
    Parent mA() {
        return p;
    }
    
    int mB() {
        return 5;
    }
}

class Child extends Parent {
    Child c;
    
    @Override
    Child mA() {
        return c;
    }
    
    @Override
    int mB() {
        return 10;
    }
}
  • super keyword එක මගින් base class method එක call කල හැක.
class Parent {  
    void mB() {        
        System.out.println("Parent");
    }
}

class Child extends Parent {
    void mB() { 
        super.mB();
        System.out.println("Child");
    }
}
  • Super-class overridden method එක exception එකක් throw කර නොමැති නම් subclass overriding method එකෙහිදී uncheck exception පමණක් throw කල හැක.
class Parent {  
    void mB() {        
        System.out.println("Parent");
    }
}

class Child extends Parent {
    void mB() throws ArithmeticException{ 
        System.out.println("Child");
    }
}
  • Super-class overridden method එක exception එකක් throw කර ඇත්නම් subclass overriding method එකෙහිදී එම exception එක හෝ එහි sub exception එකක්  throw කල හැක. ඒ වගේම subclass overriding method එකෙහිදී කිසිම exception එකක් throw නොකිරීමද කල හැක.
class Parent {  
    void mB() throws RuntimeException{        
        System.out.println("Parent");
    }
}

class Child1 extends Parent {
    void mB() throws RuntimeException{ 
        System.out.println("Child1");
    }
}

class Child2 extends Parent {
    void mB() throws ArithmeticException{ 
        System.out.println("Child2");
    }
}

class Child3 extends Parent {
    void mB() { 
        System.out.println("Child3");
    }
}

අපි ඊලග ලිපියෙන් Java ගැන තවත් විස්තර ඉගෙන ගනිමු.

- චමෝදි -

Wednesday, February 17, 2021

Java Programming sinhala tutorial - Abstraction - Part 28

 Abstraction

    OOP concept එකක් වන abstraction මගින් user ට අවශ්‍ය details පමණක් පෙන්නුම් කරන අතර අනවශ්‍ය details hide කරයි. උදාහරණයක් විදියට අපි සලකා බලමු පුද්ගලයෙක් car එකක් driving කිරීම. Car එකෙහි speed එක වැඩි කිරීමට accelerator එක press කල යුතු බව එම පුද්ගලයා දන්නා නමුත් මෙහිදී car එක ඇතුලත සිදු වන process එක එම පුද්ගලයා  දන්නේ නැ.
    Abstraction concept එක අපිට interfaces හා abstract classes මගින් implement කරන්න පුළුවන්.

Abstract Classes & Abstract Methods 

    Abstract classes java hierarchy එකක top level එකේ implementation කල නොහැකි නමුත් methods declare කල යුතු අවස්ථා වලදී භාවිතා කරයි. එනම් fully implementation methods නිර්මාණය කල නොහැකි class මෙලෙස හදුන්වයි. (Abstract නොවන classes අපි concrete classes ලෙස හදුන්වයි)  මෙහිදී පහත කරුණු ගැන සැලකිලිමත් විය යුතුයි.
  • Abstract classes, abstract keyword එක මගින් declare කල යුතුයි.
  • Abstract class එකක method implement කල නොහැකි නම් method abstract කල යුතුය.
  • Abstract method සදහා body එකක් පැවතිය නොහැක.
  • Abstract class වල  abstract method හා  abstract නොවන method තිබිය හැක.
abstract class Vehicle{
      abstract void parkVehicle();
      public void startVehicle(){
            //Implementation
      }
}
  • Abstract class extends කර අලුත් class එකක් නිර්මාණය කල විට  abstract method සියල්ලම implement කල යුතුයි. නොමැති නම් abstract method ලෙසම නිර්මාණය කර subclass එක abstract class එකක් කල යුතුය.
abstract class Vehicle{
      abstract void parkVehicle();
      abstract void startVehicle();
      void stopVehicle(){
            //
      }
}
 
class Van extends Vehicle{
      void parkVehicle(){
            //Implementation
      }
      void startVehicle(){
            //Implementation 
      }
}
abstract class MB extends Vehicle{
 
}
  • Abstract class මගින් object නිර්මාණය කල නොහැක.
abstract class Vehicle{
      abstract void parkVehicle();
}
 
class Demo{
      public static void main(String args[]){
            Vehicle v;
            v = new Vehicle(); // Illegal
      }
}
  • Abstract class එකක abstract methods සියල්ල subclass එකකදී implement කල පසු එම sub class එක මගින් object නිර්මාණය කල හැක. මෙහිදී abstract class type එකෙන් reference variable එක නිර්මාණය කල හැකි අතර sub class එකකදී implement කල methods call වේ.
abstract class Vehicle{
      abstract void parkVehicle();
}
class Car extends Vehicle{
      void parkVehicle(){
            System.out.println("Car parking..");
      }
}
class Demo{
      public static void main(String args[]){
            Vehicle v;
            v = new Car();
            v.parkVehicle();
      }
}
  • Abstract class තුල variable නිර්මාණය කල හැකි අතර abstract variable නිර්මාණය කල නොහැක.
  • Abstract class තුල constructor නිර්මාණය කල හැකි අතර ඒවා abstract නොකළ යුතුයි.
abstract class Vehicle{
      int speed;
      Vehicle(){ // Constructor
            //
      }
      abstract void park();
}
  • Abstract method, static හෝ private හෝ final කල නොහැක.
  • Class hierarchy එකේ abstract class top level එකෙහි මෙන්ම middle level එකෙහි පැවතිය හැක.
Java Interface අපි ඉදිරි ලිපියකින් ඉගෙනගමු.
අපි ඊලග ලිපියෙන් Java Polymorphism ගැන විස්තර ඉගෙන ගනිමු.

- චමෝදි -


Friday, February 12, 2021

Java Programming sinhala tutorial - Encapsulation - Part 27

 Encapsulation

       අද අපි encapsulation ගැන ඉගෙන ගමු. Inheritance වාගේම encapsulation කියන්නෙත් OOP concept එකක්. Data තනි unit එකක් ලෙස සකස් කිරීම encapsulation ලෙස හදුන්වන්න පුළුවන්. මෙය ආරක්ෂක ආවරණයක් වගේ, එම ආවරණයෙන් පිටතින් data access කිරීම වළක්වනවා. උදාහරණයක් විදියට බෙහෙත් කරලක (capsule) ඇතුලත සංකීර්ණ සංයෝග සගවා තිබීම සලකන්න පුළුවන්. 

    Encapsulation හිදී data පමනක් hide කරන අතර ඒ සදහා attributes private කරනු ලබයි. මෙහිදී වෙනත් class එකකට මෙම attributes  access කිරීමට public method නිර්මාණය කල යුතු වේ. ඒවා setters හා getters වේ.



    Encapsulation මගින් ලැබෙන වාසි ලෙස data hide කිරීම, flexibility හා reusability එක වැඩි වීම, unit testing කිරීමට පහසු වීම දක්වන්න පුළුවන්.

අපි ඊලග ලිපියෙන් Java Abstraction ගැන විස්තර ඉගෙන ගනිමු.

- චමෝදි -

Friday, January 29, 2021

Java Programming sinhala tutorial - Inheritance - Part 26

 Inheritance

    Java වල OOP concept 4 ක් පවතිනවා. ඒ තමයි,
  1. Inheritance
  2. Encapsulation
  3. Polymorphism
  4. Abstraction
    අද අපි inheritance ගැන දැන ගමු. යම් කිසි කෙනෙකු විසින් නිර්මාණය කල class එකක features (fields and methods) වෙනත් නිර්මාණයක් සදහා භාවිතා කිරීම inheritance යනුවෙන් සරලවම අපිට හදුනා ගන්න පුළුවන්. මේ සදහා extends keyword එක පාවිච්චි කරන්න පුළුවන්.
    කලින් නිර්මාණය කර තිබු හා එහි features inherit කිරීමට ඉඩ දෙන class එක super class (base class/ parent class) එක ලෙසද  එම  features inherit කරගෙන අලුතින් නිර්මාණය කරන class එක sub class (derived class/ extended class/ child class) එක ලෙසද හදුන්වයි.
    Inheritance සංකල්පය reusability සදහා උපකාරී වේ.


    අපි sub class එකට super class එක extend කල විට super class එකෙහි සියලුම private නොකළ methods හා  variables sub class object එකේ memory එකට ලබා ගන්නවා. ඒ නිසා sub class එක මගින් super class එකේ features අපිට ලබා ගන්න පුළුවන්. Sub class reference එකට super class එක ගැන knowledge එකක් පවතින නිසා sub class reference එක මගින් super class එකේ methods හා  variables access කරන්න පුළුවන්.

    මේ inheritance ක්‍රියාවලියේදී subclass object එක පමණයි create වෙන්නේ. Inheritance ක්‍රියාවලියේදී super class එකේ byte code එක sub class file එකෙහි නොපවතී. Sub class එක හා super class එක අතර logical link එකක් පමණක් පවතී. Sub class object එකක් නිර්මාණයේදී පළමුව super class එක template object එකක් ලෙස load වේ. ඊට පසු sub class එක  template object එකක් ලෙස load වේ. ඊට පසු sub class object එක නිර්මාණයවේ. එම නිසා sub class එකක් වෙනත් computer එකක run කරවීමට super class එකද එම computer එකට ඇතුලත් කල යුතු වේ.
    
    

    Sub class එක නිර්මාණයේදී super class එකෙහි methods හා variables ද sub class object එකේ නිර්මාණය වන බව ඔයාලා දැන් දන්නවනේ. කලින් ලිපියෙන් මං object  initializer ගැන විස්තර කලානේ. object  initializer variables initialize කිරීමේදී පළමුව super class එකෙහි variables ද ඉන් පසු sub class එකෙහි variables ද initialize කරයි. Sub class එක run වන විට super class එකෙහි කුමන constructor එක run විය යුතු දැයි ඇතුලත් කර නොමැති නම් compiler විසින් sub class එකේ constructor එක තුල super(); command එක ඇතුලත් කරයි. එවිට object initializer පළමුව super class එකෙහි default constructor එක run කර ඊට පසු sub class එකෙහි constructor එක run කරයි.
    අපට super class එකෙහි parameter සහිත වෙනත් constructor එක run කළ යුතු නම් ඊට අදාල  parameter සහිත super command එක ඇතුලත් කළ යුතු වේ.



    අපි ඊලග ලිපියෙන් Java Encapsulation ගැන විස්තර ඉගෙන ගනිමු.

- චමෝදි -

Friday, January 15, 2021

Java Programming sinhala tutorial - Class & Object - Part 25

Class & Object (Part 2)

    කලින් ලිපියෙන් අපි class හා object ගැන මුලික කරුණු දැන ගත්තනේ. අද අපි ඒ ගැන වැඩිපුර විස්තර ටිකක් දැනගමු.

Memory Representation of an Object

    අපි යම් source code එකක් execute කරන විට, hard disk එකේ පවතින වෙනත් object එකක් (ex :- Box object ) නිර්මාණය කිරීමට අවශ්‍ය යැයි command එක run වුවහොත්, පළමුව එම object එකේ .class file එක RAM එක තුල allocate වේ. ඉන් පසු RAM එකෙහි heap එක තුල object එක allocate වේ.



"this" keyword

    "this" යනු keyword එකක් හා predefine variable එකකි. එය තුල current variable එකෙහි address එක store වී ඇත. Method එකක් ක්‍රියා කරන විට  object එකේ හා variable stack එකේ එකම නමින් variable පවතී නම් ඒවා වෙන් කර හදුනාගන්න මෙමගින් පුළුවන්.


    මෙහිදී "this" keyword එක භාවිතා කිරීම නිසා variable stack එකෙහි ඇති variable නොසලකා object එකෙහි ඇති variable භාවිතා කර ඇත.

Default Value

    Object එකක් නිර්මාණය කරද්දීම එහි attributes initialize වේ. එලෙස object එකෙහි attributes සදහා store වන්නේ එම attribute එකෙහි data type එකට අදාල default value එක වේ.


Default Values :-

  • byte - 0
  • short - 0
  • int -  0
  • long - 0
  • float - 0.0
  • double - 0.0
  • char - null char
  • boolean - false
  • Reference Type, class type - null

Declaration Value

    Object එකෙහි attribute/ variable නිර්මාණය කරන විටම ඒවා initialize කල හැක. එවිට එම value, declaration value නම් වේ.


Constructor

    Object එකක් නිර්මාණය කරද්දීම යම් දෙයක් සිදු විය යුතු නම් එය එම class file එක තුල constructor එකක් තුල නිර්මාණය කල හැක. JVM එක මගින් automatically, object එකක් නිර්මාණය කරන විටම constructor එක execute කරයි. ඒ සදහා method call කල යුතු නොවේ. constructor එකෙහි නම class name එකට සමාන වන අතර එයට return type එකක් නොමැත. constructor එක ආරම්භයේදී return type එකක්/ void යෙදුවහොත් මෙය normal method එකක් බවට පත් වේ. constructor එකකට call කර ක්‍රියා කල නොහැකි අතර JVM එකට පමණක් මෙය ක්‍රියාකරවිය හැක.


Parameterized Constructor vs Default Constructor

    Constructor එකෙහි parameters නොමැති නම් ඒවා default constructor නම් වන අතර constructor එකෙහි parameters පවතී නම් ඒවා parameterized constructor නම් වේ. Parameterized constructor ක්‍රියා කරවීමට object එක නිර්මාණයේදී arguments ලබා දිය යුතු වේ.
    Object එකක් නිර්මාණයේදී constructor එකක් අත්‍යවශ්‍ය වේ. Constructor එකක් class file එකේ නොමැති නම් JVM එක default constructor එකක් නිර්මාණය කරයි. 


Constructor Overloading

    Constructor එකකට වඩා වැඩි ප්‍රමාණයක් class file එකෙහි නිර්මාණය කර ඇති විට, object එක නිර්මාණයේදී දෙනු ලබන arguments අනුව constructor  එක call වේ.

class Box {
    int length;
    int width;
    int height;

    Box() {
        length = 1;
        width = 1;
        height = 1;
    }

    Box(int l, int w, int h) {
        length = l;
        width = w;
        height = h;
    }

    Box(int l) {
        length = l;
        width = l;
        height = l;
    }

    void setSize(int l, int w, int h) {
        length = l;
        width = w;
        height = h;
    }

    void printVolume() {
        int volume;
        volume = length * width * height;
        System.out.println("Volume of the box is : " + volume);
    }

    void printArea() {
        int area;
        area = 2 * length * width + 2 * length * height + 2 * width * height;
        System.out.println("Area   of the box is : " + area);
    }
}

class Demo {
    public static void main(String args[]) {
        Box b1 = new Box();
        b1.printVolume();

        Box b2 = new Box(12);
        b2.printVolume();

        Box b3 = new Box(12, 5, 3);
        b3.printVolume();
    }
}

Output :- 

Volume of the box is : 1
Volume of the box is : 1728
Volume of the box is : 180 

Calling Constructor using "this(xxx)"

    Constructor එකකින් එම class file එකේම වෙනත් constructor එකකට call කිරීම සදහා this(xxx); ලෙස command කරයි ( මෙහි xxx යනු parameter වේ. ). එනම් constructor එකකට වෙනත් constructor එකක් reuse කිරීමට මෙමගින් හැකි වේ.



Static Variable/ Class Variable/ Template Variable

    Object එකේ variable/ attribute එකක් static නම් එම variable එක template එකෙහි නිර්මාණය වේ. Static variable සදහා value assign කල විට එම value object එකෙහි store නොවන අතර එම value template එකෙහි store වේ. එම නිසා සැම object එකකටම පොදුවේ එම static variable එක භාවිතා වේ.


    Static variable template එකෙහි නිර්මාණය වන නිසා object එක නිර්මාණය නොකර ද main method එක මගින් static variable ලබාගත හැක. එවිට එම static variable, class name එක මගින් identify කර ගත හැක.


Static Method/ Class Method/ Template Method

    Static variable මෙන්ම static method ද  template එකෙහි නිර්මාණය වන අතර object එක නිර්මාණය නොකර ද main method එක මගින් static method call කල හැක. එවිට එම static method, class name එක මගින් identify කර ගත හැක.


Static Block

    Static block class file එකෙහි ලිවිය හැකි code block එකකි. Java class එක hard disk සිට RAM එකට load වන හැම විටකදීම automatically මෙය run වේ.


Instance Block

    Static block හි ක්‍රියාකාරිත්වයට සමාන ක්‍රියාවක් instance block මගින් සිදු කරයි. එනම් object එකක් නිර්මාණය කරන සැම අවස්ථාවකදීම instance block එක automatically run වේ.


Template Object, Static Initializer & Object Initializer

    Java class file එකක් hard disk එකේ සිට RAM එකේ JVM එක වෙත class loader software එක මගින් ගෙන එනු ලබයි. ඉන් පසු Class file එක මගින් නිර්මාණය කරන object එක තුල එය store වේ. Main method එහි එකක් පවතී නම් එය object එක තුලම වෙනත් තැනක store වේ. මෙම object එක template object එක ලෙස හදුන්වයි. 
    Main method එක run වන විට වෙනත් java class එකක් අවශ්‍ය නම් එය පළමු java class file එක පැවති folder එකෙහි හෝ JVM tool kit එකෙහි පවතී දැයි බලයි. මෙලෙස RAM එක වෙත එනු ලබන java class, Class file එක මගින් නිර්මාණය කරන object  තුල store වේ.


Static Initializer :-
Template object එක නිර්මාණයේදී static variable, template එකෙහි store වේ. මෙම variable එහි data type එකට අදාල default value එකෙන් පළමුව initialize වේ. Declaration value හෝ static block එක මගින් එම static variable declare කර ඇත්නම් variable එමගින් initialize වේ.

Object Initializer :-
මෙමගින් object එකෙහි attributes initialize කරනු ලබයි. Object නිර්මාණය වන විටම attributes ඒවායේ data type එකට අදාල default value එකෙන් initialize වේ. Declaration value හෝ instance block හෝ constructor එක මගින් එම attributes declare කර ඇත්නම් attributes එමගින් initialize වේ.

Declaration value හා  instance block පවතී නම් ඒවා constructor එක තුලට ඇතුළු කරගෙන object එක run වේ.



    අපි ඊලග ලිපියෙන් Java OOP concept ගැන විස්තර ඉගෙන ගනිමු.

- චමෝදි -
Subscribe to: Posts (Atom)