Java 29.10.2023

Java/Java.md

@@ -406,6 +406,58 @@ public interface Swimmable {
 class Duck implements Swimmable {}
 ```
 
+Могут быть статические и приватные (доступные только внутри интерфейса) методы и константы
+
+```Java
+public interface Foo {
+    int VALUE = 5; // Подразумевается public static final т.е. публичная константная
+
+    static void foo() {
+        System.out.println("Foo");
+    }
+
+    private int bar(int a, int b) {
+        return a + b;
+    }
+}
+
+class Bar implements Foo {}
+```
+
+Интерфейсы могут расширять друг друга
+
+```Java
+interface Foo {
+    void foo();
+}
+
+interface Bar extends Foo {
+    default void bar() {
+        return;
+    }
+}
+
+class Baz implements Bar {
+    public void foo() {}
+}
+```
+
+Интерфейсы могут быть вложены в классы
+
+```Java
+class Printer {
+    interface Printable {
+        void print();
+    }
+}
+
+class Journal implements Printer.Printable {
+    public void print() {
+        System.out.println("Priniting journal");
+    }
+}
+```
+
 ### Классы обёртки
 
 *Обёртка* - класс, хранящий внутри значение примитива. Эти классы содержат полезные методы и являются не изменяемыми
@@ -657,3 +709,57 @@ public class Main {
     }
 }
 ```
+
+## Generic
+
+```Java
+class Account<T> { // Account<String> account = new Account<String>("FooBar");
+    private T id;
+    public int sum;
+
+    public Account(T id, int sum) {
+        this.id = id;
+        this.sum = sum;
+    }
+
+    public T getId() {
+        return id;
+    }
+}
+
+class Printer {
+    public static <T> void print(T[] items) { // Вызывать так: Printer.<String>print(new String[]{"a", "b"});
+        for(T item: items) {
+            System.out.println(item);
+        }
+    }
+}
+
+interface Acountable {
+    String getId();
+}
+
+class Account2 implements Acountable {
+    String id;
+
+    public <T>Account2(T id) { // Account account = new Account(5);
+        this.id = id.toString();
+    }
+
+    public String getId() {
+        return id;
+    }
+}
+
+class Transaction<T extends Account> { // T может быть только наследником Account
+    T account;
+}
+
+class Transaction2<T extends Acountable> { // T имплементирует Acountable
+    T account;
+}
+
+class Transaction3<T extends Account & Accountable> { // T имплементирует Accountable и наследует Account
+    T account;
+}
+```