 |
Представление вложенных и внутренних классов
|
|
|
|
Представление вложенных и внутренних классов
Java позволяет определять класс внутри другого класса. Такие классы называют вложенными классами. Область определения вложенного класса ограничена областью определения внешнего класса. Таким образом, если класс B определен внутри класса A, класс B не может существовать независимо от класса A. Вложенный класс имеет доступ к членам, в том числе приватным, класса, в который он вложен. Однако внешний класс не имеет доступ к членам вложенного класса. Вложенный класс, который объявлен непосредственно внутри области определения своего внешнего класса, является его членом.
Можно также объявлять вложенные классы, являющиеся локальными для блока.
Существует два типа вложенных классов: статические и нестатические. Статический вложенный класс – класс, к которому применен модификатор static. Поскольку он является статическим, он должен обращаться к своему внешнему классу посредством объекта. То есть он не может непосредственно ссылаться на члены своего внешнего класса. Из-за этого ограничения статические вложенные классы используются редко.
Наиболее важный тип вложенного класса – внутренний класс. Внутренний класс – это нестатический вложенный класс. Он имеет доступ ко всем переменным и методам своего внешнего класса и может непосредственно ссылаться на них так же, как это делают остальные нестатические члены внешнего класса.
Следующая программа иллюстрирует определение и использование внутреннего класса. Класс Outer содержит одну переменную экземпляра outer_x, один метод экземпляра test() и определяет один внутренний класс Inner.
// Демонстрация использования внутреннего класса.
|
|
|
class Outer {
int outer_x = 100;
void test() {
Inner inner = new Inner();
inner. display();
}
// это внутренний класс
class Inner {
void display() {
System. out. println(" вывод: outer_x = " + outer_x);
}
}
}
class InnerClassDemo {
public static void main(String args[]) {
Outer outer = new Outer();
outer. test();
}
}
Это приложение генерирует следующий вывод:
вывод: outer_x = 100
В этой программе внутренний класс Inner определен в области определения класса Outer. Поэтому любой кода в классе Inner может непосредственно обращаться к переменной outer_x. Метод экземпляра display() определен внутри класса Inner. Этот метод отображает значение переменной outer_x в стандартном выходном потоке. Метод main() экземпляра InnerClassDemo создает экземпляр класса Outer и вызывает его метод test(). Этот метод создает экземпляр класса Inner и вызывает метод display().
Важно понимать, что экземпляр класса Inner может быть создан только внутри области определения класса Outer. Компилятор Java генерирует сообщение об ошибке, если любой код вне класса Outer пытается инициализировать класс Inner. Однако экземпляр класса Inner можно создать снаружи класса Outer, уточняя имя внутреннего класса именем внешнего класса – например Outer. Inner.
Как уже было сказано, внутренний класс имеет доступ ко всем элементам своего внешнего класса, но не наоборот. Члены внутреннего класса известны только внутри области определения внутреннего класса и не могут быть использованы внешним классом.
Например:
// Компиляция этой программы будет не возможна.
class Outer {
int outer_x = 100;
void test() {
Inner inner = new Inner();
inner. display();
}
// это внутренний класс
class Inner {
int y = 10; // y – локальная переменная класса Inner
void display() {
System. out. println(" вывод: outer_x = " + outer_x);
}
}
void showy() {
System. out. println(y); // ошибка; здесь переменная y не известна!
}
}
class InnerClassDemo {
public static void main(String args[]) {
Outer outer = new Outer();
outer. test();
}
}
В этом примере переменная y объявлена как переменная экземпляра класса Inner.
Поэтому она не известна за пределами класса и не может использоваться методом showy().
|
|
|
Хотя мы уделили основное внимание внутренним классам, определенным в качестве членов внутри области определения внешнего класса, внутренние классы можно определять внутри области определения любого блока. Например, вложенный класс можно определить внутри блока, определенного методом, или даже внутри тела цикла for, как показано в следующем примере:
// Определение внутреннего класса внутри цикла for.
class Outer {
int outer_x = 100;
void test() {
for(int i=0; i< 10; i++) {
class Inner {
void display() {
System. out. println(" вывод: outer_x = " + outer_x);
}
}
Inner inner = new Inner();
inner. display();
}
}
}
class InnerClassDemo {
public static void main(String args[]) {
Outer outer = new Outer();
outer. test();
}
}
Вывод, генерируемый этой версией программы, показан ниже.
вывод: outer_x = 100
вывод: outer_x = 100
вывод: outer_x = 100
вывод: outer_x = 100
вывод: outer_x = 100
вывод: outer_x = 100
вывод: outer_x = 100
вывод: outer_x = 100
вывод: outer_x = 100
вывод: outer_x = 100
Работа со строками в Java
Вероятно, String – наиболее часто используемый класс из библиотеки классов Java. Очевидная причина этого в том, что строки – исключительно важный элемент программирования.
Прежде всего, следует уяснить, что любая создаваемая строка в действительности представляет собой объект типа String. Даже строковые константы в действительности являются объектами String. Например, в операторе:
System. out. println(" Это – также объект String" );
, строка " Это – также объект String" – константа типа String.
Во-вторых, объекты типа String являются неизменными. После того как объект типа String создан, его содержимое не может изменяться. Хотя это может казаться серьезным ограничением, на самом деле это не так по двум причинам. Если нужно изменить строку, всегда можно создать новую строку, содержащую все изменения. В Java определен равноправный класс String, StringBuffer, допускающий изменение строк, что позволяет выполнять в Java все обычные манипуляции со строками. (Класс StringBuffer описан во второй части этой книги. )
Существует множество способов создания строк. Простейший из них – воспользоваться оператором вроде следующего:
String myString = " тестовая строка";
Как только объект String создан, его можно использовать во всех ситуациях, в которых допустимо использование строк. Например, следующий оператор отображает содержимое myString:
|
|
|
System. out. println(myString);
Для объектов типа String в Java определена одна операция: +. Она служит для объединения двух строк. Например, оператор:
String myString = " Мне" + " нравится " + " Java. ";
Приводит к тому, что содержимым переменной myString становится строка " Мне нравится Java".
Следующая программа иллюстрирует описанные концепции:
// Демонстрация применения строк.
class StringDemo {
public static void main(String args[]) {
String strOb1 = " Первая строка";
String strOb2 = " Вторая строка";
String strOb3 = strOb1 + " и " + strOb2;
System. out. println(strOb1);
System. out. println(strOb2);
System. out. println(strOb3);
}
}
Эта программа создает следующий вывод:
Первая строка
Вторая строка
Первая строка и вторая строка
Класс String содержит несколько методов, которые можно использовать. Опишем некоторые из них. С помощью метода equals() можно проверять равенство двух строк.
Метод length() позволяет выяснить длину строки. Вызывая метод charAt(), можно получить символ с указанным индексом. Ниже приведены общие формы этих трех методов:
boolean equals(String объект)
int length( )
char charAt(int индекс)
Следующая программа демонстрирует применение этих методов:
// Демонстрация некоторых методов класса String.
class StringDemo2 {
public static void main(String args[]) {
String strOb1 = " Первая строка";
String strOb2 = " Вторая строка";
String strOb3 = strOb1;
System. out. println(" Длина strOb1: " +
strOb1. length());
System. out. println(" Символ с индексом 3 в strOb1: " +
strOb1. charAt(3));
if(strOb1. equals(strOb2))
System. out. println(" strOb1 == strOb2" );
else
System. out. println(" strOb1! = strOb2" );
if(strOb1. equals(strOb3))
System. out. println(" strOb1 == strOb3" );
else
System. out. println(" strOb1! = strOb3" );
}
}
Эта программа генерирует следующий вывод:
Длина strOb1: 12
Символ с индексом 3 в strOb1: s
strOb1! = strOb2
strOb1 == strOb3
Конечно, подобно тому, как могут существовать массивы любого другого типа объектов, могут существовать и массивы строк. Например:
// Демонстрация использования массивов объектов типа String.
class StringDemo3 {
public static void main(String args[]) {
String str[] = { " один", " два", " три" };
for(int i=0; i< str. length; i++)
System. out. println(" str[" + i + " ]: " +
str[i]);
}
}
Вывод этой программы имеет вид:
str[0]: один
str[1]: два
str[2]: три
|
|
|
