Если вы используете этот код на локальном сервере (т. е. ваш компьютер для целей разработки), он не отправит электронное письмо получателю. Что произойдет, он создаст файл .txt
в папке с именем mailoutput
.
В случае, если вы используете бесплатный сервисный сервис, например 000webhost
или hostinger
, эти поставщики услуг отключают функцию mail()
, чтобы предотвратить непреднамеренное использование электронной почты, спам и т. д. Я предпочитаю вас чтобы связаться с ними, чтобы узнать, поддерживают ли они эту функцию.
Если вы уверены, что поставщик услуг поддерживает функцию mail (), вы можете проверить это руководство по PHP для дальнейшей справки, PHP mail ()
Чтобы проверить, поддерживает ли ваша служба хостинга функцию mail (), попробуйте запустить этот код (не забудьте изменить адрес электронной почты получателя)
Надеюсь, что это помогли.
Из учебника Java Tutorial :
Вложенные классы делятся на две категории: статические и нестатические. Вложенные классы, объявленные static, просто называются статическими вложенными классами. Нестатические вложенные классы называются внутренними классами.
Доступ к статическим вложенным классам осуществляется с помощью имени класса:
OuterClass.StaticNestedClass
Например, чтобы создать объект для статического вложенного класса, используйте этот синтаксис:
OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
Объекты, являющиеся экземплярами внутреннего класса, существуют в экземпляре внешнего класса. Рассмотрим следующие классы:
class OuterClass { ... class InnerClass { ... } }
Экземпляр InnerClass может существовать только внутри экземпляра OuterClass и имеет прямой доступ к методам и полям его вмещающего экземпляра.
Чтобы создать экземпляр внутренний класс, вы должны сначала создать экземпляр внешнего класса. Затем создайте внутренний объект внутри внешнего объекта с помощью этого синтаксиса:
OuterClass.InnerClass innerObject = outerObject.new InnerClass();
см.: Учебник по Java - вложенные классы
Для полноты отметим, что там также является внутренним классом без вмещающего экземпляра :
class A { int t() { return 1; } static A a = new A() { int t() { return 2; } }; }
Здесь
new A() { ... }
является внутренним классом , определенным в статическом контексте и не имеет охватывающего экземпляра.
Я думаю, что ни один из приведенных выше ответов не объясняет вам реальную разницу между вложенным классом и статическим вложенным классом при разработке приложения:
Вложенный класс может быть нестатическим или статическим, и в каждом случае это класс, определенный в другом классе. Вложенный класс должен существовать только для того, чтобы служить является классом-оболочкой, если вложенный класс полезен другими классами (а не только оболочкой), должен быть объявлен как класс верхнего уровня.
Нестатический Вложенный класс: неявно связан с вмещающим экземпляром содержащего класса, это означает, что можно вызвать методы и получить доступ к окружающим экземплярам. Одно распространенное использование нестатического вложенного класса - это определение класса адаптера.
Статический вложенный класс: не может получить доступ к экземпляру класса и вызвать на нем методы, поэтому его следует использовать, когда вложенный класс не требуют доступа к экземпляру охватывающего класса. Обычное использование статического вложенного класса заключается в реализации компонентов внешнего объекта.
Таким образом, основное различие между двумя с точки зрения дизайна: нестатические вложенные класс может получить доступ к экземпляру класса контейнера, а static не может .
В случае создания экземпляра экземпляр нестационарного внутреннего класса создается с ссылкой на объект внешнего класса, в котором он определен. Это означает, что у него есть инклюзивный экземпляр. Но экземпляр статического внутреннего класса создается со ссылкой на класс Outer, а не ссылкой на объект внешнего класса. Это означает, что он не включает экземпляр.
Например:
class A
{
class B
{
// static int x; not allowed here…..
}
static class C
{
static int x; // allowed here
}
}
class Test
{
public static void main(String… str)
{
A o=new A();
A.B obj1 =o.new B();//need of inclosing instance
A.C obj2 =new A.C();
// not need of reference of object of outer class….
}
}
Я проиллюстрировал различные возможные правильные сценарии и ошибки, которые могут возникать в Java-коде.
class Outter1 {
String OutStr;
Outter1(String str) {
OutStr = str;
}
public void NonStaticMethod(String st) {
String temp1 = "ashish";
final String tempFinal1 = "ashish";
// below static attribute not permitted
// static String tempStatic1 = "static";
// below static with final attribute not permitted
// static final String tempStatic1 = "ashish";
// synchronized keyword is not permitted below
class localInnerNonStatic1 {
synchronized public void innerMethod(String str11) {
str11 = temp1 +" sharma";
System.out.println("innerMethod ===> "+str11);
}
/*
// static method with final not permitted
public static void innerStaticMethod(String str11) {
str11 = temp1 +" india";
System.out.println("innerMethod ===> "+str11);
}*/
}
// static class not permitted below
// static class localInnerStatic1 { }
}
public static void StaticMethod(String st) {
String temp1 = "ashish";
final String tempFinal1 = "ashish";
// static attribute not permitted below
//static String tempStatic1 = "static";
// static with final attribute not permitted below
// static final String tempStatic1 = "ashish";
class localInnerNonStatic1 {
public void innerMethod(String str11) {
str11 = temp1 +" sharma";
System.out.println("innerMethod ===> "+str11);
}
/*
// static method with final not permitted
public static void innerStaticMethod(String str11) {
str11 = temp1 +" india";
System.out.println("innerMethod ===> "+str11);
}*/
}
// static class not permitted below
// static class localInnerStatic1 { }
}
// synchronized keyword is not permitted
static class inner1 {
static String temp1 = "ashish";
String tempNonStatic = "ashish";
// class localInner1 {
public void innerMethod(String str11) {
str11 = temp1 +" sharma";
str11 = str11+ tempNonStatic +" sharma";
System.out.println("innerMethod ===> "+str11);
}
public static void innerStaticMethod(String str11) {
// error in below step
str11 = temp1 +" india";
//str11 = str11+ tempNonStatic +" sharma";
System.out.println("innerMethod ===> "+str11);
}
//}
}
//synchronized keyword is not permitted below
class innerNonStatic1 {
//This is important we have to keep final with static modifier in non
// static innerclass below
static final String temp1 = "ashish";
String tempNonStatic = "ashish";
// class localInner1 {
synchronized public void innerMethod(String str11) {
tempNonStatic = tempNonStatic +" ...";
str11 = temp1 +" sharma";
str11 = str11+ tempNonStatic +" sharma";
System.out.println("innerMethod ===> "+str11);
}
/*
// error in below step
public static void innerStaticMethod(String str11) {
// error in below step
// str11 = tempNonStatic +" india";
str11 = temp1 +" india";
System.out.println("innerMethod ===> "+str11);
}*/
//}
}
}
Вот ключевые различия и сходства между внутренним классом Java и статическим вложенным классом.
Надеюсь, что это поможет!
Outerclass.InnerClass innerObject = outerObject.new Innerclass();
OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
Согласно документации Oracle есть несколько причин ( полная документация ):
- Это способ логически группы классов, которые используются только в одном месте: если класс полезен только для одного другого класса, то логично вставлять его в этот класс и поддерживать вместе. Вложение таких «вспомогательных классов» делает их пакет более упорядоченным.
- Он увеличивает инкапсуляцию: рассмотрим два класса верхнего уровня: A и B, где B нужен доступ к членам A, которые иначе были бы объявлены частными. Скрывая класс B в классе A, члены A могут быть объявлены частными, а B может получить к ним доступ. Кроме того, сам B может быть скрыт от внешнего мира.
- Это может привести к более легко читаемому и поддерживаемому коду: Вложение небольших классов в классы верхнего уровня помещает код ближе к тому, где он используется.
Вложенный класс является очень общим термином: каждый класс, который не является верхним, представляет собой вложенный класс. Внутренний класс - это нестатический вложенный класс. Джозеф Дарси написал очень приятное объяснение о Nested, Inner, Member и Top-Level Classes .
Термины используются взаимозаменяемо. Если вы хотите быть действительно педантичным, то вы можете определить «вложенный класс» для обозначения статического внутреннего класса, который не имеет закрывающего экземпляра. В коде у вас может быть что-то вроде этого:
public class Outer {
public class Inner {}
public static class Nested {}
}
Это не совсем общепринятое определение.
Разница заключается в том, что вложенное объявление класса, которое также является статическим, может быть создано вне класса-оболочки.
Если у вас есть объявление вложенного класса, которое является not static, также известный как внутренний класс , Java не позволит вам создать экземпляр, кроме как через класс включения. Объект, созданный из внутреннего класса, связан с объектом, созданным из внешнего класса, поэтому внутренний класс может ссылаться на поля внешнего.
Но если он статичен, ссылка не существует, внешние поля не могут быть доступны (за исключением обычной ссылки, как и любой другой объект), и поэтому вы можете создать экземпляр вложенного класса самостоятельно.
Просто некоторые надстройки после того, как вы прочитали java-учебник оракула в классах и объектах. Это может помочь, если вы знаете модель памяти Java для внутреннего класса и статического вложенного класса. Пожалуйста, прочитайте следующие три вопроса, чтобы понять, почему внутренний класс и статический вложенный класс разработаны Java таким образом. И тогда вы можете знать, когда использовать внутренний класс и когда использовать статический вложенный класс.
Как внутренний объект класса находится в памяти?
Управление памятью - Внутренний статический класс в Java
Когда в него загружается статический вложенный класс (и статические члены)?
Тогда прочитайте это, чтобы сравнить внутренний класс и статический вложенный класс.
В чем преимущество создания внутреннего класса как статического с Java?
Существует тонкость использования вложенных статических классов, которые могут быть полезны в определенных ситуациях.
Если статические атрибуты получают экземпляр до того, как класс получает экземпляр через его конструктор, статические атрибуты внутри вложенных статических классов похоже, не создаются экземпляром до тех пор, пока не будет вызван конструктор класса или, по крайней мере, до тех пор, пока не будут указаны первые атрибуты, даже если они отмечены как «final».
Рассмотрим этот пример:
public class C0 {
static C0 instance = null;
// Uncomment the following line and a null pointer exception will be
// generated before anything gets printed.
//public static final String outerItem = instance.makeString(98.6);
public C0() {
instance = this;
}
public String makeString(int i) {
return ((new Integer(i)).toString());
}
public String makeString(double d) {
return ((new Double(d)).toString());
}
public static final class nested {
public static final String innerItem = instance.makeString(42);
}
static public void main(String[] argv) {
System.out.println("start");
// Comment out this line and a null pointer exception will be
// generated after "start" prints and before the following
// try/catch block even gets entered.
new C0();
try {
System.out.println("retrieve item: " + nested.innerItem);
}
catch (Exception e) {
System.out.println("failed to retrieve item: " + e.toString());
}
System.out.println("finish");
}
}
Хотя «вложенные» и «innerItem» объявляются как «статические окончательные». параметр nested.innerItem не выполняется до тех пор, пока не будет создан экземпляр класса (или, по крайней мере, до тех пор, пока не будет указан первый вложенный статический элемент), как вы можете убедиться сами, комментируя и раскомментируя строки, на которые я ссылаюсь, выше. То же самое не относится к «externalItem».
По крайней мере, это то, что я вижу в Java 6.0.
Я не думаю, что реальная разница стала понятной в приведенных выше ответах.
Сначала, чтобы получить правильные слова:
Ответ Мартина прав до сих пор. Тем не менее, актуальным вопросом является: Какова цель объявления статического кластера вложенным или нет?
Вы используете статические вложенные классы, если хотите просто сохранить свои классы вместе, если они принадлежат местно вместе или если вложенные класс используется исключительно в классе. Между статическим вложенным классом и каждым другим классом нет семантической разницы.
Нестатические вложенные классы - это другой зверь. Подобно анонимным внутренним классам, такие вложенные классы фактически закрывают. Это означает, что они захватывают свой окружающий масштаб и их охватывающий экземпляр и делают доступным. Возможно, пример пояснит это. См. Этот заглушка контейнера:
public class Container {
public class Item{
Object data;
public Container getContainer(){
return Container.this;
}
public Item(Object data) {
super();
this.data = data;
}
}
public static Item create(Object data){
// does not compile since no instance of Container is available
return new Item(data);
}
public Item createSubItem(Object data){
// compiles, since 'this' Container is available
return new Item(data);
}
}
В этом случае вы хотите получить ссылку от дочернего элемента в родительский контейнер. Используя нестатический вложенный класс, это работает без какой-либо работы. Вы можете получить доступ к закрывающему экземпляру Container с синтаксисом Container.this
.
Более подробные пояснения к хардкору:
Если вы посмотрите на байт-коды Java, которые генерирует компилятор для (нестатического ) вложенный класс может стать еще яснее:
// class version 49.0 (49)
// access flags 33
public class Container$Item {
// compiled from: Container.java
// access flags 1
public INNERCLASS Container$Item Container Item
// access flags 0
Object data
// access flags 4112
final Container this$0
// access flags 1
public getContainer() : Container
L0
LINENUMBER 7 L0
ALOAD 0: this
GETFIELD Container$Item.this$0 : Container
ARETURN
L1
LOCALVARIABLE this Container$Item L0 L1 0
MAXSTACK = 1
MAXLOCALS = 1
// access flags 1
public <init>(Container,Object) : void
L0
LINENUMBER 12 L0
ALOAD 0: this
ALOAD 1
PUTFIELD Container$Item.this$0 : Container
L1
LINENUMBER 10 L1
ALOAD 0: this
INVOKESPECIAL Object.<init>() : void
L2
LINENUMBER 11 L2
ALOAD 0: this
ALOAD 2: data
PUTFIELD Container$Item.data : Object
RETURN
L3
LOCALVARIABLE this Container$Item L0 L3 0
LOCALVARIABLE data Object L0 L3 2
MAXSTACK = 2
MAXLOCALS = 3
}
Как вы видите, компилятор создает скрытое поле Container this$0
. Это устанавливается в конструкторе, который имеет дополнительный параметр типа Container для указания экземпляра-оболочки. Вы не можете увидеть этот параметр в источнике, но компилятор неявно генерирует его для вложенного класса.
Пример Мартина
OuterClass.InnerClass innerObject = outerObject.new InnerClass();
был бы скомпилирован для вызова чего-то вроде (в байтекодах)
new InnerClass(outerObject)
Для полноты:
Анонимный класс - прекрасный пример нестатического вложенного класса, у которого просто нет имени, связанного с ним, и на него нельзя ссылаться позже.
Я не думаю, что здесь есть что добавить, большинство ответов прекрасно объясняют различия между статическим вложенным классом и внутренними классами. Однако рассмотрите следующую проблему при использовании вложенных классов и внутренних классов. Как упоминание в нескольких ответах, внутренние классы не могут быть созданы без экземпляра и их вмещающего класса, что означает, что они удерживают указатель на экземпляр их вмещающего класса, что может привести к переполнению памяти или исключению переполнения стека из-за того, что GC не смогут мусор собирать окружающие классы, даже если они больше не используются. Чтобы сделать это, проверьте следующий код:
public class Outer {
public class Inner {
}
public Inner inner(){
return new Inner();
}
@Override
protected void finalize() throws Throwable {
// as you know finalize is called by the garbage collector due to destroying an object instance
System.out.println("I am destroyed !");
}
}
public static void main(String arg[]) {
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
// out instance is no more used and should be garbage collected !!!
// However this will not happen as inner instance is still alive i.e used, not null !
// and outer will be kept in memory until inner is destroyed
outer = null;
//
// inner = null;
//kick out garbage collector
System.gc();
}
Если вы удалите комментарий на // inner = null;
, программа выйдет «Я уничтожен!», Но если оставить комментарий, это не будет. Причина в том, что белый внутренний экземпляр по-прежнему ссылается, GC не может его собрать и потому что он ссылается (имеет указатель на) внешний экземпляр, который он также не собирает. Наличие достаточного количества этих объектов в вашем проекте и может закончиться нехваткой памяти. По сравнению со статическими внутренними классами, которые не содержат точку для внутреннего экземпляра класса, поскольку он не связан с экземпляром, а связан с классом. Вышеупомянутая программа может печатать «Я уничтожен!» если вы станете классом Inner static и инстанцируются с помощью Outer.Inner i = new Outer.Inner();
Ориентационный ученик, который является новичком для Java и / или вложенных классов
Вложенные классы могут быть либо: 1. Статические вложенные классы. 2. Нестатические вложенные классы. (также известный как Внутренние классы) => Пожалуйста, запомните это
1.Интерные классы Пример:
class OuterClass {
/* some code here...*/
class InnerClass { }
/* some code here...*/
}
Внутренние классы - это подмножества вложенных классов:
Специальность класса Inner:
2.Static Вложенные классы: Пример:
class EnclosingClass {
static class Nested {
void someMethod() { System.out.println("hello SO"); }
}
}
Случай 1: Создание статического вложенного класса из не закрывающего класса
class NonEnclosingClass {
public static void main(String[] args) {
/*instantiate the Nested class that is a static
member of the EnclosingClass class:
*/
EnclosingClass.Nested n = new EnclosingClass.Nested();
n.someMethod(); //prints out "hello"
}
}
Случай 2: Создание статического вложенного класса из класса-оболочки
class EnclosingClass {
static class Nested {
void anotherMethod() { System.out.println("hi again"); }
}
public static void main(String[] args) {
//access enclosed class:
Nested n = new Nested();
n.anotherMethod(); //prints out "hi again"
}
}
Специальность статических классов:
Заключение: Вопрос: В чем основное отличие между внутренним классом и статический вложенный класс в Java? Ответ: просто рассмотрите особенности каждого класса, упомянутого выше.
Я думаю, что люди здесь должны заметить Poster, что: Static Nest Class - это только первый внутренний класс. Например:
public static class A {} //ERROR
public class A {
public class B {
public static class C {} //ERROR
}
}
public class A {
public static class B {} //COMPILE !!!
}
Итак, суммируем, статический класс не зависит от того, какой класс содержит его. Таким образом, они не могут в нормальном классе. (потому что нормальному классу нужен экземпляр).
Когда мы объявляем статический класс-член внутри класса, он известен как вложенный класс верхнего уровня или статический вложенный класс. Это можно продемонстрировать ниже:
class Test{
private static int x = 1;
static class A{
private static int y = 2;
public static int getZ(){
return B.z+x;
}
}
static class B{
private static int z = 3;
public static int getY(){
return A.y;
}
}
}
class TestDemo{
public static void main(String[] args){
Test t = new Test();
System.out.println(Test.A.getZ());
System.out.println(Test.B.getY());
}
}
Когда мы объявляем нестатический класс членов внутри класса, он известен как внутренний класс. Внутренний класс можно продемонстрировать ниже:
class Test{
private int i = 10;
class A{
private int i =20;
void display(){
int i = 30;
System.out.println(i);
System.out.println(this.i);
System.out.println(Test.this.i);
}
}
}
Прежде всего нет такого класса, который называется Static class. Использование модификатора Static с внутренним классом (называемый вложенным классом) говорит о том, что он является статическим членом Outer Class, что означает, что мы можем получить к нему доступ, как и с другими статическими членами, и без какого-либо экземпляра класса Outer. (Которая является преимуществом статического изначально.)
Разница между использованием класса Nested и регулярным внутренним классом:
OuterClass.InnerClass inner = new OuterClass().new InnerClass();
Сначала Мы можем создать экземпляр Outerclass, после чего мы можем получить доступ к Inner.
Но если класс вложен, то синтаксис:
OuterClass.InnerClass inner = new OuterClass.InnerClass();
Использует статический синтаксис как обычную реализацию статического ключевого слова.
Экземпляр внутреннего класса создается, когда создается экземпляр внешнего класса. Поэтому члены и методы внутреннего класса имеют доступ к членам и методам экземпляра (объекта) внешнего класса. Когда экземпляр внешнего класса выходит за пределы области видимости, также исчезают внутренние экземпляры классов.
Статический вложенный класс не имеет конкретного экземпляра. Он просто загружается, когда он используется в первый раз (как и статические методы). Это полностью независимая сущность, методы и переменные которой не имеют доступа к экземплярам внешнего класса.
Статические вложенные классы не связаны с внешним объектом, они быстрее, и они не 't взять память кучи / стека, потому что не нужно создавать экземпляр такого класса. Поэтому эмпирическое правило состоит в том, чтобы попытаться определить статический вложенный класс с максимально возможной областью (private> = class> = protected> = public), а затем преобразовать его во внутренний класс (удалив «статический» идентификатор) и ослабить объем, если это действительно необходимо.
Внутренний класс и вложенный статический класс в Java - это классы, объявленные внутри другого класса, известного как класс верхнего уровня в Java. В терминологии Java. Если вы объявляете вложенный класс static, он будет вызывать вложенный статический класс в Java, а нестатический вложенный класс просто называется Inner Class.
Что такое Inner Class в Java?
Любой класс, который не является верхним уровнем или объявлен внутри другого класса, известен как вложенный класс и из тех вложенных классов, класс, которые объявлены нестатические известны как класс Inner в Java. в Java есть три типа класса Inner:
1) Локальный внутренний класс - объявляется внутри кодового блока или метода. 2) Анонимный внутренний класс - это класс, который не имеет имени для ссылки и инициализируется в том же месте, где он создается. 3) Внутренний класс члена - объявлен как нестационарный член внешнего класса.
public class InnerClassTest {
public static void main(String args[]) {
//creating local inner class inside method i.e. main()
class Local {
public void name() {
System.out.println("Example of Local class in Java");
}
}
//creating instance of local inner class
Local local = new Local();
local.name(); //calling method from local inner class
//Creating anonymous inner class in Java for implementing thread
Thread anonymous = new Thread(){
@Override
public void run(){
System.out.println("Anonymous class example in java");
}
};
anonymous.start();
//example of creating instance of inner class
InnerClassTest test = new InnerClassTest();
InnerClassTest.Inner inner = test.new Inner();
inner.name(); //calling method of inner class
}
//Creating Inner class in Java
private class Inner{
public void name(){
System.out.println("Inner class example in java");
}
}
}
Что такое вложенный статический класс в Java?
Вложенный статический класс - это другой класс, который объявлен внутри класса как члена и статично. Вложенный статический класс также объявляется членом внешнего класса и может быть закрытым, открытым или защищенным, как и любой другой член. Одним из основных преимуществ вложенного статического класса над внутренним классом является то, что экземпляр вложенного статического класса не привязан к какому-либо закрывающему экземпляру класса Outer. Вам также не нужен какой-либо экземпляр класса Outer для создания экземпляра вложенного статического класса в Java .
1) Он может получить доступ к статическим членам данных внешнего класса, включая частные. 2) Статический вложенный класс не может получить доступ к нестатистическому (экземпляру) элементу данных или method .
public class NestedStaticExample {
public static void main(String args[]){
StaticNested nested = new StaticNested();
nested.name();
}
//static nested class in java
private static class StaticNested{
public void name(){
System.out.println("static nested class example in java");
}
}
}
Ссылка: Внутренний класс и вложенный Static Class в Java с примером
Я думаю, что соглашение, которое обычно соблюдается, таково:
Тем не менее, несколько других моментов для запоминания:
new YourClass(){};
означает class [Anonymous] extends YourClass {}
new YourInterface(){};
означает class [Anonymous] implements YourInterface {}
Я чувствую, что больший вопрос остается открытым, какой из них использовать и когда? Хорошо, что в основном зависит от того, с каким сценарием вы сталкиваетесь, но чтение ответа, данное @jrudolph, может помочь вам принять какое-то решение.
Ummm ... внутренний класс IS является вложенным классом ... вы имеете в виду анонимный класс и внутренний класс?
Edit: Если вы на самом деле имели в виду внутреннее или анонимное ... внутренний класс - это просто класс, определенный в классе, например:
public class A {
public class B {
}
}
. В то время как анонимный класс является расширением класса, определенного анонимно, поэтому никакого фактического «класса» не определено, как в:
public class A {
}
A anon = new A() { /* you could change behavior of A here */ };
Дальнейшее редактирование:
Википедия утверждает, что в Java существует разница , но я работаю с Java в течение 8 лет, и это первое, что я услышал такое различие ... не говоря уже о том, что нет ссылок на резервную заявку ... нижняя строка, внутренний класс - это класс, определенный внутри класса (статический или нет), а вложенный - это еще один термин, означающий одно и то же.
Существует тонкая разница между статическим и нестатическим вложенными классами ... в основном нестатические внутренние классы имеют неявный доступ к полям экземпляра и методам охватывающего класса (таким образом, они не могут быть построены в статическом контекст, это будет comp iler). Статические вложенные классы, с другой стороны, не имеют неявного доступа к полям и методам экземпляра, а CAN могут быть сконструированы в статическом контексте.
import OuterClass.StaticNestedClass;
, а затем ссылаться на класс just i> как OuterClass. – Camilo Díaz Repka 16 July 2011 в 01:22OuterClass.InnerClass innerObject = outerObject.new InnerClass();
? – Geek 28 March 2013 в 09:42