Je n'arrête pas de me répéter en tremblant de souffle, quand pourrai-je me lever ?

Comment certains membres d'une classe peuvent-ils être utilisés par d'autres classes ? Si l'héritage est utilisé, la chaîne d'héritage est trop longue. Pour plus de commodité, PHP fournit le trait technologique de réutilisation du code.

1. Définition  : Trait est un mécanisme de réutilisation de code préparé pour le type PHP 单继承语言. Les traits peuvent éliminer la situation délicate de 单继承语言摆脱 devoir hériter pour être réutilisé et rendre 面向对象 plus pur.

2. Syntaxe de base  :

Trait est un mot-clé similaire à class.

<?php
     trait Eat{
        public $a=10;      //trait内允许有类的成员属性（包括静态属性），成员方法（包括静态方法）
        public static $b=666;
        //const c=3.14;       //trait内不允许有常量
        protected $e;	//允许定义，但是实际不用
        private $f;
        public function getA()
        {
               echo $this->a,"<br>";
        }
        public static function getB()
        {
               echo self::$b,"<br>";
        }
    }
?>

trait est utilisé pour implémenter la réutilisation du code et ne peut pas être instancié ou hérité (car ce n'est pas du tout une classe).

<?php
   trait Eat{}
  // $a=new Eat;//报错
  //calss A extends Eat{}//报错
?>

3. L'utilisation des traits

Un trait n'est qu'un ensemble de codes, et il doit être référencé à l'aide de use.

<?php
    
    trait Eat{
        public $a=10;
        public static $b=666;
        //const c=3.14;
        public function getA()
        {
               echo $this->a,"<br>";
        }
        public static function getB()
        {
               echo self::$b,"<br>";
        }
    }
    
    class A{
        use Eat;


        public function getC()
        {
            echo $this->a,"<br>";
        }
    }

    $boy=new A();
    $boy->getC();
    $boy->getA();
    $boy->getB();
?>

Une classe peut utiliser plusieurs traits.

<?php
   trait A1{
   }
   trait A2{
   }
   class People{
     use A1,A2;
   }
?>

4. Problèmes d'utilisation des traits

a. Si plusieurs traits introduits en même temps ont des attributs portant le même nom, des conflits surviendront. se produire.

<?php
    trait A1{
       public $a=11;
    }
    trait A2{
       public $a=22;
    }

    class A3{
        use A1,A2;//不允许同名属性
        public function geta(){
            echo $this->a;
        }
    }

    $example=new A3();
  

?>

b. S'il existe des méthodes portant le même nom dans plusieurs traits introduits en même temps, des conflits se produiront. Il existe deux solutions telles que A3 et A4.

<?php
    trait A1{
       public $a=11;
       public function eat(){
           echo "A1中eat（）方法","<br>";
       }
    }
    trait A2{
       public $b=22;
       public function eat(){
        echo "A2中eat（）方法","<br>";
      }
    }

    class A3{
        use A1,A2{
          A1::eat insteadOf A2; //A1中的eat替代A2中的eat
        }
    }
    class A4{
        use A1,A2{
            A1::eat insteadOf A2;//A1中的eat替代A2中的eat
            A2::eat as eat2;     //A2中的eat取别名eat2
          }
    }

    $example=new A3();
    $example->eat();
    $example=new A4();
    $example->eat2();
?>

c. Problème de couverture du même nom : S'il y a un membre portant le même nom que le trait introduit dans la classe, il sera traité différemment :

• Attribut : les noms en double ne sont pas autorisés, c'est-à-dire la classe. Il n'est pas autorisé de définir des propriétés de membre avec les mêmes noms que ceux du trait (il en va de même pour les propriétés statiques).

• Méthode : trait de remplacement de classe.

d. Problème de couverture d'héritage : si une classe utilise trait, elle hérite également de la classe parent et le trait a une méthode avec le même nom que la classe parent, alors trait La méthode du même nom de la classe parent sera écrasée ; si vous souhaitez accéder à la méthode de la classe parent du même nom, vous pouvez utiliser le mot-clé parent dans la méthode de trait du même nom pour accédez à la méthode portant le même nom que la classe parent.

<?php
    trait Eat{
    public function eat(){
        echo &#39;Eat::eat&#39;;
    }
}
    class Human{
    public function eat(){
        echo &#39;Human::eat&#39;;
    }
}
//子类继承父类同时使用trait
class Man extends Human{
    use Eat;
}

$m = new Man();
$m->eat();
?>

e.trait lui-même n'est pas accessible. Il est uniquement utilisé pour permettre la réutilisation du code pour d'autres classes. Par conséquent, les classes sont autorisées à utiliser un contrôle d'accès plus élevé lors de l'utilisation de traits : après as, utilisez l'accès cible. qualificatif de modificateur.

<?php
trait Eat{
    private function show(){
        echo &#39;eat&#39;;
    }
}
class Human{
    use Eat{
        show as public eshow;				
        //注意：as是用来设定别名的，虽然没有同名show，但是系统认为show已经存在，所以必须别名,权限的更改的方法不是
        //本尊
    }
}
$h = new Human();
$h->eshow();								//eat
?>

Vous pouvez utiliser 抽象方法 dans f.trait, et la classe using doit implémenter le 抽象方法 correspondant : la classe using doit soit être une classe abstraite, soit elle doit implémenter une méthode abstraite.

<?php
   trait Eat{
     public function eat();		//抽象方法
   }
   abstract class Human{			
    use Eat;					//抽象类：可以不实现抽象方法
   }

   class Animal{
    use Eat;
    public function eat(){		//具体类：实现抽象方法
        echo &#39;Animal::eat&#39;;	
    }		
}
?>

Recommandé : tutoriel php, tutoriel vidéo php

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!