PHP ಯೊಂದಿಗೆ ಆಬ್ಜೆಕ್ಟ್ ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್: ಸಂಪೂರ್ಣ ಉದಾಹರಣೆಗಳು

ಕವರ್ » ಪ್ರೋಗ್ರಾಮಿಂಗ್ » PHP ಯೊಂದಿಗೆ ಆಬ್ಜೆಕ್ಟ್ ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್: ಸಂಪೂರ್ಣ ಉದಾಹರಣೆಗಳು

PHP ಯೊಂದಿಗೆ ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಕುರಿತು ಈ ಸಮಗ್ರ ಲೇಖನದಲ್ಲಿ, ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಅನ್ವಯಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುವ ಪ್ರಾಯೋಗಿಕ ಮತ್ತು ವಿವರವಾದ ಉದಾಹರಣೆಗಳನ್ನು ನೀವು ಕಾಣಬಹುದು. PHP ಯಲ್ಲಿ ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸುವುದು ಹೇಗೆ ಎಂದು ತಿಳಿಯಿರಿ ಮತ್ತು ನಿಮ್ಮ ಅಭಿವೃದ್ಧಿ ಕೌಶಲ್ಯಗಳನ್ನು ಸುಧಾರಿಸಿ. ಉದಾಹರಣೆಗಳನ್ನು ಅನ್ವೇಷಿಸಿ ಮತ್ತು PHP ಯೊಂದಿಗೆ OOP ನಲ್ಲಿ ಪರಿಣಿತರಾಗಿ!

