Home / ພື້ນຖານ Java / Class ແລະ Object
ກ່ອນທີ່ຈະໄປຮຽນ Class ແລະ Object ຕ້ອງຮູ້ທີ່ໄປທີ່ມາຂອງມັນກັນກ່ອນວ່າ ເຫັດຜົນຫຍັງຈື່ງ ຄິດຄົ້ນ Class ແລະ Object ຂື້ນມາ ສ້າງຂື້ນມາເພື່ອຫຍັງ ແລະ ສາມາດນຳໄປໃຊ້ໃນຮູບແບບໃດ ໃນບົດນີ້ ຈະແນະນຳໃຫ້ເຮົາຮູ້ຈັກກັບການຂຽນໂປຣແກຣມແບບວັດຖຸ (Object-oriented programming, OOP) ໃນພາສາ Java ເຊິ່ງເປັນຮູບແບບໃນການຂຽນໂປຣແກຣມທີ່ສຳຄັນໃນປະຈຸບັນ ຫລື ເປັນການພັດທະນາຈາກການຂຽນໂປຣແກຣມແບບເກົ່າ ທີ່ເຮົາເຄີຍໄດ້ຮຽນກັນກໍ່ຄື Procedural programming ແລະ ຈະແນະນຳໃຫ້ເຮົາຮູ້ຈັກກັບຄຸນສົມບັດທີ່ສຳຄັນໃນການຂຽນໂປຣແກຣມເຊີງວັດຖຸໃນພາສາ Java ເຊັ່ນ Inheritance Encapsulation ແລະ Polymorphism
ການຂຽນໂປຣແກຣມເຊີງວັດຖຸ ເປັນຮູບແບບການຂຽນໂປຣແກຣມທີ່ໃຊ້ແນວຄິດຂອງອອບເຈັກ ເຊິ່ງໃນອອບເຈັກນັ້ນຈະປະກອບໄປດ້ວຍສະມາຊິກ 2 ແບບ ຄື ຕົວແປຣເຊິ່ງເປັນຂໍ້ມູນ ຫລື ກຳນົດລັກສະນະຂອງອອບເຈັກ ແລະ ເມຕອດ ເປັນຟັງກ໌ຊັ່ນການເຮັດວຽກງານທີ່ອັອບເຈັກສາມາດເຮັດໄດ້ ໃນການສ້າງອອບເຈັກນັ້ນຈະຢູ່ພາຍໃຕ້ການກຳນົດຂອງຄາດ ໂດຍຄາດຄືການກຳນົດວ່າອອບເຈັກຈະມີສະມາຊິກຫຍັງແດ່ ແລະ ກຳນົດການເຮັດວຽກງານຂອງເມຕອດ ດັ່ງນັ້ນອອບເຈັກຈະສ້າງຈາກຄາດ ເຮົາຮຽກອອບເຈັກວ່າ instances ຂອງຄາດ
ພາສາຕ່າງໆ ເປັນຈຳນວນຫຼາຍສະໜັບສະໜູນການຂຽນໂປຣແກຣມເຊີງວັດຖຸ ເຊັ່ນ Java C++ C# Python PHP Ruby ແລະ ພາສາອື່ນໆ ເຊິ່ງ Java ຖືວ່າເປັນພາສາຂອງອອບເຈັກຢ່າງເຕັມຮູບແບບ ການຂຽນໂປຣແກຣມເຊີງວັດຖຸນັ້ນເປັນການພັດທະນາຮູບແບບຂອງການຂຽນໂປຣແກຣມໄປອີກຂັ້ນຈາກການຂຽນໂປຣແກຣມແບບເດີມທີ່ເຮົາເຄີຍຂຽນຄື ນັ້ນຈະໄດ້ເອີ້ນວ່າ Procedural programming
ການຂຽນໂປຣແກຣມເຊີງວັດຖຸ ມີຂໍ້ດີແລະຂໍ້ໄດ້ປຣຽບຈາກການຂຽນໂປຣແກຣມແບບເດີມຫລວງຫຼາຍ ເຊິ່ງສິ່ງທີ່ສຳຄັນທີ່ສຸດຂອງມັນຄືການນຳໂຄ້ດຂອງໂປຣແກຣມກລັບມາໃຊ້ໃໝ່ ແລະຄຸນສົມບັດອື່ນໆ ດັ່ງນີ້
Code reuse: ການນຳໂຄ້ດກັບມາໃຊ້ງານໃໝ່ ໄດ້ຢ່າງມີປະສິດທິພາບ
Maintenance: ງ່າຍຕໍ່ການບຳລຸງ ຫຼື ຮັກສາ ແລະ ປັບປຸງ ແຕ່ລະຄາດຈະມີຂອບເຂດການເຮັດວຽກງານ ແລະ ເມຕອດຂອງມັນເອງ
Classes: ຄາດທີ່ສ້າງຂຶ້ນນັ້ນ ສາມາດນຳໄປສ້າງເປັນອອບເຈັກໄດ້ບໍ່ຈຳກັດ ແລະ ແຕ່ລະອອບເຈັກມີສະມາຊິກເປັນຂອງມັນເອງ
Inheritance: ຄຸນສົມບັດການສືບຕອດ ຄາດສາມາດສືບຕອດຈາກຄາດອື່ນໄດ້ ເຊິ່ງເປັນການ reuse code ແລະ ພັດທະນາຈາກຄວາມສາມາດຈາກຄາດເດີມທີ່ມີຢູ່
Polymorphism: ຄຸນສົມບັດຂອງອອບເຈັກທີ່ຫຼາກຫຼາຍຮູບແບບ ເຊິ່ງສາມາດຈັດການໄດ້ຈາກ Base ຂອງຄາດນັ້ນໆ
Encapsulation: ເປັນຄຸນສົມບັດການຫຸ້ມຫໍ່ ເປັນແນວຄິດແບບນາມະທຳທີ່ວ່າເຮົາບໍ່ຈຳເປັນຕ້ອງຮູ້ວ່າເມຕອດ ຫລື ໃນຄາດນັ້ນເຮັດວຽກແບບໃດ ແຕ່ມັນສາມາດເຮັດວຽກໄດ້ສຳເລັດ ແລະ ໃຫ້ຜົນລັບທ໌ແກ່ເຮົາໄດ້ ຫຼື ບໍ່
Abstraction: ຄືການອະທິບາຍການເຮັດວຽກງານຂອງຄາດ ແລະ ເມຕອດໃນແບບນາມະທຳ ເພື່ອນຳໄປໃຊ້ສຳລັບອອບເຈັກທີ່ມີການເຮັດວຽກງານແຕກຕ່າງກັນ ເຊັ່ນ ເຮົາບອກວ່າສັດສາມາດເຄື່ອນທີ່ ການເຄື່ອນທີ່ຄືການບອກແບບເປັນນາມະທຳ ເພາະວາ່ສັດແຕ່ລະຕົວມີວິທີການເຄື່ອນທີ່ທີ່ແຕກຕ່າງກັນຢູ່ແລ້ວ ເຊັ່ນ ໝາຈະຍ່າງ ນົກຈະບິນ ສ່ວນເຕົ່າຈະຄລານ ເປັນຕົ້ນ
ຂ້າງເທິງນັ້ນເປັນຄຸນສົມບັດຂອງການຂຽນໂປຣແກຣມແບບອອບເຈັກ ທີ່ມີຄວາມສຳຄັນ ແລະ ມັນໃຊ້ກັບການຂຽນໂປຣແກຣມໃນຂັ້ນສູງ ຢ່າງໃດກໍ່ຕາມໃນບົດນີ້ ເຮົາຈະໄດ້ຮຽນຮູ້ກ່ຽວກັບມັນທັງໝົດ
ສ່ວນປະກອບຂອງການຂຽນໂປຣແກຣມເຊີງວັດຖຸທີ່ສຳຄັນຄື ຄາດ ແລະ ອອບເຈັກ ໃນຕອນທຳອິດເຮົາຕ້ອງສ້າງ ຫລື ປະກາດຄາດຂຶ້ນມາ ເຊິ່ງປະກອບໄປດ້ວຍຕົວແປຣ ແລະ ເມຕອດໃນການເຮັດວຽກງານ ຫຼັງຈາກນັ້ນເຮົາຈະນຳໄປສ້າງອອບເຈັກ ການສ້າງຄາດກໍ່ຄ້າຍຄືກັບການອອກແບບຮູບແບບຂອງວັຖຸຢ່າງໜຶ່ງທີ່ເຮົາຈະຕ້ອງສ້າງຂຶ້ນມາ ເຊັ່ນ ເຮົາຈະສ້າງລົດຂຶ້ນມາເຮົາກໍ່ຕ້ອງຂຽນແບບ ເຮົາຮຽກສິ່ງນີ້ວ່າຄາດ ແລະ ເຮົານຳເອົາມັນໄປສ້າງເປັນລົດ ເຊິ່ງກໍ່ຄືອອບເຈັກ
ຈະເຫັນໄດ້ວ່າຈະມີ attribute ເມຕອດເພື່ອອະທິບາຍກ່ຽວກັບລົດ ເຊິ່ງລົດກໍ່ຈະມີຄຸນສົມບັດຂອງມັນ ເຊັ່ນ ຈຳນວນຂອງນ້ຳມັນ ຄວາມໄວສູງສຸດ ໆລໆ ໃນສ່ວນຂອງການເຮັດວຽກງານ ຈະເປັນການເຕີມນ້ຳມັນ ການເພີ່ມ ແລະ ຫຼຸດຄວາມໄວ ການຂັບເຄື່ອນລົດອອກໄປ ແລະ ສະຕາດ ຫລື ຢຸດເຄື່ອງຍົນ ເປັນຕົ້ນ ເຊິ່ງສິ່ງເຫລົ້ານີ້ຈະຖືກກຳນົດໄວ້ໃນຄາດແລ້ວ ມາເບິ່ງຕົວຢ່າງຂອງການປະກາດຄາດໃນພາສາ Java ເຮົາຈະປະກາດຄາດ Car ເຊິ່ງຈະປະກອບໄປດ້ວຍຄຸນສົມບັດ ແລະ ເມຕອດໃນການເຮັດວຽກຂອງລົດ
public class Car {
public float fuel;
public int maxSpeed;
public int currentSpeed = 0;
public String color;
public void reFuel() {
fuel = 100;
}
public float getFuel() {
return fuel;
}
private void setSpeed(int speed) {
currentSpeed = speed;
}
public void drive() {
setSpeed(currentSpeed + 1);
if(currentSpeed >= maxSpeed) {
currentSpeed = maxSpeed;
}
}
}
ໃນຕົວຢ່າງ ເປັນຮູບແບບຂອງການປະກາດຄາດໃນພາສາ Java ທີ່ມີຊື່ຂອງຄາດຄື Car ແລະ ພາຍໃນຄາດຈະປະກອບໄປດ້ວຍຕົວແປຣ ສຳລັບເກັບຄ່າຄຸນສົມບັດຕ່າງຂອງລົດຍົນ ແລະ ເມຕອດເປັນຟັງຊັ້ນໃນການເຮັດວຽກງານທີ່ສາມາດເຮັດໄດ້ ມີພຽງແຕ່ຄາດນັ້ນໆ ໂປຣແກຣມຍັງບໍ່ສາມາດເຮັດໄດ້ ດັ່ງນັ້ນເຮົາຈຶ່ງຕ້ອງນຳຄາດນີ້ໄປສ້າງອອບເຈັກກ່ອນ ເຊິ່ງເຮົາຈະໄດ້ຮຽນກ່ຽວກັບຄາດ ແລະ ອອບເຈັກໃນບົດຕໍ່ໄປ
ໃນບົດນີ້ ເຮົາໄດ້ແນະນຳໃຫ້ເຮົາຮູ້ຈັກກັບການຂຽນໂປຣແກຣມເຊີງວັດຖຸໃນພາສາ Java ແລະ ຄຸນສົມບັດທີ່ສຳຄັນຂອງ OOP ທັງຫມົດເຖິງຮູບແບບຂອງການປະກາດຄາດສຳລັບໃຊ້ໃນການສ້າງອອບເຈັກ ໃນບົດຕໍ່ໄປ ເຮົາຈະໄດ້ຮຽນຮູ້ກ່ຽວກັບການສ້າງຄາດໃນພາສາ Java ແລະ ນຳຄາດໄປສ້າງອອບເຈັກ ເຊິ່ງຈະເປັນການເລີ່ມເຂົ້າສູ່ເນື້ອຫາຂອງການຂຽນໂປຣແກຣມເຊີງວັດຖຸ
ຄາດເປັນການກຳນົດສ່ວນປະກອບຕ່າງໆ ທີ່ຈະນຳໄປສ້າງອອບເຈັກ ຄາດຈະປະກອບໄປດ້ວຍສະມາຊິກສອງຢ່າງຄື ຕົວແປຣ ແລະເມຕອດ ຕົວແປຣໃຊ້ສຳລັບເກັບຂໍ້ມູນຕ່າງໆ ກ່ຽວກັບອອບເຈັກ ແລະເມຕອດເປັນການກຳນົດຟັງກ໌ຊັ່ນການເຮັດວຽກງານຂອງອອບເຈັກ ນິ້ເປັນຮູບແບບການປະກາດຄາດໃນພາສາ Java
class ClassName {
// member variables
// member methods
}
ໃນການສ້າງຄາດຈະໃຊ້ຄຳສັ່ງ class ແລະ ຕາມດ້ວຍຊື່ຂອງຄາດທີ່ເຮົາຈະສ້າງ ຊື່ຄາດຄວນເລີ່ມຕົ້ນຊື່ດ້ວຍຕົວໃຫຍ່ ແລະມີຫຼັກການຕັ້ງຊື່ເຊັ່ນດຽວກັບຕົວແປຣ ພາຍໃນບອກຄຳສັ່ງຂອງຄາດຈະມີສະມາຊິກທີ່ເປັນທັງຕົວແປຣ ແລະ ເມຕອດ ຫລືຢ່າງໃດຢ່າງໜຶ່ງກໍ່ໄດ້ ມາເບິ່ງຕົວຢ່າງການສ້າງຄາດໃນພາສາ Java
class Person {
public String name;
public int age;
float speed = 4.0f;
void setSpeed (float newSpeed) {
speed = newSpeed;
}
float getSpeed () {
return speed;
}
void run () {
System.out.println(name + " is running at speed " + speed + " feet/s.");
}
}
ໃນຕົວຢ່າງດ້ານເທິງ ເຮົາສ້າງຄາດທີ່ຊື່ວ່າ Person ແລະ ໃນຄາດນີ້ມີສະມາຊິກທີ່ເປັນຕົວແປຣ 3 ຕົວຄື name ເປັນຕົວແປຣ String ສຳລັບເກັບຊື່ age ເປັນຕົວແປຣແບບ integer ສຳລັບເກັບອາຍຸ ແລະ speed ເປັນຕົວແປຣແບບ float ສຳລັບເກັບຄວາມໄວ ແລະ ສະມາຊິກແບບເມຕອດ 3 ຕົວ ຄື ເມຕອດ setSpeed() ສຳລັບກຳນົດຄວາມໄວໃໝ່ ເມຕອດ getSpeed() ສຳລັບຮັບຄ່າຄວາມໄວໄປໃຊ້ງານ ແລະ ເມຕອດ run() ເປັນເມຕອດສຳລັບໃຫ້ອອບເຈັກເຮັດການຣັນ ໃນຕົວຢ່າງເປັນການສະແດງຂໍ້ຄວາມ
ໝາຍເຫດ: ໃນການສ້າງຄາດຫລື Interfaces ໃນພາສາ Java ນັ້ນ ເຮົາສາມາດສ້າງແຍກອອກເປັນໄຟລ໌ໃໝ່ໄດ້ ໃນການສ້າງຄາດຈະຕ້ອງໃຊ້ຄຳສັ່ງ public ແລະ ຊື່ຂອງຄາດຕ້ອງກົງກັນກັບຊື່ຂອງໄຟລ໌ ເຊັ່ນ ຄາດຂອງເຮົາຊື່ວ່າ public class MyClass {... ຊື່ໄຟລ໌ຕ້ອງເປັນ MyClass.java ເປັນຕົ້ນ
ຫຼັງຈາກທີ່ເຮົາສ້າງຄາດແລ້ວ ຕໍ່ໄປເປັນການນຳຄາດມາສ້າງອອບເຈັກ ເຮົາຈະນຳຄາດ Person ມາສ້າງອອບເຈັກສຳລັບຕົວຢ່າງຕໍ່ໄປ
public class ObjectExample {
public static void main(String[] args) {
Person p1 = new Person();
Person p2 = new Person();
p1.name = "Kittisay";
p1.age = 27;
p1.speed = 3.5f;
p2.name = "Danny";
p2.age = 25;
System.out.println("p1 is " + p1.name);
System.out.println("He is " + p1.age + " year old.");
System.out.println(p1.name + " has speed " + p1.speed + " feet/s.");
p1.run();
System.out.println("\np2 is " + p2.name);
System.out.println("He is " + p2.age + " year old.");
System.out.println(p2.name + " has speed " + p2.getSpeed() + " feet/s.");
p2.run();
p2.setSpeed(5.0f);
p2.run();
}
}
class Person {
public String name;
public int age;
float speed = 4.0f;
void setSpeed (float newSpeed) {
speed = newSpeed;
}
float getSpeed () {
return speed;
}
void run () {
System.out.println(name + " is running at speed " + speed + " feet/s.");
}
}
ໃນຕົວຢ່າງເຮົາໄດ້ສ້າງ Object ຈາກ Class Person ດ້ວຍຄຳສັ່ງລຸ່ມນີ້
Person p1 = new Person();
Person p2 = new Person();
ໂດຍ p1 ແລະ p2 ນັ້ນເປັນຕົວແປຣປະເພດອອບເຈັກຂອງຄາດ Person ໂດຍອອບເຈັກທັງສອງນັ້ນເປັນອິດສະຫລະຕໍ່ກັນ ໂດຍແຕ່ລະອອບເຈັກຈະມີຕົວແປຣ ແລະ ເມຕອດເປັນຂອງມັນເອງ ຕໍ່ມາເຮົາໄດ້ກຳນົດຄ່າໃຫ້ກັບອອບເຈັກທັງສອງດ້ວຍຄຳສັ່ງ
p1.name = "Kittisay";
p1.age = 27;
p1.speed = 3.5f;
p2.name = "Danny";
p2.age = 25;
ໃນການເຂົ້າເຖິງສະມາຊິກຂອງອອບເຈັກນັ້ນຈະໃຊ້ເຄື່ອງໝາຍ dot (.) ແລ້ວຕາມດ້ວຍຊື່ຂອງຕົວແປຣທີ່ຈະເຂົ້າເຖິງ ເຮົາໄດ້ກຳນົດຄ່າຕ່າງໆ ໃຫ້ກັບອອບເຈັກທັງສອງ ໃນຕົວຢ່າງເຮົາບໍ່ໄດ້ກຳນົດຄ່າ speed ໃຫ້ກັບອອບເຈັກ p2 ດັ່ງນັ້ນມັນຈະໃຊ້ default ທີ່ເຮົາໄດ້ປະກາດໄວ້ໃນຄາດຄື 4.0f
ຕໍ່ໄປເຮົາໃຊ້ຄຳສັ່ງສະແດງຜົນຂອງອອບເຈັກອອກມາສະແດງເທິງໜ້າຈໍ
System.out.println("p1 is " + p1.name);
System.out.println("He is " + p1.age + " year old.");
System.out.println(p1.name + " has speed " + p1.speed + " feet/s.");
p1.run();
System.out.println("\np2 is " + p2.name);
System.out.println("He is " + p2.age + " year old.");
System.out.println(p2.name + " has speed " + p2.getSpeed() + " feet/s.");
p2.run();
p2.setSpeed(5.0f);
p2.run();
ຈາກການສະແດງຜົນໃນຕົວຢ່າງນັ້ນກົງໄປກົງມາ ເຮົາໄດ້ສະແດງຊື່ ອາຍຸ ແລະ ຄວາມໄວຂອງແຕ່ລະອອບເຈັກອອກມາທາງໜ້າຈໍ ແລະ ເຮົາເອີ້ນໃຊ້ເມຕອດ ເຮົາຮຽກໃຊ້ເມຕອດ ໃນຕົວຢ່າງຂອງອອບເຈັກ p2 ເຮົາໃຊ້ run() ເພື່ອສັ່ງໃຫ້ອອບເຈັກເຮັດການຣັນ p2.getSpeed() ໃນການຮັບຄ່າ speed ອອກມາ ນອກຈາກນີ້ເຮົາຍັງປ່ຽນແປລງ speed ຂອງອອບເຈັກ p2 ແລະ ໃຊ້ເມຕອດ run() ອີກເທື່ອໜຶ່ງເພື່ອເບິ່ງຄວາມໄວຂອງມັນ
p1 is Kittisay
He is 27 year old.
Kittisay has speed 3.5 feet/s.
Kittisay is running at speed 3.5 feet/s.
p2 is Danny
He is 25 year old.
Danny has speed 4.0 feet/s.
Danny is running at speed 4.0 feet/s.
Danny is running at speed 5.0 feet/s.
ຄອນສະຕັກເຕີ (constructor) ນັ້ນຄືເມຕອດພິເສດທີ່ຈະເຮັດວຽກເມື່ອອອບເຈັກຖືກສ້າງຂຶ້ນ ເຮົາມັກໃຊ້ຄອນສະຕັກເຕີໃນການກຳນົດຄ່າເລີ່ມຕົ້ນໃຫ້ກັບອອບເຈັກ ຕົວຢ່າງການສ້າງ ແລະ ໃຊ້ງານຄອນສະຕັກເຕີໃນພາສາ Java
class Person {
public String name;
public int age;
float speed = 4.0f;
public Person () {
}
public Person (String name) {
this.name = name;
}
public Person (String name, int age) {
this.name = name;
this.age = age;
}
void setSpeed (float newSpeed) {
speed = newSpeed;
}
float getSpeed () {
return speed;
}
void run () {
System.out.println(name + " is running at speed " + speed + " feet/s.");
}
}
ໃນຕົວຢ່າງ ເຮົາໄດ້ສ້າງຄອນສະຕັກເຕີສຳລັບຄາດ Person ດ້ວຍໂດຍຄອນສະຕັກເຕີນັ້ນຈະຕ້ອງມີຊື່ຄືກັບຄາດ ແລະ ກຳນົດລະດັບການເຂົ້າເຖິງໃຫ້ເປັນ public ສະເໝີ ເຮົາສາມາດສ້າງໄດ້ຫຼາຍຄອນສະຕັກເຕີເຊິ່ງເຮົາເອີ້ນວ່າ Overloading Constructor ເຊັ່ນດຽວກັນກັບ Overloading Method
Person p1 = new Person("Kittisay");
Person p2 = new Person("Kittisay", 27);
Person p3 = new Person();
ເຮົາສາມາດສ້າງອອບເຈັກໃນການກຳນົດຄ່າໃຫ້ກັບອອບເຈັກໄດ້ທັນທີໃນຕອນທີ່ສ້າງຄອນສະຕັກເຕີ ໂດຍສົ່ງອາກິວເມັ້ນເຂົ້າໄປໃນຄອນສະຕັກເຕີ ແລະ ເຮົາສາມາດເລືອກໃຊ້ແບບໃດກໍ່ໄດ້ ເພາະເຮົາໄດ້ສ້າງ Overloading Constructor ສຳລັບທຸກແບບນັ້ນໄວ້ແລ້ວ
ເປັນຄຳສັ່ງສຳລັບການອ້າງເຖິງສະມາຊິກໃນອອບເຈັກປະຈຸບັນ ສຳລັບຕົວຢ່າງໃນຄອນສະຕັກເຕີນັ້ນ ເຮົາໄດ້ໃຊ້ this.name ນັ້ນໝາຍເຖິງ name ຂອງອອບເຈັກ ໃນຂະນະທີ່ name ນັ້ນຈະເປັນຂອງເມຕອດ ຖ້າຫາກໃນຂອບເຂດຂອງໂປຣແກຣມທີ່ເຮົາໃຊ້ນັ້ນບໍ່ມີຊື່ຂອງຕົວແປຣທີ່ຊ້ຳກັນເຮົາບໍ່ຈຳເປັນຕ້ອງໃຊ້ຄຳສັ່ງ this ກໍ່ໄດ້ ເຊັ່ນໃນເມຕອດ getSpeed() ນອກຈາກນີ້ຄຳສັ່ງນີ້ຍັງຖືກໃຊ້ໃນເລື່ອງຂອງ Inheritance
ເປັນຄຳສັ່ງທີ່ໃຊ້ສຳລັບກຳນົດໃຫ້ຕົວແປຣ ຫລື ເມຕອດ ສາມາດເຂົ້າເຖິງໄດ້ແບບສາທາລະນະຖ້າຫາກປະກາດເປັນ public ແລະຖ້ານຳໄປໃຊ້ກັບອອບເຈັກຈະເຮັດໃຫ້ທຸກອອບເຈັກນັ້ນອ້າງເຖິງຕົວແປຣດຽວກັນ ຕົວຢ່າງການໃຊ້ຄຳສັ່ງ static
public class ObjectExample {
public static void main(String[] args) {
Person p1 = new Person();
Person p2 = new Person();
p1.name = "Kittisay";
p1.age = 27;
p2.name = "Danny";
p2.age = 25;
System.out.println("Name: " + p1.name);
System.out.println("Age: " + p1.age);
System.out.println(StaticMember.NAME_PREFIX + " " + p1.name);
System.out.println("\nName: " + p2.name);
System.out.println("Age: " + p2.age);
StaticMember.displayName(p2.name);
}
}
class Person {
public String name;
public static int age;
}
class StaticMember {
public static String NAME_PREFIX = "Mr.";
public static void displayName (String name) {
System.out.println(NAME_PREFIX + " " + name);
}
}
ໃນຕົວຢ່າງເຮົາໄດ້ປ່ຽນໃຫ້ຕົວແປຣ age ໃນຄາດ Person ເປັນ static ດັ່ງນັ້ນອອບເຈັກທຸກອອບເຈັກທີ່ຖືກສ້າງໂດຍຄາດນີ້ ຈະໃຫ້ຕົວແປຣນີ້ຮ່ວມກັນ ແລະ ເຮົາໄດ້ສ້າງຄາດ StaticMember ໂດຍມີສະມາຊິກເປັນ static ທັງໝົດ ສະມາຊິກຂອງມັນສາມາດເຂົ້າເຖິງໄດ້ຈາກທີ່ໃດໆ ໂດຍ prefix ຂອງຄາດເຊັ່ນ StaticMember.NAME_PREFIX ແລະ StaticMember.displayName()
Name: Kittisay
Age: 27
Mr. Kittisay
Name: Danny
Age: 25
Mr. Danny