blocks|key|4051403|text|封装只是将一些数据包装在一个对象中。术语“封装”通常与“信息隐藏”互换使用。维基百科有a+pretty+thorough+article。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4051404|以下是来自Google+search+for+'php+encapsulation'中的the+first+link的示例|4051405|<?php

class+App+{
+++++private+static+$_user;

+++++public+function+User(+)+{
++++++++++if(+$this->_user+==+null+)+{
+++++++++++++++$this->_user+=+new+User();
++++++++++}
++++++++++return+$this->_user;
+++++}

}

class+User+{
+++++private+$_name;

+++++public+function+__construct()+{
++++++++++$this->_name+=+"Joseph+Crawford+Jr.";
+++++}

+++++public+function+GetName()+{
++++++++++return+$this->_name;
+++++}
}

$app+=+new+App();

echo+$app->User()->GetName();

?>|code-block|syntax|javascript|4051406|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Information_Hiding|1|http://www.google.com/search?q=php%2Bencapsulation|2|http://www.weberdev.com/get_example-4060.html^0|17|P|0|0|5|11|1|18|E|2|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]|$A|14|B|15|1|16]]|C|$]]|$1|F|3|G|5|H|7|17|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]|U|$5|N|O|P|C|$Q|V]]]]

Encapsulation is just wrapping some data in an object. The term "encapsulation" is often used interchangeably with "information hiding". Wikipedia has <a href="http://en.wikipedia.org/wiki/Information_Hiding" rel="nofollow noreferrer">a pretty thorough article</a>.

Here's an example from <a href="http://www.weberdev.com/get_example-4060.html" rel="nofollow noreferrer">the first link</a> in a <a href="http://www.google.com/search?q=php+encapsulation" rel="nofollow noreferrer">Google search for 'php encapsulation'</a>:

<pre><code>&lt;?php

class App {
 private static $_user;

 public function User( ) {
 if( $this-&gt;_user == null ) {
 $this-&gt;_user = new User();
 }
 return $this-&gt;_user;
 }

}

class User {
 private $_name;

 public function __construct() {
 $this-&gt;_name = "Joseph Crawford Jr.";
 }

 public function GetName() {
 return $this-&gt;_name;
 }
}

$app = new App();

echo $app-&gt;User()-&gt;GetName();

?&gt;
</code></pre>

blocks|key|5469957|text|与封装相反的是，将变量传递给每个方法(就像每个与文件相关的方法的文件句柄)或全局变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5469958|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The opposite of encapsulation would be something like passing a variable to every method (like a file handle to every file-related method) or global variables.

blocks|key|5469984|text|封装是一种将对象或数据作为属性存储在另一个对象中的方法，因此外部对象可以完全控制内部数据或对象的访问方式。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|5469985|例如|5469986|class+OuterClass
{
++private+var+$innerobject;

++function+increment()
++{
++++return+$this->innerobject->increment();
++}
}|code-block|syntax|javascript|5469987|在封装的对象周围有一个额外的层，它允许外部对象控制内部对象的访问方式。这与将内部对象/属性设置为private相结合，可以启用。|CODE|5469988|entityMap^0|F|8|0|0|0|1C|7|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|V|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|W|8|@$9|X|A|Y|B|O]]|D|@]|E|$]]|$1|P|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|Q|$]]

Encapsulation is a way of storing an object or data as a property within another object, so that the outer object has full control over what how the internal data or object can be accessed.

For example

<pre><code>class OuterClass
{
 private var $innerobject;

 function increment()
 {
 return $this-&gt;innerobject-&gt;increment();
 }
}
</code></pre>

You have an extra layer around the object that is encapsulated, which allows the outer object to control how the inner object may be accessed. This, in combination with making the inner object/property <code>private</code>, enables <a href="http://en.wikipedia.org/wiki/Information_hiding" rel="noreferrer">information hiding</a>.

blocks|key|1591707|text|封装是一种机制，它将代码及其操作的数据绑定在一起，并防止外部干扰和误用。将数据和方法封装到单个单元(称为类)中称为封装。封装的好处是它在内部执行任务，而不会让你担心。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1591708|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Encapsulation is the mechanism that binds together code and the data it manipulates, and keeps both safe from outside interference and misuse. The wrapping up of data and methods into a single unit (called class) is known as encapsulation. The benefit of encapsulating is that it performs the task inside without making you worry.

