当定义好类后，我们使用new关键字来生成一个对象。
$对象名称 = new 类名称()；
$对象名称 = new 类名称([参数列表])；
对象是实际存在的，占有动态资源。
类是对象的蓝图，可能占有静态资源。
对象属性占有动态资源
类（静态）属性实际上是有类名字空间上的“全局变量”
性能考虑:
每个对象要单独占用数据空间
增加的调用层次可能消耗执行时间
输出一串22222
php与Java相同，都有垃圾回收机制，但是后者程序负载较低的时候，回收，前者对象引用消失就执行垃圾回收
栈的引用后进先出，先“高老师再见”，如果想调整顺序，可以赋空值
多亏我心虚，写了一遍==
$对象名称 = new 类名称()；
$对象名称 = new 类名称([参数列表])；
由于对象资料封装的特性，对象属性（类中定义的变量）是无法由主程序区块直接来访问的，必须通过对象来调用类中所定义的属性和行为函数，间接地达成存取控制类中资料的目的。
<?php
//声明一个电话类Phone
class Phone {
//类中成员同上（略）
}
// 声明一个人类Person
class Person {
//类中成员同上（略）
}
//通过Person类实例化三个对象$person1、$person2、$person3
$person1 = new Person(); //创建第一个Person类对象，引用名为$person1
$person2 = new Person(); //创建第二个Person类对象，引用名为$person2
$person3 = new Person(); //创建第三个Person类对象，引用名为$person3
//通过Phone类实例化三个对象$phone1、$phone2、$phone3
$phone1 = new Phone(); //创建第一个Phone类对象，引用名为$phone1
$phone2 = new Phone(); //创建第二个Phone类对象，引用名为$phone2
$phone3 = new Phone(); //创建第三个Phone类对象，引用名为$phone3
对象中成员的访问
类中包含成员属性与成员方法两个部分，我们可以使用“new”关键字来创建一个对象，即：$引用名 = new 类名(构造参数)；那么我们可以使用特殊运算符“->”来访问对象中的成员属性或成员方法。如：
$引用名 = new 类名(构造参数)；
$引用名->成员属性=赋值； //对象属性赋值
echo $引用名->成员属性； //输出对象的属性
$引用名->成员方法（参数）；//调用对象的方法
如果对象中的成员不是静态的，那么这是唯一的访问方式。
对象和类的关系: $引用名 = new 类名(构造参数)；
$引用名->成员属性=赋值； //对象属性赋值
echo $引用名->成员属性； //输出对象的属性
$引用名->成员方法（参数）；//调用对象的方法
如果对象中的成员不是静态的，那么这是唯一的访问方式。
对象是实际存在的，占有动态资源。
类是对象的蓝图，可能占有静态资源。
对象属性占有动态资源
类（静态）属性实际上是有类名字空间上的“全局变量”
性能考虑:
每个对象要单独占用数据空间
增加的调用层次可能消耗执行时间
<?php
/*
* 属性
* 性别：男
* 年龄: 24
* 身高: 175cm
* 眼睛: 大
*
*
* 行为
*
* 做饭
* 做家务
*
* class 类名 {
*
*
* }
*
* 注意: 在类的成员属性前面一定要有一个修饰词， 如果不知道使用什么修饰词， 就可以使用var (关键字), 如果一旦有其它的修饰词就不要有var
*
*/
class BoyFriend {
//变量 (成员属性)
var $name = "gaoluofeng";
var $age = 24;
var $sex = "男";
//函数 (成员方法)
public function doFan($rou, $cai) {
return "做饭的功能<br>";
}
function doJW() {
return "做家务的功能<br>";
}
}
$bf1 = new BoyFriend();
$bf1 -> name = "张三";
$bf2 = new BoyFriend;
$bf2 -> name = "李四";
echo $bf1->sex."<br>";
echo $bf2->height."<br>";
echo $bf1 -> dofan("牛肉", "土豆");
echo $bf2 -> dojw();
<?php
include "boyfriend.class.php";$bf1=new BoyFriend();等号右边分配了一个存储首地址，由于地址本身是十六进制的整数，所以$bf1接受的整数储存在栈内存中。（可以这么理解==，兄弟连的视频也没说怎么着的是对的）
特殊的对象引用”$this”
特殊对象的引用$this就是在对象内部的成员方法中，代表本对象的一个引用，但只能在对象的成员方法中使用，不管是在对象内部使用$this访问自己对象内部成员。还是在对象外部通过对象的引用名称访问对象中的成员，都需要使用特殊的运算符“->”来完成访问。（这玩意用讲？？？，感觉兄弟连的视频真的是面向0基础的童鞋，怪不得学员榜里面学校都不咋地）
<?php
/** 声明一个人类Person，其中包含三个成员属性和两个成员方法 */
class Person {
//下面是声明人的成员属性
public $name; //定义人的名字
public $sex; //定义人的性别
public $age; //定义人的年龄
//下面是声明人的成员方法
public function say(){
//在类中声明说话的方法，使用$this访问自己对象内部的成员属性
echo "我的名字：".$this->name."， 性别：".$this->sex."， 年龄：".$this->age."。<br>";
}
//在类中声明另一个方法
public function run(){
echo $this->name."在走路<br>"; //使用$this访问$name属性
}
public function demo(){
$this->say(); //在此方法中调用其它方法
}
}
构造方法
大多数类都有一种称为构造函数的特殊方法。当创建一个对象时，它将自动调用构造函数，通常用它执行一些有用的初始化任务。
构造函数的声明与其它操作的声明一样，只是其名称必须是两个下划线__construct( )。这是PHP5中的变化；PHP4的版本中，构造函数的名称必须与类名相同。为了向下兼容，如果一个类中没有名为__construct( )的方法，PHP将搜索一个与类名相同的方法。
格式： [修饰符] function __construct ( [参数] ) {
... ...
}
构造函数的声明与其它操作的声明一样，只是其名称必须是两个下划线__construct( )。这是PHP5中的变化；PHP4的版本中，构造函数的名称必须与类名相同。为了向下兼容，如果一个类中没有名为__construct( )的方法，PHP将搜索一个与类名相同的方法。
格式： [修饰符] function __construct ( [参数] ) {
... ...
}
<?php
/*
* 属性
* 性别：男
* 年龄: 24
* 身高: 175cm
* 眼睛: 大
*
*
* 行为
*
* 做饭
* 做家务
*
* class 类名 {
*
*
* }
*
* 注意: 在类的成员属性前面一定要有一个修饰词， 如果不知道使用什么修饰词， 就可以使用var (关键字), 如果一旦有其它的修饰词就不要有var
*
*
* 只要是对象中的成员， 就必须使用这个对象来访问到这个对象内部的属性和方法
*
*
* 构造方法
*
* 1. 是对象创建完成以后， 第一个 自动调用的方法(特殊)
* 2. 方法名称比较特殊 可以和类名相同名的方法名
* 3. 给对象中的成员赋初值使用的 *
*
*
*
* */
class BoyFriend {
//变量 (成员属性)
var $name;
var $age;
var $sex;
function BoyFriend($name, $age, $sex="男") {
$this->name = $name;
$this->age = $age;
$this->sex = $sex;
}
//函数 (成员方法)
public function doFan() {
echo "{$this->name} 有做饭的功能<br>";
$this->doJW();
}
function doJW() {
echo "做家务的功能<br>";
}
}
$bf1 = new BoyFriend("高洛峰", 28);
$bf2 = new BoyFriend("高老师", 26, "男");
$bf1 -> doFan();
$bf2 -> doFan();
魔术方法初步：
php当中同一个类中不允许用函数重载！！！
<?php
/*
* 属性
* 性别：男
* 年龄: 24
* 身高: 175cm
* 眼睛: 大
*
*
* 行为
*
* 做饭
* 做家务
*
* class 类名 {
*
*
* }
*
* 注意: 在类的成员属性前面一定要有一个修饰词， 如果不知道使用什么修饰词， 就可以使用var (关键字), 如果一旦有其它的修饰词就不要有var
*
*
* 只要是对象中的成员， 就必须使用这个对象来访问到这个对象内部的属性和方法
*
*
* 构造方法
*
* 1. 是对象创建完成以后， 第一个 自动调用的方法(特殊)
* 2. 方法名称比较特殊 可以和类名相同名的方法名
* 3. 给对象中的成员赋初值使用的 *
*
* 魔术方法 __construct();
*
* */
class BoyFriend {
//变量 (成员属性)
var $name;
var $age;
var $sex;
function __construct($name, $age, $sex="男") {//这个类里面也可以有构造方法，名字都不相同，当然不算重载啊，但是建议用魔术方法
$this->name = $name;
$this->age = $age;
$this->sex = $sex;
echo "222222222222222<br>";
}
//函数 (成员方法)
public function doFan() {
echo "{$this->name} 有做饭的功能<br>";
$this->doJW();
}
function doJW() {
echo "做家务的功能<br>";
}
function __destruct() {
echo "{$this->name} 再见! <br>";
}
}
$bf1 = new BoyFriend("高洛峰", 28);
$bf2 = new BoyFriend("高老师", 26, "男");
$bf1 -> doFan();
$bf2 -> doFan();
$bf1=null;
输出一串22222
析构函数
与构造函数相对的就是析构函数。析构函数是PHP5新添加的内容，在PHP4中没有析构函数。析构函数是在对象被销毁之前自动调用的方法，主要执行一些特定的操作，例如关闭文件，释放结果集等。
与构造函数的名称类似，一个类的析构函数名称必须是两个下划线 _ _destruct( )。析构函数不能带有任何参数。
<?php
class Person {
//声明的析构方法，在对象销毁前自动调用
public function __destruct() {
echo "再见".$this->name."<br>";
}
}
php与Java相同，都有垃圾回收机制，但是后者程序负载较低的时候，回收，前者对象引用消失就执行垃圾回收
<?php
/*
* 属性
* 性别：男
* 年龄: 24
* 身高: 175cm
* 眼睛: 大
*
*
* 行为
*
* 做饭
* 做家务
*
* class 类名 {
*
*
* }
*
* 注意: 在类的成员属性前面一定要有一个修饰词， 如果不知道使用什么修饰词， 就可以使用var (关键字), 如果一旦有其它的修饰词就不要有var
*
*
* 只要是对象中的成员， 就必须使用这个对象来访问到这个对象内部的属性和方法
*
*
* 析构方法
*
* 对象释放前自动调用，方法名特殊，php有资源类型，对象用完，需要释放资源
*
*
* 魔术方法 __construct();
*
* */
class BoyFriend {
//变量 (成员属性)
var $name;
var $age;
var $sex;
function __construct($name, $age, $sex="男") {
$this->name = $name;
$this->age = $age;
$this->sex = $sex;
echo "222222222222222<br>";
}
//函数 (成员方法)
public function doFan() {
echo "{$this->name} 有做饭的功能<br>";
$this->doJW();
}
function doJW() {
echo "做家务的功能<br>";
}
function __destruct() {
<pre> echo "{$this->name} 再见! <br>";
<pre> }
}
$bf1 = new BoyFriend("高洛峰", 28);
$bf2 = new BoyFriend("高老师", 26, "男");
$bf1 -> doFan();
$bf2 -> doFan();
$bf1=null;栈的引用后进先出，先“高老师再见”，如果想调整顺序，可以赋空值
综合栗子：
<?php
/*
* 只看封装的一部分， 方法的封装
*
*
* 将一些“特殊的方法 ” 加上一个 关键字 private修饰， 就不能拿到这个对象之后， 用对象中private有的内容, 但对象自己中的其它成员可以使用这个， 因为是自己用自己的成员
*
*
*
*/
class Person {
//成员属性
private $name;
private $age;
private $sex;
//构造方法
function __construct($name="", $age=0, $sex="男") {
$this->name = $name;
$this->age = $age;
$this->sex = $sex;
}
function setSex($sex) {
if(!($sex=="男" or $sex =="女"))
return;
$this->sex = $sex;
}
function getAge() {
if($this->age < 20){
return $this->age;
}else if($this->age < 30){
return $this->age - 5;
}else if($this->age < 40) {
return $this->age - 8;
}else{
return 29;
}
}
//成员方法
function say() {
echo "我的名子是：{$this->name}, 我的年龄是：{$this->age}, 我的性别是：{$this->sex}.<br>";
}
function run() {
$this->left();
$this->left();
$this->right();
$this->right();
$this->go();
$this->go();
$this->go();
}
private function left() {
echo "迈左脚<br>";
}
private function right() {
echo "迈右脚<br>";
}
private function go() {
echo "前进<br>";
}
function eat() {
$this->say();
}
//析构方法
function __destruct() {
echo "再见:{$this->name} <br>";
}
}
$p1 = new Person("妹子", 88, "女");
//$p1->age=120;
// echo $p1->age;
// $p1 -> setSex("男");
//
echo $p1 -> getAge();
// echo $p1->say();封装性
封装性是面向对象编程中的三大特性之一，封装就是把对象中的成员属性和成员方法加上访问修饰符，使其尽可能隐藏对象的内部细节，以达到对成员的访问控制(切记不是拒绝访问)。
这是PHP5的新特性，但却是OOP语言的一个好的特性。而且大多数OOP语言都已支持此特性。
PHP5支持如下3种访问修饰符:
public (公有的 默认的)
private (私有的)
protected (受保护的)
这是PHP5的新特性，但却是OOP语言的一个好的特性。而且大多数OOP语言都已支持此特性。
PHP5支持如下3种访问修饰符:
public (公有的 默认的)
private (私有的)
protected (受保护的)
只要在声明成员属性或成员方法时，使用private关键字修饰就是实现了对成员的私有封装。封装后的成员在对象的外部不能直接访问，只能在对象的内部方法中使用 $this访问。
<?php
class Person {
private $name; //第一个成员属性$name定义人的名字，此属性被封装
private $sex; //第二个成员属性$sex定义人的性别，此属性被封装
public function __construct($name="", $sex="男") {
$this->name = $name;
$this->sex = $sex;
}
private function leftLeg() { //声明一个迈左腿的方法，被封装所以只能在内部使用
return "迈左腿";
}
}
__set()、__get()、__isset()和__unset()
魔术方法：
__set()： 用于替代通用的set赋值方法
__get(): 用于替代通用的get取值方法
__isset()： 检测对象中成员属性是否存在
__unset()： 销毁对象中成员属性方法
注意：
上面四个魔术方法只对类中的私有、受保护成员属性有效。
魔术方法前的修饰符可以是公有、私有，不影响调用。
__set()： 用于替代通用的set赋值方法
__get(): 用于替代通用的get取值方法
__isset()： 检测对象中成员属性是否存在
__unset()： 销毁对象中成员属性方法
注意：
上面四个魔术方法只对类中的私有、受保护成员属性有效。
魔术方法前的修饰符可以是公有、私有，不影响调用。
__set( )方法：
格式 [修饰符] function __set(string $name,mixed $value){
... }
当我们直接为一个对象中非公有属性赋值时会自动调用此方法，并将属性名以第一个参数(string)，值作为第二参数(mixed)传进此方法中。
__get( )方法：
格式：[修饰符] function __get(string $name){ ... }
当我们直接输出一个对象中非公有属性时会自动调用此方法，并将属性名以第一个参数传进去。
<?php
/*
* 只看封装的一部分， 方法的封装
*
*
* 将一些“特殊的方法 ” 加上一个 关键字 private修饰， 就不能拿到这个对象之后， 用对象中private有的内容, 但对象自己中的其它成员可以使用这个， 因为是自己用自己的成员
*
* 魔术方法:
*
* __get()
*
* 1. 自动调用： 是在直接访问私有成员时，自动调用! 一个参数
* __set()
* 1. 自动调用： 是在直接设置私有属性值时， 两个参数
*
* __isset() isset() 在使用isset()判断一个私有属性是否存在时， 自动调用__isset()魔术方法， 参数则是属性名称
* __unset() unset();
*
*/
class Person {
//成员属性
private $name;
private $age;
private $sex;
//构造方法
function __construct($name="", $age=0, $sex="男") {
$this->name = $name;
$this->age = $age;
$this->sex = $sex;
}
function __unset($proname) {
echo "$proname !!!!!!!!!!!!!!!!<br>";
if($proname != "age") {
unset($this->$proname);
}
}
function __isset($proname) {
if($proname=="age")
return false;
return isset($this->$proname);
}
/*
function __get($pro) {
return $this->$pro;
}
function __set($name, $value) {
if($name=="age") {
if($value < 0 or $value > 100)
return;
}
$this->$name = $value;
}
*/
//成员方法
function say() {
echo "我的名子是：{$this->name}, 我的年龄是：{$this->age}, 我的性别是：{$this->sex}.<br>";
}
function eat() {
$this->say();
}
//析构方法
function __destruct() {
echo "再见:{$this->name} <br>";
}
}
$p1 = new Person("妹子", 88, "女");
unset($p1->name);
if(isset($p1->name)) {
echo "这个对象中的name是存的属性<br>";
}else{
echo "对象p1中不存在name属性";
}
文章里面没讲get set方法的运用 必须得手动写这两个，才能读取、设置私有属性，不用显示调用这两个函数，指出变量即可
<?php
class Person{
private $name;
private $age;
private $sex;
function __construct($name="",$age=0,$sex="male"){
$this->name=$name;
$this->age=$age;
$this->sex=$sex;
}
function __unset($proname){
echo "$proname!!!<br>";
if($proname!="age") unset($this->$proname);
}
function __isset($proname){
if($proname=="age") return false;
return isset($this->$proname);
}
/*function __get($pro){
return $this->$pro;//我要试一下有没有内置的get方法 没有！
}
function __set($name,$value){
//if($name=="age"&&($value<0||$value>100) return ;
$this->name=$value;
}*/
function say(){
echo "my name is:{$this->name},my age is:{$this->age}";
}
function __destruct(){
echo "byebye<br>";
}
}
$p1=new person("MissZhou",21,"female");
$p1->say();
echo "<br>";
$p1->name="zyj";
echo "<br>";
$p1->say();
echo "<br>";
echo $p1->name;多亏我心虚，写了一遍==
京公网安备 11010502036488号