java | - Part 2

Что такое статический блок и статическая инициализация в Java?

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

Статический блок выполняется только один раз, при загрузке класса загрузчиком.

Статический блок выполняется до вызова конструктора.

Также можно сказать что статические поля и методы принадлежат классу, нестатические — объекту.

Пример синтаксиса ниже: Читать далее Что такое статический блок и статическая инициализация в Java?

Отправка email из программы java по протоколу SMTP

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

Можно ли наследовать внутренние классы?

Да. Внутренние классы можно расширять. В плане наследования классов и реализации интерфейсов у них нет проблем.

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();
    }
}

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, но ведь никто не мешает заранее подготовиться и расширить нужный интерфейс, который будем реализовывать с помощью анонимного класса. Пример в коде ниже.

import java.awt.event.WindowListener;

public class TestExtendAnonym {
    private interface MyInterface extends Runnable, WindowListener {
    }

    Runnable r = new MyInterface() {
    ...
    //Пример того как реализовать 2 и более интерфейса в анонимном классе
    };
}

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, наследующийся от класса А и ещё раз описать в классе С класс В.

public class InnerOver {

    public InnerOver() {
        System.out.println("Конструктор в InnerOver");
        new InnClass();
    }

    protected class InnClass{
        public InnClass() {
            System.out.println("Внутренний класс в InnerOver");
        }
    }
}

public class InnerOver {

public InnerOver() {

System.out.println("Конструктор в InnerOver");

new InnClass();

}

protected class InnClass{

public InnClass() {

System.out.println("Внутренний класс в InnerOver");

}

    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("========================");
        }
}

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("========================");

}

Вывод:
Конструктор в InnerOver
Внутренний класс в InnerOver
Конструктор TestInnerClass
========================
Конструктор в InnerOver
Внутренний класс в InnerOver
Конструктор TestInnerClass
Внутренний переопределённый класс в TestInnerOver
========================
Конструктор в InnerOver
Внутренний класс в InnerOver
Внутренний класс в InnerOver
========================

Вывод:

Конструктор в InnerOver

Внутренний класс в InnerOver

Конструктор TestInnerClass

========================

Конструктор в InnerOver

Внутренний класс в InnerOver

Конструктор TestInnerClass

Внутренний переопределённый класс в TestInnerOver

========================

Конструктор в InnerOver

Внутренний класс в InnerOver

========================

Из примера видно что повторное описание внутреннего класса — это не более чем работа с пространством имён. Итог — внутренний класс, подобно методам, переопределить нельзя.

Какие ограничения есть у локальных классов?

Вначале вспомним что такое локальный класс. Это класс, описанный в блоке кода, то есть, по-простому — между кавычек {}. Наиболее часто эти кавычки являются телом метода. Но могут они быть и просто блоком, статическим блоком, телом if-ов, циклов и т.д.
Локальный класс наделён особенностями внутренних классов, но имеет отличительные черты, а именно:
1)он имеет доступ только к финальным полям и аргументам обрамляющего метода, а также ко всем полям обрамляющего класса, в том числе приватным и статическим;
2)локальный класс виден и может создаваться только в блоке, в котором описан;

3)у локального класса не ставиться модификатор доступа;
4)не может иметь статических полей, методов, классов (за исключением финальных);
5)локальный класс, объявленный в статическом блоке может обращаться только к статическим полям внешнего класса.

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

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

100

Но! Начиная с Java8 мы можем обращаться в локальных классах к не финальным локальным переменным, если они не были изменены до момента инициализации класса. Также теперь стало возможным обращение к не финальным параметрам метода.

    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");
            }
        }

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, если вы попытаетесь запустить в ней код ниже.

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(){ //ошибка
                //...
            }
        };
    }
}

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(){ //ошибка

//...

}

};

}

Можно ли создать объект внутреннего класса, если у внешнего класса только private конструктор?

Имея подобный код

public class PrivateConst {
    private PrivateConst() {}
    public class InnerClass{
        public void f(){
            System.out.println("hello");
        }
   }
}