blocks|key|4051551|text|人们似乎混淆了面向对象和封装的细节，封装是一个更古老、更广泛的概念。封装的数据结构|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4051552|可以使用单个引用传递|4051553|，例如增量(MyDate)而不是增量(年、月、日)|unordered-list-item|4051554|将一组适用的操作存储在单个程序单元(类、模块、文件等)中|4051555|不允许任何客户端查看或操作其子组件，除非通过调用适用的操作|4051556|4051557|您可以在几乎任何语言中进行封装，并且在模块化和可维护性方面获得了巨大的好处。|4051558|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|R|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|T|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|U|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|V|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|O|$]]

People seem to be mixing up details of object orientation with encapsulation, which is a much older and wider concept. An encapsulated data structure

<ul>
<li>can be passed around with a single reference, eg increment(myDate)
rather than increment(year,month,day)</li>
<li>has a set of applicable operations stored in a single program unit
(class, module, file etc)</li>
<li>does not allow any client to see or manipulate its sub-components
EXCEPT by calling the applicable operations</li>
</ul>

You can do encapsulation in almost any language, and you gain huge benefits in terms of modularisation and maintainability.

blocks|key|1940968|text|封装是对外部世界隐藏对象数据的过程，只有类的成员才能访问它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1940969|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Encapsulation is the process of hidding the data of the object from outside world and accessed to it is restricted to members of the class.

blocks|key|1591729|text|Encapsulation：-在单个单元中包装数据。我们也可以说隐藏必要细节的信息。示例：你有一部手机....在那里有一些界面，可以帮助你与手机交互，你可以使用手机的服务。但真正在手机里工作的是隐藏。你不知道它是如何在内部工作的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1591730|entityMap^0|0|D|16|2|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

Encapsulation: - wrapping of data in single unit. also we can say hiding the information of essential details. 
Example: You have a mobile phone.... there it some interface which helps u to interact with cell phone and u can uses the services of mobile phone. But the actually working in cell phone is hide. u don't know how it works internally.

blocks|key|4051615|text|简单地说，我更喜欢类的属性和方法的可见性。例如--+public+-+private+-+protected|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4051616|让我们来看一个实际的封装示例。|4051617|+class+MyClass{
++++private+$name;

++++public+function+showName($newName){
++++++++$this->name+=+$newName;
++++++++return+$this->name;
++++}
+}


+//instantiate+object

+$obj+=+new+MyClass();
+echo+$obj->showName("tisuchi");|code-block|syntax|javascript|4051618|在这种情况下，封装意味着我们限制了一些属性。像name属性一样，我们不能从类的外部访问。另一方面，我们可以使用一个私有参数访问名为showName()的公共函数。|4051619|简单地说，我更喜欢封装的是-|4051620|属性和方法的可见性。|4051621|不过，如果您有进一步了解封装的意图，请参阅我的基于封装的特殊教程。|4051622|http://tisuchi.com/object-oriented-php-part-3-encapsulation-php/|offset|length|4051623|希望，这会让你的概念更清晰。玩得开心!|4051624|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|0|0|0|0|1S|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|14|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|15|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|16|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|17|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|18|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|19|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1A|8|@]|9|@$S|1B|T|1C|1|1D]]|A|$]]|$1|U|3|V|5|6|7|1E|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|R]]]]

Simply I prefer that is visibility of your class's property and method. For example-
 - public 
 - private
 - protected

Let's take a look real life example for encapsulation. 

<pre><code> class MyClass{
 private $name;

 public function showName($newName){
 $this-&gt;name = $newName;
 return $this-&gt;name;
 }
 }


 //instantiate object

 $obj = new MyClass();
 echo $obj-&gt;showName("tisuchi");
</code></pre>

In this case, encapsulation means, we restrict some properties. Like, name property, we can not access from outside of the class. On the other hand, we can access public function entitled showName() with one private parameter.

Simply what I prefer of encapsulation is- 

<h2>visibility of your property and method.</h2>

Although, if you have any intension to understand encapsulation further, I refer to my special tutorial based on encapsulation. 

<a href="http://tisuchi.com/object-oriented-php-part-3-encapsulation-php/" rel="nofollow">http://tisuchi.com/object-oriented-php-part-3-encapsulation-php/</a>

Hope, it will make your concept more clear. Have fun!