ಪರಿಚಯ

ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ (OOP) ಎನ್ನುವುದು ಅಪ್ಲಿಕೇಶನ್ ಮತ್ತು ವೆಬ್‌ಸೈಟ್ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುವ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾದರಿಯಾಗಿದೆ. ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಾಗಿ PHP, (https://informatecdigital.com/php-orientado-a-objetos-ejemplos-guia-completa/) ಗೆ ಸಂಪೂರ್ಣ ಬೆಂಬಲವನ್ನು ನೀಡುತ್ತದೆ, ಇದು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಹೆಚ್ಚು ಮಾಡ್ಯುಲರ್, ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ರಚಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಈ ಲೇಖನದಲ್ಲಿ, ನಾವು PHP ಯೊಂದಿಗೆ ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಸಮಗ್ರ ಉದಾಹರಣೆಗಳ ಮೂಲಕ ಅನ್ವೇಷಿಸುತ್ತೇವೆ. OOP ಯ ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಮತ್ತು ಅವುಗಳನ್ನು ನಿಮ್ಮ PHP ಯೋಜನೆಗಳಲ್ಲಿ ಹೇಗೆ ಅನ್ವಯಿಸಬೇಕು ಎಂಬುದನ್ನು ನೀವು ಕಲಿಯುವಿರಿ. ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಕೌಶಲ್ಯಗಳನ್ನು ಮುಂದಿನ ಹಂತಕ್ಕೆ ಕೊಂಡೊಯ್ಯಲು ಸಿದ್ಧರಾಗಿ!

ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಎಂದರೇನು?

ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ (OOP) ಎನ್ನುವುದು ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿ ವಿಧಾನವಾಗಿದ್ದು, ಇದು ಡೇಟಾ ಮತ್ತು ನಡವಳಿಕೆಯನ್ನು ಒಳಗೊಳ್ಳುವ ಸಂವಾದಾತ್ಮಕ "ವಸ್ತುಗಳ" ಕಲ್ಪನೆಯನ್ನು ಆಧರಿಸಿದೆ. ರಚನಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿರುವಂತೆ ಕಾರ್ಯಗಳು ಮತ್ತು ಕಾರ್ಯವಿಧಾನಗಳ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುವ ಬದಲು, OOP ನೈಜ-ಪ್ರಪಂಚದ ಘಟಕಗಳು ಅಥವಾ ಅಮೂರ್ತ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ವಸ್ತುಗಳ ನಡುವಿನ ಪರಸ್ಪರ ಕ್ರಿಯೆಯ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ. ಈ ವಸ್ತುಗಳನ್ನು ವರ್ಗಗಳಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ, ಅವು ಆ ವಸ್ತುಗಳ ನಿದರ್ಶನಗಳನ್ನು ರಚಿಸಲು ಟೆಂಪ್ಲೇಟ್‌ಗಳಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ.

ಪೂರ್ಣ ಉದಾಹರಣೆ: "ವ್ಯಕ್ತಿ" ವರ್ಗವನ್ನು ರಚಿಸುವುದು

ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಬಳಸಿ PHP ಯಲ್ಲಿ "ವ್ಯಕ್ತಿ" ವರ್ಗವನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂಬುದರ ಸಂಪೂರ್ಣ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

ವರ್ಗ ವ್ಯಕ್ತಿ {
// ಗುಣಲಕ್ಷಣಗಳು
ಸಾರ್ವಜನಿಕ $ಹೆಸರು;
ಸಾರ್ವಜನಿಕ ವಯಸ್ಸು;
// ಕನ್ಸ್ಟ್ರಕ್ಟರ್
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ __ನಿರ್ಮಾಣ($ಹೆಸರು, $ವಯಸ್ಸು) {
$ಈ->ಹೆಸರು = $ಹೆಸರು;
$ಈ->ವಯಸ್ಸು = $ವಯಸ್ಸು;
}
// ವಿಧಾನಗಳು
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ ಶುಭಾಶಯ () {
ಪ್ರತಿಧ್ವನಿ "ಹಲೋ! ನನ್ನ ಹೆಸರು {$this->name} ಮತ್ತು ನನಗೆ {$this->age} ವರ್ಷ.";
}
}

// "ವ್ಯಕ್ತಿ" ವರ್ಗದ ಒಂದು ನಿದರ್ಶನವನ್ನು ರಚಿಸಿ
$ವ್ಯಕ್ತಿ = ಹೊಸ ವ್ಯಕ್ತಿ("ಜುವಾನ್", 25);

// "ಶುಭಾಶಯ" ವಿಧಾನವನ್ನು ಕರೆ ಮಾಡಿ
$ವ್ಯಕ್ತಿ->ಶುಭಾಶಯ();

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು "ವ್ಯಕ್ತಿ" ಎಂಬ ವರ್ಗವನ್ನು ಎರಡು ಗುಣಲಕ್ಷಣಗಳೊಂದಿಗೆ ರಚಿಸಿದ್ದೇವೆ: "ಹೆಸರು" ಮತ್ತು "ವಯಸ್ಸು". ವರ್ಗದ ಹೊಸ ನಿದರ್ಶನವನ್ನು ರಚಿಸಿದಾಗ ಈ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲು ನಾವು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಸಹ ವ್ಯಾಖ್ಯಾನಿಸಿದ್ದೇವೆ. ಈ ವರ್ಗವು "greet" ಎಂಬ ವಿಧಾನವನ್ನು ಸಹ ಹೊಂದಿದೆ, ಇದು ಆಸ್ತಿ ಮೌಲ್ಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಶುಭಾಶಯ ಸಂದೇಶವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ ನಾಲ್ಕು ಸ್ತಂಭಗಳು

La ವಸ್ತು ಆಧಾರಿತ ಪ್ರೊಗ್ರಾಮಿಂಗ್ ಇದು ಘನ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಸಾಫ್ಟ್‌ವೇರ್ ವಿನ್ಯಾಸಕ್ಕೆ ಅನುವು ಮಾಡಿಕೊಡುವ ನಾಲ್ಕು ಮೂಲಭೂತ ಸ್ತಂಭಗಳನ್ನು ಆಧರಿಸಿದೆ. ಈ ಸ್ತಂಭಗಳು:

1. ಎನ್ಕ್ಯಾಪ್ಸುಲೇಷನ್

ಎನ್ಕ್ಯಾಪ್ಸುಲೇಷನ್ ಎಂದರೆ ಒಂದು ವಸ್ತುವಿನ ಆಂತರಿಕ ವಿವರಗಳನ್ನು ಮರೆಮಾಡುವ ಮತ್ತು ಅದರೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಸೀಮಿತ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಮಾತ್ರ ಬಹಿರಂಗಪಡಿಸುವ ಪ್ರಕ್ರಿಯೆ. ಇದನ್ನು ಸಾರ್ವಜನಿಕ, ಖಾಸಗಿ ಅಥವಾ ಸಂರಕ್ಷಿತ ಎಂದು ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ ಸಾಧಿಸಲಾಗುತ್ತದೆ. ಎನ್ಕ್ಯಾಪ್ಸುಲೇಷನ್ ಕೋಡ್ ಅನ್ನು ವ್ಯವಸ್ಥಿತವಾಗಿಡಲು, ಸೂಕ್ಷ್ಮ ಡೇಟಾವನ್ನು ರಕ್ಷಿಸಲು ಮತ್ತು ಕೋಡ್ ಓದುವಿಕೆ ಮತ್ತು ನಿರ್ವಹಣೆಯನ್ನು ಸುಧಾರಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಪೂರ್ಣ ಉದಾಹರಣೆ: “ಬ್ಯಾಂಕ್ ಖಾತೆ” ತರಗತಿಯಲ್ಲಿ ಎನ್ಕ್ಯಾಪ್ಸುಲೇಷನ್

ನಾವು ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಬಳಸಿ ಬ್ಯಾಂಕ್ ಖಾತೆಯನ್ನು ರೂಪಿಸಲು ಬಯಸುತ್ತೇವೆ ಎಂದು ಭಾವಿಸೋಣ. PHP ಯಲ್ಲಿ “ಬ್ಯಾಂಕ್ ಅಕೌಂಟ್” ತರಗತಿಯಲ್ಲಿ ಎನ್ಕ್ಯಾಪ್ಸುಲೇಷನ್ ಅನ್ನು ಹೇಗೆ ಅನ್ವಯಿಸಬೇಕು ಎಂಬುದರ ಸಂಪೂರ್ಣ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

ವರ್ಗ ಬ್ಯಾಂಕ್ ಖಾತೆ {
// ಖಾಸಗಿ ಆಸ್ತಿಗಳು
ಖಾಸಗಿ $ಬ್ಯಾಲೆನ್ಸ್;
// ಕನ್ಸ್ಟ್ರಕ್ಟರ್
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ __ನಿರ್ಮಾಣ($ಆರಂಭಿಕ ಸಮತೋಲನ) {
$ಈ->ಸಮತೋಲನ = $ಆರಂಭಿಕ ಸಮತೋಲನ;
}
// ಹಣವನ್ನು ಠೇವಣಿ ಮಾಡಲು ಸಾರ್ವಜನಿಕ ವಿಧಾನ
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ ಠೇವಣಿ ($ಮೊತ್ತ) {
$ಈ->ಬ್ಯಾಲೆನ್ಸ್ += $ಮೊತ್ತ;
}
// ಹಣವನ್ನು ಹಿಂಪಡೆಯಲು ಸಾರ್ವಜನಿಕ ವಿಧಾನ
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ ಹಿಂತೆಗೆದುಕೊಳ್ಳುವಿಕೆ ($ ಪ್ರಮಾಣ) {
($ಮೊತ್ತ <= $ಈ->ಬ್ಯಾಲೆನ್ಸ್) { ಆಗಿದ್ದರೆ
$ಈ->ಬ್ಯಾಲೆನ್ಸ್ -= $ಮೊತ್ತ;
} ಬೇರೆ {
ಪ್ರತಿಧ್ವನಿ "ಸಾಕಷ್ಟು ಸಮತೋಲನವಿಲ್ಲ.";
}
}
// ಪ್ರಸ್ತುತ ಸಮತೋಲನವನ್ನು ಪಡೆಯಲು ಸಾರ್ವಜನಿಕ ವಿಧಾನ
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ getBalance() {
$this->ಬ್ಯಾಲೆನ್ಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ;
}
}

// "ಬ್ಯಾಂಕ್ ಖಾತೆ" ವರ್ಗದ ಒಂದು ನಿದರ್ಶನವನ್ನು ರಚಿಸಿ
$ಖಾತೆ = ಹೊಸ ಬ್ಯಾಂಕ್ ಖಾತೆ(1000);

// ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಿ
$ಖಾತೆ->ಠೇವಣಿ(500);
$ಖಾತೆ->ಹಿಂತೆಗೆದುಕೊಳ್ಳುವಿಕೆ(200);

// ಪ್ರಸ್ತುತ ಸಮತೋಲನವನ್ನು ಪಡೆಯಿರಿ
ಪ್ರತಿಧ್ವನಿ "ಪ್ರಸ್ತುತ ಬ್ಯಾಲೆನ್ಸ್:" . $account->getBalance();

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು "ಬ್ಯಾಲೆನ್ಸ್" ಆಸ್ತಿಯನ್ನು ವರ್ಗದ ಹೊರಗಿನಿಂದ ಮರೆಮಾಡಲು ಖಾಸಗಿ ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಿದ್ದೇವೆ. ಈ ಆಸ್ತಿಯೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು, ನಾವು "ಠೇವಣಿ", "ಹಿಂತೆಗೆದುಕೊಳ್ಳುವಿಕೆ" ಮತ್ತು "ಸಮತೋಲನವನ್ನು ಪಡೆಯಿರಿ" ನಂತಹ ಸಾರ್ವಜನಿಕ ವಿಧಾನಗಳನ್ನು ರಚಿಸಿದ್ದೇವೆ. ಈ ವಿಧಾನಗಳು ಬ್ಯಾಂಕ್ ಖಾತೆಯಲ್ಲಿ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ನಿಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತವೆ, ಆದರೆ "ಬ್ಯಾಲೆನ್ಸ್" ಆಸ್ತಿಗೆ ನೇರ ಪ್ರವೇಶವನ್ನು ಅನುಮತಿಸುವುದಿಲ್ಲ.

2. ಆನುವಂಶಿಕತೆ

ಇನ್ಹೆರಿಟೆನ್ಸ್ ಎನ್ನುವುದು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ವರ್ಗವನ್ನು ಆಧರಿಸಿ ಹೊಸ ವರ್ಗವನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಒಂದು ಕಾರ್ಯವಿಧಾನವಾಗಿದೆ. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ತರಗತಿಯನ್ನು ಪೋಷಕ ವರ್ಗ ಅಥವಾ ಸೂಪರ್‌ಕ್ಲಾಸ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಆದರೆ ಹೊಸ ತರಗತಿಯನ್ನು ಮಕ್ಕಳ ವರ್ಗ ಅಥವಾ ಉಪವರ್ಗ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಆನುವಂಶಿಕತೆಯು ಕೋಡ್ ಮರುಬಳಕೆ ಮತ್ತು ವರ್ಗ ಶ್ರೇಣಿಗಳ ರಚನೆಯನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತದೆ, ಅಲ್ಲಿ ಮಕ್ಕಳ ತರಗತಿಗಳು ಪೋಷಕ ವರ್ಗದಿಂದ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುತ್ತವೆ.

ಪೂರ್ಣ ಉದಾಹರಣೆ: "ಪ್ರಾಣಿ" ಮತ್ತು "ನಾಯಿ" ತರಗತಿಗಳಲ್ಲಿ ಆನುವಂಶಿಕತೆ

ನಾವು ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಬಳಸಿ ವಿವಿಧ ರೀತಿಯ ಪ್ರಾಣಿಗಳನ್ನು ಮಾದರಿ ಮಾಡಲು ಬಯಸುತ್ತೇವೆ ಎಂದು ಭಾವಿಸೋಣ. PHP ಯಲ್ಲಿ “ಅನಿಮಲ್” ಮತ್ತು “ಡಾಗ್” ತರಗತಿಗಳಲ್ಲಿ ಆನುವಂಶಿಕತೆಯನ್ನು ಹೇಗೆ ಅನ್ವಯಿಸಬೇಕು ಎಂಬುದರ ಸಂಪೂರ್ಣ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

ವರ್ಗ ಪ್ರಾಣಿ {
// ಸಂರಕ್ಷಿತ ಆಸ್ತಿ
ಸಂರಕ್ಷಿತ $ಹೆಸರು;
// ಕನ್ಸ್ಟ್ರಕ್ಟರ್
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ __ನಿರ್ಮಾಣ($ಹೆಸರು) {
$ಈ->ಹೆಸರು = $ಹೆಸರು;
}
// ಹೆಸರನ್ನು ಪಡೆಯಲು ಸಾರ್ವಜನಿಕ ವಿಧಾನ
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ getName() {
$this->ಹೆಸರನ್ನು ಹಿಂತಿರುಗಿಸಿ;
}
// ಸಾರ್ವತ್ರಿಕ ಧ್ವನಿಯನ್ನು ಹೊರಸೂಸಲು ಸಾರ್ವಜನಿಕ ವಿಧಾನ
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ emitSound() {
ಪ್ರತಿಧ್ವನಿ "ಪ್ರಾಣಿ ಶಬ್ದ ಮಾಡುತ್ತದೆ.";
}
}

ವರ್ಗ ನಾಯಿ ವಿಸ್ತರಿಸುತ್ತದೆ ಪ್ರಾಣಿ {
// ತೊಗಟೆಗಳನ್ನು ಹೊರಸೂಸುವ ಸಾರ್ವಜನಿಕ ವಿಧಾನ
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ emitSound() {
ಪ್ರತಿಧ್ವನಿ "ನಾಯಿ ಬೊಗಳುತ್ತದೆ: ವೂಫ್ ವೂಫ್!";
}
}

// "ಡಾಗ್" ವರ್ಗದ ಒಂದು ನಿದರ್ಶನವನ್ನು ರಚಿಸಿ
$dog = ಹೊಸ ನಾಯಿ("ಫಿರುಲೈಸ್");

// ನಾಯಿಯ ಹೆಸರನ್ನು ಪಡೆಯಿರಿ
ಪ್ರತಿಧ್ವನಿ "ನಾಯಿಯ ಹೆಸರು:" . $dog->getName() . "
";

// ನಾಯಿಯ ಶಬ್ದ ಮಾಡಿ
$dog->ಪ್ಲೇಸೌಂಡ್();

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಪೋಷಕ ವರ್ಗವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ "ಪ್ರಾಣಿ" ವರ್ಗವನ್ನು ಮತ್ತು "ಪ್ರಾಣಿ" ವರ್ಗದಿಂದ ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುವ "ನಾಯಿ" ವರ್ಗವನ್ನು ರಚಿಸಿದ್ದೇವೆ. "ಅನಿಮಲ್" ವರ್ಗವು "ಹೆಸರು" ಎಂಬ ಸಂರಕ್ಷಿತ ಆಸ್ತಿಯನ್ನು ಮತ್ತು "getName" ಮತ್ತು "playSound" ಎಂಬ ಎರಡು ಸಾರ್ವಜನಿಕ ವಿಧಾನಗಳನ್ನು ಹೊಂದಿದೆ. "ನಾಯಿ" ವರ್ಗವು ನಿರ್ದಿಷ್ಟ ತೊಗಟೆಯನ್ನು ಹೊರಸೂಸಲು "ಹೊರಸೂಸುವ ಧ್ವನಿ" ವಿಧಾನವನ್ನು ಅತಿಕ್ರಮಿಸುತ್ತದೆ. "ಡಾಗ್" ವರ್ಗದ ಒಂದು ನಿದರ್ಶನವನ್ನು ರಚಿಸುವ ಮೂಲಕ, ನಾವು "ಅನಿಮಲ್" ವರ್ಗದಿಂದ "ಹೆಸರು" ಆಸ್ತಿ ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುತ್ತೇವೆ ಮತ್ತು ಅವುಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.

3. ಬಹುರೂಪತೆ

ಬಹುರೂಪತೆಯು ಒಂದು ವಸ್ತುವು ಸಂದರ್ಭಕ್ಕೆ ಅನುಗುಣವಾಗಿ ವಿಭಿನ್ನ ರೀತಿಯಲ್ಲಿ ವರ್ತಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ವಿಭಿನ್ನ ವರ್ಗಗಳಲ್ಲಿ ಒಂದೇ ಹೆಸರಿನ ವಿಧಾನಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ, ಆದರೆ ವಿಭಿನ್ನ ಅನುಷ್ಠಾನಗಳೊಂದಿಗೆ ಇದನ್ನು ಸಾಧಿಸಬಹುದು. ಬಹುರೂಪತೆಯು ವಿವಿಧ ವರ್ಗಗಳ ವಸ್ತುಗಳನ್ನು ಏಕರೂಪವಾಗಿ ಪರಿಗಣಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುವ ಮೂಲಕ ಕೋಡ್‌ನ ನಮ್ಯತೆ ಮತ್ತು ವಿಸ್ತರಣೆಯನ್ನು ಉತ್ತೇಜಿಸುತ್ತದೆ.

ಪೂರ್ಣ ಉದಾಹರಣೆ: "ಚಿತ್ರ" ಮತ್ತು "ವೃತ್ತ"/"ಆಯತ" ವರ್ಗಗಳೊಂದಿಗೆ ಬಹುರೂಪತೆ.

ನಾವು ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಬಳಸಿ ವಿಭಿನ್ನ ಜ್ಯಾಮಿತೀಯ ಆಕೃತಿಗಳನ್ನು ರೂಪಿಸಲು ಬಯಸುತ್ತೇವೆ ಎಂದು ಭಾವಿಸೋಣ. PHP ಯಲ್ಲಿ “ಆಕಾರ”, “ವೃತ್ತ” ಮತ್ತು “ಆಯತ” ತರಗತಿಗಳಲ್ಲಿ ಬಹುರೂಪತೆಯನ್ನು ಹೇಗೆ ಅನ್ವಯಿಸುವುದು ಎಂಬುದರ ಸಂಪೂರ್ಣ ಉದಾಹರಣೆ ಕೆಳಗೆ ಇದೆ:

ಅಮೂರ್ತ ವರ್ಗ ಚಿತ್ರ {
// ಪ್ರದೇಶವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಅಮೂರ್ತ ವಿಧಾನ
ಅಮೂರ್ತ ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ ಲೆಕ್ಕಾಚಾರಏರಿಯಾ();
}

ವರ್ಗ ವೃತ್ತವು ಚಿತ್ರ { ಅನ್ನು ವಿಸ್ತರಿಸುತ್ತದೆ
ಖಾಸಗಿ $ರೇಡಿಯೋ;

// ಕನ್ಸ್ಟ್ರಕ್ಟರ್
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ __ನಿರ್ಮಾಣ($ರೇಡಿಯೋ) {
$ಈ->ರೇಡಿಯೋ = $ರೇಡಿಯೋ;
}

// ಅಮೂರ್ತ ವಿಧಾನದ ಅನುಷ್ಠಾನ
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ ಲೆಕ್ಕಾಚಾರ ಪ್ರದೇಶ () {
ರಿಟರ್ನ್ ಪೈ() * ಪೌ($this->ರೇಡಿಯೋ, 2);
}
}

ವರ್ಗ ಆಯತವು ಚಿತ್ರ { ವಿಸ್ತರಿಸುತ್ತದೆ
ಖಾಸಗಿ $ಬೇಸ್;
ಖಾಸಗಿ $ ಎತ್ತರ;

// ಕನ್ಸ್ಟ್ರಕ್ಟರ್
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ __ನಿರ್ಮಾಣ($ಬೇಸ್, $ಎತ್ತರ) {
$ಈ->ಬೇಸ್ = $ಬೇಸ್;
$ಈ->ಎತ್ತರ = $ಎತ್ತರ;
}

// ಅಮೂರ್ತ ವಿಧಾನದ ಅನುಷ್ಠಾನ
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ ಲೆಕ್ಕಾಚಾರ ಪ್ರದೇಶ () {
$this->ಬೇಸ್ * $this->ಎತ್ತರವನ್ನು ಹಿಂತಿರುಗಿಸಿ;
}
}

// "ವೃತ್ತ" ಮತ್ತು "ಆಯತ" ತರಗತಿಗಳ ನಿದರ್ಶನಗಳನ್ನು ರಚಿಸಿ
$ವೃತ್ತ = ಹೊಸ ವೃತ್ತ(5);
$ಆಯತ = ಹೊಸ ಆಯತ(4, 6);

// ಬಹುರೂಪತೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರದೇಶಗಳನ್ನು ಲೆಕ್ಕಹಾಕಿ
ಪ್ರತಿಧ್ವನಿ "ವೃತ್ತದ ಪ್ರದೇಶ: " . $circle->calculateArea() . "
";
ಪ್ರತಿಧ್ವನಿ "ಆಯತದ ಪ್ರದೇಶ:" . $rectangle->calculateArea();

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು "calculateArea" ಎಂಬ ಅಮೂರ್ತ ವಿಧಾನದೊಂದಿಗೆ "Figure" ಎಂಬ ಅಮೂರ್ತ ವರ್ಗವನ್ನು ರಚಿಸಿದ್ದೇವೆ. ಮುಂದೆ, ನಾವು "ಸರ್ಕಲ್" ಮತ್ತು "ರೆಕ್ಟ್ಯಾಂಗಲ್" ಎಂಬ ಎರಡು ವರ್ಗಗಳನ್ನು ರಚಿಸಿದ್ದೇವೆ, ಅದು "ಆಕಾರ" ವರ್ಗದಿಂದ ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುತ್ತದೆ ಮತ್ತು "ಕ್ಯಾಲ್ಕುಲೇಟ್ ಏರಿಯಾ" ವಿಧಾನದ ಕಾಂಕ್ರೀಟ್ ಅನುಷ್ಠಾನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ವೃತ್ತ ಮತ್ತು ಆಯತ ವರ್ಗಗಳನ್ನು ನಿದರ್ಶನಗೊಳಿಸುವ ಮೂಲಕ ಮತ್ತು ಕ್ಯಾಲ್ಕುಲೇಟ್ ಏರಿಯಾ ವಿಧಾನವನ್ನು ಕರೆಯುವ ಮೂಲಕ, ನಾವು ಪ್ರತಿಯೊಂದು ಜ್ಯಾಮಿತೀಯ ಆಕೃತಿಯ ನಿರ್ದಿಷ್ಟ ಪ್ರದೇಶವನ್ನು ಪಡೆಯಬಹುದು.

4. ಅಮೂರ್ತತೆ

ಅಮೂರ್ತೀಕರಣವು ಒಂದು ವಸ್ತುವಿನ ಅಗತ್ಯ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಗುರುತಿಸುವ ಮತ್ತು ಆ ವಸ್ತುವಿನ ಸರಳೀಕೃತ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ವರ್ಗದ ರೂಪದಲ್ಲಿ ರಚಿಸುವ ಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ. ಅಮೂರ್ತತೆಯು ಅನಗತ್ಯ ವಿವರಗಳನ್ನು ಮರೆಮಾಡುವ ಮೂಲಕ ಮತ್ತು ಸಂಬಂಧಿತ ಅಂಶಗಳ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುವ ಮೂಲಕ ಸಂಕೀರ್ಣತೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಅಮೂರ್ತ ತರಗತಿಗಳು ಮತ್ತು ಇಂಟರ್ಫೇಸ್‌ಗಳು ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ಅಮೂರ್ತತೆಯನ್ನು ಸಾಧಿಸಲು ಬಳಸುವ ಸಾಮಾನ್ಯ ಸಾಧನಗಳಾಗಿವೆ.

PHP ಯೊಂದಿಗೆ ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ ಸಂಪೂರ್ಣ ಉದಾಹರಣೆಗಳು

ಕೆಳಗೆ ನಾವು PHP ಯೊಂದಿಗೆ ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ ಸಂಪೂರ್ಣ ಉದಾಹರಣೆಗಳ ಸರಣಿಯನ್ನು ಪ್ರಸ್ತುತಪಡಿಸುತ್ತೇವೆ. ಈ ಉದಾಹರಣೆಗಳು ವಿಭಿನ್ನ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಒಳಗೊಂಡಿವೆ ಮತ್ತು ನಿಮ್ಮ PHP ಯೋಜನೆಗಳಲ್ಲಿ OOP ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಅನ್ವಯಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.

1. ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಿಧಾನಗಳೊಂದಿಗೆ "ಉತ್ಪನ್ನ" ವರ್ಗವನ್ನು ರಚಿಸುವುದು

ಉತ್ಪನ್ನ ವರ್ಗ {
ಖಾಸಗಿ $ಹೆಸರು;
ಖಾಸಗಿ $ಬೆಲೆ;

ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ __ನಿರ್ಮಾಣ($ಹೆಸರು, $ಬೆಲೆ) {
$ಈ->ಹೆಸರು = $ಹೆಸರು;
$ಈ->ಬೆಲೆ = $ಬೆಲೆ;
}

ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ getName() {
$this->ಹೆಸರನ್ನು ಹಿಂತಿರುಗಿಸಿ;
}

ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ getPrice() {
$ಈ->ಬೆಲೆಯನ್ನು ಹಿಂತಿರುಗಿಸಿ;
}

ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ ಪ್ರದರ್ಶನ ವಿವರಗಳು() {
ಪ್ರತಿಧ್ವನಿ "ಹೆಸರು: " . $this->ಹೆಸರು . "
";
ಪ್ರತಿಧ್ವನಿ "ಬೆಲೆ: $ " . $this->ಬೆಲೆ . "
";
}
}

$ಉತ್ಪನ್ನ = ಹೊಸ ಉತ್ಪನ್ನ("ಟಿ-ಶರ್ಟ್", 29.99);
$ಉತ್ಪನ್ನ->ವಿವರಗಳನ್ನು ತೋರಿಸಿ();

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು "ಹೆಸರು" ಮತ್ತು "ಬೆಲೆ" ಎಂಬ ಖಾಸಗಿ ಗುಣಲಕ್ಷಣಗಳೊಂದಿಗೆ "ಉತ್ಪನ್ನ" ವರ್ಗವನ್ನು ರಚಿಸಿದ್ದೇವೆ. ವರ್ಗದ ನಿದರ್ಶನವನ್ನು ರಚಿಸಿದಾಗ ಈ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಜವಾಬ್ದಾರನಾಗಿರುತ್ತಾನೆ. ಈ ತರಗತಿಯು ಉತ್ಪನ್ನದ ಹೆಸರು ಮತ್ತು ಬೆಲೆಯನ್ನು ಪಡೆಯುವ ವಿಧಾನಗಳನ್ನು ಹೊಂದಿದೆ, ಜೊತೆಗೆ ಪೂರ್ಣ ಉತ್ಪನ್ನ ವಿವರಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

2. "ವಾಹನ" ಮತ್ತು "ಆಟೋಮೊಬೈಲ್" ವರ್ಗಗಳ ನಡುವಿನ ಆನುವಂಶಿಕತೆ

ವರ್ಗ ವಾಹನ {
ಸಂರಕ್ಷಿತ $ಬ್ರ್ಯಾಂಡ್;

ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ __ನಿರ್ಮಾಣ($ಗುರುತು) {
$ಈ->ಬ್ರ್ಯಾಂಡ್ = $ಬ್ರ್ಯಾಂಡ್;
}

ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ getBrand() {
$this->ಬ್ರಾಂಡ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ;
}

ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ ಡ್ರೈವ್() {
ಪ್ರತಿಧ್ವನಿ "ವಾಹನ ಚಾಲನೆ...";
}
}

ವರ್ಗ ಆಟೋಮೊಬೈಲ್ ವಾಹನವನ್ನು ವಿಸ್ತರಿಸುತ್ತದೆ {
ಖಾಸಗಿ $ಮಾದರಿ;

ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ __ನಿರ್ಮಾಣ($ಬ್ರಾಂಡ್, $ಮಾದರಿ) {
ಪೋಷಕ::__ನಿರ್ಮಾಣ($ಬ್ರಾಂಡ್);
$ಈ->ಮಾದರಿ = $ಮಾದರಿ;
}

ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ getModel() {
$this->ಮಾದರಿ ಹಿಂತಿರುಗಿ;
}

ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ ಪ್ರದರ್ಶನ ವಿವರಗಳು() {
ಪ್ರತಿಧ್ವನಿ "ಬ್ರ್ಯಾಂಡ್: " . $this->ಬ್ರ್ಯಾಂಡ್ . "
";
ಪ್ರತಿಧ್ವನಿ «ಮಾದರಿ: » . $ಈ->ಮಾದರಿ . «
";
}
}

$ಆಟೋಮೊಬೈಲ್ = ಹೊಸ ಆಟೋಮೊಬೈಲ್("ಟೊಯೋಟಾ", "ಕೊರೊಲ್ಲಾ");
$ಆಟೋಮೊಬೈಲ್->ವಿವರಗಳನ್ನು ತೋರಿಸಿ();
$ಕಾರ್->ಡ್ರೈವ್();

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು "ವಾಹನ" ವರ್ಗವನ್ನು ರಚಿಸಿದ್ದೇವೆ, ಇದರಲ್ಲಿ "ತಯಾರಿಸು" ಎಂಬ ಸಂರಕ್ಷಿತ ಆಸ್ತಿ ಮತ್ತು ವಾಹನವನ್ನು ಉತ್ಪಾದಿಸುವ ಮತ್ತು ಚಾಲನೆ ಮಾಡುವ ವಿಧಾನಗಳು ಸೇರಿವೆ. ಮುಂದೆ, ನಾವು "ವಾಹನ" ವರ್ಗದಿಂದ ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುವ "ಕಾರು" ವರ್ಗವನ್ನು ರಚಿಸಿದ್ದೇವೆ ಮತ್ತು ಖಾಸಗಿ ಆಸ್ತಿ "ಮಾದರಿ" ಮತ್ತು ಕಾರಿನ ಸಂಪೂರ್ಣ ವಿವರಗಳನ್ನು ಪ್ರದರ್ಶಿಸುವ ವಿಧಾನವನ್ನು ಸೇರಿಸುತ್ತೇವೆ. "ಕಾರ್" ವರ್ಗದ ಒಂದು ನಿದರ್ಶನವನ್ನು ರಚಿಸುವ ಮೂಲಕ, ನಾವು ಪೋಷಕ ವರ್ಗದ ವಿಧಾನಗಳು ಮತ್ತು ಮಕ್ಕಳ ವರ್ಗದ ನಿರ್ದಿಷ್ಟ ವಿಧಾನಗಳೆರಡನ್ನೂ ಪ್ರವೇಶಿಸಬಹುದು.

3. "ಪ್ರಾಣಿ" ಮತ್ತು "ಬೆಕ್ಕು" ತರಗತಿಗಳಲ್ಲಿ ಬಹುರೂಪತೆಯನ್ನು ಅನ್ವಯಿಸುವುದು.

ಅಮೂರ್ತ ವರ್ಗ ಪ್ರಾಣಿ {
ಸಂರಕ್ಷಿತ $ಹೆಸರು;

ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ __ನಿರ್ಮಾಣ($ಹೆಸರು) {
$ಈ->ಹೆಸರು = $ಹೆಸರು;
}

ಅಮೂರ್ತ ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ makeSound();
}

ವರ್ಗ ನಾಯಿ ವಿಸ್ತರಿಸುತ್ತದೆ ಪ್ರಾಣಿ {
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ makeSound() {
ಪ್ರತಿಧ್ವನಿ "ನಾಯಿ ಬೊಗಳುತ್ತದೆ: ವೂಫ್ ವೂಫ್!";
}
}

ವರ್ಗ ಬೆಕ್ಕು ಪ್ರಾಣಿಯನ್ನು ವಿಸ್ತರಿಸುತ್ತದೆ {
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ makeSound() {
ಪ್ರತಿಧ್ವನಿ «ಬೆಕ್ಕು ಮಿಯಾಂವ್: ಮಿಯಾಂವ್!»;
}
}

$dog = ಹೊಸ ನಾಯಿ("ಫಿರುಲೈಸ್");
$cat = ಹೊಸ Cat("Garfield");

$dog->ಮೇಕ್‌ಸೌಂಡ್();
$cat->ಮೇಕ್‌ಸೌಂಡ್();

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು "makeSound" ಎಂಬ ಅಮೂರ್ತ ವಿಧಾನದೊಂದಿಗೆ "Animal" ಎಂಬ ಅಮೂರ್ತ ವರ್ಗವನ್ನು ರಚಿಸಿದ್ದೇವೆ. ಮುಂದೆ, ನಾವು "ಡಾಗ್" ಮತ್ತು "ಕ್ಯಾಟ್" ತರಗತಿಗಳನ್ನು ರಚಿಸಿದ್ದೇವೆ, ಅದು "ಅನಿಮಲ್" ವರ್ಗದಿಂದ ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುತ್ತದೆ ಮತ್ತು "ಮೇಕ್‌ಸೌಂಡ್" ವಿಧಾನದ ನಿರ್ದಿಷ್ಟ ಅನುಷ್ಠಾನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. "ನಾಯಿ" ಮತ್ತು "ಬೆಕ್ಕು" ವರ್ಗಗಳ ನಿದರ್ಶನಗಳಲ್ಲಿ "ಮೇಕ್‌ಸೌಂಡ್" ವಿಧಾನವನ್ನು ಕರೆಯುವ ಮೂಲಕ, ಪ್ರತಿಯೊಂದು ಪ್ರಾಣಿಯು ಹೇಗೆ ವಿಭಿನ್ನ ಶಬ್ದವನ್ನು ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ನಾವು ನೋಡಬಹುದು.

4. "ಪಾವತಿ" ಮತ್ತು "ಪೇಪಾಲ್" ತರಗತಿಗಳಲ್ಲಿ ಇಂಟರ್ಫೇಸ್‌ಗಳನ್ನು ಬಳಸುವುದು

ಇಂಟರ್ಫೇಸ್ ಪಾವತಿ {
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ ಪ್ರಕ್ರಿಯೆ ಪಾವತಿ($ಮೊತ್ತ);
}

ವರ್ಗ ಪೇಪಾಲ್ ಪಾವತಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ {
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ ಪ್ರಕ್ರಿಯೆ ಪಾವತಿ($ಮೊತ್ತ) {
ಪ್ರತಿಧ್ವನಿ "$ ಪಾವತಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತಿದೆ". $ಮೊತ್ತ. "ಪೇಪಾಲ್ ಮೂಲಕ...";
}
}

ವರ್ಗ ಕ್ರೆಡಿಟ್‌ಕಾರ್ಡ್ ಪಾವತಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ {
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ ಪ್ರಕ್ರಿಯೆ ಪಾವತಿ($ಮೊತ್ತ) {
ಪ್ರತಿಧ್ವನಿ "$ ಪಾವತಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತಿದೆ". $ಮೊತ್ತ. "ಕ್ರೆಡಿಟ್ ಕಾರ್ಡ್ ಮೂಲಕ...";
}
}

$ಪೇಪಾಲ್ = ಹೊಸ ಪೇಪಾಲ್();
$ಕಾರ್ಡ್ = ಹೊಸ ಕ್ರೆಡಿಟ್ ಕಾರ್ಡ್();

$ಪೇಪಾಲ್->ಪ್ರಕ್ರಿಯೆಪಾವತಿ(100);
$ಕಾರ್ಡ್->ಪ್ರಕ್ರಿಯೆಪಾವತಿ(50);

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು "processPayment" ವಿಧಾನದೊಂದಿಗೆ "ಪಾವತಿ" ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ರಚಿಸಿದ್ದೇವೆ. ಮುಂದೆ, ನಾವು "ಪೇಪಾಲ್" ಮತ್ತು "ಕ್ರೆಡಿಟ್‌ಕಾರ್ಡ್" ತರಗತಿಗಳನ್ನು ರಚಿಸಿದ್ದೇವೆ, ಅದು "ಪಾವತಿ" ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ ಮತ್ತು "ಪ್ರಕ್ರಿಯೆ ಪಾವತಿ" ವಿಧಾನದ ನಿರ್ದಿಷ್ಟ ಅನುಷ್ಠಾನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ವರ್ಗಗಳ ನಿದರ್ಶನಗಳಲ್ಲಿ “processPayment” ವಿಧಾನವನ್ನು ಕರೆಯುವ ಮೂಲಕ, ನಾವು ವಿಭಿನ್ನ ಪಾವತಿ ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಪಾವತಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಹುದು.

ಈ ಉದಾಹರಣೆಗಳು PHP ಯಲ್ಲಿ ನೀವು ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದರ ಕಲ್ಪನೆಯನ್ನು ನೀಡುತ್ತದೆ. PHP ಯೊಂದಿಗೆ ನಿಮ್ಮ ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಕೌಶಲ್ಯಗಳನ್ನು ಸುಧಾರಿಸಲು ಹೆಚ್ಚಿನ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಅಭ್ಯಾಸಗಳನ್ನು ಅನ್ವೇಷಿಸಿ.

ಪದೇ ಪದೇ ಕೇಳಲಾಗುವ ಪ್ರಶ್ನೆಗಳು

PHP ಯೊಂದಿಗೆ ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ ಅನುಕೂಲಗಳು ಯಾವುವು?

PHP ಯೊಂದಿಗಿನ ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಹಲವಾರು ಪ್ರಯೋಜನಗಳನ್ನು ನೀಡುತ್ತದೆ, ಉದಾಹರಣೆಗೆ ಕೋಡ್ ಮರುಬಳಕೆ, ಮಾಡ್ಯುಲಾರಿಟಿ, ಕೋಡ್ ಓದುವಿಕೆ ಮತ್ತು ನಿರ್ವಹಣೆ, ಮತ್ತು ವಸ್ತುಗಳು ಮತ್ತು ಅವುಗಳ ಪರಸ್ಪರ ಕ್ರಿಯೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸಮಸ್ಯೆಗಳನ್ನು ಹೆಚ್ಚು ನಿಖರವಾಗಿ ರೂಪಿಸುವ ಸಾಮರ್ಥ್ಯ. ಇದರ ಜೊತೆಗೆ, ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮತ್ತು ವೆಬ್‌ಸೈಟ್‌ಗಳ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಹೆಚ್ಚಿನ ನಮ್ಯತೆ ಮತ್ತು ವಿಸ್ತರಣೆಗೆ OOP ಅನುಮತಿಸುತ್ತದೆ.

PHP ಯಲ್ಲಿ ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಪ್ರೋಗ್ರಾಮ್ ಮಾಡಲು ಕಲಿಯುವುದು ಅಗತ್ಯವೇ?

PHP ಯಲ್ಲಿ ಪ್ರೋಗ್ರಾಮ್ ಮಾಡಲು ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಕಲಿಯುವುದು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಅಗತ್ಯವಿಲ್ಲ, ಏಕೆಂದರೆ PHP ಸಹ ರಚನಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, PHP ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮತ್ತು ವೆಬ್‌ಸೈಟ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವಲ್ಲಿ ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಕಲಿಯುವುದರಿಂದ ಹೆಚ್ಚು ಮಾಡ್ಯುಲರ್, ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಕೋಡ್‌ಗೆ ಬಾಗಿಲು ತೆರೆಯುತ್ತದೆ.

ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ವರ್ಗ ಮತ್ತು ವಸ್ತುವಿನ ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು?

ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ, ವರ್ಗವು ಒಂದು ಟೆಂಪ್ಲೇಟ್ ಅಥವಾ ಅಚ್ಚು ಆಗಿದ್ದು, ಅದರಿಂದ ರಚಿಸಲಾದ ವಸ್ತುಗಳು ಹೊಂದಿರುವ ಸಾಮಾನ್ಯ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಮತ್ತೊಂದೆಡೆ, ಒಂದು ವಸ್ತುವು ಒಂದು ವರ್ಗದ ನಿರ್ದಿಷ್ಟ ನಿದರ್ಶನವಾಗಿದ್ದು, ಅದು ತನ್ನದೇ ಆದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ವರ್ಗದಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ವಿಧಾನಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು.

PHP ಯೊಂದಿಗೆ ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ನೀವು ಯಾವಾಗ ಆನುವಂಶಿಕತೆಯನ್ನು ಬಳಸಬೇಕು?

ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ವರ್ಗವನ್ನು ಆಧರಿಸಿ ಹೊಸ ವರ್ಗವನ್ನು ರಚಿಸಲು ನೀವು ಬಯಸಿದಾಗ, ಅದರ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುವ ಮತ್ತು ಹೆಚ್ಚುವರಿ ಕಾರ್ಯವನ್ನು ಸೇರಿಸುವ ಅಥವಾ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ನಡವಳಿಕೆಯನ್ನು ಮಾರ್ಪಡಿಸುವ ಗುರಿಯೊಂದಿಗೆ, ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ಇನ್ಹೆರಿಟೆನ್ಸ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಇನ್ಹೆರಿಟೆನ್ಸ್ ಕೋಡ್ ಮರುಬಳಕೆ ಮತ್ತು ವರ್ಗ ಶ್ರೇಣಿಗಳ ರಚನೆಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಇದು ಕೋಡ್ ಅನ್ನು ಸಂಘಟಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.

PHP ಯಲ್ಲಿ ಅಮೂರ್ತ ವರ್ಗ ಮತ್ತು ಇಂಟರ್ಫೇಸ್ ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು?

ಅಮೂರ್ತ ವರ್ಗವು ನೇರವಾಗಿ ನಿದರ್ಶನಗೊಳಿಸಲಾಗದ ವರ್ಗವಾಗಿದೆ, ಆದರೆ ಉಪವರ್ಗಗಳನ್ನು ರಚಿಸಲು ಆಧಾರವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಇದು ಕಾಂಕ್ರೀಟ್ ಅನುಷ್ಠಾನಗಳೊಂದಿಗೆ ವಿಧಾನಗಳು ಮತ್ತು ಉಪವರ್ಗಗಳಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾದ ಅಮೂರ್ತ ವಿಧಾನಗಳನ್ನು ಒಳಗೊಂಡಿರಬಹುದು. ಮತ್ತೊಂದೆಡೆ, ಇಂಟರ್ಫೇಸ್ ಎನ್ನುವುದು ಅಮೂರ್ತ ವಿಧಾನಗಳ ಸಂಗ್ರಹವಾಗಿದ್ದು, ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಯಾವುದೇ ವರ್ಗವು ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು. ಒಂದು ವರ್ಗವು ಬಹು ಇಂಟರ್ಫೇಸ್‌ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು, ಆದರೆ ಒಂದು ಅಮೂರ್ತ ವರ್ಗದಿಂದ ಮಾತ್ರ ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯಬಹುದು.

ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ಎನ್ಕ್ಯಾಪ್ಸುಲೇಷನ್‌ನ ಪ್ರಾಮುಖ್ಯತೆ ಏನು?

ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಷನ್ ಮೂಲಭೂತವಾಗಿದೆ ಏಕೆಂದರೆ ಇದು ವಸ್ತುವಿನ ಆಂತರಿಕ ವಿವರಗಳನ್ನು ಮರೆಮಾಡಲು ಮತ್ತು ಅದರೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಸೀಮಿತ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಮಾತ್ರ ಬಹಿರಂಗಪಡಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದು ಸೂಕ್ಷ್ಮ ಡೇಟಾವನ್ನು ರಕ್ಷಿಸಲು, ವಸ್ತುವಿನ ಸ್ಥಿತಿಯ ಸ್ಥಿರತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಮತ್ತು ಕೋಡ್ ಓದುವಿಕೆ ಮತ್ತು ನಿರ್ವಹಣೆಯನ್ನು ಸುಧಾರಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ವಸ್ತುವಿನ ಆಂತರಿಕ ಬದಲಾವಣೆಗಳು ಅದರೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವ ಇತರ ವಸ್ತುಗಳ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲವಾದ್ದರಿಂದ, ಎನ್ಕ್ಯಾಪ್ಸುಲೇಷನ್ ಕೋಡ್ ವಿಕಸನವನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತದೆ.

ತೀರ್ಮಾನಕ್ಕೆ

PHP ಯೊಂದಿಗೆ ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮತ್ತು ವೆಬ್‌ಸೈಟ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಪ್ರಬಲ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವ ವಿಧಾನವಾಗಿದೆ. ತರಗತಿಗಳು, ವಸ್ತುಗಳು, ಆನುವಂಶಿಕತೆ, ಬಹುರೂಪತೆ ಮತ್ತು ಅಮೂರ್ತತೆಯನ್ನು ಬಳಸಿಕೊಂಡು, ನೀವು ಮಾಡ್ಯುಲರ್, ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ರಚಿಸಬಹುದು. ಈ ಲೇಖನದಲ್ಲಿ, ನಾವು PHP ಯೊಂದಿಗೆ ಸಂಪೂರ್ಣ ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಉದಾಹರಣೆಗಳನ್ನು ಅನ್ವೇಷಿಸಿದ್ದೇವೆ, ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಒಳಗೊಂಡಿದ್ದೇವೆ ಮತ್ತು ಅವುಗಳ ಪ್ರಾಯೋಗಿಕ ಅನ್ವಯವನ್ನು ತೋರಿಸುತ್ತೇವೆ. ಈ ಉದಾಹರಣೆಗಳು ನಿಮ್ಮ PHP ಯೋಜನೆಗಳಲ್ಲಿ ವಸ್ತು-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಅನ್ವಯಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡಿದೆ ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ!