Внутренние и вложенные Java-классы

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

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

Внутренние классы (нестатические вложенные классы)

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

Вот пример такой ситуации:

public class Program{

public static void main(String[] args) {

Person tom = new Person(«Tom», «qwerty»);
tom.displayPerson();
tom.account.displayAccount();
}
}
class Person{

private String name;
Account account;

Person(String name, String password){
this.name = name;
account = new Account(password);
}
public void displayPerson(){
System.out.printf(«Person \t Name: %s \t Password: %s \n», name, account.password);
}

public class Account{
private String password;

Account(String pass){
this.password = pass;
}
void displayAccount(){
System.out.printf(«Account Login: %s \t Password: %s \n», Person.this.name, password);
}
}
}

Еще одна особенность внутреннего класса заключается в том, что у него есть доступ ко всем полям с элементами внешнего. Также, учитывается и доступ к тем объектам, что имеют модификатор private. И значит, что никаких ограничений у данного класса нет. Но такое правило работает и в обратную сторону – внешнему классу может быть без проблем предоставлен доступ ко всему, что находится во внутреннем.

Также, ссылку на объект внешнего класса из внутреннего возможно получить, если использовать специальную команду. Называется она, к примеру, «Внешний_Класс.this». Однако, возможно придумать все, что угодно. И никаких дополнительных модификаторов для проведения таких действий не потребуется.
Что немаловажно – объекты внутренних классов имеют право создаваться только в тех классах, где внутренние определены. А во внешних – такой возможности нет.

Что дополнительно можно сказать о внутренних классах – «они везде». Если объяснять на понятнее, то их возможно объявить в любом месте. Это может быть даже метод или цикл. Потому, можно будет без проблем вписать в любое место внутренний класс и работать с ним. Никаких при этом затруднений не возникнет. Все же, Java это допускает.

Выглядит это зачастую таким образом:

public class Program{

public static void main(String[] args) {

Person tom = new Person(«Tom»);
tom.setAccount(«qwerty»);
}
}
class Person{

private String name;

Person(String name){
this.name = name;
}

public void setAccount (String password){

class Account{

void display(){
System.out.printf(«Account Login: %s \t Password: %s \n», name, password);
}
}
Account account = new Account();
account.display();
}
}

Статический вложенный класс в Java

Что также может быть полезно обучающимся программистам на Java – присутствует помимо внутреннего класса еще и статический вложенный тип класса. Он отличается некоторыми моментами, ввиду чего обязательно требуется обратить на этот абзац внимание.

Их цель заключается в скрытии комплексной информации во внешнем классе. Делается это с помощью элемента кода «publicstaticclass». Вот такой пример применения статического вложенного класса предоставляется начинающему кодеру:

class Math{

public static class Factorial{

private int result;
private int key;

public Factorial(int number, int x){

result=number;
key = x;
}

public intgetResult(){
return result;
}

public intgetKey(){
return key;
}
}

public static Factorial getFactorial(int x){

int result=1;
for (inti = 1; i<= x; i++){

result *= i;
}
return new Factorial(result, x);
}
}

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

Также, стоит отметить один важный момент. Он касается возврата объекта во внешний класс. А речь идет о факториале, который как раз-таки и вычислялся в коде. Также, возможно использовать классы в методе main.

Выглядеть это будет таким образом:

public static void main(String[] args) {

Math.Factorial fact = Math.getFactorial(6);
System.out.printf(«Факториал числа %d равен %d \n», fact.getKey(), fact.getResult());
}

Анонимный внутренний класс как аргумент

Если производится какая-либо операция, то возможно без каких-либо проблем передать объект методу. Это делается в случае, когда метод принимает объект класса, абстрактный/конкретный класс. В общем, при таких обстоятельствах передается объект методу и, следовательно, реализовывается интерфейс. В таком случае стоит сделать единственную операцию – передать анонимный внутренний класс методу, что Java позволяет без каких-либо затруднений.

Касательно синтаксиса – он здесь представлен легко и просто. Он выглядит примерно таким образом:

obj.my_Method(new My_Class() {
publicvoidDo() {
«остальная часть кода пользователя»
}
});

Естественно, нужно вместо фразы «остальная часть кода пользователя» использовать различные функции и так далее. А вот пример применения синтаксиса, что представлен выше с использованием собственных данных для ввода информации:

// Интерфейс
interface Message {
String greet();
}

publicclassMy_class {
// Метод, который принимает объект интерфейса Message
public void displayMessage(Message m) {
System.out.println(m.greet() +
«, это пример анонимного внутреннего класса в качестве аргумента»);
}

public static void main(String args[]) {
// Создание класса
My_classobj = new My_class();

// Передача анонимного внутреннего класса в качестве аргумента
obj.displayMessage(new Message() {
public String greet() {
return «Привет»;
}
});
}
}

Такое можно использовать за пример простой программы. Однако, стоит понимать, что пользователям придется что-то самостоятельно додумывать. Но стоит понимать, что на выходе, пример, представленный выше, выдает следующий результат, которого можно запросто добиться:

Привет, это пример анонимного внутреннего класса в качестве аргумента

Java — самоучитель, рекомендованный новичкам

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

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

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

Образовательный портал 3TY.RU
Adblock
detector