Концепция инкапсуляции Java не понятна

Ответ 1

Да, иногда это может немного запутать. Отпустите шаг за шагом: во-первых, вам нужно понять

• Что такое инкапсуляция и почему она используется?

Инкапсуляция является одной из четырех основных концепций ООП .Эккапсуляция - это метод создания полей в классе 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;
   }
}

Вышеупомянутые методы называются Accessors (aka getters и seters). Теперь вы можете спросить:

• Почему вы должны использовать аксессоры..? На самом деле существует много веских причин рассматривать использование аксессуаров, а не прямое отображение полей класса. Getter и Setters делают API более стабильными.

Например, рассмотрите публикацию в открытом классе в классе, к которому обращаются другие классы. Теперь позже вы хотите добавить дополнительную логику при получении и настройке переменной. Это повлияет на существующего клиента, который использует API. Поэтому любые изменения в этом публичном поле потребуют изменения для каждого класса, который ссылается на него. Напротив, с помощью методов доступа, можно легко добавить некоторую логику, например, кешировать некоторые данные, лениво инициализировать ее позже. Кроме того, можно запустить событие изменения свойства, если новое значение отличается от предыдущего значения. Все это будет беспрепятственно для класса, который получает значение с помощью метода доступа.

Есть так много учебников и объяснений, как и каковы они. Google их.

Что касается вашей текущей проблемы:

• У вас есть два разных класса, каждый из которых имеет основное. Это не правильно. Они будут иметь разные свойства.
• Изменение кода, предложенное @Subhrajyoti Majumder, является правильным. Проверьте ответ для решения проблемы.

Тем временем прочитайте

• Encapsulation
• Аксессоры

для лучшего понимания понятий. Надеюсь, поможет.:)

Ответ 2

Кажется, что вы выполняете два разных класса отдельно и предполагаете, что изменения, внесенные в атрибуты при запуске EmployeeTest, будут отображаться в Employee run. Обратите внимание, что изменения будут отображаться в одном экземпляре 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);
    }

}

Ответ 3

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);
      }
}

Документация для лучшего понимания инкапсуляции

Ответ 4

конечно, изменение одного объекта не повлияет на другой объект. предположим, что у вас есть класс student, и все дети в вашей школе - это объекты. если вы покинете школу, это не означает, что каждый другой студент (объект студенческого класса) также должен покинуть школу.

Инкапсуляция - это концепция наличия переменных класса как private, так что никто не может напрямую играть с вашими членами данных из внешнего мира. но вы предоставляете общедоступный метод, чтобы внешний мир играл с вашим членом данных, как вы хотите. хороший пример кодирования инкапсуляции приведен выше Subhrajyoti Majumder.

(статические члены одинаковы для всех объектов класса, например: статическая переменная count, для подсчета количества объектов класса ученика (количество учеников в школе)).

Изменить, как вы просили:

Пример:

public class student{
    public String name;
    public student() {}
 }

и в вашей основной функции внешний мир может играть с вашими атрибутами класса как:

student s = new student();
s.name = "xyz";

предположим, вы не хотите, чтобы внешний мир менял свой атрибут имени объекта. то вы должны сделать имя "имя" частным и предоставить публичный метод только для просмотра имени (get).

Пример:

public class student{
    private String name;
    public student() {}
    public String getName(){
      return this.name;
      }
 }

и теперь в вашем основном методе вы можете получить только объект name и не можете установить его на новое значение, как вы могли бы сделать в первом примере.

student s = new student();
String sname = s.getName();

и если вы попробуете:

s.name = "newname";

не позволит вам этого. поскольку у вас нет разрешения на доступ к закрытым членам.

Ответ 5

Концепция инкапсуляции - это дизайн, который связан с скрытием информации. Основным принципом является обеспечение защищенного доступа к атрибутам класса через хорошо продуманный интерфейс. Целью инкапсуляции является принудительное применение инвариантов класса.

В следующем примере рассмотрим интерфейс этого класса:

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;
  }
}

Обратите внимание, что, объявив атрибуты как private, этот класс ограничивает доступ клиентов к состоянию экземпляров объекта employee. Единственный способ доступа клиентов к ним - через метод getName(). Это означает, что эти атрибуты инкапсулируются классом. Также обратите внимание, что, объявляя атрибуты как final и инициализируя их в конструкторе, мы создаем эффективно неизменяемый класс, то есть тот, состояние которого не может быть изменено после построения.

