ObjektorientiertÜbung in PHP
Grundlegende Übung
Fortgeschrittene Übung
Spezielle Übung
Klassenkonzept
Instanziierungskonzept
Konstruktor
Destruktorfunktion
Datenzugriff
ObjektReferenzkonzept
Klassenkonzept
Klasse
? Vögel einer Feder scharen sich zusammen, gruppieren
Objekte mit ähnlichen Eigenschaften in einem Klasse
? Eine Klasse definiert die gleichen Eigenschaften und Methoden
, die diesen ähnlichen Objekten
gehören. Eine Klasse ist eine Beschreibung eines ähnlichen
Objekts , das als Definition von bezeichnet wird Die Klasse. Der Bauplan oder Prototyp der Klasse
Objekt? Das
Objekt
der Klasse wird als Instanz der Klasse (Instanz) bezeichnet // Die Klasse zeichnet ein Framework und das Objekt
Das Framework ist vollständig? Die Attribute und Methoden einer Klasse werden gemeinsam als Klassenmitglieder bezeichnet
Beispiel
? NBA-Spieler sind die Definition einer Klasse (Klassendefinition)
? James und Kobe werden Instanzen der Klasse (Instanz)
NBA-Spieler
+Name
+Größe
+Gewicht
+Team
+Spielernummer
--- genannt. ---------
+Running()
+Jump()
+Dribbling()
+Shoot()
+Dunk()
+Pass( )
Instanz instanziieren
<?php
//类的定义以关键字class开始,后面跟着这个类的名称。类的命名通常每个单词的第一个字母大写。以中括号开始和结束
//定义NbaPlayer类
class NbaPlayer{
//定义属性
public $name="Jordan";
public $height="198cm";
public $weight="98kg";
public $team="Bull";
public $playerNumber="23";
//定义方法
public function run(){
echo "Running\n";
}
public function jump(){
echo "Jumping\n";
}
public function dribble(){
echo "Dribbling\n";
}
public function shoot(){
echo "Shooting\n";
}
public function dunk(){
echo "Dunking\n";
}
public function pass(){
echo "Passing\n";
}
}
//类到<strong>对象</strong>的实例化
//类的实例化为<strong>对象</strong>时使用关键字new,new之后紧跟这类的名称和一对括号
$jordan = new NbaPlayer();
//<strong>对象</strong>中的属性成员可以通过->符号来访问
echo $jordan->name."\n";
//<strong>对象</strong>中的成员方法可以通过->符号来访问
$jordan->dribble();
$jordan->pass();
?>Ausgabe:<br>In NbaPlayer Konstruktor<br>Jordan<br>Dribbeln<br>Passen<br>In NbaPlayer Konstruktor </p>
<div class="code" style="position:relative; padding:0px; margin:0px;"><pre name="code"><?php
date_default_timezone_set("PRC");
//类的定义以关键字class开始,后面跟着这个类的名称。类的命名通常每个单词的第一个字母大写。以中括号开始和结束
//定义NbaPlayer类
class NbaPlayer{
//定义属性
public $name="Jordan";
public $height="198cm";
public $weight="98kg";
public $team="Bull";
public $playerNumber="23";
//构造函数,在<strong>对象</strong>被实例化的时候自动调用
function __construct($name,$height,$weight,$team,$playerNumber){ //没有被明确调用,但是也被调用了
echo "In NbaPlayer Constructor\n";
$this->name=$name; //$this是PHP里的伪变量,表示<strong>对象</strong>自身。可以通过$this->的方法访问<strong>对象</strong>的属性和方法
$this->height=$height;
$this->weight=$weight;
$this->team=$team;
$this->playerNumber=$playerNumber;
}
//定义方法
public function run(){
echo "Running\n";
}
public function jump(){
echo "Jumping\n";
}
public function dribble(){
echo "Dribbling\n";
}
public function shoot(){
echo "Shooting\n";
}
public function dunk(){
echo "Dunking\n";
}
public function pass(){
echo "Passing\n";
}
}
//类到<strong>对象</strong>的实例化
//类的实例化为<strong>对象</strong>时使用关键字new,new之后紧跟这类的名称和一对括号
$jordan = new NbaPlayer("Jordan","198cm","98kg","Bull","23");
//<strong>对象</strong>中的属性成员可以通过->符号来访问
echo $jordan->name."\n";
//<strong>对象</strong>中的成员方法可以通过->符号来访问
$jordan->dribble();
$jordan->pass();
//每一次用new实例化<strong>对象</strong>的时候,都会用类名后面的参数列比调用构造函数
$james= new NbaPlayer("James","203cm","120kg","Heat","6");
echo $james->name;
echo $james->height;
echo $james->weight;
echo $james->team;
echo $james->playerNumber;
?>
Nach dem Login kopieren
James
203cm
120kg
Heat
6
Destructor
Ausgabe:
In NbaPlayer Constructor
Jordan
Dribbeln
Passen
In NbaPlayer Constructor
James
<?php
date_default_timezone_set("PRC");
//类的定义以关键字class开始,后面跟着这个类的名称。类的命名通常每个单词的第一个字母大写。以中括号开始和结束
//定义NbaPlayer类
class NbaPlayer{
//定义属性
public $name="Jordan";
public $height="198cm";
public $weight="98kg";
public $team="Bull";
public $playerNumber="23";
//构造函数,在<strong>对象</strong>被实例化的时候自动调用
function __construct($name,$height,$weight,$team,$playerNumber){ //没有被明确调用,但是也被调用了
echo "In NbaPlayer Constructor\n";
$this->name=$name; //$this是PHP里的伪变量,表示<strong>对象</strong>自身。可以通过$this->的方法访问<strong>对象</strong>的属性和方法
$this->height=$height;
$this->weight=$weight;
$this->team=$team;
$this->playerNumber=$playerNumber;
}
//析构函数,在程序执行结束的时候会自动调用
//析构函数通常被用于清理程序使用的资源,比如程序使用了打印机,那么可以在析构函数里面释放打印机资源。
function __destruct(){
echo "Destroying ".$this->name."<br/>";
}
//定义方法
public function run(){
echo "Running\n";
}
public function jump(){
echo "Jumping\n";
}
public function dribble(){
echo "Dribbling\n";
}
public function shoot(){
echo "Shooting\n";
}
public function dunk(){
echo "Dunking\n";
}
public function pass(){
echo "Passing\n";
}
}
//类到<strong>对象</strong>的实例化
//类的实例化为<strong>对象</strong>时使用关键字new,new之后紧跟这类的名称和一对括号
$jordan = new NbaPlayer("Jordan","198cm","98kg","Bull","23");
//<strong>对象</strong>中的属性成员可以通过->符号来访问
echo $jordan->name."\n";
//<strong>对象</strong>中的成员方法可以通过->符号来访问
$jordan->dribble();
$jordan->pass();
//每一次用new实例化<strong>对象</strong>的时候,都会用类名后面的参数列比调用构造函数
$james= new NbaPlayer("James","203cm","120kg","Heat","6");
echo $james->name;
//通过把变量设置为null,可以触发析构函数的调用
$james=null;
echo "From now on James will not be used. <br/>";
?>
Nach dem Login kopieren
James zerstören
Von jetzt an wird James nicht mehr verwendet.
Jordan zerstören
Grundkonzepte von Objekt
Referenz
Objekt
Referenzzuweisung
James ist ein Objekt
.
$james ist ein Verweis auf das Objekt
und verweist direkt auf James, das
<?php
date_default_timezone_set("PRC");
//类的定义以关键字class开始,后面跟着这个类的名称。类的命名通常每个单词的第一个字母大写。以中括号开始和结束
//定义NbaPlayer类
class NbaPlayer{
//定义属性
public $name="Jordan";
public $height="198cm";
public $weight="98kg";
public $team="Bull";
public $playerNumber="23";
//构造函数,在<strong>对象</strong>被实例化的时候自动调用
function __construct($name,$height,$weight,$team,$playerNumber){ //没有被明确调用,但是也被调用了
echo "In NbaPlayer Constructor\n";
$this->name=$name; //$this是PHP里的伪变量,表示<strong>对象</strong>自身。可以通过$this->的方法访问<strong>对象</strong>的属性和方法
$this->height=$height;
$this->weight=$weight;
$this->team=$team;
$this->playerNumber=$playerNumber;
}
//析构函数,在程序执行结束的时候会自动调用
//析构函数通常被用于清理程序使用的资源,比如程序使用了打印机,那么可以在析构函数里面释放打印机资源。
function __destruct(){
echo "Destroying ".$this->name."<br/>";
}
//定义方法
public function run(){
echo "Running\n";
}
public function jump(){
echo "Jumping\n";
}
public function dribble(){
echo "Dribbling\n";
}
public function shoot(){
echo "Shooting\n";
}
public function dunk(){
echo "Dunking\n";
}
public function pass(){
echo "Passing\n";
}
}
//类到<strong>对象</strong>的实例化
//类的实例化为<strong>对象</strong>时使用关键字new,new之后紧跟这类的名称和一对括号
$jordan = new NbaPlayer("Jordan","198cm","98kg","Bull","23");
//<strong>对象</strong>中的属性成员可以通过->符号来访问
echo $jordan->name."\n";
//<strong>对象</strong>中的成员方法可以通过->符号来访问
$jordan->dribble();
$jordan->pass();
//每一次用new实例化<strong>对象</strong>的时候,都会用类名后面的参数列比调用构造函数
$james= new NbaPlayer("James","203cm","120kg","Heat","6");
echo $james->name;
//通过把变量设置为null,可以触发析构函数的调用
//当<strong>对象</strong>不会再被使用的时候,会触发析构函数
//james1也是指向new NbaPlayer();
$james1=$james;
$james=null;
echo "From now on James will not be used. <br/>";
?>Destroying James<br>Destroying Jordan<br>Beispiel 2:<br><br><br>Ausgabe:<br>In NbaPlayer Constructor<br>Jordan<br>Dribbling<br>Passen<br>Im NbaPlayer Constructor<br>James<div class="code" style="position:relative; padding:0px; margin:0px;"><pre name="code"><?php
date_default_timezone_set("PRC");
//类的定义以关键字class开始,后面跟着这个类的名称。类的命名通常每个单词的第一个字母大写。以中括号开始和结束
//定义NbaPlayer类
class NbaPlayer{
//定义属性
public $name="Jordan";
public $height="198cm";
public $weight="98kg";
public $team="Bull";
public $playerNumber="23";
//构造函数,在<strong>对象</strong>被实例化的时候自动调用
function __construct($name,$height,$weight,$team,$playerNumber){ //没有被明确调用,但是也被调用了
echo "In NbaPlayer Constructor\n";
$this->name=$name; //$this是PHP里的伪变量,表示<strong>对象</strong>自身。可以通过$this->的方法访问<strong>对象</strong>的属性和方法
$this->height=$height;
$this->weight=$weight;
$this->team=$team;
$this->playerNumber=$playerNumber;
}
//析构函数,在程序执行结束的时候会自动调用
//析构函数通常被用于清理程序使用的资源,比如程序使用了打印机,那么可以在析构函数里面释放打印机资源。
function __destruct(){
echo "Destroying ".$this->name."<br/>";
}
//定义方法
public function run(){
echo "Running\n";
}
public function jump(){
echo "Jumping\n";
}
public function dribble(){
echo "Dribbling\n";
}
public function shoot(){
echo "Shooting\n";
}
public function dunk(){
echo "Dunking\n";
}
public function pass(){
echo "Passing\n";
}
}
//类到<strong>对象</strong>的实例化
//类的实例化为<strong>对象</strong>时使用关键字new,new之后紧跟这类的名称和一对括号
$jordan = new NbaPlayer("Jordan","198cm","98kg","Bull","23");
//<strong>对象</strong>中的属性成员可以通过->符号来访问
echo $jordan->name."\n";
//<strong>对象</strong>中的成员方法可以通过->符号来访问
$jordan->dribble();
$jordan->pass();
//每一次用new实例化<strong>对象</strong>的时候,都会用类名后面的参数列比调用构造函数
$james= new NbaPlayer("James","203cm","120kg","Heat","6");
echo $james->name;
//通过把变量设置为null,可以触发析构函数的调用
//当<strong>对象</strong>不会再被使用的时候,会触发析构函数
//james1也是指向new NbaPlayer();
$james1=$james; //$james1直接指向詹姆斯
$james2=&james; //$james2相当于$james的影子,指向$james, $james再指向詹姆斯
$james=null; //不需要再次设置$james2=null,因为他俩的效果是一样的
$james1=null; //任何一个赋值为null相当于删除了一个<strong>对象</strong>的引用
echo "From now on James will not be used. <br/>";
?>
Nach dem Login kopieren
Von nun an wird James nicht mehr verwendet.
Das Obige stellt die objektorientierte PHP-Programmierung vor – grundlegende Übung am 2. Tag, einschließlich einiger Aspekte des Inhalts. Ich hoffe, dass es für Freunde hilfreich sein wird, die sich für PHP-Tutorials interessieren.