blocks|key|5470218|text|简而言之，它是我们定义属性和方法可见性的方式。在创建类时，您必须问自己哪些属性和方法可以在类之外访问。假设我们有一个名为foo的属性。如果一个类扩展了你的类，是否允许它操作和访问foo？如果有人创建了你的类的实例怎么办？允许他们操纵和访问foo吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5470219|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

In basic terms, it’s the way we define the visibility of our properties and methods. When you’re creating classes, you have to ask yourself what properties and methods can be accessed outside of the class. Let’s say we had a property named foo. If a class extends your class, is it allowed to manipulate and access foo? What if someone creates an instances of your class? Are they allowed to manipulate and access foo?

blocks|key|4051716|text|封装是类和数据结构的保护机制。它会让你的生活变得更轻松。使用封装，您可以控制访问和设置类参数和方法。你有一个控件来告诉外人哪个部分是可见的，以及如何设置你的对象参数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4051717|访问和设置类参数|offset|length|style|BOLD|4051718|(好方法)|4051719|<?php

class+User
{
++++private+$gender;

++++public+function+getGender()
++++{
++++++++return+$this->gender;
++++}

++++public+function+setGender($gender)
++++{
++++++++if+('male'+!==+$gender+and+'female'+!==+$gender)+{
++++++++++++throw+new+\Exception('Set+male+or+female+for+gender');
++++++++}

++++++++$this->gender+=+$gender;
++++}
}|code-block|syntax|javascript|4051720|现在，您可以从User类创建对象，并且可以安全地设置性别参数。如果您为您的类设置了任何错误，那么它将抛出和异常。您可能认为这是不必要的，但是当您的代码增长时，您希望看到一个有意义的异常消息，而不是系统中没有异常的尴尬的逻辑问题。|4051721|$user+=+new+User();
$user->setGender('male');

//+An+exception+will+throw+and+you+can+not+set+'Y'+to+user+gender
$user->setGender('Y');|4051722|(糟糕的方式)|4051723|如果您不遵循封装角色，那么您的代码将如下所示。维护起来非常困难。请注意，我们可以将任何内容设置为user+gender属性。|4051724|<?php

class+User
{
++++public+$gender;
}

$user+=+new+User();
$user->gender+=+'male';

//+No+exception+will+throw+and+you+can+set+'Y'+to+user+gender+however+
//+eventually+you+will+face+some+logical+issue+in+your+system+that+is+
//+very+hard+to+detect
$user->gender+=+'Y';|4051725|访问类方法|4051726|4051727|<?php

class+User
{
++++public+function+doSomethingComplex()
++++{
++++++++$this->doThis(...);
++++++++...
++++++++$this->doThat(...);
++++++++...
++++++++$this->doThisExtra(...);
++++}

++++private+function+doThis(...some+Parameters...)
++++{
++++++...
++++}

++++private+function+doThat(...some+Parameters...)
++++{
++++++...
++++}

++++private+function+doThisExtra(...some+Parameters...)
++++{
++++++...
++++}
}|4051728|我们都知道，我们不应该用200行代码做一个函数，而应该把它分解成一些单独的函数，这样可以破坏代码，提高代码的可读性。现在，通过封装，你可以让这些函数成为私有的，这意味着它不能被外人访问，以后当你想修改一个函数时，当你看到private关键字时，你会非常高兴。|4051729|4051730|class+User
{
++++public+function+doSomethingComplex()
++++{
++++++++//+do+everything+here
++++++++...
++++++++...
++++++++...
++++++++...
++++}
}|4051731|entityMap^0|0|0|8|0|0|0|0|0|0|0|0|0|5|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1B|8|@$D|1C|E|1D|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1E|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1F|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1G|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1H|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1I|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1J|8|@]|9|@]|A|$]]|$1|W|3|X|5|L|7|1K|8|@]|9|@]|A|$M|N]]|$1|Y|3|Z|5|6|7|1L|8|@$D|1M|E|1N|F|G]]|9|@]|A|$]]|$1|10|3|I|5|6|7|1O|8|@]|9|@]|A|$]]|$1|11|3|12|5|L|7|1P|8|@]|9|@]|A|$M|N]]|$1|13|3|14|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|15|3|T|5|6|7|1R|8|@]|9|@]|A|$]]|$1|16|3|17|5|L|7|1S|8|@]|9|@]|A|$M|N]]|$1|18|3|-4|5|6|7|1T|8|@]|9|@]|A|$]]]|19|$]]

