C# 24.09.2023

C#/C#.md

@@ -108,3 +108,245 @@ int foo = Convert.ToInt32(Console.ReadLine());
 * \*
 * /
 * %
+
+## Преобразование базовых типов данных
+
+Операция сложения и вычитания возвращает int, если типы, на которые применяется операция, <= int (byte, short, int)
+
+### Неявное преобразование
+
+Работает только на расширение
+
+```C#
+byte a = 4;
+ushort = a;
+```
+
+### Явное преобразовывание
+
+Работает на расширение и на сужение
+
+```C#
+byte a = 5;
+byte b = 4;
+byte c = (byte) (a+b);
+```
+
+## Ветвление
+
+```C#
+int a = 5;
+
+if (a == 5) {
+    Console.WriteLine("It works");
+} else {
+    Console.WriteLine("Cosmic ray!");
+}
+```
+
+### Тернарный оператор
+
+Краткая возвращающая форма if
+
+```C#
+int x = 3;
+int y = 5;
+
+string z = x < y ? "Works" : "Cosmic ray";
+```
+
+### Switch
+
+```C#
+int number = 1;
+
+switch (number) {
+    case 1:
+        Console.WriteLine("case 1");
+        goto case 5;
+    case 3:
+        Console.WriteLine("case 3");
+        break;
+    case 5:
+        Console.WriteLine("case 5");
+        break;
+    default:
+        Console.WriteLine("case whatever");
+        break;
+}
+```
+
+### Циклы
+
+Всё как в С++
+
+* while
+* do-while
+* for
+* foreach
+
+## Массивы
+
+Массивы позволяют хранить заранее известное кол-во элементов вместе
+
+### Инициализация массивов
+
+```C#
+int[] a = new int[3] {10, 20, 30};
+double[] b = new double[5];
+float[] c = {1.5f, 2.3f}; // Поймёт, что нужна длина 2
+```
+
+### Длинна массивов
+
+```C#
+int[] a = {10, 20};
+int len = a.Length;
+```
+
+### Методы
+
+```C#
+int[] a = {10, 30, 20};
+
+Array.IndexOf(a, 10) // Вернёт 0. -1, если не найдёт.
+Array.Sort(a); // Сортирует по возрастанию. Станет {10, 20, 30}
+```
+
+### Двумерный массив
+
+```C#
+int[,] a = new int[10,10];
+```
+
+### Динамический массив
+
+```C#
+using System.Collections.Generic;
+
+List<string> words = new List<string> ();
+words.Add("Foo");
+words.Add("Bar");
+words.RemoveAt(1);
+```
+
+## Random
+
+```C#
+Random r = new Random();
+int a = r.Next(); // От 0 до 2 миллиардов
+int b = r.Next(5); // От 0 до 5 (не включительно)
+int c = r.Next(3, 5); // От 3 до 5
+```
+
+## Функции
+
+```C#
+void Foo() {
+    Console.WriteLine("Hello");
+}
+
+// Краткая форма
+void Bar() => Console.WriteLine("Hi");
+```
+
+### Параметры функции
+
+```C#
+int Sum(int x, int y) => x + y; // Тут x и y - параметры
+
+Sum(5, 6); // Тут 5 и 6 - аргументы
+```
+
+#### Необязательные параметры
+
+```C#
+void PrintPerson(string name, int age = 1) {
+    Console.WriteLine($"{name} - {age}");
+}
+
+PrintPerson("John", 5);
+PrintPerson(age: 5, name: "Bob"); // Именованные параметры
+```
+
+#### Передача по ссылке
+
+При передаче по ссылке и  зменения внутри функции меняют оригинальное значение
+
+```C#
+void Inc(ref int a) {
+    a++;
+}
+
+void BadInc(int a) {
+    a++;
+}
+
+int b = 5;
+Inc(ref b); // b == 6
+BadInc(b); // b осталась 6
+
+Inc(b); // Так низя
+Inc(5); // И так низя
+Inc(ref 5); // И так тоже низя
+```
+
+#### Выходной параметр
+
+Функция может иметь несколько выходных параметров, а так лучше return
+
+```C#
+void Sum(int a, int b, out int result) {
+    result = a + b;
+}
+
+int result;
+
+Sum(5, 6, out result);
+```
+
+#### Входные параментры
+
+Передача по неизменяемой ссылке. Судя по всему полезно только для массивов
+
+```C#
+int Sum(in int a, in int b) {
+    return a + b;
+}
+
+int a = 5;
+int b = 6;
+Sum(a, b);
+```
+
+#### params
+
+*params* позволяет передать не определённое кол-во параметров. После него не может быть больше параметров
+
+```C#
+int Sum(params int[] nums) {
+    int sum = 0;
+
+    foreach (int i in nums) {
+        sum += i;
+    }
+
+    return sum;
+}
+
+int[] nums = {1, 2, 3, 4};
+Sum(nums);
+Sum(1, 2, 3);
+Sum(20);
+Sum();
+```
+
+### Возвращение значений
+
+```C#
+int Sum1(int a, int b) {
+    return a + b;
+}
+
+int Sum2(int a, int b) => a + b;
+```

Java/Java.md

@@ -0,0 +1,76 @@
+# Java
+
+## Функция main
+
+```Java
+package org.example;
+
+public class Main {
+    public static void main(String[] args) {
+        System.out.println("Hello world!");
+    }
+}
+```
+
+## Сокращения InteliJ
+
+* psvm - public static void main
+* sout - Sytem.out.println()
+* serr - System.err.println()
+* I - for(Object object: ){}
+* fori - for (int i = 0; i< ; i++) {}
+* shift + shift - поиск по проекту
+* ctrl + alt + t - сниппеты для блоков кода (циклы, if, switch, try-catch)
+* alt + insert - сниппеты для класса
+
+## Строки
+
+Строки неизменяемые (immutable) и не могут иметь наследников (final). Для изменения копии
+
+```Java
+// foo и bar - 1 объект в Pool (аля static)
+String foo = "foo";
+String bar = "foo";
+// baz - объект в куче
+String baz = new String("baz");
+```
+
+### StringBuffer и StringBuilder
+
+Данные типы - изменяемые строки с изменениями на месте. StringBuffer синхронизирует методы, поэтому медленее, но можно работать в многопотоке. StringBuilder быстрее, но методы не синхронизирует
+
+```Java
+// Можно передать строку в инициализатор, но не обязательно
+StringBuffer sb = new StringBuffer(); 
+
+sb.append("foo");
+sb.append(5);
+```
+
+#### Методы StringBuffer и StringBuilder
+
+* append (смотреть выше)
+* delete(int start, int end)
+* insert(int offeset, String str)
+* replace(int start, int end, String str)
+* reverse()
+* substring(int start, int end) - создаст новую строку
+* toString - перевести в строку
+
+### RegEx
+
+RegEx - щаблон для поиска строки в тексте
+
+#### Примеры RegEx
+
+* "java" - только слово java подойдёт
+* "\\d{3}" - 3 цифры
+
+#### Pattern для RegEx
+
+Pattern - скомпилированный RegEx
+
+```Java
+Pattern p = Pattern.compile("java");
+p = Pattern.compile("java", Pattern.CASE_INSENSETIVE);
+```