[php] PHP에서 :: (이중 콜론)과-> (화살표)의 차이점은 무엇입니까?

왼쪽 부분이 객체 인스턴스이면을 사용 ->합니다. 그렇지 않으면을 사용 ::합니다.

이는 ->주로 인스턴스 멤버에 액세스하는 데 사용되며 (정적 멤버에 액세스하는데도 사용할 수 있지만 이러한 사용은 권장되지 않음) ::일반적으로 정적 멤버에 액세스하는 데 사용됩니다 (특별한 경우에는 인스턴스 멤버에 액세스하는 데 사용됨) ).

일반적으로 ::사용되는 범위 해상도 , 그리고 중 하나를 가질 수있다 클래스 이름 parent, self또는 (PHP 5.3) static의 왼쪽. parent클래스가 사용되는 클래스의 수퍼 클래스 범위를 나타냅니다. self사용되는 클래스의 범위를 나타냅니다. static“범위”라고합니다 ( 늦은 정적 바인딩 참조 ).

규칙은 다음과 같은 ::경우에만 with를 호출하는 것 입니다.

• 대상 방법은 정적으로 선언되지 및
• 호출 시점에 호환 가능한 객체 컨텍스트가 있습니다. 이는 다음과 같은 사실이어야합니다.
  1. $this존재 하는 상황에서 호출
  2. 의 클래스는 $this호출되는 메소드의 클래스이거나 서브 클래스입니다.

예:

class A {
    public function func_instance() {
        echo "in ", __METHOD__, "\n";
    }
    public function callDynamic() {
        echo "in ", __METHOD__, "\n";
        B::dyn();
    }

}

class B extends A {
    public static $prop_static = 'B::$prop_static value';
    public $prop_instance = 'B::$prop_instance value';

    public function func_instance() {
        echo "in ", __METHOD__, "\n";
        /* this is one exception where :: is required to access an
         * instance member.
         * The super implementation of func_instance is being
         * accessed here */
        parent::func_instance();
        A::func_instance(); //same as the statement above
    }

    public static function func_static() {
        echo "in ", __METHOD__, "\n";
    }

    public function __call($name, $arguments) {
        echo "in dynamic $name (__call)", "\n";
    }

    public static function __callStatic($name, $arguments) {
        echo "in dynamic $name (__callStatic)", "\n";
    }

}

echo 'B::$prop_static: ', B::$prop_static, "\n";
echo 'B::func_static(): ', B::func_static(), "\n";
$a = new A;
$b = new B;
echo '$b->prop_instance: ', $b->prop_instance, "\n";
//not recommended (static method called as instance method):
echo '$b->func_static(): ', $b->func_static(), "\n";

echo '$b->func_instance():', "\n", $b->func_instance(), "\n";

/* This is more tricky
 * in the first case, a static call is made because $this is an
 * instance of A, so B::dyn() is a method of an incompatible class
 */
echo '$a->dyn():', "\n", $a->callDynamic(), "\n";
/* in this case, an instance call is made because $this is an
 * instance of B (despite the fact we are in a method of A), so
 * B::dyn() is a method of a compatible class (namely, it's the
 * same class as the object's)
 */
echo '$b->dyn():', "\n", $b->callDynamic(), "\n";

산출:

B :: $ prop_static : B :: $ prop_static 값
B :: func_static () :에서 B :: func_static

$ b-> prop_instance : B :: $ prop_instance 값
$ b-> func_static () : B :: func_static에서

$ b-> func_instance () :
B :: func_instance에서
A :: func_instance에서
A :: func_instance에서

$ a-> dyn () :
A :: callDynamic에서
동적 dyn에서 (__callStatic)

$ b-> dyn () :
A :: callDynamic에서
동적 dyn (__ call)

답변

class Math {
    public static function sin($angle) {
        return ...;
    }
}

$result = Math::sin(123);

class Rectangle {
     protected $x, $y;

     public function __construct($x, $y) {
         $this->x = $x;
         $this->y = $y;
     }
}

class Square extends Rectangle {
    public function __construct($x) {
        parent::__construct($x, $x);
    }
}

class Hello {
    public function say() {
       echo 'hello!';
    }
}

$h = new Hello();
$h->say();

class Test {

    public $name;

    public function __construct() {
        $this->name = 'Mrinmoy Ghoshal';
    }

    public static function doWrite($name) {
        print 'Hello '.$name;
    }

    public function write() {
        print $this->name;
    }
}

$fruits = array(
  'Apple'  => 'Red',
  'Banana' => 'Yellow'
);

foreach ($fruits as $fruit => $color)
  echo "$fruit is $color in color.";