Heim > Backend-Entwicklung > PHP-Tutorial > Objektorientierte PHP-Programmierung – Grundübung TAG 2

Objektorientierte PHP-Programmierung – Grundübung TAG 2

WBOY
Freigeben: 2016-07-29 09:15:05
Original
1028 Leute haben es durchsucht
ObjektorientiertÜbung in PHP
Grundlegende Übung
Fortgeschrittene Übung
Spezielle Übung
Klassenkonzept
Instanziierungskonzept
Konstruktor
Destruktorfunktion
Datenzugriff
ObjektReferenzkonzept
Klassenkonzept
PHP-orientierte <img src=
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 KlasseObjekt? Das
Objekt der Klasse wird als Instanz der Klasse (Instanz) bezeichnet // Die Klasse zeichnet ein Framework und das ObjektDas 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-orientierte <p>Objekt<img src=Objektorientierte PHP-Programmierung - TAG 2

PHP面向<strong></strong>Fall<br>Klasse und Klasseninstanziierungsfall</p>? Wie definiere ich eine Klasse <br>? um ein <br> Objekt einer Klasse <br><br> zu instanziieren? Wie rufe ich eine Methode einer Klasse <strong></strong> auf? 🎜>Jordan<br>Dribbling <br>Passen <br>Konstruktor<p></p><pre name=<?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
PHP-orientiert <br>Objekt<p> Programmierung – Grundübung TAG 2James ist ein Objekt
. $james ist ein Verweis auf das Objekt
und verweist direkt auf James, das PHP面向<strong>Objekt</strong>. <br>$james1 und $james sind zwei unabhängige Referenzen von $james1, dem <strong>Objekt</strong>, verweist direkt auf James, das <br>Objekt<strong>. </strong>$james2 ist eine <strong>Objekt</strong>-Referenz, die auf $james, das <br>Objekt<strong>, verweist (ein bisschen wie ein Schluck), und nicht direkt auf James, das </strong>Objekt verweist <strong>. $james2 zeigt auf das </strong> von James, das <br>Objekt<strong>, durch die Referenz von $james, das </strong>Objekt<strong>, und zeigt nun direkt auf das </strong>Objekt<strong>James </strong>Objekt<strong> Es gibt zwei Referenzen, nämlich $james und $james1. Und $james2 ist das Bild von $james. </strong>Beispiel 1:<strong></strong>Ausgabe:<br>In NbaPlayer Constructor<strong>Jordan</strong>Dribbling<strong>Passen</strong>In NbaPlayer Constructor<br>James</p>Von jetzt an wird James es tun nicht verwendet werden.<pre name=<?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
Destroying James
Von nun an wird James nicht mehr verwendet.
Destroying Jordan

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.


Verwandte Etiketten:
Quelle:php.cn
Vorheriger Artikel:PHP-Deduplizierung mehrdimensionaler Arrays (Deduplizierung für jeden Schlüsselwert) – Eindeutigkeit des zweidimensionalen Arrays – Zeitkomplexität ~Ein Nächster Artikel:PHP-Parameterübergabemethode 1 – Ajax
Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Neueste Artikel des Autors
Aktuelle Ausgaben
verwandte Themen
Mehr>
Beliebte Empfehlungen
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage