Embedded Files
Home / ພື້ນຖານ Java / Interfaces
Interfaces ແມ່ນຫຍັງ?
Interfaces ແມ່ນຫຍັງ?
Interface ນັ້ນຄ້າຍກັບຄາດ ແຕ່ພາຍໃນ interface ຈະມີໄດ້ແຕ່ຄ່າຄົງທີ່ ແລະ ການປະກາດຣູບແບບຂອງເມຕອດເທົ່ານັ້ນ ໂດຍເມຕອດທີ່ກຳນົດຂຶ້ນຈະບໍ່ມີສ່ວນການເຮັດວຽກງານ ຫລື ເປັນເມຕອດວ່າງເປົ່າທີ່ມີແຄ່ສ່ວນຫົວຂອງມັນ interface ນັ້ນຈະຕ້ອງນຳໄປໃຊ້ຮ່ວມກັບຄາດ ກ່ວາອີກໜຶ່ງ Interfaces ນັ້ນເປັນການອະທິບາຍວ່າຄາດຈະຕ້ອງມີເມຕອດ ແລະນຳເມຕອດເຫຼົ່ານັ້ນໄປກຳນົດການງານໃນຕອນສ້າງຄາດ ການເຊິ່ງຮຽກວ່າ Implement interface
ຕົວຢ່າງໃນການໃຊ້ interface ມັກຈະໃຊ້ກັບວ່າການກຳນົດໂຄງສ້າງເມຕອດໃຫ້ກັບຄາດ ແລະ interface ຈະບໍ່ສາມາດນຳໄປສ້າງອອບເຈັກໄດ້ ໃນການໃຊ້ງານ interface ຈະຕ້ອງນຳໄປ implements ກັບຄາດເທົ່ານັ້ນ ດັ່ງນັ້ນຖ້າບໍ່ມີຄາດ interface ບໍ່ກໍ່ສາມາດເຮັດວຽກໄດ້ ດັ່ງນັ້ນຄາດຫຼາຍຄາດອາດຈະມີການ implements ຈາກ Interfaces ດຽວກັນ
interface InterfaceName {
...
}
ໃນການປະກາດ interface ນັ້ນຈະໃຊ້ຄຳສັ່ງ interface ຕາມດ້ວຍຊື່ຂອງມັນ InterfaceName ແລະພາຍໃນບລັອກຄຳສັ່ງຂອງ interface ຈະປະກອບໄປດ້ວຍຄ່າຄົງທີ່ ແລະສ່ວນຫັວຂອງເມຕອດເທົ່ານັ້ນ ຕໍ່ໄປມາເບິ່ງຕົວຢ່າງການປະກາດ interface ໃນພາສາ Java
interface ICar {
public void engineStart();
public void changeGear(int newGear);
public void turnLeft();
public void turnRight();
}
ໝາຍເຫດ: ຈາກຕົວຢ່າງເຮົາໄດ້ສ້າງ interface ຊື່ ICar ຂຶ້ນມາ ແລະ ເມຕອດ header ພາຍໃນ interface ເຊິ່ງເປັນການບອກວ່າຄາດທີ່ນຳ interface ນີ້ໄປໃຊ້ງານຈະຕ້ອງມີເມຕອດເຫຼົ່ານີ້ຢູ່ ຕໍ່ໄປເຮົາຈະນຳໄປສ້າງຄາດ
class Car implements ICar {
int gear = 0;
public void engineStart() {
// start engine
}
public void changeGear(int newGear) {
// assign new gear
}
public void turnLeft() {
// turn car to left direction
}
public void turnRight() {
// turn car to right direction
}
}
ໝາຍເຫດ: ພາຍໃນຄາດ ຕອນນີ້ເຮົາຕ້ອງກຳນົດການເຮັດວຽກງານໃນເມຕອດທັງໝົດ ທີ່ເຮົາໄດ້ກຳນົດໄວ້ໃນ interface ທີ່ນຳມາ Implements
Implements Multiple Interfaces
Implements Multiple Interfaces
ໃນພາສາ Java ເຮົາສາມາດນຳຫຼາຍ interface ມາ implements ໃນການສ້າງຄາດໄດ້ ນັ້ນໝາຍຄວາມວ່າເຮົາຕ້ອງກຳນົດການເຮັດວຽກງານຂອງເມຕອດໃຫ້ຄົບທຸກເມຕອດທີ່ກຳນົດໃນ interface ດ້ວຍເຊັ່ນກັນ ໂດຍຂັ້ນດ້ວຍເຄື່ອງໝາຍ commas (,)
class CarName implements Ineterface1, Interface2, ... {
...
}
class CarName extends SuperClass implements Ineterface1, Interface2, ... {
...
}
ໝາຍເຫດ: ເຮົາສາມາດໃຊ້ຄຳສັ່ງ extends ສຳລັບການສືບຕອດຄາດຮ່ວມກັບການ implements interface ໄດ້ເຊັ່ນກັນ ຕໍ່ໄປມາເບິ່ງຕົວຢ່າງໃນການ implement ຫຼາຍ interface
interface IVolume{
public void increaseVolume();
public void decreaseVolume();
}
interface IChanel {
public void nextChangel();
public void previousChangel();
}
interface INetwork {
public void connectNetwork();
public void disconnectNetwork();
}
ໝາຍເຫດ: ເຮົາໄດ້ສ້າງສາມ interface ຂຶ້ນມາເຊິ່ງແຕ່ລະອັນນັ້ນໝາຍເຖິງລະບົບ ແລະ ພາຍໃນລະບົບຈະມີເມຕອດທີ່ຈະເຮັດວຽກຢູ່ພາຍໃນ ໂດຍ interface ແຕ່ລະອັນນັ້ນຈະໝາຍເຖິງລະບົບກ່ຽວກັບຄວາມດັ່ງສຽງ ລະບົບກ່ຽວກັບຊ່ອງສັຍຍານ ແລະ ລະບົບຂອງເນັດເວີກ
class Radio implements IVolume, IChanel {
public void increaseVolume() {
...
}
public void decreaseVolume() {
...
}
public void nextChangel() {
...
}
public void previousChangel() {
...
}
}
class Computer implements IVolume, INetwork {
public void increaseVolume() {
...
}
public void decreaseVolume() {
...
}
public void connectNetwork() {
...
}
public void disconnectNetwork() {
...
}
}
ໝາຍເຫດ: ເຮົາສ້າງຄາດ Radio ເຊິ່ງ implement ຈາກ interface IVolume ແລະ IChanel ເພາະວ່າວິດຍຸກນັ້ນມີລະບົບໃນການເພີ່ມລຸດຣະດັບສຽງ ແລະມີລະບົບປ່ຽນຊ່ອງສຖານີ ເຮົາຈະຕ້ອງກໍ່ການ override ທຸກເມຕອດທີ່ມາຈາກ interface
ແລະຄາດ Computer ເຊິ່ງຈະ implement ຈາກ interfaces IVolume ແລະ INetwork ໂດຍຄອມພິວເຕີນັ້ນຈະມີລະບົບເພີ່ມລຸດຣະດັບສຽງເຊັ່ນກັນ ແຕ່ຄອມພິວເຕີຈະມີລະບົບເນັກເວິຣົ໌ກແທນ
ເຮົາຈະເຫັນວ່າເຮົາແຄ່ພຽງປະກາດປະເພດຂອງເມຕອດໄວ້ໃນ interface ການສ້າງ interface ເໝືອນກາຣວາງແຜນລະບົບ ການກຳນົດລະບົບແລະການງານຂອງມັນຢ່າງຄຣ່າວໆ ວ່າມີຫຍັງດ້ວຍ ສ່ວນການນຳມາ implement ຄາດເປັນການພັດທະນາລະບົບທີ່ໄດ້ອອກແບບໄວ້ກ່ອນໜ້າ
ໃນບົດນີ້, ທ່ານໄດ້ຮຽນຮູ້ກ່ຽວກັບ interface ແລະ ຮູ້ຈັກຜົນປະໂຫຍດຂອງມັນ. ແລະ ນໍາໄປໃຊ້ກັບ Class ເຊິ່ງພວກເຮົາຈະຕ້ອງ override ເມຕອດທີ່ມາຈາກ interface ສະເໝີ.
Packages
Packages
Package ຄືການຈັດໝວດໝູ່ ຫລື ແບ່ງແຍກກລຸ່ມຂອງຄາດໃຫ້ເປັນກລຸ່ມໆ ເຊິ່ງຮຽກວ່າ namespaces ເພື່ອໃຫ້ງ່າຍຕໍ່ການໃຊ້ງານໃນການຂຽນໂປຣແກຣມ ຫລື ການເຮັດໃຫ້ໂຄງສ້າງຂອງໂປຣແກຣມມີລະບຽບ
Package ນັ້ນມີແນວຄິດຄ້າຍກັບ file system ຂອງລະບົບປະຕິບັດການ ຢົກຕົວຢ່າງເຊັ່ນ ເຮົາໃຊ້ໂຟລ໌ເດີໃນການຈັດເກັບໄຟປະເພດຕ່າງໆ ເຊັ່ນດຽວກັນກັບ package ໃນພາສາ Java ມັນເຮັດຫນ້າທີ່ຄ້າຍຄືກັບໂຟລ໌ເດີ ທີ່ລວມໄຟຄາດເຂົ້າໄວ້ນຳກັນ
Package ເໝືອນຄາດໄລບຣາຣີ່ທີ່ເກັບແຍກໄວ້ເປັນສ່ວນໆ ເພື່ອໃຫ້ງ່າຍຕໍ່ການໃຊ້ງານ ແລະໃນພາສາ Java ກໍ່ມີ package ຕ່າງໆ ທີ່ຈຳເປັນໃຫ້ໃຊ້ຫລວງຫຼາຍ ນອກຈາກນີ້ package ຍັງສາມາດຈັດເກັບໃນຮູບແບບຂອງ compressed file ໄດ້ ເຊິ່ງຈະໄຟລ໌ extension ເປັນ .jar
ຈາກຮູບດ້ານເທິງເປັນຕົວຢ່າງຂອງ package ທີ່ສະແດງໃນໂປຣແກຣມ NetBeans ເຮົາຈະພົບວ່າມັນຢູ່ໃນຮູບແບບຂອງ tree ໂດຍມີໂຟລ໌ເດີ src ເປັນ root ຂອງໂປຣເຈັກ ໃນຄວາມເປັນຈິງແລ້ວ package ກໍ່ຄືໂຟລ໌ເດີທີ່ຖືກເກັບຢູ່ໃນ directory ຂອງໂປຣເຈັກນັ້ນເອງ
4.1. ສ້າງ Package ໃນພາສາ Java
ໃນການສ້າງ package ໃນພາສາ Java ຢ່າງທີ່ເຮົາໄດ້ບອກ package ນັ້ນຖືກສ້າງເປັນ directory ໃນໂຟລ໌ເດິໂປຣເຈັກຂອງເຮົາ ເຊັ່ນ ເຮົາສ້າງໂປຣເຈັກຂອງເຮົາໄວ້ທີ່ D:/project/MarcusCode/src/ ເຮົາສາມາດສ້າງ package ທັງໝົດໄດ້ພາຍໃນໂຟລ໌ເດີ src ເພາະມັນຄື directory root ຂອງໂປຣເຈັກ
ອີກວິທີໜຶ່ງເຊິ່ງເປັນວິທີຫຼັກ ແລະ ງ່າຍຕໍ່ການສ້າງ package ຄືການສ້າງໃນ IDE ທີ່ເຮົາໃຊ້ຂຽນໂປຣແກຣມ ເຊັ່ນ ໃນໂປຣແກຣມ NetBeans ຄິກຂວາທີ່ ໂປຣເຈັກແລ້ວເລືອກ New -> Java Package...
ແນ່ນອນວ່າ package ຖືກອອກແບບມາເພື່ອຈັດເກັບຄາດຕ່າງໆ ໃຫ້ເປັນໝວດໝູ່ ເຮົາສາມາດແຍກຄາດແຕ່ລະຄາດອອກເປັນຄາດຍ່ອຍໆ ໄດ້ ເຊິ່ງການແບ່ງໂປຣແກຣມເປັນໄຟລ໌ຍ່ອຍໆ ຈະເຮັດໃຫ້ໂປຣແກຣມເຮັດວຽກໄດ້ໄວຂຶ້ນເພາະເຮົາຮຽກໃຊ້ແຕ່ຄາດທີ່ຈຳເປັນເທົ່ານັ້ນ
ສ້າງຄາດພາຍໃນ package
ສ້າງຄາດພາຍໃນ package
ຄາດທີ່ຢູ່ພາຍໃນ package ຈະຕ້ອງກຳນົດ package ຂອງມັນໃນບັນທັດທຳອິດສະເໝີ ຕົວຢ່າງຕໍ່ໄປເຮົາຈະສ້າງຄາດສຳລັບການແປງຄ່າຂອງຄວາມຍາວ
//LengthConvert.java
package unit.convert.length;
public class LengthConvert {
public static float meterToFeet (float m) {
return m * 3.28084f;
}
public static float centimeterToinch (float centi) {
return centi * 0.393701f;
}
}
ໃນຕົວຢ່າງ ເຮົາໄດ້ສ້າງຄາດ LengthConvert ເຊິ່ງຢູ່ພາຍໃນ package unit.convert.length ເຊິ່ງເປັນ package ທີ່ຖືກເຊື່ອງຢູ່ ເຮົາໃຊ້ເຄື່ອງໝາຍຈຸດ (*) ໃນກໍ່ລະນີມັນຊ້ອນກັນ ເຮົາໄດ້ກຳນົດ package ດ້ວຍຄຳສັ່ງ
package unit.convert.length;
ຄຳສັ່ງນີ້ເປັນການບອກ Java ຄອມໄພເລີໃຫ້ຮູ້ຄາດນີ້ຖືກກຳນົດໃຫ້ຢູ່ພາຍໃນ package unit.convert.length
ຄຳສັ່ງ import package
ຄຳສັ່ງ import package
ໃນການໃຊ້ງານ package ໃນພາສາ Java ນັ້ນຈະໃຊ້ຄຳສັ່ງ import ເພື່ອນຳເຂົ້າຄາດພາຍໃນ package ເຂົ້າມາໃນໂປຣແກຣມຂອງເຮົາ ມັນມີຮູບແບບການໃຊ້ງານດັ່ງນີ້
import package_name.ClassName; // import a class to program
import package_name.*; // import all classes to program
ຈາກຮູບແບບການໃຊ້ງານດ້ານເທິງ ເຮົາສາມາດ import ຄາດທີ່ລະບຸທັງໝົດພາຍໃນ package ກໍ່ໄດ້ໂດຍໃຊ້ເຄື່ອງໝາຍ (*) ແທນຊື່ຂອງຄາດ
ຈາກຄາດ ແລະ package ທີ່ເຮົາໄດ້ສ້າງໃນຕົວຢ່າງກ່ອນໜ້າ ຕໍ່ໄປເຮົາຈະສ້າງໂປຣແກຣມທີ່ຈະໃຊ້ງານຄາດທີ່ຢູ່ພາຍໃນ package ນັ້ນ
// Main.java
import unit.convert.length.LengthConvert;
public class Main {
public static void main (String[] args) {
System.out.println("1 meter equal " + LengthConvert.meterToFeet(1) + " feets");
System.out.println("14 meters equal " + LengthConvert.meterToFeet(14) + " feets");
System.out.println("5 centimeter equal " + LengthConvert.centimeterToinch(5) + " inches");
}
}
ໝາຍເຫດ: ໃນຕົວຢ່າງເຮົາໄດ້ສ້າງ ໄຟລ໌ໂປຣແກຣມຫຼັກທີ່ຊື່ວ່າ Main.java ເຮົາໄດ້ import ຄາດເຂົ້າມາໃນໂປຣແກຣມດ້ວຍຄຳສັ່ງ
import unit.convert.length.LengthConvert;
ໝາຍເຫດ: ເຊິ່ງເຮັດໃຫ້ເຮົາສາມາດໃຊ້ງານຄາດນີ້ໄດ້ຄືກັນກັບມັນຢູ່ໃນ package ຫລືໄຟລ໌ດຽວກັນ ຮູບພາບຂ້າງລຸ່ມສະແດງໂຄງສ້າງຂອງໂປຣເຈັກນີ້
ຄາດທີ່ຖືກສ້າງໃນ directory root ເຊັ່ນໃນຕົວຢ່າງ ຄາດ Main.java ຈະຖືວ່າເປັນ default package (ຫລືບໍ່ມີ package) ເຮັດໃຫ້ເຮົາບໍ່ຕ້ອງກຳນົດ package ໃຫ້ມັນເລີຍ ຈາກບົດຮຽນກ່ອນໜ້າ ເຮົາສ້າງໃນ directory root ທັງໝົດ ນັ້ນເປັນເຫດຜົນວ່າເປັນຫຍັງເຮົາຈຶ່ງບໍ່ໄດ້ກຳນົດ package ຄືກັບຄາດ LengthConvert.java
Access Modifiers
Access Modifiers
ໃນບົດນີ້, ພວກເຮົາຈະເວົ້າກ່ຽວກັບ Access Modifiers ໃນ Java, ເຊິ່ງເປັນຄໍາສັ່ງທີ່ໃຊ້ເພື່ອກໍານົດການເຂົ້າເຖິງໃນໂປຼແກຼມຕ່າງໆ. Access modifiers ແມ່ນຄໍາສັ່ງເພື່ອຄວບຄຸມລະດັບການເຂົ້າເຖິງຂອງຕົວແປ ຫຼື Method ພາຍໃນ Class. ດັ່ງທີ່ເຈົ້າສາມາດເຫັນໄດ້ໃນການສ້າງ Class ພື້ນຖານ. ຊື່ຂອງ Class ແລະ ໄຟລ໌ຕ້ອງກົງກັນ. ແລະ ຕ້ອງຕັ້ງການເຂົ້າເຖິງເປັນສາທາລະນະ, ເຊິ່ງເຮັດໃຫ້ Class ນີ້ສາມາດເຂົ້າເຖິງໄດ້ຈາກທຸກບ່ອນໃນໂຄງການ. Access modifiers ຍັງເປັນຄໍາສັ່ງທີ່ໃຊ້ເພື່ອກໍານົດການເຂົ້າ Object ຕ່າງໆ Package ເຊັ່ນ: Class ແລະ Interfaces ເປັນຕົ້ນ, ຕໍ່ມາເຮົາຈະມາເວົ້າກ່ຽວກັບລະດັບສະມາຊິກ (member level) ເຊິ່ງມັນຈະມາພ້ອມກັບການປະກາດຕົວປ່ຽນທີ່ທ່ານໄດ້ເຫັນໃນຕົວຢ່າງທີ່ຜ່ານມາ.
private int width;
private int height;
private int calArea () {
return width * height;
}
ໃນ Java, ນັ້ນມີຄໍາສັ່ງໃນການຄວບຄຸມລະດັບການເຂົ້າເຖິງຢູ່ 4 ລະດັບຄື: public, protected, private , ແລະ no modifier (ບໍ່ຕ້ອງກຳນົດ) ໂດຍແຕ່ລະຮູບແບບນັ້ນມີຄວາມໝາຍດັ່ງນີ້
public: Class ຫຼື ສະມາຊິກສາມາດເຂົ້າເຖິງໄດ້ຈາກທຸກສ່ວນຂອງໂປຣແກຣມ
protected: Class ຫຼື ສະມາຊິກສາມາດເຂົ້າເຖິງພາຍໃນ package ດຽວກັນ ແລະ sub class ຂອງມັນ
no modifier. (ບໍ່ກຳນົດ): Class ຫຼື ສະມາຊິກສາມາດເຂົ້າເຖິງພາຍໃນ package ດຽວກັນ
private: Class ຫຼື ສະມາຊິກສາມາດເຂົ້າເຖິງໄດ້ພາຍໃນ Class ດຽວກັນເທົ່ານັ້ນ
ຈາກຄໍາອະທິບາຍຂ້າງເທິງ ພວກເຮົາສາມາດຂຽນຕາຕະລາງການເຂົ້າເຖິງຂອງຄໍາສັ່ງທັງຫມົດດັ່ງຕໍ່ໄປນີ້, public ເປັນການເຂົ້າເຖິງທີ່ເປັນສາທາລະນະ ຫຼາຍກ່ວາ ແລະ private ປິດກັ້ນຫຼາຍທີ່ສຸດ
Modifiers
Modifiers
Public
Protected
No modifier
Private
Class
Class
Yes
Yes
Yes
Yes
Package
Package
Yes
Yes
Yes
No
Sub class
Sub class
Yes
Yes
No
No
World
World
Yes
No
No
No
ຕໍ່ໄປ, ມາເບິ່ງຕົວຢ່າງຂອງການໃຊ້ Access Modifier ກັບການຂຽນໂປຼແກຼມໃນ Java.
public class TestFruit {
public static void main (String[] args) {
Fruit fr = new Fruit();
fr.name = "Grape";
fr.flavor = "sour";
fr.setColor("green");
System.out.println("Fruit name: " + fr.name);
System.out.println("Flavor: " + fr.flavor);
System.out.println("Color: " + fr.getColor());
}
}
class Fruit {
public String name;
String flavor;
private String color;
public String getColor () {
return color;
}
public void setColor (String c) {
color = c;
}
}
ໃນຕົວຢ່າງ, ເປັນການໃຊ້ access modifier ແບບຕ່າງໆ, ໃນຕອນທຳອິດເຮົາໄດ້ສ້າງ Class: Fruit ທີ່ມີສະມາຊິກທັງຕົວປ່ຽນ ແລະ Method ທີ່ມີລະດັບການເຂົ້າເຖິງໃນແບບຕ່າງໆ
Fruit fr = new Fruit();
fr.name = "Grape";
fr.flavor = "sour";
fr.setColor("green");
ຕໍ່ມາ, ເຮົາສ້າງ object Fruit ທີ່ມີຊື່ fr. ໂດຍສັງເກດເຫັນ object ທີ່ເຮົາສ້າງນັ້ນຢູ່ໃນ Class: TestFruit, ນັ້ນຫມາຍຄວາມວ່າພວກເຮົາບໍ່ສາມາດເຂົ້າເຖິງຕົວປ່ຽນ color ໄດ້ເພາະວ່າມັນມີ access modifier ແບບ private ເຊິ່ງສາມາດເຂົ້າເຖິງໄດ້ພາຍໃນ Class ເທົ່ານັ້ນ. ເຮົາຈື່ງເຂົ້າເຖິງມັນຜ່ານ public Method getColor() ແລະ setColor() ເຊິ່ງຢູ່ໃນ Class ດຽວກັນ.
ສໍາລັບຕົວປ່ຽນ name ແລະ flavor, ເຮົາສາມາດເຂົ້າເຖິງຕົວປ່ຽນ Object ໄດ້ໂດຍກົງ. ເພາະພວາກມັນມີ access modifier ເປັນແບບ public ເຊິ່ງສາມາດເຂົ້າເຖິງຈາກພາຍນອກໄດ້
Fruit name: Grape
Flavor: sour
Color: green
ການເຂົ້າເຖິງແບບ Public
ການເຂົ້າເຖິງແບບ Public
ຕໍ່ໄປແມ່ນຕົວຢ່າງເພີ່ມເຕີມຂອງການໃຊ້ Access modifiers ຮູບແບບຕ່າງໆ ໃນການກຳນົດການເຂົ້າເຖິງຂອງໂປຣແກຣມພາຍໃນ Class. ໂດຍເຮົາຈະເລີ່ມຕົ້ນດ້ວຍຄໍາສັ່ງ public , ເຊິ່ງເປັນການກໍານົດການເຂົ້າເຖິງສາທາລະນະ.
class Person {
public String firstName;
public String lastName;
protected int age;
private int height;
public String getFullname() {
return firstName + " " + lastName;
}
public void setHeight(int h) {
height = h;
}
public int getHeight() {
return height;
}
}
public class PublicExample {
public static void main(String[] args) {
Person p1 = new Person();
p1.firstName = "Shawn";
p1.lastName = "Roberts";
p1.age = 32;
p1.setHeight(178);
System.out.println(p1.getFullname());
System.out.println("Age " + p1.age + " years");
System.out.println("Height " + (p1.getHeight() / 100.0f) + " m");
}
}
ໃນຕົວຢ່າງ ເຮົາໄດ້ສ້າງຄລາດ Person ສຳລັບເກັບຂໍ້ມູນຂອງບຸກຄົນ ທີ່ປະກອບໄປດ້ວຍຕົວປ່ຽນ firstName ແລະ lastName ທີ່ມີການກຳນົດການເຂົ້າເຖິງເປັນແບບ public ແລະ ເມທອດພາຍໃນຄລາດນັ້ນເປັນແບບ public ທັງໝົດ ຈຶ່ງເຮັດໃຫ້ພວກມັນສາມາດເຂົ້າເຖິງຜ່ານອອບເຈັກໄດ້ ເຊັ່ນ p1.firstName ເປັນຕົ້ນ
ການເຂົ້າເຖິງແບບ Protected ແລະ Private
ການເຂົ້າເຖິງແບບ Protected ແລະ Private
ຕໍ່ໄປເປັນການໃຊ້ງານຕົວປ່ຽນ age ເຊິ່ງມີການກຳນົດການເຂົ້າເຖິງແບບ protected ການກຳນົດການເຂົ້າເຖິງແບບນີ້ໃຊ້ກັບການໃຊ້ງານໃນການສືບທອດຂອງຄລາດ ເມື່ອເຈົ້າໄດ້ກໍ່ການສືບທອດຄລາດໃດໆ ສະມາຊິກທັງໝົດຂອງຄລາດຍົກເວັ້ນທີ່ມີກຳນົດການເຂົ້າເຖິງເປັນແບບ Private ຈະບໍ່ຖືກສືບທອດ ດັ່ງນັ້ນໃນຕົວຢ່າງເຮົາບໍ່ສາມາດເຂົ້າເຖິງສະມາຊິກທີ່ເປັນ Private ຜ່ານຕົວແປຣອອບເຈັກ p1 ໄດ້
Shawn Roberts
Age 32 years
Height 1.78 m
ນິ້ເປັນຜົນລັບການເຮັດວຽກຂອງໂປຣແກຣມ ໃນການກຳນົດການເຂົ້າເຖິງຂອງໂປຣແກຣມ
ໃນບົດນີ້ ເຈົ້າໄດ້ຮຽນຮູ້ກັບ access modifier ແບບຕ່າງໆ ໃນພາສາ Java ຊຶ່ງຈະມີການກຳນົດການເຂົ້າເຖິງຕົວປ່ຽນໃນລະດັບທີ່ຕ່າງກັນ ໂດຍເນື້ອຫາໃນບົດນີ້ນັ້ນສຳຄັນກັບແນວຄິດໃນການເຮັດ Encapsulation (ການຫໍ່ຫຸ້ມຂໍ້ມູນ)
Page updated
Google Sites
Report abuse