Encapsulation is protection mechanism for your class and data structure. It makes your life much easier. With Encapsulation you have a control to access and set class parameters and methods. You have a control to say which part is visible to outsiders and how one can set your objects parameters. 

Access and sett class parameters 

(Good Way)

<pre><code>&lt;?php

class User
{
 private $gender;

 public function getGender()
 {
 return $this-&gt;gender;
 }

 public function setGender($gender)
 {
 if ('male' !== $gender and 'female' !== $gender) {
 throw new \Exception('Set male or female for gender');
 }

 $this-&gt;gender = $gender;
 }
}
</code></pre>

Now you can create an object from your User class and you can safely set gender parameters. If you set anything that is wrong for your class then it will throw and exception. You may think it is unnecessary but when your code grows you would love to see a meaningful exception message rather than awkward logical issue in the system with no exception. 

<pre><code>$user = new User();
$user-&gt;setGender('male');

// An exception will throw and you can not set 'Y' to user gender
$user-&gt;setGender('Y');
</code></pre>

(Bad Way)

If you do not follow Encapsulation roles then your code would be something like this. Very hard to maintain. Notice that we can set anything to the user gender property.

<pre><code>&lt;?php

class User
{
 public $gender;
}

$user = new User();
$user-&gt;gender = 'male';

// No exception will throw and you can set 'Y' to user gender however 
// eventually you will face some logical issue in your system that is 
// very hard to detect
$user-&gt;gender = 'Y';
</code></pre>

Access class methods

(Good Way)

<pre><code>&lt;?php

class User
{
 public function doSomethingComplex()
 {
 $this-&gt;doThis(...);
 ...
 $this-&gt;doThat(...);
 ...
 $this-&gt;doThisExtra(...);
 }

 private function doThis(...some Parameters...)
 {
 ...
 }

 private function doThat(...some Parameters...)
 {
 ...
 }

 private function doThisExtra(...some Parameters...)
 {
 ...
 }
}
</code></pre>

We all know that we should not make a function with 200 line of code instead we should break it to some individual function that breaks the code and improve the readability of code. Now with encapsulation you can get these functions to be private it means it is not accessible by outsiders and later when you want to modify a function you would be sooo happy when you see the private keyword. 

(Bad Way)
 

<pre><code>class User
{
 public function doSomethingComplex()
 {
 // do everything here
 ...
 ...
 ...
 ...
 }
}
</code></pre>

blocks|key|5470300|text|封装就是您希望对象/方法或属性/变量在应用程序中可见的方式。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5470301|class+ecap+{

public+$name;

private+$id;

protected+$tax;

}|code-block|syntax|javascript|5470302|如果要访问私有或受保护的属性，则必须在类中使用可从类外部访问的getter和setter方法。这意味着，您不能直接从类的外部访问私有或受保护的属性，但可以通过任何方法使用。让我们来看看-|5470303|在类中，添加以下方法：|5470304|class+ecap+
{
+public+function+userId(){
+return+$this->id;
+}
}+|5470305|我们可以像这样访问它：|5470306|+$obj+=+new+ecap();
+echo+$obj->userId();|5470307|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|W|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Encapsulation is just how you wanted your objects/methods or properties/variables to be visible in your application.
for example, :


<pre><code>class ecap {

public $name;

private $id;

protected $tax;

}
</code></pre>

If you want to access private or protected properties, then you have to use getter and setter methods in your class that will be accessible from outside of your class. Meaning, you cannot access your private or protected properties directly from outside of your class but you can use through any methods. Let’s take a look-

in the class, add the following method:


<pre><code>class ecap 
{
 public function userId(){
 return $this-&gt;id;
 }
} 
</code></pre>

and we can access it like:

<pre><code> $obj = new ecap();
 echo $obj-&gt;userId();
</code></pre>

blocks|key|5470334|text|将数据成员和方法包装到单个单元(即类)中的方法称为类(+Encapsulation.+)封装类似于封装在一个胶囊中。也就是说，将与对象相关的操作和数据封装到该对象中。封装就像你的包，你可以把你的笔、书等放在里面。这意味着这是封装成员和函数的属性。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|5470335|<?php
+class+YourMarks
++{
+++private+$mark;
+++public+Marks
++{
+++get+{+return+$mark;+}
+++set+{+if+($mark+>+0)+$mark+=+10;+else+$mark+=+0;+}
++}
++}
?>|code-block|syntax|javascript|5470336|我举了另一个现实生活中的(日常使用)的例子，那就是“电视操作”。许多人在日常生活中操作电视。|5470337|它是用盖子封装的，我们可以用遥控器操作，不需要打开电视和更换频道。这里的一切都是私密的，除了遥控器，这样任何人都可以访问，而不是操作和改变电视中的东西。|5470338|entityMap^0|S|D|18|2|0|0|J|R|0|0|24|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|P|$]]

