7.18 面向对象：三大特性，抽象类，接口

三大特性：1 封装 2继承 3多态

类的封装修饰词: 1 public 公开的：类外面可以访问，子类可以访问，父类可以访问

　　　　　　　 2 protected 被保护的：类外面不能访问，子类可以访问，父类可以访问.

　　　　　　　3 private 私有的：类外面不能访问，子类不能访问，父类可以访问

继承的关键字：extends

抽象类： 1 关键字：abstract

2 含有抽象方法的类是抽象类

3 子类中必须实现父类的抽象方法，否则报错

接口：1 关键字interface

2 只含有抽象方法的类

3 体内不能含有普通方法

4 子类中必须实现父类的所有的抽象方法，否则报错

5 子类继承不能用extends，用implements

6 抽象类中的抽象方法都是抽象方法，所以不用加abstract

<?php
    header("Content_type: text/html; charset=utf-8");
    //多态
      /*
       class Animal{
               private function say(){
                   echo "我是父类的say方法";
               }
       }
       class Dog extends Animal{
               public function say($num1){
                   echo $num1."我是子类的say方法";
               }
       }
       $d1 = new Dog();
       $d1 ->say(1);
       $d1 ->say(2);*/
   //================抽象======================
 /*  abstract class Psrson{
        public $name;
        public $age;
        public function say(){
            
        }
        abstract public function jump();
        abstract public function jump1();
   }
   class Man extends Person{
            public function jump(){
                echo "我跳的高";
            }
   }*/

abstract class Usb{
   public function load(){
      echo "usb is loading";
   }
   public function start(){
      echo "usb is starting";
   }
   abstract public function unload();//抽象方法
}

class Upan extends Usb{
    public function unload(){//子类中必须实现父类的抽象方法，否则报错
    echo "usb is unloading";
    }
}



   //===============继承===================
   class Animal{
       private $name;
       public $age;
       function __construct(){
           echo "我是父类的构造函数";
       }
       public function say($name){
            $this->name =$name;
            echo "{$name}会叫";
       }
   public function pp(){
           echo "$this->name " ;
            
       }
   }
   
   
   class Dog extends Animal{
       public $address;
       function __construct(){
           parent:: __construct();
           echo "我是子类的构造函数";
       }
       public function jump(){
           echo "跳";
       }
   }
   $d1 = new Dog();
   $d1 ->say("旺财");
   $d1->jump();
   $d1->pp();
   //echo $name;
   //单继承
   //子类继承父类的所有
   
   //================接口===================
 /*  interface Usb{
       public function jump();
       public function jump1();
   }
   interface UsbDaoban{
       public function jump2();
       public function jump3();
   }
   class Keywords implements Usb,UsbDaoban{
            public function jump(){
                echo "跳1";
            }
             public function jump1(){
                echo "跳1";
            }
             public function jump2(){
                echo "跳1";
            }
             public function jump3(){
                echo "跳1";
            }
            
   }*/

//接口
interface Usb1{
   public function load();
   public function start();
   public function unload();
}

class Upan1 implements Usb1{//子类中必须实现父类的所有抽象方法，否则报错
public function load(){
    echo "usb is load";
    }
    public function start(){
    echo "usb is unloading";
    }
    public function unload(){
    echo "usb is unloading";
    }
}



   //===============封装==============
   /*class Person{
           //把类中的成员设为私有
           private $name;
           private $age;
           //单独写一个方法进行调用
           public function getName(){
               return $this->name;
           }
           public function getAge(){
               return $this->age;
           }
           public function setName($n){
               if(is_string($n)){
                   $this->name=$n;
               }
           }
           public function setAge($num){
               if($num>0 && $num<130){
                   $this->age=$num;
               }
           }
           
   }
   $p1 = new Person();
   $p1->setName("zhangsan");
   $p1->setAge(100);
   var_dump($p1);*/
?>

7.18 面向对象：三大特性 ，抽象类，接口

7.18 面向对象：三大特性，抽象类，接口