这是基本的问题，但我还是不明白，封装概念。余did't了解我们如何可以改变其他class.because类的属性，每当我们尝试设置类的公共实例值，我们必须创建该类的对象，然后设置value.and每个对象指的是不同的内存。所以即使我们改变实例值，这将不会影响到任何其他对象。
即使我尝试使用静态公网实例值改变也我不能够改变类的属性值。
实施例下面给出
// Employee class
public class Employee {
public static int empid;
public static String empname;
public static void main(String[] args) {
System.out.println("print employe details:"+empid+" "+empname);
}
// EmployeeTest class
public class EmployeeTest {
public static void main(String[] args) {
Employee e = new Employee();
e.empid=20;
e.empname="jerry";
Employee.empid=10;
Employee.empname="tom";
}
}
}
我每次运行Employee类我收到相同的值
print employe details:0 null
虽然我不是以下封装概念，我不能够改变员工的公共实例值class.Please帮助我理解我要去的地方错误的概念。
是啊，这可有点混乱的时候。让我们走一步看一步：首先，你需要了解
封装是四种基本OOP concepts.Encapsulation之一，是一类私人制作领域，并通过公共方式提供接入领域的技术。如果某个字段声明为private，它不能由类以外的任何人访问，从而隐藏了类中的字段。出于这个原因，封装也被称为数据隐藏。
封装可以被描述为防止所述代码和数据被随机地由类外定义其他代码访问的保护屏障。到的数据和代码访问紧密由接口控制。
封装的主要好处是修改我们的执行代码，而不破坏其他人谁使用我们的代码的代码的能力。有了这个功能封装提供了可维护性，灵活性和可扩展到我们的代码。
举一个小例子：
public class EncapTest{
private String name;
private String idNum;
private int age;
public int getAge(){
return age;
}
public String getName(){
return name;
}
public String getIdNum(){
return idNum;
}
public void setAge( int newAge){
age = newAge;
}
public void setName(String newName){
name = newName;
}
public void setIdNum( String newId){
idNum = newId;
}
}
上述方法被称为访问器（又名getter和setter）。现在你可能会问，
例如，考虑在由其他类访问的类中的公共领域。现在，以后，你要添加任何额外的逻辑，同时获取和设置变量。这将影响到现有的客户端使用的API。所以这个公共领域的任何改变都需要改变每个引用它的类。相反，与存取方法，可以很容易地添加一些逻辑，像缓存一些数据，后来懒洋洋地初始化。此外，如果新值与前值不同可以触发一个属性更改事件。这一切都将是无缝的，使用存取方法获取值的级别。
有这么多的教程和说明如何以及它们是什么。谷歌他们。
至于你的，当前的问题：
在此期间，在读了
为了更好地理解的概念。希望能帮助到你。 :)
封装是一个面向对象的概念。该类被视为像包含数据+行为的胶囊。该数据应该是私有的，只能使用公有方法称为getter和setter方法进行访问。您可以检查此encapsulation教程关于这个概念的更多信息。
封装是缠绕方法和变量一起作为单个单元的机制。例如胶囊即混合几种药物。
一类变量，会从其他类是隐藏的，因为它会被声明为私有，并且可以通过他们的当前类的方法只能访问
为了实现在Java中封装 - *声明一个类为私有的变量。 *提供公共setter和getter方法来修改和查看变量的值。 *这个Java bean类是完全密封的类的实例。
你的意思是说，EMPID的值应该是10和empname汤姆而不是0和空，如果是，则─：
1）存储到变量在运行时被分配，并且还释放程序终止之后。
2）因此，如果您认为一旦如果你给10 EMPID它应该永远是10，不是这样的，因为EMPID仅仅是其中存储“10”存储器中的参考。
3）因此，通过解除分配，我的意思是EMPID不再指向存储器区域中存储图10中，程序终止后
4）无论何时执行新的程序时，EMPID现在指向其他存储区域，并且该存储器是根据吨各个数据类型分配的缺省值，在静态变量的情况下。因此，始终为0和空。
看来你是单独运行两个不同的类别，并假设做属性的变化，当您运行EmployeeTest将Employee运行反映。需要注意的是变化将在同一个JRE实例反映。请问如果我误解了你的问题。
编辑：由于每用户的输入。下面是代码，您可以访问和更新静态成员的值：
class Employee {
public static int empid;
public static String empname;
public static void main(String[] args) {
System.out.println("print employe details:" + empid + " " + empname);
}
}
// EmployeeTest class
public class EmployeeTest {
public static void main(String[] args) {
Employee e = new Employee();
e.empid = 20;
e.empname = "jerry";
Employee.empid = 10;
Employee.empname = "tom";
Employee.main(null);
}
}
public static领域的与类与对象不，它打破对象的封装规则相关联。
Employee类有两个封装领域empid & empname。
public class Employee {
private int empid;
private String empname;
public int getEmpid(){
return this.empid;
}
public void setEmpid(int empid){
this.empid = empid;
}
...
}
public class EmployeeTest {
public static void main(String[] args) {
Employee e = new Employee();
e.setempId(1);
Employee e1 = new Employee();
e1.setempId(2);
}
}
封装可以被描述为防止所述代码和数据被随机地由类外定义其他代码访问的保护屏障。到的数据和代码访问紧密由接口控制。
封装在Java是一类私人制作领域，并通过公共方式提供接入领域的技术。
如果某个字段声明为private，它不能由类以外的任何人访问，从而隐藏了类中的字段。出于这个原因，封装也被称为数据隐藏。
实时例如：汽车和车主。汽车的所有功能封装与业主。因此，没有人可以访问它..
下面是用于本实施例中的代码。
public class Main {
public static void main(String[] args) {
Owner o1=new Car("SONY","Google Maps");
o1.activate_Sunroof();
o1.getNavigationSystem();
o1.getRadioSytem();
}
}
//Interface designed for exposing car functionalities that an owner can use.
public interface Owner {
void getNavigationSystem();
void getRadioSytem();
void activate_Sunroof();
}
/*
Car class protects the code and data access from outside world access by implementing Owner interface(i.e, exposing Cars functionalities) and restricting data access via private access modifier.
*/
public class Car implements Owner {
private String radioSystem;
private String gps;
public Car(String radioSystem, String gps) {
super();
this.radioSystem = radioSystem;
this.gps = gps;
}
public String getRadioSystem() {
return radioSystem;
}
public void setRadioSystem(String radioSystem) {
this.radioSystem = radioSystem;
}
public String getGps() {
return gps;
}
public void setGps(String gps) {
this.gps = gps;
}
@Override
public void getNavigationSystem() {
System.out.println("GPS system " + getGps() + " is in use...");
}
@Override
public void getRadioSytem() {
System.out.println("Radio system " + getRadioSystem() + " activated");
}
@Override
public void activate_Sunroof() {
System.out.println("Sunroof activated");
}
}
封装的概念是一种设计技术，与信息隐藏涉及。基本的原则是提供受保护的访问类的属性，通过精心设计的界面。封装的目的是强制类的不变量。
要遵循你的榜样考虑这个类的界面：
class Employee
private final String firstName;
private final String lastName;
public Employee(final firstName, final lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public String getName() {
return firstName + " " + lastName;
}
}
需要注意的是通过声明属性为私有此类限制客户直接访问Employee对象实例的状态。对于客户端访问它们的唯一方法是通过getName（）方法。这意味着，这些属性由类封装。还要注意的是通过声明属性作为最终并在构造函数初始化它们，我们创建一个有效的不可变类，这是一个国家，其施工后不能修改。
另一种实现是以下几点：
class Employee
private String firstName;
private String lastName;
public Employee(firstName, lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public String getName() {
return firstName + " " + lastName;
}
public String setName(String firstName, String lastName) {
if (firstName == null) {
throw new IllegalArgumentException("First name cannot be null");
}
if (lastName == null) {
throw new IllegalArgumentException("Last name cannot be null");
}
this.firstName = firstName;
this.lastName = lastName;
}
}
在这个例子中，对象并不是一成不变的，但它的状态被封装，因为对它的访问只能通过访问器和修改器发生。注意，这里的封装如何帮助您保护对象的状态不变。通过一个方法约束修改你获得的对象状态如何修改一个更好的控制，增加验证，以确保任何修改都与类的规范是一致的。
Encapsulation means combining data and code together(class). The main purpose of encapsulation is you would have full control on data by using the code.
class Encap{
private int amount;
public void setAmount(int amount)
{
this.amount = amount;
}
Here, you can set the amount using the setAmount method, but value should be more than 100. So, i have the control on it.
public void setAmount(int amount)
{
if(amount>100)
this.amount = amount;
}
封装=变量（让私人A，B，C）+方法（组A＆木屐，组B＆getB ....），我们可以通过使用专用改性剂包封。让考虑你创建了一个公共变量并在类中的一个私有变量...的情况下，如果非要给这些变量到另一个类只读（只有自己可以看到和使用不能修改）没有与可能性公共变量或方法，但我们可以做到，在私人提供get方法。所以你的类私有变量或方法是你的控制之下。但在公开场合没有机会....我想你能明白。
当然，改变一个对象不会对其他对象产生影响。假设你有一个类学生，都在学校的孩子是对象。如果一个人离开了学校，这并不意味着，所有其他学生（学生类的对象）要离开学校了。
封装是具有类的变量为私有，所以没有人可以直接与外部世界的数据成员玩概念。但您提供的公共方法，让外部世界与您的数据成员，您希望的方式来打。封装的nice编码实例由Subhrajyoti Majumder上面给出。
（静态成员是同为类的所有对象如：静态计数变量，计算学生类对象的数量（在校学生人数）。）。
编辑为你问：
例：
public class student{
public String name;
public student() {}
}
并在主函数中，外部世界可以与你的类在属性发挥：
student s = new student();
s.name = "xyz";
让我们假设，你不想让外界改变对象的名称属性。那么你应该做的名字“名”为私有，并提供一个公共的方法只能查看域名（获得）。
例：
public class student{
private String name;
public student() {}
public String getName(){
return this.name;
}
}
现在在你的主要方法，你只能得到名字对象，不能将其设置为新的价值，就像你可以在第一个例子做。
student s = new student();
String sname = s.getName();
如果你尝试：
s.name = "newname";
编译器不会让你。因为你没有权限访问私有成员。
你所得到的输出之所以“打印雇工细节：0零”的办员工上课的时候是因为这些变量不会被初始化。也就是说，你不Employee类中指定任意值给他们。
不管你的EmployeeTest类中做到这一点是在下次运行时不会影响员工的变量的值。考虑一个Java程序的“清白”的每次运行。
在封装的时候，你真的不应该使用static关键字。如果你要进行封装看看其他的回答了这个问题，它已经为你使用一个很好的示例代码。