Wrapping up data member and method together into a single unit (i.e. Class) is called Encapsulation.
Encapsulation is like enclosing in a capsule. That is enclosing the related operations and data related to an object into that object.
Encapsulation is like your bag in which you can keep your pen, book etc. It means this is the property of encapsulating members and functions.

<pre><code>&lt;?php
 class YourMarks
 {
 private $mark;
 public Marks
 {
 get { return $mark; }
 set { if ($mark &gt; 0) $mark = 10; else $mark = 0; }
 }
 }
?&gt;
</code></pre>

I am giving an another example of real life (daily use) that is “TV operation”. Many peoples operate TV in daily life.

It is encapsulated with cover and we can operate with remote and no need to open TV and change the channel.
Here everything is in private except remote so that anyone can access not to operate and change the things in TV.

blocks|key|1941171|text|/*+class+that+covers+all+ATM+related+operations+*/
class+ATM+{

++++private+$customerId;
++++private+$atmPinNumber;
++++private+$amount;

++++//+Verify+ATM+card+user
++++public+function+verifyCustomer($customerId,+$atmPinNumber)+{
++++++++...+function+body+...
++++}

++++//+Withdraw+Cash+function
++++public+function+withdrawCash($amount)+{
++++++++...+function+body+...
++++}

++++//+Retrieve+mini+statement+of+our+account
++++public+function+miniStatement()+{
++++++++...+function+body+...
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1941172|在上面的示例中，我们使用私有访问修饰符声明了所有ATM类属性(变量)。这仅仅意味着外部世界的最终用户不能直接访问ATM类属性。因此，外部世界的最终用户不能直接更改或更新它们。|unstyled|1941173|更改类属性(数据)的唯一可能方法是方法(函数)。这就是为什么我们声明了带有公共访问修饰符的ATM类方法。用户可以将所需的参数传递给类方法以执行特定的操作。|1941174|这意味着用户不了解ATM类的完整实现细节。这就是所谓的数据隐藏。|1941175|参考：http://www.thecreativedev.com/php-encapsulation-with-simple-example/|offset|length|1941176|entityMap|0|LINK|mutability|MUTABLE|url|http://www.thecreativedev.com/php-encapsulation-with-simple-example/^0|0|0|0|0|3|1W|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|X|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|F|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

<pre><code>/* class that covers all ATM related operations */
class ATM {

 private $customerId;
 private $atmPinNumber;
 private $amount;

 // Verify ATM card user
 public function verifyCustomer($customerId, $atmPinNumber) {
 ... function body ...
 }

 // Withdraw Cash function
 public function withdrawCash($amount) {
 ... function body ...
 }

 // Retrieve mini statement of our account
 public function miniStatement() {
 ... function body ...
 }
}
</code></pre>

In the above example, we have declared all the ATM class properties (variables) with private access modifiers. It simply means that ATM class properties are not directly accessible to the outer world end-user. So, the outer world end-user cannot change or update them directly.

The only possible way to change a class property (data) is a method (function). That’s why we have declared ATM class methods with public access modifier. The user can pass the required arguments to a class method to do a specific operation.

It means users do not have whole implementation details for ATM class. It’s simply known as data hiding.

Reference:
<a href="http://www.thecreativedev.com/php-encapsulation-with-simple-example/" rel="nofollow noreferrer">http://www.thecreativedev.com/php-encapsulation-with-simple-example/</a>

blocks|key|4051824|text|在单个单元内包装数据称为封装。意味着类成员(如方法和属性)在类内绑定在一起，以避免从outside.This访问，这是通过将类的变量和函数设置为私有来实现的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4051825|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Wrapping up of data inside single unit is called encapsulation. Means class members such as method and properties binds together inside a class to avoid accessibility from outside.This is done by making variables and functions of class private.

What is encapsulation with simple example in php?

What is encapsulation with simple example in php?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

在php中用简单的例子封装是什么？

问在php中用简单的例子封装是什么？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在php中用简单的例子封装是什么？EN