Как передать переменную из одного класса в другой java
Одним из ключевых аспектов объектно-ориентированного программирования является наследование. С помощью наследования можно расширить функционал уже имеющихся классов за счет добавления нового функционала или изменения старого. Например, имеется следующий класс Person, описывающий отдельного человека:
class Person < String name; public String getName()< return name; >public Person(String name) < this.name=name; >public void display() < System.out.println("Name: " + name); >>
И, возможно, впоследствии мы захотим добавить еще один класс, который описывает сотрудника предприятия — класс Employee. Так как этот класс реализует тот же функционал, что и класс Person, поскольку сотрудник — это также и человек, то было бы рационально сделать класс Employee производным (наследником, подклассом) от класса Person, который, в свою очередь, называется базовым классом, родителем или суперклассом:
class Employee extends Person < public Employee(String name)< super(name); // если базовый класс определяет конструктор // то производный класс должен его вызвать >>
Чтобы объявить один класс наследником от другого, надо использовать после имени класса-наследника ключевое слово extends , после которого идет имя базового класса. Для класса Employee базовым является Person, и поэтому класс Employee наследует все те же поля и методы, которые есть в классе Person.
Если в базовом классе определены конструкторы, то в конструкторе производного классы необходимо вызвать один из конструкторов базового класса с помощью ключевого слова super . Например, класс Person имеет конструктор, который принимает один параметр. Поэтому в классе Employee в конструкторе нужно вызвать конструктор класса Person. То есть вызов super(name) будет представлять вызов конструктора класса Person.
При вызове конструктора после слова super в скобках идет перечисление передаваемых аргументов. При этом вызов конструктора базового класса должен идти в самом начале в конструкторе производного класса. Таким образом, установка имени сотрудника делегируется конструктору базового класса.
Причем даже если производный класс никакой другой работы не производит в конструкторе, как в примере выше, все равно необходимо вызвать конструктор базового класса.
public class Program < public static void main(String[] args) < Person tom = new Person("Tom"); tom.display(); Employee sam = new Employee("Sam"); sam.display(); >> class Person < String name; public String getName()< return name; >public Person(String name) < this.name=name; >public void display() < System.out.println("Name: " + name); >> class Employee extends Person < public Employee(String name)< super(name); // если базовый класс определяет конструктор // то производный класс должен его вызвать >>
Производный класс имеет доступ ко всем методам и полям базового класса (даже если базовый класс находится в другом пакете) кроме тех, которые определены с модификатором private . При этом производный класс также может добавлять свои поля и методы:
public class Program < public static void main(String[] args) < Employee sam = new Employee("Sam", "Microsoft"); sam.display(); // Sam sam.work(); // Sam works in Microsoft >> class Person < String name; public String getName()< return name; >public Person(String name) < this.name=name; >public void display() < System.out.println("Name: " + name); >> class Employee extends Person < String company; public Employee(String name, String company) < super(name); this.company=company; >public void work() < System.out.printf("%s works in %s \n", getName(), company); >>
В данном случае класс Employee добавляет поле company, которое хранит место работы сотрудника, а также метод work.
Переопределение методов
Производный класс может определять свои методы, а может переопределять методы, которые унаследованы от базового класса. Например, переопределим в классе Employee метод display:
public class Program < public static void main(String[] args) < Employee sam = new Employee("Sam", "Microsoft"); sam.display(); // Sam // Works in Microsoft >> class Person < String name; public String getName()< return name; >public Person(String name) < this.name=name; >public void display() < System.out.println("Name: " + name); >> class Employee extends Person < String company; public Employee(String name, String company) < super(name); this.company=company; >@Override public void display() < System.out.printf("Name: %s \n", getName()); System.out.printf("Works in %s \n", company); >>
Перед переопределяемым методом указывается аннотация @Override . Данная аннотация в принципе необязательна.
При переопределении метода он должен иметь уровень доступа не меньше, чем уровень доступа в базовом класса. Например, если в базовом классе метод имеет модификатор public, то и в производном классе метод должен иметь модификатор public.
Однако в данном случае мы видим, что часть метода display в Employee повторяет действия из метода display базового класса. Поэтому мы можем сократить класс Employee:
class Employee extends Person < String company; public Employee(String name, String company) < super(name); this.company=company; >@Override public void display() < super.display(); System.out.printf("Works in %s \n", company); >>
С помощью ключевого слова super мы также можем обратиться к реализации методов базового класса.
Запрет наследования
Хотя наследование очень интересный и эффективный механизм, но в некоторых ситуациях его применение может быть нежелательным. И в этом случае можно запретить наследование с помощью ключевого слова final . Например:
public final class Person
Если бы класс Person был бы определен таким образом, то следующий код был бы ошибочным и не сработал, так как мы тем самым запретили наследование:
class Employee extends Person
Кроме запрета наследования можно также запретить переопределение отдельных методов. Например, в примере выше переопределен метод display() , запретим его переопределение:
public class Person < //. public final void display()< System.out.println("Имя: " + name); >>
В этом случае класс Employee не сможет переопределить метод display.
Динамическая диспетчеризация методов
Наследование и возможность переопределения методов открывают нам большие возможности. Прежде всего мы можем передать переменной суперкласса ссылку на объект подкласса:
Person sam = new Employee("Sam", "Oracle");
Так как Employee наследуется от Person, то объект Employee является в то же время и объектом Person. Грубо говоря, любой работник предприятия одновременно является человеком.
Однако несмотря на то, что переменная представляет объект Person, виртуальная машина видит, что в реальности она указывает на объект Employee. Поэтому при вызове методов у этого объекта будет вызываться та версия метода, которая определена в классе Employee, а не в Person. Например:
public class Program < public static void main(String[] args) < Person tom = new Person("Tom"); tom.display(); Person sam = new Employee("Sam", "Oracle"); sam.display(); >> class Person < String name; public String getName() < return name; >public Person(String name) < this.name=name; >public void display() < System.out.printf("Person %s \n", name); >> class Employee extends Person < String company; public Employee(String name, String company) < super(name); this.company = company; >@Override public void display() < System.out.printf("Employee %s works in %s \n", super.getName(), company); >>
Консольный вывод данной программы:
Person Tom Employee Sam works in Oracle
При вызове переопределенного метода виртуальная машина динамически находит и вызывает именно ту версию метода, которая определена в подклассе. Данный процесс еще называется dynamic method lookup или динамический поиск метода или динамическая диспетчеризация методов.
Как передать переменную из одного класса в другой java
Регистрация: 16.03.2013
Сообщений: 599
Java EE + JSF. Как передать значение из одного класса в другой?
Для создания шаблона, в хедере которого происходит авторизация, требуется передать из класса, который используется в части контента, переменную вроде «needRole».
Далее идет псевдокод с упущенными сеттерами/геттерами и прочей технической частью.
Код класса авторизации:
class Auth < String needRole; // требуемая роль User u; // получаем юзера из сессии public void Auth() < u = session.getUser(); // функция получения пользователя if (u.getRole() != needRole) // если роль не соответствует - перенаправляем redirectTo("http://site/login.jsp"); >>Код внутреннего (контентного) класса:
class Entered
Код шаблона:
Код страницы контента:
//------------------------------------------------- // Сюда требуется вставить код, который будет передавать значение // из Entered.needRole в Auth.needRole // вроде = #"/> // может какой-то код должен быть в какой-то функции в //------------------------------------------------- alextrof94$gmail.com
Последний раз редактировалось alextrof94; 16.12.2014 в 01:05 .
| alextrof94 |
| Посмотреть профиль |
| Найти ещё сообщения от alextrof94 |
Обзор всех модификаторов в Java
Модификаторы это ключевые слова в Java, которые «изменяют и регулируют» работу классов, методов и переменных.
27 авг. 2022 · 9 минуты на чтение
Все члены класса в языке Java имеют модификаторы. Модификаторы — это ключевые слова, которые «изменяют и регулируют» работу классов, методов и переменных.
В Java множество различных модификаторов, но они не имеют строгой структуры. Однако, из всех модификаторов принято выделять «модификаторы доступа». Их мы рассмотрим в самом конце.
Спонсор поста
Прочие модификаторы
Начнём наш разбор с модификаторов, которые нельзя объединить в какую-то группу. Этакие модификаторы одиночки 🙂
Модификатор final
С английского «final» можно перевести как «последний, окончательный». Этот модификатор тем или иным образом защищает от изменений переменные, методы и классы.
Переменная final
Переменная объявленная как final после инициализации становится неизменной. Это значит, что примитив изменить не выйдет, а для ссылочной переменной не удастся присвоить новую ссылку на другой объект.
Для final переменных на уровне класса значение устанавливается сразу или через конструктор.
public class Foo < private final int a = 10; private final Bar bar; public Foo(Bar bar) < this.bar = bar; >> class Bar
В примере выше переменную a мы устанавливаем сразу, а переменную bar в конструкторе.
Изменить значения этих переменных не выйдет (строка 13 и 14). Однако данные внутри объекта могут быть изменены (строка 16). Таким образом, состояние полей объекта, на который ссылается final переменная, изменяемо.
Аргументы и локальные переменные метода также могут быть final . Тогда изменить их тоже не выйдет (строки 4, 5).
public void method(final int a) < final long b = 10; a = 10; // error b = 20; // error >Помните, что final переменную класса объявляют сразу или в конструкторе. Но на локальную переменную метода это правило не распространяется. Вы можете объявить её, но не инициализировать до момента ее использования.
public void method() < final long b; System.out.println(b); // error >Такое поведение позволяет инициализировать final переменную по условию. Например, так:
public void method(int a) < final long b; if (a >10) < b = 20; >else < b = 30; >b = 50; // error >Метод final
Для методов final означает запрет на переопределение в наследниках.
class Foo < final void method() < System.out.println("test"); >> class Bar extends Foo < final void method() < // error System.out.println("test"); >>Это полезно, когда вы допускаете использование класса в наследовании, но поведение конкретного метода хотите запретить переопределять.
Класс final
Применение final по отношению к классу объявляет класс завершённым — запрещает дальнейшее наследование от такого класса.
final class Foo < >class Bar extends Foo < // error >Модификатор static
Обычный подход в Java — это создать класс, потом создать экземпляр класса, то есть объект, и вызывать метод класса у этого объекта.
С использованием модификатора static объявляются методы и переменные, которые не нуждаются в объекте класса. Таким образом, методы и переменные вызываются от класса, а не от объекта.
Этот модификатор не получится применить к конструктору, а также к обычному классу, но к вложенному классу применить static можно.
package p1; class Foo < static String field = "Test"; static String getString() < return "Test two"; >> class Main < public static void main(String[] args) < System.out.println(Foo.field); System.out.println(Foo.getString()); > >Вы можете вызывать static методы и переменные от объекта, но делать так не рекомендуется. Если мы говорим про объекты, то каждый объект обладает полями, которые содержат уникальные значения. Изменяя поле у одного объекта класса, мы не повлияем на поля другого объекта того же класса. Если вы измените static поле, то оно изменится у всех экземпляров класса.
Также у вас не получится сделать наследника, так как при наследовании вызывается конструктор класса родителя.
Зачем нужен такой конструктор?
Может показаться, что это бред. Зачем тогда нужен такой класс? Выделяют два случая, когда такой конструктор оказывается полезным.
Первый — это статические фабричные методы для создания объекта. О них мы говорили в разделе модификатора static . Таким образом, мы скрываем конструктор и оставляем только фабричные методы.
public class Foo < private Foo(int a) < >public static Foo of(int a) < return new Foo(a); >public static Foo doubleCreate(int a) < return new Foo(a * a); >>Второй случай — это создание утилитарных классов, также упоминаемые раньше. Обычно вы не хотите, чтобы кто-то создавал объекты таких классов, так как это не имеет никакого смысла.
Класс private
Обратите внимание, что перед самим Foo стоит модификатор доступа public . Поставить private попросту не выйдет. Однако, мы сможем поставить модификатор private у вложенного класса:
public class Foo < private String field; private class Bar < >>Метод private
Приватный метод невозможно вызвать из другого класса.
class Foo < private void privateMethod() < >public void method() < >> class Bar < void method(Foo foo) < foo.method(); // success foo.privateMethod(); // error >>Приватные методы недоступны для вызова даже у наследника.
class Foo < private void privateMethod() < >> class ChildFoo < void method() < this.privateMethod(); // error >>Не имеет смысла объявлять метод private final так как private метод не виден в наследниках, соответственно не может быть предопределен.
Переменная private
Повторяет особенности private-метода: у других классов, в том числе у наследников, нет доступа к этому полю.
Модификатор доступа default-package
Особенностью этого модификатора — отсутствие ключевого слова. Если вы не указываете модификатор, то он применяется по умолчанию.
С таким модификатором доступ есть внутри этого класса, а также все классы, которые находятся в этом пакете, имеют доступ.
Рассмотрим пример использования. У нас есть класс Foo и Bar в одном пакете p1 и класс DifferentPackage в другом пакете.
package p1; public class Foo < int defaultField; Foo(int i, int i2) < >void defaultMethod() < >>package p1; public class Bar < public void testMethod(Foo foo) < foo.defaultField = 2; // success foo.defaultMethod(); // success foo = new Foo(1); // success >>В случае с классом Bar никаких ошибок не будет, мы сможем получить доступ и к конструктору, и к методу, и к полю. Но если мы попробуем то же самое сделать в классе DifferentPackage , то столкнёмся с ошибками.
package p2; public class DifferentPackage < public void testMethod(Foo foo) < foo.defaultField = 2; // error foo.defaultMethod(); // error foo = new Foo(1); // error >>Модификатор доступа protected
Этот модификатор доступа обладает свойствами модификаторов private и default-package . А также позволяет наследникам обращаться к членам класса родителя.
Посмотрим на примере. У нас есть класс Foo в пакете p1 и пакет p2 с классом наследником ChildFoo и классом DifferentPackage .
package p1; public class Foo < protected int defaultField; protected Foo(int i) < >protected void defaultMethod() < >>C классом DifferentPackage всё так же, как и в прошлом примере. А для ChildFoo теперь есть доступ к полям/методам/конструктору своего родителя.
package p2; import p1.Foo; public class ChildFoo extends Foo < protected ChildFoo(int i) < super(i); >void method() < System.out.println(defaultField); defaultMethod(); >>Также необходимо у ChildFoo реализовать конструктор, который будет вызывать конструктор родителя.
Модификатор доступа public
Этот модификатор позволяет обращаться к членам класса откуда угодно. Если это переменная, то любой класс из любого пакета может её прочитать и изменить. Если это метод, то любой класс может его вызывать. Если это конструктор, то любой класс может его вызвать.
Шпаргалка для модификаторов доступа переменной
Визуально модификаторы доступа переменной класса можно представить таким образом:
Резюмирую
Модификаторы неотъемлемая базовая составляющая языка Java. Без полного понимания работы всех модификаторов будет сложно продолжать изучать этот язык.
Помните, не ко всем членам класса можно применять тот или иной модификатор. А также, что не все они сочетаются друг с другом.
Отдельным особняком стоят модификаторы доступа. Они позволяют вам защищать члены классов от модификации извне, тем самым реализуя один из принципов ООП — Инкапсуляцию.
Передача данных между классами java
Возможно вопрос покажется простым, но я конкретно торможу и у меня не получается передать переменную из одного класса в другой( Есть класс Recieve , в мейне которого есть методы:
public int receivedId(String recievedid) < int id; return >public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException
я хочу переменную id , которую возвращает метод receivedId , передать новому классу. Для этого, как я понимаю, в новом классе нужно создать объект класса Recieve , но дальше я подвис.
Отслеживать
8,900 11 11 золотых знаков 31 31 серебряный знак 55 55 бронзовых знаков