From f8e860027308f4f0b4611ec26bac865550f2aa4b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=93=9D=E6=A0=91=E5=8D=8E?= <2977492336@qq.com>
Date: Tue, 17 May 2022 21:23:07 +0800
Subject: [PATCH] zuoye

---
 ...31\346\200\201\346\226\271\346\263\225.md" | 462 ++++++++++++++++++
 1 file changed, 462 insertions(+)
 create mode 100644 "\350\223\235\346\240\221\345\215\216/20220517-\344\275\234\344\270\232+\347\261\273+\344\277\256\351\245\260\346\226\271\346\263\225+\346\236\204\351\200\240\346\226\271\346\263\225+\346\236\220\346\236\204\346\226\271\346\263\225+\351\235\231\346\200\201\346\226\271\346\263\225.md"

diff --git "a/\350\223\235\346\240\221\345\215\216/20220517-\344\275\234\344\270\232+\347\261\273+\344\277\256\351\245\260\346\226\271\346\263\225+\346\236\204\351\200\240\346\226\271\346\263\225+\346\236\220\346\236\204\346\226\271\346\263\225+\351\235\231\346\200\201\346\226\271\346\263\225.md" "b/\350\223\235\346\240\221\345\215\216/20220517-\344\275\234\344\270\232+\347\261\273+\344\277\256\351\245\260\346\226\271\346\263\225+\346\236\204\351\200\240\346\226\271\346\263\225+\346\236\220\346\236\204\346\226\271\346\263\225+\351\235\231\346\200\201\346\226\271\346\263\225.md"
new file mode 100644
index 0000000..bcc78c4
--- /dev/null
+++ "b/\350\223\235\346\240\221\345\215\216/20220517-\344\275\234\344\270\232+\347\261\273+\344\277\256\351\245\260\346\226\271\346\263\225+\346\236\204\351\200\240\346\226\271\346\263\225+\346\236\220\346\236\204\346\226\271\346\263\225+\351\235\231\346\200\201\346\226\271\346\263\225.md"
@@ -0,0 +1,462 @@
+## 作业：
+
+1、 写一段代码，定义一个汽车类，有品牌与价格两种属性。并为类实例化对象，为对象的属性赋值并引用。
+
+2、 在上例的基础上为汽车类定义一个子类——跑车类。为子类实例化对象并访问父类的属性。
+
+3、 定义一个类，分别定义3个公共的属性和方法，3个受保护的属性和方法，3个私有属性和方法。
+
+```php
+<?php
+/**
+ * Created by PhpStorm.
+ * User: Administrator
+ * Date: 2022/5/17
+ * Time: 16:06
+ */
+
+//1、	写一段代码，定义一个汽车类，有品牌与价格两种属性。并为类实例化对象，为对象的属性赋值并引用。
+
+class Car
+{
+
+private $brand;
+private $price;
+
+    /**
+     * Car constructor.
+     * @param $brand
+     * @param $price
+     */
+    public function __construct($brand, $price)
+    {
+        $this->brand = $brand;
+        $this->price = $price;
+    }
+
+
+
+
+    /**
+     * @return mixed
+     */
+    public function getBrand()
+    {
+        return $this->brand;
+    }
+
+    /**
+     * @param mixed $brand
+     */
+    public function setBrand($brand)
+    {
+        $this->brand = $brand;
+    }
+
+    /**
+     * @return mixed
+     */
+    public function getPrice()
+    {
+        return $this->price;
+    }
+
+    /**
+     * @param mixed $price
+     */
+    public function setPrice($price)
+    {
+        $this->price = $price;
+    }
+
+
+}
+
+$c = new Car("汽车",123123);
+
+echo "品牌：".$c->getBrand().",价格:".$c->getPrice();
+
+
+echo "<br>";
+
+
+
+//2、	在上例的基础上为汽车类定义一个子类——跑车类。为子类实例化对象并访问父类的属性。
+
+
+class SportsCar extends Car {
+
+    public function __construct($brand, $price)
+    {
+        parent::__construct($brand,$price);
+    }
+
+    public function fly(){
+        echo "会漂移";
+    }
+
+}
+
+
+$s  = new SportsCar("五菱宏光",51123);
+
+echo "品牌：".$s->getBrand().",价格:".$s->getPrice();
+echo $s->fly();
+
+
+
+//3、	定义一个类，分别定义3个公共的属性和方法，3个受保护的属性和方法，3个私有属性和方法。
+
+<?php
+class Person
+{
+    // 公共
+    var $name;
+    var $age;
+    var $height;
+
+    function look(){
+        echo "看东西";
+    }
+
+    function hear(){
+        echo "听声音";
+    }
+
+    function smell(){
+        echo "闻东西";
+    }
+
+//  受保护
+    protected  $liberty;    // 人身自由
+    protected  $bankcardpassword;  // 银行卡
+    protected   $mobilepassword;  // 手机密码
+    protected   function verificationcode(){    // 验证码
+        echo "****";
+    }
+    protected   function bankpassword(){        // 银行卡密码
+        echo "******";
+    }
+    protected function balance(){
+        echo   1;
+    }
+
+
+    // 私有
+    private $IDnumber;   // 身份证号
+    private $xuehao;    // 学号
+    private $wallet; // 钱包
+
+    private function money(){   // 钱
+        echo "身上没有一分钱";
+    }
+    private function character(){    //
+        echo "懒";
+    }
+    private function interest(){
+        echo "刷抖音";
+    }
+
+    /**
+     * @return mixed
+     */
+    public function getIDnumber()
+    {
+        return $this->IDnumber;
+    }
+
+    /**
+     * @param mixed $IDnumber
+     */
+    public function setIDnumber($IDnumber)
+    {
+        $this->IDnumber = $IDnumber;
+    }
+
+    /**
+     * @return mixed
+     */
+    public function getXuehao()
+    {
+        return $this->xuehao;
+    }
+
+    /**
+     * @param mixed $xuehao
+     */
+    public function setXuehao($xuehao)
+    {
+        $this->xuehao = $xuehao;
+    }
+
+    /**
+     * @return mixed
+     */
+    public function getWallet()
+    {
+        return $this->wallet;
+    }
+
+    /**
+     * @param mixed $wallet
+     */
+    public function setWallet($wallet)
+    {
+        $this->wallet = $wallet;
+    }
+
+
+
+
+}
+```
+
+# 笔记：
+
+## 类：
+
+1. 成员变量：就是在类结构{}下直接定义的变量，但是定义的方式与普通变量稍微有点不同，需要在变量名字前使用一个关键字public，定义语法：public 变量名字 [= 值];，成员变量可以赋值也可以不赋值。
+
+```PHP
+<?php
+//定义买家类：买家有姓名，有钱
+class Buyer{
+	//$name;			//错误
+    public $name;		 //正确：没有赋值
+    public $money = 0;	 //正确：有赋值
+}
+```
+
+2. 成员变量访问：成员变量必须通过对象才能进行访问，也就是需要先通过实例化得到对象，然后通过对象实现对成员变量的增删改查：访问语法：$对象名->属性名;
+
+```PHP
+<?php
+#定义买家类
+class Buyer{
+    public $name;	
+    public $money = 0;	 
+}
+
+$b = new Buyer();
+//访问属性
+echo $b->money;
+//修改属性
+$b->money = 1000;
+//删除属性
+unset($b->name);
+//新增属性
+$b->age = 20;
+```
+
+**注意**：删除属性和新增属性通常使用较少，更多的属性操作是访问和修改
+
+1. PHP类结构中有三种成员：属性、方法和类常量
+2. 类结构中只能有三种成员，不限数量，其他代码需要写到方法里面，否则报错
+3. 类中属性和方法的访问方式都是通过对象来调用：$对象->属性名/方法名()；注意属性名不带$符号
+4. 类中定义属性不能直接使用属性名，需要使用符号public（var）修饰
+
+
+
+## 修饰方法：
+
+2. public：公有，即表示所修饰的内容（属性或者方法）可以在当前类的内部访问，也可以在类的外部访问
+
+```PHP
+<?php
+class Saler{
+  //公有属性
+  public $count = 100;
+}
+$s = new Saler();
+echo $s->count;				//正常输出100
+```
+
+3. protected：受保护，即表示所修饰的内容只能在`类的内部`访问（在学习继承时再讲）
+
+```PHP
+<?php
+class Saler{
+  //受保护属性
+  protected $discount = 0.8;
+}
+$s = new Saler();
+echo $s->discount;				//错误：受保护属性不允许在类外访问
+```
+
+
+
+4. private：私有，即表示所修饰的内容只能在`当前类的内部`访问
+
+```PHP
+<?php
+class Saler{
+  //私有属性
+  private $money = 100;
+}
+$s = new Saler();
+echo $s->money;				//错误：私有属性不允许在类外访问
+```
+
+5. 访问修饰限定符不只是限定属性，也用来限定方法
+
+```PHP
+<?php
+class Saler{
+  //属性
+  public $count = 100;
+  protected $discount = 0.8;
+  private $money = 100;
+    
+  public function getCount(){}	
+  protected function getDiscount(){}
+  private function getMoney(){}
+  function getAll(){}					#如果没有指定访问修饰限定符，默认public
+}
+```
+
+**总结**
+
+1. 访问修饰限定符分为三种：public、protected和private，访问权限依次降低
+2. 访问修饰限定符限定的是成员到底在哪里能被访问，私有和受保护都只能在类内部访问，公有可以在任何地方访问（但都必须是对象去访问）
+3. 属性必须写清楚访问修饰限定符，方法可以省去（不建议），因为系统默认是public
+
+## 构造方法：
+
+构造方法实现：在类中增加一个方法__construct()即可
+
+```PHP
+<?php
+class Saler{
+  	//属性
+  	public $count;				
+  	private $money;
+    
+    //构造方法
+    public function __construct(){
+        echo __CLASS__;
+    }
+}
+```
+
+1. 构造方法__construct()是一种系统内置的方法，该方法的特性是会在对象实例化之后，对象立即自动调用
+2. 构造方法的目的就是为了初始化资源，包含对象属性和其他资源
+3. 一旦构造方法定义好之后，且构造方法自带参数，那么就只能使用`new 类名(参数列表)`方式才能正确实例化
+4. 构造方法可以当做普通方法由对象调用（不建议）
+
+## 析构方法：
+
+析构方法实现：类中增加一个__destruct()方法
+
+```php
+<?php
+//接上述代码
+//实例化
+$s = new Saler();
+unset($s);			//删除对象
+```
+
+
+
+1. 析构方法是一种对象销毁时自动调用的方法
+2. 析构方法是用来对象销毁自身所占用的资源
+3. PHP中脚本执行结束，系统会自动回收所有资源，因此一般PHP中很少使用析构方法
+
+## 静态方法（static）:
+
+1. 静态属性：在类中定义属性的时候使用static关键字修饰，访问的时候只能使用类+范围解析操作符+静态属性访问
+
+```PHP
+<?php
+class Saler{
+	//属性
+    public $money = 0;
+    public static $count = 0;	//静态属性
+}
+
+//静态成员可以直接使用类访问，而不需要先实例化对象
+echo Saler::$count;
+```
+
+2. 静态方法：在勒种定义方法的时候使用static关键字修饰，访问的时候使用类+范围解析操作符+静态方法名字()访问
+
+```PHP
+<?php
+class Saler{
+	//方法
+    public static function showClass(){
+        echo __CLASS__;
+    }
+}
+
+//类直接访问
+Saler::showClass();
+```
+
+3. 在类的内部也可以访问静态成员，同样是使用类名+范围解析操作符+静态属性/静态方法()
+
+```PHP
+<?php
+class Saler{
+    //属性
+    private static $count = 0;			//私有，不允许外部直接访问
+	//方法
+    public static function showClass(){
+        echo Saler::$count;
+    }
+}
+
+//类直接访问
+Saler::showClass();
+```
+
+4. 静态方法本质也是类中定义的方法，因此也可以使用对象进行访问，但是**不建议**
+
+```PHP
+<?php
+class Saler{
+    //属性
+    private static $count = 0;			//私有，不允许外部直接访问
+	//方法
+    public static function showClass(){
+        echo Saler::$count;
+    }
+}
+
+//对象访问静态方法
+$s = new Saler();
+$s->showClass();						//输出0
+```
+
+5. 同理，方法也是在类内部，在编译时就存在，因此可以通过类来进行访问，使用范围解析操作符，但是**非常不建议**（会报错：因为类只允许访问静态成员和类常量）
+
+```PHP
+<?php
+class Saler{
+    public function testStatic(){
+        echo __FUNCTION__;
+    }
+}
+
+//类访问普通成员方法
+Saler::testStatic();				//输出testStatic，但是报错，当前访问的不是静态方法
+```
+
+6. 静态方法本质是给类访问，所以不允许在静态方法内部使用$this对象
+
+```PHP
+<?php
+class Saler{
+    public static function testStaticThis(){
+        var_dump($this);				//致命错误：$this放到了不该放的位置
+    }
+}			
+```
+
+
+
+1. 为了保障类能直接访问数据和操作数据，可以在属性和方法前增加static关键字变成静态属性和静态方法
+2. 类通过类名+范围解析操作符+静态成员的方式进行访问
+3. 静态成员也收访问修饰限定符的限定，访问权限与普通属性和方法的限制一样
+4. 对象可以无条件访问静态方法，而类只能访问不带$this的普通方法（不建议）
+5. 静态成员是给类访问的，非静态成员是给对象访问的
+6. 静态成员的访问效率比非静态成员高，因此有种说法是能用静态的时候就不用非静态
-- 
Gitee