При необходимости вызова одного конструктора из другого мы можем сделать это используя this() и передав те параметры, которые нужны вызываемому конструктору. Есть условия, которые необходимо соблюдать в таком случае, а именно:
Так бывает, что после переезда с локального сервера на хостинг блог функционирует нормально, но вместо страницы входа в админ-панель Вы получаете чистый лист в виде белого экрана. Это довольно неприятная картина для начинающего администратора, так как проблем может быть несколько, а никаких ошибок, подсказывающих в каком направлении двигаться для решения проблемы, нет.
Такое поведение чаще всего возникает когда имя сайта на локальном сервере и у хостинга различались. Всё усугубляется если Вы ещё и устанавливали плагины. Читать далее Вместо админки на wordpress белый экран
Статические блоки и статическая инициализация используются для инициализации статических полей в Java. Мы объявляем статический блок в тот момент, когда хотим проинициализировать статические поля в классе.
Статический блок выполняется только один раз, при загрузке класса загрузчиком.
Статический блок выполняется до вызова конструктора.
Также можно сказать что статические поля и методы принадлежат классу, нестатические — объекту.
Пример синтаксиса ниже: Читать далее Что такое статический блок и статическая инициализация в Java?
SMTP (Simple Mail Transfer Protocol) является протоколом передачи электронной почты по сетям tcp/ip. Он включает в себя набор несложных правил, с помощью которых происходит процесс общения почтовых клиента и сервера. Клиент подключается к почтовому серверу по 25 порту, далее происходит примерно такой диалог:
Server: (ожидает соединения)
Client: (Подключается к порту 25 сервера)
Server:220 mail.company.tld ESMTP CommuniGate Pro 5.1.4i is glad to see you! Читать далее Отправка email из программы java по протоколу SMTP
Да. Внутренние классы можно расширять. В плане наследования классов и реализации интерфейсов у них нет проблем.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
public class TestExtend { public class InnerClass extends Thread{ public synchronized void start() { super.start(); System.out.println("Hello from Inner Class extends Thread!"); } } public static void main(String[] args) { new TestExtend().new InnerClass().start(); } } |
Описывая анонимный класс мы уже наследуемся от какого-то класса или реализуем какой-либо интерфейс. К анонимным классам напрямую нельзя применить слова extends или implements, но ведь никто не мешает заранее подготовиться и расширить нужный интерфейс, который будем реализовывать с помощью анонимного класса. Пример в коде ниже.
|
1 2 3 4 5 6 7 8 9 10 11 |
import java.awt.event.WindowListener; public class TestExtendAnonym { private interface MyInterface extends Runnable, WindowListener { } Runnable r = new MyInterface() { ... //Пример того как реализовать 2 и более интерфейса в анонимном классе }; } |
В начале нужно четко понять что же мы хотим сделать. Логика следующая:[
1)Есть некий класс A;
2)Есть некий класс B, внутренний для класса A;
3)Мы хотим создать класс C, наследующийся от класса А и ещё раз описать в классе С класс В.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
public class InnerOver { public InnerOver() { System.out.println("Конструктор в InnerOver"); new InnClass(); } protected class InnClass{ public InnClass() { System.out.println("Внутренний класс в InnerOver"); } } } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
public class TestInnerOver extends InnerOver { public TestInnerOver() { System.out.println("Конструктор TestInnerClass"); } public class InnClass{ public InnClass() { System.out.println("Внутренний переопределённый класс в TestInnerOver"); } } public static void main(String[] args) { new TestInnerOver(); System.out.println("========================"); // Для создания "переопределённого" внутреннего класса пользуемся экземпляром потомка new TestInnerOver().new InnClass(); System.out.println("========================"); // Для создания внутреннего класса из родителя вызываем его через создание экземпляра супер-класса new InnerOver().new InnClass(); System.out.println("========================"); } } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Вывод: Конструктор в InnerOver Внутренний класс в InnerOver Конструктор TestInnerClass ======================== Конструктор в InnerOver Внутренний класс в InnerOver Конструктор TestInnerClass Внутренний переопределённый класс в TestInnerOver ======================== Конструктор в InnerOver Внутренний класс в InnerOver Внутренний класс в InnerOver ======================== |
Из примера видно что повторное описание внутреннего класса — это не более чем работа с пространством имён. Итог — внутренний класс, подобно методам, переопределить нельзя.
Вначале вспомним что такое локальный класс. Это класс, описанный в блоке кода, то есть, по-простому — между кавычек {}. Наиболее часто эти кавычки являются телом метода. Но могут они быть и просто блоком, статическим блоком, телом if-ов, циклов и т.д.
Локальный класс наделён особенностями внутренних классов, но имеет отличительные черты, а именно:
1)он имеет доступ только к финальным полям и аргументам обрамляющего метода, а также ко всем полям обрамляющего класса, в том числе приватным и статическим;
2)локальный класс виден и может создаваться только в блоке, в котором описан;
3)у локального класса не ставиться модификатор доступа;
4)не может иметь статических полей, методов, классов (за исключением финальных);
5)локальный класс, объявленный в статическом блоке может обращаться только к статическим полям внешнего класса.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
public class TestLocalClass { int x = 1; static int y = 2; final int z = 3; public void someMethod(int a, final double b){ int c = 0; final int d = 100; class LocalClass{ static final int stat = 10; // static int stat = 10; Ошибка компиляции public LocalClass() { // System.out.println(a); Ошибка компиляции System.out.println(b); // System.out.println(c); Ошибка компиляции System.out.println(x); System.out.println(y); System.out.println(z); System.out.println(d); } } new LocalClass(); } public static void main(String[] args) { new TestLocalClass().someMethod(10,20); } } Вывод: 20.0 1 2 3 100 |
Но! Начиная с Java8 мы можем обращаться в локальных классах к не финальным локальным переменным, если они не были изменены до момента инициализации класса. Также теперь стало возможным обращение к не финальным параметрам метода.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
public class TestLocalClassJava8 { private static void someMethod(String s1, String s2){ int finalInt = 100; //<-Локальная переменная class LocalClass{ public LocalClass() { System.out.println(finalInt); //<-Обращение в локальном классе к локальной переменной System.out.println(s1+s2); } } new LocalClass(); } public static void main(String[] args) { someMethod("Java", "Way"); } } |
Нет. У Анонимных внутренних классов, как и у внутренних классов не может быть статических полей, методов. Это вам подтвердит IDE, если вы попытаетесь запустить в ней код ниже.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
public class AnonymVsStatic { public static void main(String[] args) { Runnable runnable = new Runnable() { public static int k; //ошибка @Override public void run() { //... } public static void testStatic(){ //ошибка //... } }; } } |
Имея подобный код
|
1 2 3 4 5 6 7 8 |
public class PrivateConst { private PrivateConst() {} public class InnerClass{ public void f(){ System.out.println("hello"); } } } |
Напрямую, в другом классе (вне обрамляющего), конечно, создать объект InnerClass следующим способом не получится:
|
1 |
PrivateConst.InnerClass priv = new PrivateConst().new InnerClass(); |
Но! Что если у нас есть метод, возвращающий экземпляр PrivateConst:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
public class PrivateConst { private static PrivateConst instance; private PrivateConst() {} public static PrivateConst getInstance(){ instance = new PrivateConst(); return instance; } public class InnerClass{} } |
В этом случае приватный конструктор нам не помеха для создания объекта InnerClass. Так же мы без проблем сможем создавать его в методах и в других внутренних классах, принадлежащих PrivateConst. Ответ — можно, если каким-либо способом нам удастся получить объект обрамляющего класса.
Так же можно по хардкору пройтись рефлексией, выдернуть скрытый коструктор и уже с его помощью добыть объект класса. Попахивает изнасилованием, но работает.
|
1 2 3 4 5 6 7 8 9 10 11 |
public class TestClass { public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException { Class clazz = PrivateConst.class; Constructor[] constructors = clazz.getDeclaredConstructors(); Constructor<PrivateConst> cons = constructors[0]; cons.setAccessible(true); PrivateConst priv = (PrivateConst) constructors[0].newInstance(); PrivateConst.InnerClass inner = priv.new InnerClass(); inner.f(); } } |