public class PrivateConst {

private PrivateConst() {}

public class InnerClass{

public void f(){

System.out.println("hello");

}

Напрямую, в другом классе (вне обрамляющего), конечно, создать объект InnerClass следующим способом не получится:

PrivateConst.InnerClass priv = new PrivateConst().new InnerClass();

1	PrivateConst.InnerClass priv = new PrivateConst().new InnerClass();

Но! Что если у нас есть метод, возвращающий экземпляр PrivateConst:

public class PrivateConst {
private static PrivateConst instance;

private PrivateConst() {}

    public static PrivateConst getInstance(){
        instance = new PrivateConst();
        return instance;
    }

    public class InnerClass{}
}

public class PrivateConst {

private static PrivateConst instance;

private PrivateConst() {}

public static PrivateConst getInstance(){

instance = new PrivateConst();

return instance;

}

public class InnerClass{}

}

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

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

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();
    }
}

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();

}

Во что компилируются анонимные внутренние классы?

Анонимные внутренние классы компилируются в файлы внешнийКласс$n.class. На месте внешнего класса, соответственно, название обрамляющего класса, внутри которого описывается анонимный внутренний класс. На месте n число от 1 до количества анонимных классов. Всё станет понятно когда Вы скомпилируете код и проследите за компиляцией файлов в директории проекта.

public class TestAnonym {
    private static Runnable anon;
    private static Runnable anon2;
    private static Runnable anon3;
    public static void main(String[] args) {
         anon = new Runnable() {
            public void run() {
                while(true){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        anon2 = new Runnable() {
            public void run() {
                while(true){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        anon3 = new Runnable() {
            public void run() {
                while(true){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        System.out.println(anon.getClass().getName());
        TestAnonym.InnClass inn = new TestAnonym().new InnClass();
        System.out.println(inn.r.getClass().getName());
        InnStaticClass isc = new InnStaticClass();
        System.out.println(isc.r.getClass().getName());
    }

    class InnClass{
        public Runnable r = new Runnable() {
            public void run() {
                System.out.println("Hello from InnClass");
            }
        };
    }

    static class InnStaticClass{
        public Runnable r = new Runnable() {
            public void run() {
                System.out.println("Hello from InnStaticClass");
            }
        };
    }
}

Вывод:
TestAnonym$1
TestAnonym$InnClass$1
TestAnonym$InnStaticClass$1

public class TestAnonym {

private static Runnable anon;

private static Runnable anon2;

private static Runnable anon3;

public static void main(String[] args) {

anon = new Runnable() {

public void run() {

while(true){

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

};

anon2 = new Runnable() {

public void run() {

while(true){

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

};

anon3 = new Runnable() {

public void run() {

while(true){

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

};

System.out.println(anon.getClass().getName());

TestAnonym.InnClass inn = new TestAnonym().new InnClass();

System.out.println(inn.r.getClass().getName());

InnStaticClass isc = new InnStaticClass();

System.out.println(isc.r.getClass().getName());

}

class InnClass{

public Runnable r = new Runnable() {

public void run() {

System.out.println("Hello from InnClass");

}

};

}

static class InnStaticClass{

public Runnable r = new Runnable() {

public void run() {

System.out.println("Hello from InnStaticClass");

}

};

}

Вывод:

TestAnonym$1

TestAnonym$InnClass$1

TestAnonym$InnStaticClass$1

Чем отличаются анонимные классы созданные на основе интерфейса и на основе класса? Можно ли создать анонимный статический вложенный класс?

Каких то преимуществ в выборе способа создания анонимного класса при реализации интерфейса или же наследовании от другого класса мы не получаем. Отталкиваться следует от начальной задачи. Если при обычной реализации интерфейса нам доступно неограниченное количество, которое мы можем объявить в списке имплементируемых, то при создании анонимного класса данное преимущество утрачивается, так как нам становится доступен лишь один интерфейс. Конечно можно где-то в другом месте унаследовать нужный нам интерфейс от множества других и в итоге создать на его основе анонимный класс… но это же можно сделать и с наследованием классов. Так что отличия анонимного класса созданного на основе интерфейса от созданного на основе класса такие же как и у обычных классов… методы реализуются/перегружаются и т.п.
Анонимный класс является статическим(не статическим) в зависимости от того находится ли он в статическом (не статическом) блоке кода или нет.

Пн	Вт	Ср	Чт	Пт	Сб	Вс
« Апр
	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