C# 08.10.2020

C#/C#.md

@@ -424,6 +424,12 @@ namespace Foo {
         public int armor;
         public int damage;
 
+        public Enemy(int hp, int armor, int damage) {
+            this.hp = hp;
+            this.armor = armor;
+            this.damage = damage;
+        }
+
         public void Move() {
             Console.WriteLine("I am moving");
         }
@@ -434,3 +440,90 @@ namespace Foo {
     }
 }
 ```
+
+Конструкторов может быть несколько
+
+### Инициализаторы
+
+```C#
+Person tom = new Person {name = "Tom", company = { title = "Microsoft" }};
+
+class Person {
+    public string name = "Undefined";
+    public Company company;
+
+    public Person() {
+        company = new Company();
+    }
+}
+
+class Company {
+    public string title = "Unknown";
+}
+```
+
+### Деконструкторы
+
+Деконструкторы - методы, чтобы "разобрать" объект на составные части
+
+```C#
+class Person {
+    public string name;
+    public string age;
+
+    public void Deconstruct(out string personName, out int PersonAge) {
+        personName = name;
+        personAge = age;
+    }
+}
+```
+
+### Структуры
+
+Структуру - аналог классов с особенностями:
+
+* Храняться на стеке
+* Нет наследования: нельзя использовать *abstract*, *virtual*, *protected*
+* При присваивании создаются копия
+* Имеется ключевое слово with
+
+```C#
+Person tom;
+tom.name = "Tom";
+tom.age = 1;
+Person bob = tom with { name = "Bob" };
+Person Alice = new Person { name = "Alice", age = 5 };
+Person Jan = new Person("Jan", 10);
+
+struct Person
+{
+    public string name;
+    public int age;
+
+    public Person(string name, int age)
+    {
+        this.name = name;
+        this.age = age; 
+    }
+}
+```
+
+### Типы значений и ссылочные типы
+
+Типы значений (значимые типы) хранятся на стеке. К таким типам относятся:
+
+* Целочисленные значения
+* Числа с плавающей точкой
+* *decimal*
+* *bool*
+* *char*
+* Перечисления
+* Структуры
+
+Ссылочные типы в куче, а ссылка на них в стеке. К ним относятся:
+
+* *string*
+* *object*
+* Классы
+* Интерфейсы
+* Делегаты

Java/Java.md

@@ -167,16 +167,167 @@ try {
 }
 ```
 
-### Throw
+### *throw*
 
 ```Java
 throw new Exception("Very important exception! Don't you dare not handle it");
 ```
 
-### Throws
+### *throws*
 
 Позволяет кинуть ошибку вверх по стаку
 
 ```Java
 public static void main(String[] args) throws Exception {}
 ```
+
+## OOP
+
+OOP - бяка, Java - OOP => Java - бяка
+
+```Java
+public class Foo {
+    int bar;
+    string baz;
+
+    void fooBar() {
+        System.out.println("FooBaz");
+    }
+}
+```
+
+### Модификаторы доступа
+
+* public - везде
+* private - только внутри класса
+* protected - подклассы и сам класс
+
+Если не указан, то применяется модификатор по умолчанию. Он делает переменную public в пределах данного пакета
+
+### Конструктор и инициализатор
+
+```Java
+public class Test {
+    int age;
+    int age2;
+    int age3;
+
+    // Блок - инициализатор
+    {
+        age = 5
+    }
+
+    // Конструктор
+    public Test(int age2, int age3_input) {
+        this.age2 = age2;
+        age3 = age3_input; // Такое не делать, ибо не красиво
+    }
+}
+```
+
+### Наследование
+
+```Java
+public class Foo {}
+
+public class Bar extends Foo {}
+```
+
+Множественное наследование низя. Приватное не наследуется
+
+#### *Override*
+
+```Java
+class Foo  {
+    int foo() {
+        return 5;
+    }
+}
+
+class Bar extends Foo {
+    @Override
+    int foo() {
+        return 6;
+    }
+}
+```
+
+Уровень видимости при *Override* не может понижаться. У переопределённого метода должен быть такой же интерфейс, как и у родителя
+
+#### *super*
+
+*super* позволяет обратиться к методам родительского класса
+
+```Java
+class Foo  {
+    int foo() {
+        return 5;
+    }
+}
+
+class Bar extends Foo {
+    @Override
+    int foo() {
+        return super.foo();
+    }
+}
+```
+
+#### *final* при наследовании
+
+*final* запрещает наследование
+
+#### Наследование конструктора
+
+```Java
+class Foo {
+    int a, b;
+
+    Foo(int a, int b) {
+        this.a = a;
+        this.b = b;
+    }
+}
+
+class Bar extends Foo {
+    int c;
+
+    Bar(int a, int b, int c) {
+        // Тут super должен быть сверху, иначе ошибка
+        super(a, b);
+        this.c = c;
+    }
+}
+```
+
+#### *instanceof*
+
+Позволяет проверить, создан ли объект на основе какого-то класса
+
+```Java
+class Foo {
+    int a, b;
+
+    Foo(int a, int b) {
+        this.a = a;
+        this.b = b;
+    }
+}
+
+class Bar extends Foo {
+    int c;
+
+    Bar(int a, int b, int c) {
+        // Тут super должен быть сверху, иначе ошибка
+        super(a, b);
+        this.c = c;
+    }
+}
+
+class Main {
+    public static void main() {
+        Bar bar = new Bar();
+        System.out.println(bar instanceof Foo);
+    }
+}
+```