Heim > Artikel > Backend-Entwicklung > Ausführliche Erläuterung der drei objektorientierten Datenzugriffsmethoden von PHP (Codebeispiele)
Ausführliche Erläuterung der drei objektorientierten Datenzugriffsmethoden von PHP (Codebeispiele)
- 易达Original
- 2020-05-24 17:15:312150Durchsuche
Das Ziel dieses Artikels
Beherrschen Sie die Definition und Funktion der drei Datenzugriffsmethoden in PHP
1, public
2, protected
3. private
(1). 3 Möglichkeiten des Datenzugriffs
1 PublicKann überall zugegriffen werden, insbesondere auf Folgendes:
● Die Klasse, die diese Klasse definiert (selbst)
● Unterklassen dieser Klasse
● Andere Klassen
2.
: Geschützte KlassenmitgliederProtected● Die Klasse, die diese Klasse definiert (selbst)
● Die Unterklasse dieser Klasse
3 .
: Private KlassenmitgliederPrivate● Nur Sie können darauf zugreifen
Basierend auf der obigen Textbeschreibung ist es für uns immer noch etwas schwierig, es zu verstehen, daher sollten wir es theoretisch und praktisch verstehen. Dann werden wir diese drei Datenzugriffsmethoden durch spezifische Codes verstehen. Was sind ihre jeweiligen Eigenschaften? Lassen Sie uns abschließend ihre Bindungsfähigkeiten verstehen.
(2) Spezifischer Code
Erklärung: Damit jeder objektorientiert besser verstehen kann, versuche ich beim Schreiben von Artikeln auch bestimmte Regeln zu befolgen zu tief, von einfach bis schwierig, daher bezieht sich jeder Artikel, den ich schreibe, auf den vorherigen Artikel. Im folgenden Codefall erweitere und erweitere ich beispielsweise den Code des vorherigen Artikels.
Fall 1: Kennen Sie die Definition von öffentlich und beweisen Sie dann, dass an drei Stellen darauf zugegriffen werden kann (1. In Ihrer eigenen definierten Klasse, 2. In Unterklasse 3. Außerhalb)
<?php
//定义 “人” 类
class Human{
public $name = "";//姓名
public $height = "";//身高
public $weight = "";//体重
public function eat($food){
echo $this->name."在吃".$food."<br/>";
}
}
//女主播
class Anchors extends Human{
public $name = "";
public $stageName = "";
public function __construct( $name,$stageName ){
$this->name = $name;
$this->stageName = $stageName;
}
public function singing(){
echo "我是女主播，我会唱歌<br/>";
}
}
// Nba球员类
class NbaPlayer extends Human{
//因为父类已经有了，所以就不需要再写了，通过extends来实现
// public $name = "";//姓名
// public $height = "";//身高
// public $weight = "";//体重
public $team = "";//团队
public $playerName = "";//球员号码
public function __construct( $name,$height,$weight,$team,$playerName ){
$this->name = $name;
$this->height=$height;
$this->weight = $weight;
$this->team = $team;
$this->playName = $playerName;
echo "构造函数执行了,当前对象是{$this->name}<br/>";
}
//跑步
public function run(){
echo "跑步中<br/>";
}
//跳跃
public function jump(){
echo "跳跃<br/>";
}
//运球
public function dribble(){
echo "运球<br/>";
}
//传球
public function pass(){
echo "传球<br/>";
}
//投篮
public function shoot(){
echo "投篮<br/>";
}
//扣篮
public function dunk(){
echo "扣篮<br/>";
}
}
//数据访问测试
//public 测试
//1、测试在类的外部可以访问
//创建乔丹对象
$jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
//输出乔丹对象
echo "名称= ".$jordon->name."<br/>";//结果能够输出来，说明在外部是可以访问Public类成员的
//2、测试在类的自身里面可以访问
//例子：比如构造函数里，我们可以直接通过$this->team
//3、测试是否可以子类中可以访问
//例子：比如父类中定义的name 一样可以在子类（NbaPlayer）的构造函数中直接访问
?>Der Operationseffekt ist wie folgt:
<?php
//定义“人”类
class Human{
public $name = "";//姓名
public $height = "";//身高
public $weight = "";//体重
protected $addr = "长沙";//受保护的类
public function eat($food){
echo $this->name."在吃".$food."<br/>";
}
//测试protected类成员是否可以在自身类中可以访问
public function getAddrInHuman(){
echo "Human 自身类中的add=".$this->addr."<br/>";
}
}
//女主播
class Anchors extends Human{
public $name = "";
public $stageName = "";
public function __construct( $name,$stageName ){
$this->name = $name;
$this->stageName = $stageName;
}
public function singing(){
echo "我是女主播，我会唱歌<br/>";
}
//重写方法eat
public function eat($food){
echo "我是女主播，我是边唱歌边吃{$food}<br/>";
}
}
class NbaPlayer extends Human{
//因为父类已经有了，所以就不需要再写了，通过extends来实现
// public $name = "";//姓名
// public $height = "";//身高
// public $weight = "";//体重
public $team = "";//团队
public $playerName = "";//球员号码
public function __construct( $name,$height,$weight,$team,$playerName ){
$this->name = $name;
$this->height=$height;
$this->weight = $weight;
$this->team = $team;
$this->playName = $playerName;
echo "构造函数执行了,当前对象是{$this->name}<br/>";
}
//测试protected类成员是否可以在子类中可以访问
public function getAddrInNbaPlayer(){
echo "在NbaPlayer子类中addr=".$this->addr."<br/>";
}
}
//创建乔丹对象
$jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
//数据访问测试
//protected测试
//1、测试是否可以在自身类中可以访问
$jordon->getAddrInHuman();//结果OK，确实是可以访问
//2.测试是否可以在子类中访问
$jordon->getAddrInNbaPlayer();//结果OK，确实也是可以访问
//3.测试是否可以被外部访问
echo "在类外部访问addr=".$jordon->addr."<br/>";//结果报错，说明不行
?>Der Operationseffekt ist wie folgt folgt:
<?php
//定义“人”类
class Human{
public $name = "";//姓名
public $height = "";//身高
public $weight = "";//体重
private $isHungry = true;//测试私有变量是否可以在子类中访问
//为了让外部可以访问private类成员
public function getPrivateInfo(){
return "private 变量 isHungry=".$this->isHungry."<br/>";
}
}
//女主播
class Anchors extends Human{
public $name = "";
public $stageName = "";
public function __construct( $name,$stageName ){
$this->name = $name;
$this->stageName = $stageName;
}
public function singing(){
echo "我是女主播，我会唱歌<br/>";
}
//重写方法eat
public function eat($food){
echo "我是女主播，我是边唱歌边吃{$food}<br/>";
}
}
class NbaPlayer extends Human{
//因为父类已经有了，所以就不需要再写了，通过extends来实现
// public $name = "";//姓名
// public $height = "";//身高
// public $weight = "";//体重
public $team = "";//团队
public $playerName = "";//球员号码
public function __construct( $name,$height,$weight,$team,$playerName ){
$this->name = $name;
$this->height=$height;
$this->weight = $weight;
$this->team = $team;
$this->playName = $playerName;
// echo "构造函数执行了,当前对象是{$this->name}<br/>";
}
//测试private类成员是否可以在子类中访问
public function getIsHungryInNbaPlayer(){
echo "在NbaPlayer子类中isHungry=".$this->isHungry."<br/>";
}
}
//创建乔丹对象
$jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
//数据访问测试
//private测试
//1.测试私有变量能否被外部访问
echo "私有变量isHungry =".$jordon->isHungry ."<br/>";//结果不能访问，说明private变量不能被子类访问
//测试私有变量能否在定义的类的内部访问
echo $jordon->getPrivateInfo();//结果Ok，说明可以
//测试私有变量是否可以在子类中访问
$jordon->getIsHungryInNbaPlayer();//结果报错，说明也不能在子类中访问
?>Der Operationseffekt ist wie folgt:
1. Öffentlich: Auf öffentliche Klassenmitglieder
kann überall zugegriffen werden, insbesondere auf welche:
● Die Klasse, die dies definiert Klasse (selbst)
● Unterklassen dieser Klasse
● Andere Klassen
2. Geschützt: Geschützte Klassenmitglieder
● Auf sie selbst und sie zugreifen können seine Unterklassen
3. Privat: Private Klassenmitglieder
● Nur Sie können darauf zugreifen
4. Damit die Außenwelt auf private Klassenmitglieder zugreifen kann, können wir dies tun Definieren Sie ein öffentliches Mitglied in der Klassenmethode und geben Sie dann das private Klassenmitglied in der öffentlichen Methode zurück
Okay, jetzt, wo wir hier sind, denke ich, dass jeder ein klareres Verständnis des Datenzugriffs haben sollte, also wenden wir was an Wir haben jetzt gelernt, die folgenden Fragen zu lösen. Überlegen Sie zunächst, wie es geht, und schauen Sie sich dann die Antworten an.
Frage: NBA-Spieler möchten zum Beispiel nicht, dass andere ihre richtigen Namen kennen , ich bin offensichtlich 40 Jahre alt, aber ich möchte nur, dass andere denken, ich sei 38 Jahre alt
Wenn ich darüber nachdenke.................... ..
Die Antwort wird enthüllt:
Der Code lautet wie folgt:
<?php
class Human{
public $name = "";//姓名
public $height = "";//身高
public $weight = "";//体重
}
//女主播
class Anchors extends Human{
public $name = "";
public $stageName = "";
public function __construct( $name,$stageName ){
$this->name = $name;
$this->stageName = $stageName;
}
public function singing(){
echo "我是女主播，我会唱歌<br/>";
}
//重写方法eat
public function eat($food){
echo "我是女主播，我是边唱歌边吃{$food}<br/>";
}
}
class NbaPlayer extends Human{
//因为父类已经有了，所以就不需要再写了，通过extends来实现
// public $name = "";//姓名
// public $height = "";//身高
// public $weight = "";//体重
public $team = "";//团队
public $playerName = "";//球员号码
//数据访问
private $age = "40";
//end
public function __construct( $name,$height,$weight,$team,$playerName ){
$this->name = $name;
$this->height=$height;
$this->weight = $weight;
$this->team = $team;
$this->playName = $playerName;
echo "构造函数执行了,当前对象是{$this->name}<br/>";
}
//跑步
public function run(){
echo "跑步中<br/>";
}
//跳跃
public function jump(){
echo "跳跃<br/>";
}
//运球
public function dribble(){
echo "运球<br/>";
}
//传球
public function pass(){
echo "传球<br/>";
}
//投篮
public function shoot(){
echo "投篮<br/>";
}
//扣篮
public function dunk(){
echo "扣篮<br/>";
}
//数据访问
public function getAge(){
// echo $this->name."的age=".$this->age."<br/>";
//既然能够在自身类中获取到年龄，那么为了解决NBA球员不想让别人知道自己真实年龄的问题
//我们就可以对年龄进行操作-造假 让年龄更小
$age = $this->age-2;
echo $this->name."的age=".$age."<br/>";
}
}
//创建乔丹对象
$jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
$jordon->getAge();//结果Ok 说明年龄是可以获取到的，既然可以获取到age我们在函数内部作假，来达到一个谎报年龄的目的
?>Der Laufeffekt ist wie folgt:
 "159031095638380Ausführliche Erläuterung der drei objektorientierten Datenzugriffsmethoden von PHP (Codebeispiele)")
1. Wissen Sie, dass es in PHP drei Formen des Datenzugriffs gibt: öffentlich, geschützt und privat
2. Wissen die Eigenschaften der drei Datenzugriffsmethoden
Das obige ist der detaillierte Inhalt vonAusführliche Erläuterung der drei objektorientierten Datenzugriffsmethoden von PHP (Codebeispiele). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!