Альтернативная реализация будет следующей:

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;
  }
}

В этом примере объект не является неизменным, но его состояние инкапсулировано, поскольку доступ к нему происходит только через аксессоры и модификаторы. Обратите внимание, как инкапсуляция может помочь вам защитить инварианты состояния объекта. Ограничивая модификации с помощью метода, вы получаете лучший контроль над изменением состояния объекта, добавляя проверки, чтобы убедиться, что любые изменения соответствуют спецификации класса.

Ответ 6

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;
}

Ответ 7

encapsulation = VARIABLES (пусть private a, b, c) + МЕТОДЫ (setA & getA, setB & getB....) мы можем инкапсулировать с помощью частного модификатора. рассмотрим вашу созданную одну общедоступную переменную и одну личную переменную в вашем классе... в случае, если вам придется передавать эти переменные другому классу только для чтения (только они могут видеть и использовать неспособные к изменению), нет возможности с общедоступными переменными или методами, но мы можем сделать это частным образом, предоставляя get метод. поэтому ваши личные переменные или методы вашего класса находятся под вашим контролем. но IN public нет никаких шансов... я думаю, вы можете понять.

Ответ 8

Инкапсуляция может быть описана как защитный барьер , который предотвращает случайный доступ кода и данных к другому коду, определенному вне класса. Доступ к данным и коду жестко контролируется интерфейсом.

Инкапсуляция в 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");
                }
}

Ответ 9

Причина, по которой вы получаете вывод "печатать данные о сотрудниках: 0 null" при запуске класса Employee, заключается в том, что эти переменные не инициализируются. То есть вы не присваиваете им никаких значений в классе Employee.

Что бы вы ни делали в классе EmployeeTest, это не повлияет на значения переменных в Employee при следующем запуске. Рассмотрим каждый запуск программы Java "чистый сланец".

В момент инкапсуляции вам не следует использовать ключевое слово static. Если вы собираетесь инкапсулировать, проверьте другой ответ на этот вопрос, у него есть хороший образец кода, который вы можете использовать.

Ответ 10

Инкапсуляция представляет собой концепцию ООП. Класс рассматривается как капсула, которая содержит данные + поведение. Данные должны быть закрытыми и должны быть доступны только с использованием общедоступных методов, называемых getters и seters. Вы можете проверить этот encapsulation учебник для получения дополнительной информации об этой концепции.

Ответ 11

ENCAPSULATION - это механизм обертывания методов и переменных вместе как единое целое. например, капсулы, то есть смешанной из нескольких лекарственных средств.

переменные класса будут скрыты от других классов, поскольку они будут объявлены частными и могут быть доступны только с помощью методов их текущего класса

Чтобы добиться инкапсуляции в Java - * Объявлять переменные класса как частные. * Предоставлять общедоступные методы setter и getter для изменения и просмотра значений переменных. * Класс Java Bean является примером полностью инкапсулированного класса.

Ответ 12

Вы хотите сказать, что значение empid должно быть 10 и empname tom вместо 0 и null, если да, то -:

1) память для переменных выделяется во время выполнения, а также освобождается после завершения программы.

2) Следовательно, если вы думаете, что один раз, если вы дадите 10 на empid, это всегда должно быть 10, это не так, потому что empid - это просто ссылка на память, которая хранит "10".

3) Итак, путем освобождения я имею в виду, что empid больше не указывает на сохранение области памяти 10, после того, как программа завершает

4) всякий раз, когда вы выполняете новую программу, empid теперь указывает на другую область памяти, и этой памяти присваивается значение по умолчанию, соответствующее соответствующему типу данных, в случае статической переменной. следовательно, всегда 0 и null.

Ответ 13

в соответствии с вышеприведенной программой вы написали два класса "работник" и "работник" и сделали два класса независимо друг от друга основным публичным методом static void. когда вы пытаетесь выполнить программу, компилятор Java рассматривает два разных класса. // это работает отдельно и выводит 0 и ноль

даже если вы устанавливаете значения из класса тестирования сотрудника.