특징과 인터페이스
최근 PHP에 대해 공부하려고 하는데, 특징에 집착하고 있습니다.수평 코드 재사용의 개념을 이해하고 추상 클래스에서 반드시 계승하고 싶지 않습니다.이해가 안 되는 건특성을 사용하는 것과 인터페이스를 사용하는 것의 중요한 차이점은 무엇입니까?
블로그의 적절한 투고나 글을 검색해 본 결과, 어느 한쪽을 사용할지를 설명하고 있습니다만, 지금까지의 예는 거의 같은 것 같습니다.
공공 서비스 공지:
나는 특징들이 거의 항상 코드 냄새이며 구성을 선호하기 위해 피해야 한다고 믿고 있다는 것을 공식적으로 말하고 싶다.저는 단일 상속이 반패턴이 될 정도로 악용되는 경우가 많고 다중 상속은 이 문제만 더 복잡하게 만든다고 생각합니다.대부분의 경우 상속(단일 또는 복수)보다 구성을 선호하면 훨씬 더 나은 서비스를 제공할 수 있습니다.특징과 인터페이스와의 관계에 관심이 있는 경우는, 다음의 문서를 참조해 주세요.
먼저 다음과 같이 말씀드리겠습니다.
객체 지향 프로그래밍(OOP)은 이해하기 어려운 패러다임이 될 수 있습니다.클래스를 사용한다고 해서 코드가 객체 지향(OO)인 것은 아닙니다.
OO 코드를 작성하기 위해서는 OOP가 실제로 객체의 기능에 관한 것임을 이해해야 합니다.당신은 수업에 대해 그들이 실제로 무엇을 할 수 있는지 아닌 그들이 무엇을 할 수 있는지에 대해 생각해야 합니다.이는 "뭔가를 한다"는 약간의 코드를 만드는 데 초점을 맞추는 기존의 프로시저 프로그래밍과는 매우 대조적입니다.
OOP 코드가 계획 및 설계에 관한 경우 인터페이스는 Blueprint이고 개체는 완전히 구성된 하우스입니다.한편, 특성은 청사진(인터페이스)에 의해 설계되어 있는 집을 짓는 데 도움이 되는 단순한 방법입니다.
인터페이스
그럼 왜 인터페이스를 사용해야 할까요?간단히 말해, 인터페이스는 우리의 코드를 덜 취약하게 만듭니다.이 문장이 의심스러울 경우 인터페이스에 대해 작성되지 않은 레거시 코드를 유지하도록 강요받은 적이 있는 사람에게 문의하십시오.
인터페이스는 프로그래머와 프로그래머의 코드 사이의 계약입니다.인터페이스에는 "내 규칙에 따라 행동하는 한 원하는 대로 나를 구현할 수 있으며 다른 코드를 어기지 않을 것을 약속합니다."라고 쓰여 있습니다.
예를 들어 실제 시나리오(자동차나 위젯 없음)를 생각해 보겠습니다.
서버 부하를 줄이기 위해 웹 응용 프로그램의 캐싱 시스템을 구현하려고 합니다.
먼저 APC를 사용하여 요청 응답을 캐시하는 클래스를 작성합니다.
class ApcCacher
{
public function fetch($key) {
return apc_fetch($key);
}
public function store($key, $data) {
return apc_store($key, $data);
}
public function delete($key) {
return apc_delete($key);
}
}
그런 다음 HTTP 응답 개체에서 캐시 히트를 확인한 후 모든 작업을 수행하여 실제 응답을 생성합니다.
class Controller
{
protected $req;
protected $resp;
protected $cacher;
public function __construct(Request $req, Response $resp, ApcCacher $cacher=NULL) {
$this->req = $req;
$this->resp = $resp;
$this->cacher = $cacher;
$this->buildResponse();
}
public function buildResponse() {
if (NULL !== $this->cacher && $response = $this->cacher->fetch($this->req->uri()) {
$this->resp = $response;
} else {
// Build the response manually
}
}
public function getResponse() {
return $this->resp;
}
}
이 접근방식은 매우 효과적입니다.그러나 몇 주 후 APC 대신 파일 기반 캐시 시스템을 사용하기로 결정할 수 있습니다. now 、 now 、 now 、 이 、 now 、 now 、 now 、 now 、 now 、 now 、 now 、 now 、 now 、 now now 。컨트롤러가 이 기능을 사용하도록 프로그래밍되어 있기 때문입니다.ApcCacher "class"의 가 아닌 클래스ApcCacher의 명령어 예, 가, 신, 신, 신, 신, 신, 신, 신, 신, 신, 신, 신, 신, class, class, class, class, class, class,Controller에 reli reli reli reli reli reli reli reli reliCacherInterface인 ApcCacher다음과 같이 합니다.
// Your controller's constructor using the interface as a dependency
public function __construct(Request $req, Response $resp, CacherInterface $cacher=NULL)
이와 함께, 다음과 같이 인터페이스를 정의합니다.
interface CacherInterface
{
public function fetch($key);
public function store($key, $data);
public function delete($key);
}
에는 두 가지 모두 .ApcCacher 당신의 ★★★★★★★★★★★★★★★★★★★★★★★★★」FileCacher은 클래 the the the the the를 한다.CacherInterface의 프로그램을 있습니다.Controller.class: 에 필요한 합니다.
이 예에서는 (바람직하게) 인터페이스에 대한 프로그래밍을 통해 변경으로 인해 다른 코드가 파손될 염려 없이 클래스의 내부 구현을 변경할 수 있는 방법을 보여 줍니다.
특성들
반면에 특성은 단순히 코드를 재사용하는 방법입니다.인터페이스는 특성을 서로 배타적으로 대체하는 것으로 간주해서는 안 됩니다.실제로 인터페이스에 필요한 기능을 충족하는 특성을 만드는 것이 이상적인 사용 사례입니다.
여러 클래스가 같은 기능을 공유하는 경우(같은 인터페이스에 의해 지시된 경우)에만 특성을 사용해야 합니다.단일 클래스에 기능을 제공하기 위해 특성을 사용하는 것은 의미가 없습니다. 즉, 클래스가 수행하는 작업을 난독화시킬 뿐이며 더 나은 설계가 해당 특성 기능을 관련 클래스로 이동시킬 수 있습니다.
다음 특성 구현을 고려하십시오.
interface Person
{
public function greet();
public function eat($food);
}
trait EatingTrait
{
public function eat($food)
{
$this->putInMouth($food);
}
private function putInMouth($food)
{
// Digest delicious food
}
}
class NicePerson implements Person
{
use EatingTrait;
public function greet()
{
echo 'Good day, good sir!';
}
}
class MeanPerson implements Person
{
use EatingTrait;
public function greet()
{
echo 'Your mother was a hamster!';
}
}
더 구체적인 예로서, 의 두 상상해 보세요.FileCacher 당신의 ★★★★★★★★.ApcCacher인터페이스 설명에서 캐시 엔트리가 오래되어 삭제되어야 하는지 여부를 판단하기 위해 동일한 방법을 사용합니다(실제에서는 그렇지 않지만 그대로 사용합니다).Atribute를 기술하고, 양쪽 클래스에서 공통 인터페이스 요건에 대해 사용할 수 있도록 할 수 있습니다.
마지막으로 한 가지 주의할 점은 특징에 너무 집착하지 않도록 주의하라는 것입니다.고유한 클래스 구현으로 충분할 때 특성이 열악한 설계를 위한 목발로 사용되는 경우가 많습니다.최적의 코드 설계를 위해 인터페이스 요건을 충족하는 특성을 제한해야 합니다.
인터페이스는 구현 클래스가 구현해야 하는 일련의 메서드를 정의합니다.
이 ★★★★★use'방식의 구현도 함께 이루어졌습니까? - 이것은 다른 방법에서는 일어나지 않습니다.Interface.
그것이 가장 큰 차이입니다.
특성은 PHP와 같은 단일 상속 언어에서 코드를 재사용하는 메커니즘입니다.특성은 개발자가 서로 다른 클래스 계층에 있는 여러 독립 클래스에서 메서드 집합을 자유롭게 재사용할 수 있도록 함으로써 단일 상속의 일부 제한을 줄이는 것을 목적으로 합니다.
A traitPHP 입니다.mixin으로 모든 할 수 trait메서드는 상속을 사용하지 않고 해당 클래스 구현의 일부가 됩니다.
PHP 매뉴얼(강조 광산)에서:
특성은 PHP와 같은 단일 상속 언어에서 코드를 재사용하는 메커니즘입니다.기존 상속의 추가 기능으로 동작의 수평적 구성, 즉 상속 없이 클래스 멤버를 적용할 수 있습니다.
예:
trait myTrait {
function foo() { return "Foo!"; }
function bar() { return "Bar!"; }
}
위의 특성을 정의하면 다음을 수행할 수 있습니다.
class MyClass extends SomeBaseClass {
use myTrait; // Inclusion of the trait myTrait
}
때MyClass 방법,즉 '2가지 방법'이 foo() ★★★★★★★★★★★★★★★★★」bar()- 에서 유래합니다.myTrait - 는 다음과 같이 되어 것에 해 주세요.trait본문을 있습니다. 메서드는 메서드 본문을 가지고 있습니다.Interface안 -defined method는 안 돼요.
또한 PHP는 다른 많은 언어와 마찬가지로 단일 상속 모델을 사용합니다. 즉, 클래스는 여러 인터페이스에서 파생될 수 있지만 여러 클래스에서 파생될 수는 없습니다.단, PHP 클래스는 여러 개를 가질 수 있습니다.trait포함 - 프로그래머가 여러 기본 클래스를 포함하는 것처럼 재사용 가능한 조각을 포함할 수 있습니다.
주의사항:
-----------------------------------------------
| Interface | Base Class | Trait |
===============================================
> 1 per class | Yes | No | Yes |
---------------------------------------------------------------------
Define Method Body | No | Yes | Yes |
---------------------------------------------------------------------
Polymorphism | Yes | Yes | No |
---------------------------------------------------------------------
다형성:
앞의 예에서는 다음과 같이 되어 있습니다.MyClass SomeBaseClass,MyClass 의 예다.SomeBaseClassㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ㄴ, ., 음, 열, ., ., ., ., ., ..SomeBaseClass[] bases를 포함할 수 .MyClass '만나면'의 경우MyClass '''IBaseInterface의 , " " "IBaseInterface[] bases의 인스턴스를 포함할 수 .MyClass.trait a - 냐 - - -trait기본적으로 프로그래머의 편의를 위해 이를 사용하는 각 클래스에 복사되는 코드입니다.
우선 순위:
설명서에 설명된 대로:
기본 클래스의 상속된 멤버는 특성에 의해 삽입된 멤버에 의해 재정의됩니다.우선 순서는 현재 클래스의 멤버가 특성 메서드를 재정의하고 상속된 메서드를 재정의하는 것입니다.
따라서 다음과 같은 시나리오를 고려하십시오.
class BaseClass {
function SomeMethod() { /* Do stuff here */ }
}
interface IBase {
function SomeMethod();
}
trait myTrait {
function SomeMethod() { /* Do different stuff here */ }
}
class MyClass extends BaseClass implements IBase {
use myTrait;
function SomeMethod() { /* Do a third thing */ }
}
위의 MyClass 인스턴스를 만들 때 다음과 같은 상황이 발생합니다.
InterfaceIBase가 없는 합니다.SomeMethod()제공될 예정입니다.- 클래스 " " " "
BaseClass는 요구를 충족시키는 이 방법을 구현하고 있습니다. traitmyTrait가 없는 '모수'를 합니다.SomeMethod()또, 이것은, 보다 우선합니다.BaseClass- - 전전classMyClass이 있습니다.SomeMethod()- 이 명령어는 다음 명령어보다 우선합니다.traitversion . - 전 -
결론
- 안
Interface할 수 단, 「」는, 「」의 실장할 수 없습니다.trait수 있습니다. - 안
Interface는 다형성, 상속된 구성체입니다.단,trait렇지않않 않않않다다 - ★★
Interface할 수 여러 개의 클래스도 할 수 .또한 여러 개의 클래스에서도 사용할 수도 있습니다.traits.
생각에는traits는 여러 다른 클래스의 메서드로 사용할 수 있는 메서드를 포함하는 클래스를 만들 때 유용합니다.
예를 들어 다음과 같습니다.
trait ToolKit
{
public $errors = array();
public function error($msg)
{
$this->errors[] = $msg;
return false;
}
}
이 "오류" 메서드는 이 특성을 사용하는 모든 클래스에서 사용할 수 있습니다.
class Something
{
use Toolkit;
public function do_something($zipcode)
{
if (preg_match('/^[0-9]{5}$/', $zipcode) !== 1)
return $this->error('Invalid zipcode.');
// do something here
}
}
함께 있을 때interfaces메서드 시그니처만 선언할 수 있고 함수의 코드는 선언할 수 없습니다.를 사용하려면 을 사용하려면 계층을 해야 합니다.implements특성의 되지 않는다특징은 그렇지 않습니다.
완전히 달라요!
위의 답변은 초보자에게 어려울 수 있습니다.이것이 가장 알기 쉬운 방법입니다.
특성들
trait SayWorld {
public function sayHello() {
echo 'World!';
}
}
것이 있다면.sayHello 만들지 합니다. 즉할 수 있습니다.
class MyClass{
use SayWorld;
}
$o = new MyClass();
$o->sayHello();
멋있다!
성함 、 수, 、 수수 、 수......이렇게 여러 특성을 할 수 .use SayWorld, AnotherTraits;
인터페이스
interface SayWorld {
public function sayHello();
}
class MyClass implements SayWorld {
public function sayHello() {
echo 'World!';
}
}
인터페이스와 특성은 다음과 같습니다.구현된 클래스에서 인터페이스 내의 모든 것을 다시 작성해야 합니다.인터페이스에는 구현이 없으며 인터페이스는 함수와 상수만 가질 수 있으며 변수를 가질 수 없습니다.
도움이 됐으면 좋겠네요!
특성은 단순히 코드 재사용을 위한 것입니다.
인터페이스는 프로그래머의 재량에 따라 사용할 수 있는 클래스에서 정의되는 함수의 시그니처만 제공합니다.따라서 클래스 그룹의 프로토타입을 얻을 수 있습니다.
참조용 - http://www.php.net/manual/en/language.oop5.traits.php
특성을 설명하기 위해 자주 사용되는 비유는 특성이 구현과의 인터페이스라는 것입니다.
이것은 대부분의 상황에서 그것에 대해 생각하는 좋은 방법이지만, 둘 사이에는 미묘한 차이가 많이 있다.
「」입니다.instanceof연산자는 특성(특성이 실제 객체가 아님)을 사용하지 않으므로 해당 특성을 사용하여 클래스에 특정 특성이 있는지(또는 관련이 없는 두 클래스가 특성을 공유하는지 확인) 확인할 수 없습니다.수평적 코드 재사용을 위한 구성체라는 의미입니다.
현재 PHP에는 클래스가 사용하는 모든 특성 목록을 가져올 수 있는 함수가 있지만 특성 상속은 클래스에 특정 특성이 있는지 확인하기 위해 재귀 검사를 수행해야 함을 의미합니다(PHP doco 페이지에 예제 코드가 있음).하지만, 이건 확실히 다른 사람들처럼 단순하고 깨끗하지 않아요instanceofIMHO, PHP, IMHO, PHP, IMHO, PHP 등
또한 추상 클래스는 여전히 클래스이기 때문에 다중 상속 관련 코드 재사용 문제를 해결하지 못합니다.1개의 클래스(실제 또는 추상)만 확장할 수 있지만 여러 인터페이스를 구현할 수 있습니다.
유사 다중 상속을 만들기 위해 함께 사용할 수 있는 특성과 인터페이스가 매우 좋다는 것을 알게 되었습니다.예:
class SlidingDoor extends Door implements IKeyed
{
use KeyedTrait;
[...] // Generally not a lot else goes here since it's all in the trait
}
''를 사용할 수 .instanceof특정 Door 객체가 Keyed인지 아닌지를 판단하려면 일관된 메서드 세트를 얻을 수 있으며 KeyedTrait를 사용하는 모든 클래스에서 모든 코드가 한 곳에 있습니다.
특성은 기본적으로 코드의 자동화된 "복사 붙여넣기"로 간주할 수 있습니다.
특성을 사용하는 것은 실행 전에 무엇을 하는지 알 수 있는 수단이 없기 때문에 위험하다.
그러나 유전과 같은 제한이 없기 때문에 특성이 더 유연하다.
특성은 예를 들어 다른 메서드 또는 Atribute의 존재와 같이 어떤 것을 클래스에 체크하는 메서드를 주입하는 데 유용할 수 있습니다.그것에 대한 좋은 기사(프랑스어로, 죄송합니다).
그것을 얻을 수 있는 프랑스어를 읽는 사람들을 위해, GNU/Linux Magazine HS54에는 이 주제에 관한 기사가 실려 있다.
를 알고 을 알고 있는지 trait츠미야 및 으로, 클래스리스 메서드 및 속성을 합니다.use
기본적으로 단일 변수와 비교할 수 있습니다.는, 「Closures functions(폐쇄 기능)」를 사용할 수 있습니다.use이 변수들은 범위 밖의 변수이며, 그렇게 하면 내부에 값을 갖게 됩니다.그것들은 강력하며 모든 것에 사용할 수 있습니다.사용 중인 특성에도 동일한 현상이 발생합니다.
다른 답변들은 인터페이스와 특성 간의 차이를 잘 설명했습니다.유용한 실제 예, 특히 특성이 인스턴스 변수를 사용할 수 있다는 것을 보여주는 예에 초점을 맞춥니다. 즉, 최소한의 보일러 플레이트 코드로 클래스에 동작을 추가할 수 있습니다.
여기서도, 다른 사람이 말한 것과 같이, 특성은 인터페이스와 적절히 조합되기 때문에, 인터페이스는 동작 계약을 지정할 수 있고, 또 실장을 실시하기 위한 특성을 지정할 수 있습니다.
이벤트 퍼블리시/구독 기능을 클래스에 추가하는 것은 일부 코드베이스에서 일반적인 시나리오가 될 수 있습니다.3가지 일반적인 솔루션이 있습니다.
- 기본 클래스를 이벤트 pub/sub 코드로 정의하면 이벤트를 제공하려는 클래스는 이 클래스를 확장하여 기능을 얻을 수 있습니다.
- event pub/sub 코드로 클래스를 정의하면 이벤트를 제공하는 다른 클래스는 컴포지션을 통해 해당 클래스를 사용할 수 있습니다.이러한 클래스는 컴포지션을 통해 컴포지션 오브젝트를 랩하는 자체 메서드를 정의하고 메서드 호출을 프록시합니다.
- 는 이벤트를 제공할 수 있습니다.
use그 특성, 일명 수입, 능력을 얻기 위한 것이다.
각각 얼마나 잘 작동합니까?
#1 잘 작동하지 않는다.이미 다른 것을 확장하고 있기 때문에 기본 클래스를 확장할 수 없다는 것을 깨닫는 그날까지 그렇게 할 수 있습니다.이렇게 상속을 사용하는 것이 얼마나 제한적인지는 분명해야 하기 때문에 나는 이것의 예를 보여주지 않을 것이다.
#2와 #3은 둘 다 잘 작동합니다.몇 가지 차이점을 강조하는 예를 보여드리겠습니다.
첫 번째, 두 예에서 동일한 코드가 몇 가지 있습니다.
인터페이스
interface Observable {
function addEventListener($eventName, callable $listener);
function removeEventListener($eventName, callable $listener);
function removeAllEventListeners($eventName);
}
사용법을 보여주는 코드:
$auction = new Auction();
// Add a listener, so we know when we get a bid.
$auction->addEventListener('bid', function($bidderName, $bidAmount){
echo "Got a bid of $bidAmount from $bidderName\n";
});
// Mock some bids.
foreach (['Moe', 'Curly', 'Larry'] as $name) {
$auction->addBid($name, rand());
}
요.Auction이치노
먼저, #2(작성 사용)는 다음과 같습니다.
class EventEmitter {
private $eventListenersByName = [];
function addEventListener($eventName, callable $listener) {
$this->eventListenersByName[$eventName][] = $listener;
}
function removeEventListener($eventName, callable $listener) {
$this->eventListenersByName[$eventName] = array_filter($this->eventListenersByName[$eventName], function($existingListener) use ($listener) {
return $existingListener === $listener;
});
}
function removeAllEventListeners($eventName) {
$this->eventListenersByName[$eventName] = [];
}
function triggerEvent($eventName, array $eventArgs) {
foreach ($this->eventListenersByName[$eventName] as $listener) {
call_user_func_array($listener, $eventArgs);
}
}
}
class Auction implements Observable {
private $eventEmitter;
public function __construct() {
$this->eventEmitter = new EventEmitter();
}
function addBid($bidderName, $bidAmount) {
$this->eventEmitter->triggerEvent('bid', [$bidderName, $bidAmount]);
}
function addEventListener($eventName, callable $listener) {
$this->eventEmitter->addEventListener($eventName, $listener);
}
function removeEventListener($eventName, callable $listener) {
$this->eventEmitter->removeEventListener($eventName, $listener);
}
function removeAllEventListeners($eventName) {
$this->eventEmitter->removeAllEventListeners($eventName);
}
}
3번(트레이트)의 외형은 다음과 같습니다.
trait EventEmitterTrait {
private $eventListenersByName = [];
function addEventListener($eventName, callable $listener) {
$this->eventListenersByName[$eventName][] = $listener;
}
function removeEventListener($eventName, callable $listener) {
$this->eventListenersByName[$eventName] = array_filter($this->eventListenersByName[$eventName], function($existingListener) use ($listener) {
return $existingListener === $listener;
});
}
function removeAllEventListeners($eventName) {
$this->eventListenersByName[$eventName] = [];
}
protected function triggerEvent($eventName, array $eventArgs) {
foreach ($this->eventListenersByName[$eventName] as $listener) {
call_user_func_array($listener, $eventArgs);
}
}
}
class Auction implements Observable {
use EventEmitterTrait;
function addBid($bidderName, $bidAmount) {
$this->triggerEvent('bid', [$bidderName, $bidAmount]);
}
}
「 」의 는, 「 」에해 주세요.EventEmitterTrait요.EventEmitter가 "Disclass"를 선언합니다.triggerEvent()메서드가 보호되고 있습니다.따라서, 여러분이 살펴봐야 할 유일한 차이점은 수업의 구현입니다.
그리고 그 차이는 크다.컴포지션을 솔루션을 수 있으며, 이 을 사용하면 의 컴포지션을 할 수 .EventEmitter★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★♪은 에 된 각 기술 및한 보일러 입니다.이는 에 정의되어 있는 각 방법에 대해Observable하고, 그 를 단지 해, 코드를 쓸 .EventEmitter물건.이 예에서 특성을 사용하면 이러한 문제를 피할 수 있으므로 보일러 플레이트 코드를 줄이고 유지관리성을 개선할 수 있습니다.
여러분이 수 .Auction ( 구현)Observableinterface - 독자적인 메서드시그니처를 정의할 수 있도록1개 또는 2개의 메서드만 공개하거나 아예 공개하지 않을 수도 있습니다.이 경우에도 구성 방법을 선호할 수 있습니다.
그러나 대부분의 시나리오에서 이 특성은 매우 설득력이 있습니다.특히 인터페이스에 많은 메서드가 있어 많은 보일러 플레이트를 쓸 수 있습니다.
두 가지를 할 수. - 이 두 가지를 할 수 .EventEmitter하고 class를 compositionally로 합니다.EventEmitterTrait'성격'을 EventEmitter를 설정합니다.
주요 차이점은 인터페이스에서는 해당 인터페이스를 구현하는 각 클래스 내에서 각 메서드의 실제 구현을 정의해야 한다는 것입니다.그러면 많은 클래스가 같은 인터페이스를 구현하지만 동작은 다른 반면 특성은 클래스에 삽입된 코드 청크일 뿐입니다.또 다른 중요한 차이점은 특성 메서드 c입니다.instance 메서드(통상은 instance 메서드)가 될 수 있는 인터페이스 메서드와는 달리 class-interface 메서드 또는 static-interface 메서드만 있습니다.
특성은 여러 상속 목적으로 사용할 수 있는 클래스와 동일하며 코드 재사용도 가능합니다.
우리는 수업에서 특성을 사용할 수 있고, 또한 'use 키워드'를 사용하여 같은 수업에서 여러 특성을 사용할 수 있습니다.
인터페이스는 특성처럼 코드 재사용을 위해 사용하고 있습니다.
인터페이스는 여러 인터페이스를 확장하기 때문에 여러 상속 문제를 해결할 수 있지만 인터페이스를 구현할 때는 클래스 내에 모든 메서드를 작성해야 합니다.자세한 내용은 아래 링크를 클릭하십시오.
http://php.net/manual/en/language.oop5.traits.php http://php.net/manual/en/language.oop5.interfaces.php
인터페이스는 "이 객체가 이 작업을 수행할 수 있습니다"라고 하는 계약이지만 특성은 객체에 작업을 수행할 수 있는 능력을 부여합니다.
특성은 기본적으로 클래스 간에 코드를 "복사하여 붙여넣기"하는 방법입니다.
언급URL : https://stackoverflow.com/questions/9205083/traits-vs-interfaces
'source' 카테고리의 다른 글
| 마리아에서 테이블 2개를 완전히 연결하다DB (0) | 2022.11.12 |
|---|---|
| System.out.println()을 짧게 하는 방법 (0) | 2022.11.12 |
| 레퍼런스:MySQL 확장자를 사용하는 완벽한 코드 샘플은 무엇입니까? (0) | 2022.11.02 |
| PHP 프로젝트의 루트 디렉터리 경로 가져오기 (0) | 2022.11.02 |
| 브라우저가 두 번 새로 고쳐질 때까지 NodeJS 스크립트가 응답하지 않음 (0) | 2022.11.02 |