នៅក្នុងមេរៀននេះយើងសិក្សាលំអិតចំនួន ៥ចំណុចគឺ static & final keyword, static inner class, member inner class និង anonymous inner class។
static & final keyword
static keyword
static យើងប្រើជាមួយ variable, method, block និង inner class
យើងប្រើ static keyword ដើម្បីបញ្ជាក់ថា variable, method, block និង inner class វាជាកម្មសិទ្ធរបស់ class មិនមែនកម្មសិទ្ធរបស់ instance (object) ណាមួយទេ ហើយ static បង្កើតមកប្រើជារួម។ ជាធម្មតាយើងបង្កើត class សំរាប់ធ្វើពុម្ភបង្កើត object ហើយ variable, method... វាជាកម្មសិទ្ធទៅតាម object នីមួយៗដែលយើងបានបង្កើតចេញពី class។
public class Bank {
int id;
String brance;
float rate;
}
public class Main {
public static void main(String[] args) {
Bank bank1 = new Bank();
bank1.id =1;
bank1.brance = "Phnom Penh";
bank1.rate = 10.1f;
Bank bank2 = new Bank();
bank2.id = 2;
bank2.brance = "Kep";
bank2.rate = 12.0f;
}
}
កូដខាងលើនេះយើងឃើញហើយថា class Bank មាន field មួយគឺ float rate យើងអាចប្រើទៅតាម object នីមួយៗគឺ bank1 និង bank2។
public class Bank {
int id;
String brance;
static float rate;
}
public class Main {
public static void main(String[] args) {
Bank bank1 = new Bank();
bank1.id =1;
bank1.brance = "Phnom Penh";
Bank.rate = 10.1f;
Bank bank2 = new Bank();
bank2.id = 2;
bank2.brance = "Kep";
Bank.rate = 12.0f;
}
}
យើងដាក់ field rate នៃ class Bank ជា static យើងមិនអាចហៅតាមរយ object មកប្រើបានទេគឺ ហៅតាមរយ class។
static variable
static variable គឺជា variable ដែលជាកម្មសិទ្ធរបស់ class មិនមែនរបស់ object ណាមួយឡើយ។ ហើយលក្ខណសម្បត្តិរបស់វា សុី memory តែម្តង។
public class Bank {
static float rate;
}
public class Main {
public static void main(String[] args) {
Bank.rate = 10.1f;
}
}
static method
វាដូចទៅនឹង static variable ដែរប៉ុន្តែ យើងយកពាក្យ static ដាក់នៅមុខ method វិញ។ ហើយក្នុងការហៅវាមកប្រើតាមរយ ឈ្មោះ class ហើយ doc(.) ឈ្មោះ method។
static method មានសិទ្ធអាច access ទៅហៅ static data member មកប្រើបាន ប៉ុន្តែមិនអាចហៅ data member មកប្រើដោយផ្ទាលបានទេ ទាល់តែយើងបង្កើតជា object ទើបយើងហៅមកប្រើបាន។
public class Bank {
int id;
String brance;
static float rate;
static void findInterested(float deposit) {
float interested = deposit * rate /100.0f;
System.out.println(interested);
}
}
method នេះយើងអាចហៅបានតែ static data member តែប៉ុណ្នោះ ប្រសិនជាយើងចង់ហៅ data member ធម្មតាប្រើគឺត្រូវបង្កើត object។
public class Bank {
int id;
String brance;
static float rate;
static void findInterested(float deposit) {
float interested = deposit * rate /100.0f;
String myBranch = new Bank().brance;
myBranch = "Kampot";
System.out.println("Branc: "+myBranch+"\t"+interested);
}
}
public class Main {
public static void main(String[] args) {
Bank.rate = 12.0f;
Bank.findInterested(10000f);
}
}
Static block
Static block គឺជា block មួយដើរមុន main method ទៅទៀត។ ជាធម្មតា កម្មវិធីដើរមុនគេ public static void main(String[] args) {} នៅពេល run program ប៉ុន្តែប្រសិនជាយើងដាក់ static block នោះវានឹងដើរមុន main method ទៅទៀត។
យើងប្រើវាដើម្បី initialize ទៅឲ្យ static data member
syntaxstatic{
----
}
ឧទាហរណ៍
public class Bank {
int id;
String brance;
static float rate;
//static block
static{
rate = 25.0f;
}
static void findInterested(float deposit) {
float interested = deposit * rate /100.0f;
String myBranch = new Bank().brance;
myBranch = "Kampot";
System.out.println("Branc: "+myBranch+"\t"+interested);
}
}
public class Main {
public static void main(String[] args) {
Bank.findInterested(10000f);
System.out.println("Rate :"+Bank.rate);
}
}
Final keyword
Final keyword ប្រើជាមួយ variable, method និង class
Final variable
Final variable គឺជាកំណត់តំលៃថេ ដែលមិនកែប្រែបាន ហើយនៅពេលយើងប្រកាស់វាហើយ វាទាមទាឲ្យយើងឲ្យតំលៃទៅវាឲ្យហើយ។ ក្នុងការដាក់ឈ្មោះ variable គឹត្រូវតែប្រើអក្សរធំទាំងអស់
class Myclass{
// final variable
final int MY_VALUE = 100;
void showInfo() {
System.out.println(MY_VALUE);
}
}
public class FinalDemo {
public static void main(String[] args) {
Myclass myclass = new Myclass();
myclass.showInfo();
}
}
Final method
Final method គឺជា super class ដែលមិនឲ្យ sub class override បានទេ ប៉ុន្តែអាចហៅយកមកប្រើបាន។
class SuperClass{
final void info() {
System.out.println("This is Super class");
}
}
class SubClass extends SuperClass{
// Can't override method superClass
}
ខាងក្រោមនេះរបៀបហៅ final method មកប្រើ ដោយប្រើ keyword super
class SuperClass{
final void info() {
System.out.println("This is Super class");
}
}
class SubClass extends SuperClass{
// Can't override method superClass
//this call final method to use
void ShowInfo() {
super.info();
}
}
public class FinalMethod {
public static void main(String[] args) {
SubClass sub = new SubClass();
sub.ShowInfo();
}
}
Final class
Final class គេប្រើវាដើម្បីកុំឲ្យគេ inheritance បាន
public final class SuperClass{
void info() {
System.out.println("This is Super class");
}
}
Inner Class / Nested Class
Inner Class ឬ Nested Class គឺសំដៅទៅលើ class ទាំងឡាយដែលយើងបង្កើតនៅក្នុង class មួយផ្សេងៗ។
Inner class បង្កើតឡើងមកដើម្បី បំបែក class ដ៏ធំទៅជា class តូចៗងាយស្រួលក្នុងការ maintenmain និង បង្កើន encapsulation
Inner Class ឬ Nested Class មានបួនគឺ៖
- Static inner class
- Member inner class
- Local inner class
- Anonymous inner class
Static inner class
ដើម្បីកំណត់ static inner class បានយើងគ្រាន់តែប្រើជាមួយ keyword static ហើយវាមាន access modifier ធម្មតា។
static inner class មានសិទ្ធ access ទៅយក static data member របស់ class ខាងក្រៅបានរួមបញ្ចូលទាំង private។
static inner class ពុំមានសិទ្ធ access non-static data member ឬក៏ method របស់ outer class (class ធំ) របស់វា។
public class Outer{
private static int id = 1;
private static String name = "Ros Dul";
private static String birth = "22-02-1991";
//static inner class
static class Inner{
public String info() {
return "Id:"+id+"\tName:"+name+"\tBirth:"+birth;
}
}
public static void main(String[] args) {
Outer.Inner inner = new Outer.Inner();
String myInner = inner.info();
System.out.println(myInner);
}
}
Member inner class
Member inner class វាស្រដៀងទៅនឹង static inner class ដែរ ប៉ុន្តែលក្ខណរបស់វាអត់ប្រើ keyword static។ វាគឺជា member ធម្មតារបស់ class មួយនឹង។
syntaxpublic class OuterClass{
//member inner class
class InnerClass{
//Statement
}
}
public class OuterClass {
private String str = "Wello study java";
class Inner{
void print() {
System.out.println(str);
}
}
public static void main(String[] args) {
OuterClass outer = new OuterClass();
OuterClass.Inner inner = outer.new Inner();
inner.print();
}
}
Note: member inner class វាពិបាកក្នុងការបង្កើត object មន្ទិចដោយសារវាមិនជា កម្មសិទ្ធរបស់ outer class វាជាកម្មសិទ្ធរបស់ object នីមួយៗ។
OuterClass outer = new OuterClass(); OuterClass.Inner inner = outer.new Inner();
Local inner class
Local inner class គឺជា class មួយដែលបង្កើតនៅក្នុង method ហើយវាមិនត្រូវដាក់ជា static ទេ។
យើងត្រូវតែបង្កើត object
public class LocalInner {
private String msg = "Hello World";
void showMessage() {
class Local{
void message() {
System.out.println(msg);
}
}
//create object local class
Local local = new Local();
local.message();
}
public static void main(String[] args) {
LocalInner localInner = new LocalInner();
localInner.showMessage();
}
}
Anonymous Inner Class
Anonymous Inner Class គឺជា class ដែលប្រកាសដែលគ្មានឈ្មោះ
វានៅពេល ប្រកាស(declareed) និង បង្កើត object (instantiated) នៅពេលតែមួយ
យើងត្រូវ implement ពី interface ឬ extends ពី class ប៉ុន្តែវាមិនត្រូវការ implement និង extends ទេ។
Anonymous Inner Class វាអត់មាន Constructor ទេ។
field, method និង class របស់វាមិនអាចប្រើជាមួយ static បានទេ។
គេបង្កើត anonymous class ឡើងមកដើម្បីជំនួសប្រើ keyword extends និង implement។
ខាងក្រោមនេះគឺជា abstract class ធម្មតាabstract class Msg{
abstract void smg();
}
public class AnonymousClass extends Msg {
@Override
void smg() {
// TODO Auto-generated method stub
System.out.println("Hello World");
}
public static void main(String[] args) {
AnonymousClass anony = new AnonymousClass();
anony.smg();
}
}
យើងធ្វើជា anonymous class កូដខាងក្រោមនេះ
abstract class Msg{
abstract void smg();
}
public class AnonymousClass{
public static void main(String[] args) {
//This is anonymous
Msg message = new Msg() {
@Override
void smg() {
// TODO Auto-generated method stub
System.out.println("Hello World");
}
};
message.smg();
}
}
យើងគ្រាន់តែសរសេរឈ្មោះរបស់ abstract class AnonymousClass រួចឲ្យឈ្មោះថ្មី រួចចុច = ហើយ new បន្ទាប់មកចុ keyboad "control+space" វានឹងឡូតមកឲ្យយើង override។
0 Comments