package com.company;

import org.omg.CORBA.portable.OutputStream;

import java.io.InputStream;
import java.util.*;
import java.util.function.UnaryOperator;

abstract class My {
    int i;
    My(int k) {
        i = k;
    };

    public void foo() {

    }

    public  abstract  void f();
}

// class MyAbstractClass {
//   int x;
//   int y;
//   virtual void move() = 0;
//
// }

interface IMy {
    void foo();
}

interface  Movable {
    void move();
    void Save();
}

interface  Serizalizable {
    void Save();
    void Load(InputStream in);
}

class CarData implements Movable, Serizalizable {

    @Override
    public void move() {

    }

    @Override
    public void Save() {
        System.out.println("Save!");
    }

    @Override
    public void Load(InputStream in) {

    }
}

class Impl extends  My {
    @Override
    public void f() {
        System.out.println(i);
    }

    Impl() {
        super(10);
    }
};

class MyClass implements Comparable<MyClass> {
    int i;
    MyClass(int j) { i = j; };
    @Override
    public int compareTo(MyClass o) {
        return i - o.i;
    }
}

// Object
class MyArrayList<T extends Comparable<T>> implements Iterable<T> { // type erasure
    Object[] objects = new Object[10];
    int size = 0;

    void add(T obj) {
        objects[size++] = obj;
    }

    T get(int index) {
        return  (T)objects[index];
    }

    static class Another {
    }

    class MyIterator implements  Iterator<T> {
        int cur = 0;
        @Override
        public boolean hasNext() {
            return cur < size;
        }

        @Override
        public T next() {
            return (T)objects[cur++];
        }
    }

    @Override
    public Iterator<T> iterator() {
        return new Iterator<T>() {
            int cur = 0;
            @Override
            public boolean hasNext() {
                return  cur < size;
            }

            @Override
            public T next() {
                return (T)objects[cur++];
            }
        };
    }
}
// class Interface {
// virtual void foo() = 0;
// virtual void do() = 0;
//}

// class A {
//
// virtual void foo() = 0;
// }

class Base {
    @Override
    public String toString() {
        return "Base";
    }

    void doSmth() {
        System.out.println("do");
    }
}

class Derieved extends  Base {
    @Override
    public String toString() {
        return "Derieved";
    }

    @Override
    void doSmth() {
        System.out.println("do1");
    }
}


public class Main {
    static void doSmth(Base b) {
        b.doSmth();
    }



    static <T extends Base> void foo (List<T> b) {
        for (Base bb : b) {
            System.out.println(bb);
            bb.doSmth();
        }
    }

    public static void main(String[] args) {
        System.out.println("hello");
        Main m = new Main();
        int i;
        double f;

//        Collections.

        // n*log(n) // <
        // n!
        // log(n!) (n / e) ^ n
        // nlogn

        char a;
        // ASCII
        // KOI8-R
        // UNICODE VVV

        // UTF-8 // variable
        // UTF-16 суррогатные пары
        // UTF-32 -- 4 байта
        // 010101011 11111000 10........ 10.......
        byte c;


        Impl ij = new Impl();
        ij.f();
        Serizalizable obj = new CarData();
        obj.Save();

        int[] ar = new int[10];
        // vector ->
        //ArrayList
        MyArrayList<Integer> lst
                = new MyArrayList<>(); // Diamond Syntax

        lst.add(10);
        lst.add(11);

        List<Integer> l = new ArrayList<>();
        l.add(10);
        l.add(11);
        for (Integer it : lst) {
            System.out.println(it);
        }

        Iterator<Integer> it1 =
                lst.new MyIterator();
        MyArrayList.Another ab =
                new MyArrayList.Another();

        // class Base
        // class Derieved
        // vector<Base>
        // vector<Derieved>
        // f(Base* b) { .... }
        // f(vector<Base*>& fst) {
        // }
        System.out.println("-----");
        List<Integer> first = new ArrayList<>();
        first.add(10);
        for (Integer it : first) {
            System.out.println(it);
        }
//        List<Integer> scd = new ArrayList<>();
//        Collections.copy(scd, first);

//        scd.add(15);
        for (Integer it : first) {
            System.out.println(it);
        }
        List<Base> d =
                new ArrayList<>();

        List<?> baseL = d;
        //baseL.get(0).doSmth();

        d.add(new Derieved());
        foo(d);
    }
}