├── .gitignore ├── assets ├── 12-lecture │ ├── array.png │ ├── hashmap.jpg │ ├── hash_set.png │ ├── stack_push_pop_animation.gif │ ├── binary_search_tree_animation.gif │ ├── linked_list_insertion_animation.gif │ ├── queue_enqueue_dequeue_animation.gif │ └── java_collections_and_map_hierarchy.png ├── 01-lecture │ ├── java-logo.jpg │ ├── memory-cpu.png │ ├── jdk-jre-jvm.png │ ├── memory-brain.jpg │ ├── src-javac-bytecode-jvm-os.png │ └── variable-type-name-value-box.jpg ├── 02-lecture │ ├── for-loop.png │ ├── if-else-statement.png │ ├── control-flow-graph.png │ └── switch-case-statement.jpg ├── 13-lecture │ ├── call_stack.jpg │ ├── stack_trace.png │ ├── handled_exception.jpg │ ├── unhandled_exception.jpg │ ├── spiderman_try_catch_meme.jpg │ ├── search_for_exception_handler.jpg │ └── checked_vs_unchecked_exceptions.jpg ├── 15-lecture │ ├── generic_cup.jpg │ └── boxing_unboxing.png ├── 03-lecture │ └── variable_scope.jpg ├── 08-lecture │ ├── encapsulation.png │ ├── spaggeti-code.png │ ├── package-structure.png │ ├── static-class-example.png │ ├── software-architecture.png │ └── non-static-class-example.png ├── 07-lecture │ └── bank_uml_diagram.png ├── 09-lecture │ ├── 4-pillars-of-oop.png │ ├── inheritance-illustration.png │ └── intellij_idea_logo.svg ├── 14-lecture │ ├── stream_hierarchy.jpg │ ├── input_vs_output_stream.png │ ├── buffered_writer_stream.jpeg │ └── data_input_vs_data_output_stream.png ├── 10-lecture │ ├── garbage_collection.jpg │ ├── stack_representation.jpg │ ├── recursive_fibonacci_call_stack.png │ ├── stack_vs_heap_representation.png │ └── alocated_stack_and_heap_presentation.gif ├── 11-lecture │ ├── bird_morph_into_plain.jpg │ ├── interface_contract_watch.jpg │ ├── abstract_class_vs_interface.png │ └── mechanical_watch_interfaces.jpg ├── idea_cheat_sheet │ ├── idea_small_logo.png │ └── idea_multiple_selections.gif ├── 06-lecture │ └── class-object-featured-image.png └── further_reading │ ├── clean_code_book_cover.jpg │ ├── effective_java_book_cover.jpg │ ├── head_first_java_book_cover.jpg │ └── programming_interviews_exposed_book_cover.jpg ├── src ├── lecture11 │ └── exercies │ │ ├── zoo │ │ ├── Animal.java │ │ ├── Cat.java │ │ ├── Dog.java │ │ ├── Bird.java │ │ ├── PersianCat.java │ │ ├── ZooDemo.java │ │ └── Zoo.java │ │ ├── interfaces │ │ ├── Watch.java │ │ └── DigitalWatch.java │ │ └── polymorphism │ │ ├── Flyer.java │ │ ├── Bird.java │ │ ├── Airplane.java │ │ └── Main.java ├── misc │ └── Main.java ├── lecture6 │ ├── exercise │ │ ├── Person.java │ │ ├── Main.java │ │ └── Car.java │ └── homework │ │ └── task2 │ │ ├── Computer.java │ │ └── ComputerDemo.java ├── lecture9 │ └── exercises │ │ ├── methodoverride │ │ ├── Animal.java │ │ └── Dog.java │ │ ├── heiarchy │ │ ├── Animal.java │ │ ├── Cat.java │ │ └── Dog.java │ │ └── hospital │ │ └── HospitalDemo.java ├── lecture5 │ └── Lecture5.java ├── lecture14 │ └── exercises │ │ ├── task1 │ │ └── Task1.java │ │ └── task4 │ │ └── WriteDemo.java ├── lecture7 │ ├── exercises │ │ ├── task1 │ │ │ └── Chameleon.java │ │ ├── task2 │ │ │ └── Person.java │ │ ├── task3 │ │ │ └── Task3.java │ │ ├── task4 │ │ │ └── Task4.java │ │ └── task5 │ │ │ └── Task5.java │ └── homework │ │ └── bank │ │ ├── BankDemo.java │ │ ├── Customer.java │ │ ├── Account.java │ │ └── Bank.java ├── lecture8 │ ├── CarDemo.java │ └── Car.java ├── lecture13 │ └── exercises │ │ ├── Task1.java │ │ └── Task2.java ├── lecture12 │ └── exercises │ │ ├── chickenbarn │ │ ├── Main.java │ │ ├── Egg.java │ │ ├── Chicken.java │ │ └── Barn.java │ │ ├── task1 │ │ └── Task1.java │ │ ├── task2 │ │ └── Task2.java │ │ ├── task3 │ │ └── Task3.java │ │ └── rpn │ │ └── RPNDemo.java ├── lecture10 │ ├── singleton │ │ └── Universe.java │ └── homework │ │ ├── shop │ │ ├── TwoForOnePrice.java │ │ ├── PurchaseReceipt.java │ │ ├── Price.java │ │ ├── Shop.java │ │ └── ProductStorage.java │ │ └── ShopDemo.java ├── lecture4 │ └── Lecture4.java ├── lecture1 │ └── Lecture1.java └── lecture3 │ └── Lecture3.java ├── README.md ├── IDEACheatSheet.md ├── lectures └── bg │ ├── 09-inheritance │ ├── Lecture9Homework.md │ ├── Lecture9HomeworkSolutions.md │ └── Lecture9.md │ ├── Contents.md │ ├── 06-oop-introduction │ ├── Lecture6Homework.md │ └── Lecture6.md │ ├── 02-control-flow │ └── Lecture2Homework.md │ ├── 01-introduction │ ├── Lecture1Homework.md │ ├── Lecture1HomeworkSolutions.md │ └── Lecture1.md │ ├── 05-2d-arrays │ ├── Lecture5Homework.md │ └── Lecture5.md │ ├── 04-arrays │ ├── Lecture4.md │ └── Lecture4Homework.md │ └── 14-files-io │ └── Lecture14.md ├── TODO.md └── FurtherReading.md /.gitignore: -------------------------------------------------------------------------------- 1 | out/ 2 | .idea/ 3 | *.iml 4 | .DS_Store 5 | -------------------------------------------------------------------------------- /assets/12-lecture/array.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/12-lecture/array.png -------------------------------------------------------------------------------- /assets/12-lecture/hashmap.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/12-lecture/hashmap.jpg -------------------------------------------------------------------------------- /assets/01-lecture/java-logo.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/01-lecture/java-logo.jpg -------------------------------------------------------------------------------- /assets/01-lecture/memory-cpu.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/01-lecture/memory-cpu.png -------------------------------------------------------------------------------- /assets/02-lecture/for-loop.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/02-lecture/for-loop.png -------------------------------------------------------------------------------- /assets/12-lecture/hash_set.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/12-lecture/hash_set.png -------------------------------------------------------------------------------- /assets/13-lecture/call_stack.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/13-lecture/call_stack.jpg -------------------------------------------------------------------------------- /assets/01-lecture/jdk-jre-jvm.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/01-lecture/jdk-jre-jvm.png -------------------------------------------------------------------------------- /assets/01-lecture/memory-brain.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/01-lecture/memory-brain.jpg -------------------------------------------------------------------------------- /assets/13-lecture/stack_trace.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/13-lecture/stack_trace.png -------------------------------------------------------------------------------- /assets/15-lecture/generic_cup.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/15-lecture/generic_cup.jpg -------------------------------------------------------------------------------- /assets/03-lecture/variable_scope.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/03-lecture/variable_scope.jpg -------------------------------------------------------------------------------- /assets/08-lecture/encapsulation.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/08-lecture/encapsulation.png -------------------------------------------------------------------------------- /assets/08-lecture/spaggeti-code.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/08-lecture/spaggeti-code.png -------------------------------------------------------------------------------- /assets/15-lecture/boxing_unboxing.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/15-lecture/boxing_unboxing.png -------------------------------------------------------------------------------- /assets/02-lecture/if-else-statement.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/02-lecture/if-else-statement.png -------------------------------------------------------------------------------- /assets/07-lecture/bank_uml_diagram.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/07-lecture/bank_uml_diagram.png -------------------------------------------------------------------------------- /assets/08-lecture/package-structure.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/08-lecture/package-structure.png -------------------------------------------------------------------------------- /assets/09-lecture/4-pillars-of-oop.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/09-lecture/4-pillars-of-oop.png -------------------------------------------------------------------------------- /assets/13-lecture/handled_exception.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/13-lecture/handled_exception.jpg -------------------------------------------------------------------------------- /assets/14-lecture/stream_hierarchy.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/14-lecture/stream_hierarchy.jpg -------------------------------------------------------------------------------- /src/lecture11/exercies/zoo/Animal.java: -------------------------------------------------------------------------------- 1 | package lecture11.exercies.zoo; 2 | 3 | public interface Animal { 4 | 5 | void eat(); 6 | } 7 | -------------------------------------------------------------------------------- /src/misc/Main.java: -------------------------------------------------------------------------------- 1 | package misc; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /assets/02-lecture/control-flow-graph.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/02-lecture/control-flow-graph.png -------------------------------------------------------------------------------- /assets/08-lecture/static-class-example.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/08-lecture/static-class-example.png -------------------------------------------------------------------------------- /assets/10-lecture/garbage_collection.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/10-lecture/garbage_collection.jpg -------------------------------------------------------------------------------- /assets/10-lecture/stack_representation.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/10-lecture/stack_representation.jpg -------------------------------------------------------------------------------- /assets/13-lecture/unhandled_exception.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/13-lecture/unhandled_exception.jpg -------------------------------------------------------------------------------- /assets/02-lecture/switch-case-statement.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/02-lecture/switch-case-statement.jpg -------------------------------------------------------------------------------- /assets/08-lecture/software-architecture.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/08-lecture/software-architecture.png -------------------------------------------------------------------------------- /assets/11-lecture/bird_morph_into_plain.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/11-lecture/bird_morph_into_plain.jpg -------------------------------------------------------------------------------- /assets/14-lecture/input_vs_output_stream.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/14-lecture/input_vs_output_stream.png -------------------------------------------------------------------------------- /assets/idea_cheat_sheet/idea_small_logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/idea_cheat_sheet/idea_small_logo.png -------------------------------------------------------------------------------- /assets/01-lecture/src-javac-bytecode-jvm-os.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/01-lecture/src-javac-bytecode-jvm-os.png -------------------------------------------------------------------------------- /assets/08-lecture/non-static-class-example.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/08-lecture/non-static-class-example.png -------------------------------------------------------------------------------- /assets/09-lecture/inheritance-illustration.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/09-lecture/inheritance-illustration.png -------------------------------------------------------------------------------- /assets/11-lecture/interface_contract_watch.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/11-lecture/interface_contract_watch.jpg -------------------------------------------------------------------------------- /assets/12-lecture/stack_push_pop_animation.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/12-lecture/stack_push_pop_animation.gif -------------------------------------------------------------------------------- /assets/13-lecture/spiderman_try_catch_meme.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/13-lecture/spiderman_try_catch_meme.jpg -------------------------------------------------------------------------------- /assets/14-lecture/buffered_writer_stream.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/14-lecture/buffered_writer_stream.jpeg -------------------------------------------------------------------------------- /assets/06-lecture/class-object-featured-image.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/06-lecture/class-object-featured-image.png -------------------------------------------------------------------------------- /assets/11-lecture/abstract_class_vs_interface.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/11-lecture/abstract_class_vs_interface.png -------------------------------------------------------------------------------- /assets/11-lecture/mechanical_watch_interfaces.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/11-lecture/mechanical_watch_interfaces.jpg -------------------------------------------------------------------------------- /assets/further_reading/clean_code_book_cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/further_reading/clean_code_book_cover.jpg -------------------------------------------------------------------------------- /assets/01-lecture/variable-type-name-value-box.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/01-lecture/variable-type-name-value-box.jpg -------------------------------------------------------------------------------- /assets/10-lecture/recursive_fibonacci_call_stack.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/10-lecture/recursive_fibonacci_call_stack.png -------------------------------------------------------------------------------- /assets/10-lecture/stack_vs_heap_representation.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/10-lecture/stack_vs_heap_representation.png -------------------------------------------------------------------------------- /assets/12-lecture/binary_search_tree_animation.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/12-lecture/binary_search_tree_animation.gif -------------------------------------------------------------------------------- /assets/13-lecture/search_for_exception_handler.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/13-lecture/search_for_exception_handler.jpg -------------------------------------------------------------------------------- /assets/further_reading/effective_java_book_cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/further_reading/effective_java_book_cover.jpg -------------------------------------------------------------------------------- /assets/idea_cheat_sheet/idea_multiple_selections.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/idea_cheat_sheet/idea_multiple_selections.gif -------------------------------------------------------------------------------- /src/lecture11/exercies/interfaces/Watch.java: -------------------------------------------------------------------------------- 1 | package lecture11.exercies.interfaces; 2 | 3 | public interface Watch { 4 | 5 | long getCurrentTime(); 6 | 7 | } 8 | -------------------------------------------------------------------------------- /assets/12-lecture/linked_list_insertion_animation.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/12-lecture/linked_list_insertion_animation.gif -------------------------------------------------------------------------------- /assets/12-lecture/queue_enqueue_dequeue_animation.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/12-lecture/queue_enqueue_dequeue_animation.gif -------------------------------------------------------------------------------- /assets/13-lecture/checked_vs_unchecked_exceptions.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/13-lecture/checked_vs_unchecked_exceptions.jpg -------------------------------------------------------------------------------- /assets/14-lecture/data_input_vs_data_output_stream.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/14-lecture/data_input_vs_data_output_stream.png -------------------------------------------------------------------------------- /assets/further_reading/head_first_java_book_cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/further_reading/head_first_java_book_cover.jpg -------------------------------------------------------------------------------- /assets/12-lecture/java_collections_and_map_hierarchy.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/12-lecture/java_collections_and_map_hierarchy.png -------------------------------------------------------------------------------- /assets/10-lecture/alocated_stack_and_heap_presentation.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/10-lecture/alocated_stack_and_heap_presentation.gif -------------------------------------------------------------------------------- /src/lecture6/exercise/Person.java: -------------------------------------------------------------------------------- 1 | package lecture6.exercise; 2 | 3 | public class Person { 4 | 5 | String name; 6 | int age; 7 | 8 | Person friend; 9 | } 10 | -------------------------------------------------------------------------------- /src/lecture11/exercies/polymorphism/Flyer.java: -------------------------------------------------------------------------------- 1 | package lecture11.exercies.polymorphism; 2 | 3 | public interface Flyer { 4 | 5 | int foo = 10; 6 | 7 | void fly(); 8 | } 9 | -------------------------------------------------------------------------------- /assets/further_reading/programming_interviews_exposed_book_cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/NewestUser/Java-Introduction/HEAD/assets/further_reading/programming_interviews_exposed_book_cover.jpg -------------------------------------------------------------------------------- /src/lecture9/exercises/methodoverride/Animal.java: -------------------------------------------------------------------------------- 1 | package lecture9.exercises.methodoverride; 2 | 3 | class Animal { 4 | 5 | void speak() { 6 | System.out.println("Speaking..."); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/lecture11/exercies/zoo/Cat.java: -------------------------------------------------------------------------------- 1 | package lecture11.exercies.zoo; 2 | 3 | public class Cat implements Animal { 4 | 5 | @Override 6 | public void eat() { 7 | System.out.println("Cat is eating..."); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /src/lecture11/exercies/zoo/Dog.java: -------------------------------------------------------------------------------- 1 | package lecture11.exercies.zoo; 2 | 3 | public class Dog implements Animal { 4 | 5 | @Override 6 | public void eat() { 7 | System.out.println("Dog is eating..."); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /src/lecture11/exercies/zoo/Bird.java: -------------------------------------------------------------------------------- 1 | package lecture11.exercies.zoo; 2 | 3 | public class Bird implements Animal { 4 | 5 | @Override 6 | public void eat() { 7 | System.out.println("Bird is eating..."); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /src/lecture9/exercises/heiarchy/Animal.java: -------------------------------------------------------------------------------- 1 | package lecture9.exercises.heiarchy; 2 | 3 | public class Animal { 4 | 5 | public int age; 6 | 7 | public void eat() { 8 | System.out.println("Eating..."); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /src/lecture9/exercises/methodoverride/Dog.java: -------------------------------------------------------------------------------- 1 | package lecture9.exercises.methodoverride; 2 | 3 | class Dog extends Animal { 4 | 5 | @Override 6 | void speak() { 7 | System.out.println("Woff woff..."); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /src/lecture11/exercies/polymorphism/Bird.java: -------------------------------------------------------------------------------- 1 | package lecture11.exercies.polymorphism; 2 | 3 | public class Bird implements Flyer { 4 | 5 | @Override 6 | public void fly() { 7 | System.out.println("Flap wings"); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /src/lecture11/exercies/polymorphism/Airplane.java: -------------------------------------------------------------------------------- 1 | package lecture11.exercies.polymorphism; 2 | 3 | public class Airplane implements Flyer { 4 | 5 | @Override 6 | public void fly() { 7 | System.out.println("Starting engines"); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /src/lecture11/exercies/interfaces/DigitalWatch.java: -------------------------------------------------------------------------------- 1 | package lecture11.exercies.interfaces; 2 | 3 | public class DigitalWatch implements Watch { 4 | 5 | @Override 6 | public long getCurrentTime() { 7 | return System.currentTimeMillis(); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /src/lecture11/exercies/zoo/PersianCat.java: -------------------------------------------------------------------------------- 1 | package lecture11.exercies.zoo; 2 | 3 | public class PersianCat extends Cat { 4 | 5 | void play() { 6 | System.out.println("Persian cat is having fun..."); 7 | } 8 | 9 | @Override 10 | public void eat() { 11 | System.out.println("Persian cat is eating..."); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/lecture5/Lecture5.java: -------------------------------------------------------------------------------- 1 | package lecture5; 2 | 3 | 4 | public class Lecture5 { 5 | 6 | public static void main(String[] args) { 7 | task1CreateAndPrintMatrix(); 8 | } 9 | 10 | private static void task1CreateAndPrintMatrix() { 11 | int[][] matrix = new int[2][3]; 12 | 13 | matrix[0][1] = 555; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/lecture14/exercises/task1/Task1.java: -------------------------------------------------------------------------------- 1 | package lecture14.exercises.task1; 2 | 3 | import java.io.File; 4 | 5 | public class Task1 { 6 | 7 | public static void main(String[] args) { 8 | File file = new File("iotest"); 9 | 10 | if (!file.exists()) { 11 | file.mkdir(); 12 | } 13 | 14 | for (String name : file.list()) { 15 | System.out.println(name); 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/lecture9/exercises/heiarchy/Cat.java: -------------------------------------------------------------------------------- 1 | package lecture9.exercises.heiarchy; 2 | 3 | public class Cat extends Animal { 4 | 5 | public int numberOfLives; 6 | 7 | public void purr() { 8 | System.out.println("PurRrRr..."); 9 | } 10 | 11 | public void printDetailsAndEat() { 12 | // age е дефинирано в супер класът 13 | System.out.println("Num of Lives: " + numberOfLives + " " + "Age: " + age); 14 | 15 | // този метод е дефиниран в супер класът 16 | eat(); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/lecture11/exercies/zoo/ZooDemo.java: -------------------------------------------------------------------------------- 1 | package lecture11.exercies.zoo; 2 | 3 | public class ZooDemo { 4 | 5 | public static void main(String[] args) { 6 | 7 | Animal bird = new Bird(); 8 | Animal cat = new Cat(); 9 | Animal dog = new Dog(); 10 | Animal persianCat = new PersianCat(); 11 | 12 | Zoo zoo = new Zoo(); 13 | 14 | zoo.add(bird); 15 | zoo.add(cat); 16 | zoo.add(dog); 17 | zoo.add(persianCat); 18 | 19 | zoo.feedAnimals(); 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /src/lecture7/exercises/task1/Chameleon.java: -------------------------------------------------------------------------------- 1 | package lecture7.exercises.task1; 2 | 3 | public class Chameleon { 4 | String color; 5 | double weight; 6 | 7 | /** 8 | * Change the color of the chameleon. If the desired color is gray then the color won't be changed. 9 | * 10 | * @param color the new color of the chameleon. 11 | */ 12 | void changeColor(String color) { 13 | if ("gray".equals(color)) { 14 | return; 15 | } 16 | 17 | this.color = color; 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /src/lecture8/CarDemo.java: -------------------------------------------------------------------------------- 1 | package lecture8; 2 | 3 | public class CarDemo { 4 | 5 | public static void main(String[] args) { 6 | 7 | // използваме конструктора със задължителните полета 8 | Car bmw = new Car("BMW", 2010, true); 9 | 10 | bmw.printCarDetails(); 11 | 12 | // използваме конструктора с всички полета 13 | Car ford = new Car("Ford", 2000, false, 220, "Green"); 14 | ford.printCarDetails(); 15 | 16 | bmw.changeColor("Red"); // сменяме цвета на bmw 17 | 18 | bmw.printCarDetails(); 19 | ford.printCarDetails(); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/lecture6/homework/task2/Computer.java: -------------------------------------------------------------------------------- 1 | package lecture6.homework.task2; 2 | 3 | public class Computer { 4 | 5 | int year; 6 | int price; 7 | boolean isNotebook; 8 | long hardDiskMemory; 9 | long freeMemory; 10 | String operatingSystem; 11 | 12 | void changeOperatingSystem(String newOperatingSystem) { 13 | operatingSystem = newOperatingSystem; 14 | } 15 | 16 | void useMemory(long memory) { 17 | if (freeMemory < memory) { 18 | System.out.println("Not enough memory!"); 19 | } else { 20 | freeMemory -= memory; 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/lecture9/exercises/heiarchy/Dog.java: -------------------------------------------------------------------------------- 1 | package lecture9.exercises.heiarchy; 2 | 3 | public class Dog extends Animal { 4 | 5 | public String breed; 6 | 7 | Dog(String breed, int age) { 8 | this.breed = breed; 9 | this.age = age; 10 | } 11 | 12 | 13 | public void bark() { 14 | System.out.println("Woff woff..."); 15 | } 16 | 17 | public void printDetailsAndEat() { 18 | // age е дефинирано в супер класът 19 | System.out.println("Breed: " + breed + " " + "Age: " + age); 20 | 21 | // този метод е дефиниран в супер класът 22 | eat(); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/lecture13/exercises/Task1.java: -------------------------------------------------------------------------------- 1 | package lecture13.exercises; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Task1 { 6 | 7 | public static void main(String[] args) { 8 | 9 | Scanner scanner = new Scanner(System.in); 10 | 11 | try { 12 | String text = scanner.nextLine(); 13 | 14 | System.out.print("Въведете число: "); 15 | double number = Double.parseDouble(text); 16 | 17 | System.out.println("Вие въведохте " + number); 18 | } catch (NumberFormatException e) { 19 | System.out.println("Въведеното от вас число е невалидно"); 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/lecture12/exercises/chickenbarn/Main.java: -------------------------------------------------------------------------------- 1 | package lecture12.exercises.chickenbarn; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class Main { 7 | 8 | public static void main(String[] args) { 9 | List chickens = new ArrayList<>(); 10 | 11 | chickens.add(new Chicken(3)); 12 | chickens.add(new Chicken(4)); 13 | chickens.add(new Chicken(5)); 14 | 15 | Barn barn = new Barn(chickens); 16 | 17 | List evolvedChickens = barn.evolve(4); 18 | 19 | for (Chicken chicken : evolvedChickens) { 20 | System.out.println(chicken); 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/lecture7/exercises/task2/Person.java: -------------------------------------------------------------------------------- 1 | package lecture7.exercises.task2; 2 | 3 | public class Person { 4 | String name; 5 | int age; 6 | boolean isWoman; 7 | 8 | void eat() { 9 | System.out.println("Eating..."); 10 | } 11 | 12 | void growUp() { 13 | age++; 14 | } 15 | 16 | void drinkWater(double liters) { 17 | if (liters > 1) { 18 | System.out.println("This is too much water!"); 19 | } else { 20 | System.out.printf("%s is drinking %.2f liters of watter", name, liters); 21 | } 22 | } 23 | 24 | int calculateAge(int years) { 25 | return age + years; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/lecture11/exercies/zoo/Zoo.java: -------------------------------------------------------------------------------- 1 | package lecture11.exercies.zoo; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class Zoo { 7 | 8 | private List animals = new ArrayList<>(); 9 | 10 | public void add(Animal animal) { 11 | this.animals.add(animal); 12 | } 13 | 14 | public void feedAnimals() { 15 | for (Animal animal : animals) { 16 | 17 | if (animal instanceof PersianCat) { // проверяваме дали животното е PersianCat 18 | PersianCat persianCat = (PersianCat) animal; // кастваме Animal към PersianCat 19 | persianCat.play(); 20 | } 21 | 22 | animal.eat(); 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/lecture10/singleton/Universe.java: -------------------------------------------------------------------------------- 1 | package lecture10.singleton; 2 | 3 | public final class Universe { 4 | 5 | // статична final инстанция 6 | private static Universe INSTANCE; 7 | 8 | // private конструктор, за да не може друг да инстанцира този клас 9 | private Universe() { 10 | } 11 | 12 | /** 13 | * Метод, който предоставя единствената инстанция на този клас. 14 | * Инстанцията ще бъде създадена при първото извикване на този метод. 15 | * 16 | * @return единствената инстанция на този клас. 17 | */ 18 | public static Universe getInstance() { 19 | if (INSTANCE == null) { 20 | INSTANCE = new Universe(); 21 | } 22 | 23 | return INSTANCE; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/lecture11/exercies/polymorphism/Main.java: -------------------------------------------------------------------------------- 1 | package lecture11.exercies.polymorphism; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | Flyer bird = new Bird(); 7 | Flyer airplane = new Airplane(); 8 | 9 | startFlying(bird); // Bird приема формата на Flyer 10 | startFlying(airplane); // Airplane приема формата на Flyer 11 | } 12 | 13 | /** 14 | * Този метод приема {@link Flyer}. 15 | * Той е абстрахиран от {@link Bird} и {@link Airplane}. 16 | * 17 | * @param flyer инстанция, която ще полети. 18 | */ 19 | private static void startFlying(Flyer flyer) { 20 | if (flyer instanceof Bird) { 21 | Bird bird = (Bird) flyer; 22 | bird.fly(); 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/lecture13/exercises/Task2.java: -------------------------------------------------------------------------------- 1 | package lecture13.exercises; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Task2 { 6 | 7 | public static void main(String[] args) { 8 | 9 | Scanner scanner = new Scanner(System.in); 10 | 11 | double sum = 0; 12 | int count = 0; 13 | 14 | while (count < 5) { 15 | 16 | try { 17 | String text = scanner.nextLine(); 18 | 19 | System.out.print("Въведете число: "); 20 | double number = Double.parseDouble(text); 21 | 22 | sum += number; 23 | count++; 24 | 25 | } catch (NumberFormatException e) { 26 | System.out.println("Въведеното от вас число е невалидно"); 27 | } 28 | } 29 | 30 | System.out.println("Сумата от 5-те числа е: " + sum); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/lecture7/exercises/task3/Task3.java: -------------------------------------------------------------------------------- 1 | package lecture7.exercises.task3; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Task3 { 6 | 7 | public static void main(String[] args) { 8 | 9 | Scanner scanner = new Scanner(System.in); 10 | 11 | String input = scanner.nextLine(); 12 | String[] words = input.split("\\s"); // раздели текста на space-ове 13 | 14 | String longestWord = findLongest(words); 15 | 16 | System.out.printf("length: %d word: %s", longestWord.length(), longestWord); 17 | } 18 | 19 | private static String findLongest(String[] words) { 20 | String longestWord = null; 21 | int maxLength = 0; 22 | 23 | for (String word : words) { 24 | if (word.length() > maxLength) { 25 | longestWord = word; 26 | maxLength = word.length(); 27 | } 28 | } 29 | 30 | return longestWord; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # ☕ Introduction to Java 2 | #java course# 3 | 4 | #### Какво представлява курсът? 5 | Този курс цели да покрие основите на програмирането, като за целта се използва езикът Java. 6 | Това не означава че концепциите разглеждани в курса са приложими само за този език. 7 | Напротив те са основополагащи и намират своето приложение и в други обектно ориентирани езици. 8 | След покриването и **разбирането** на съдържанието на курса ще имате една добра основа, 9 | в/у която може да се гради кариера в IT сферата. 10 | 11 | #### Какво включва? 12 | Курсът е разделен на теми включващи теория, задачи с решения, домашни и препрадки към други видео и текстови материали. 13 | 14 | #### За кого е подходящ? 15 | Подходящ е за хора проявяващи интерес към програмирането, ученици и студенти 16 | изучаващи сходни дисциплини или хора с малко опит целящи да затвърдят познанията си. 17 | 18 | За съдържанието на курса вижте [Contents.md](/lectures/bg/Contents.md). 19 | -------------------------------------------------------------------------------- /src/lecture12/exercises/chickenbarn/Egg.java: -------------------------------------------------------------------------------- 1 | package lecture12.exercises.chickenbarn; 2 | 3 | public class Egg { 4 | 5 | private static final int HATCHING_WEEK = 2; 6 | 7 | private String chickenName; 8 | private int age; 9 | 10 | /** 11 | * Конструктор, за създаванен на ново яйце. 12 | * 13 | * @param chickenName името на кокошката снесла яйцето. 14 | */ 15 | public Egg(String chickenName) { 16 | this.chickenName = chickenName; 17 | age = 0; 18 | } 19 | 20 | /** 21 | * Увеличи възрастта на яйцето с 1 седмица. 22 | */ 23 | public void ageByOneWeek() { 24 | age++; 25 | } 26 | 27 | /** 28 | * Излюпи яйцето, ако е навършило необходимата възраст. 29 | * 30 | * @return излюпената кокоша или null, ако яйцето не може да бъде излюпено. 31 | */ 32 | public Chicken hatch() { 33 | 34 | if (age < HATCHING_WEEK) { 35 | return null; 36 | } 37 | 38 | return new Chicken(chickenName); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/lecture12/exercises/task1/Task1.java: -------------------------------------------------------------------------------- 1 | package lecture12.exercises.task1; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | import java.util.Scanner; 6 | 7 | public class Task1 { 8 | 9 | private static final double STOP_NUMBER = -1; 10 | 11 | public static void main(String[] args) { 12 | Scanner scanner = new Scanner(System.in); 13 | 14 | List myNumbers = new ArrayList<>(); 15 | 16 | double min = STOP_NUMBER; 17 | 18 | while (true) { 19 | System.out.print("Въведете число: "); 20 | double currentNum = scanner.nextDouble(); 21 | 22 | if (currentNum == STOP_NUMBER) { 23 | break; 24 | } 25 | 26 | if (min == STOP_NUMBER) { 27 | min = currentNum; 28 | } else if (min > currentNum) { 29 | min = currentNum; 30 | } 31 | 32 | myNumbers.add(currentNum); 33 | } 34 | 35 | System.out.printf("%nРезултат: "); 36 | for (int i = myNumbers.size() - 1; i >= 0; i--) { 37 | double element = myNumbers.get(i); 38 | 39 | System.out.print(element + " "); 40 | } 41 | 42 | System.out.printf("%nНай-малкото число е: " + min); 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /src/lecture7/exercises/task4/Task4.java: -------------------------------------------------------------------------------- 1 | package lecture7.exercises.task4; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Task4 { 6 | 7 | public static void main(String[] args) { 8 | Scanner scanner = new Scanner(System.in); 9 | 10 | String input = scanner.nextLine(); 11 | String[] words = input.split("\\s"); 12 | 13 | int maxWeight = 0; 14 | String heaviestWord = null; 15 | 16 | for (String word : words) { 17 | int weight = computeWeight(word); 18 | 19 | if (weight > maxWeight) { 20 | maxWeight = weight; 21 | heaviestWord = word; 22 | } 23 | } 24 | 25 | System.out.printf("weight: %d word: %s", maxWeight, heaviestWord); 26 | } 27 | 28 | static int computeWeight(String word) { 29 | int weight = 0; 30 | 31 | for (int i = 0; i < word.length(); i++) { 32 | char symbol = word.charAt(i); 33 | weight += computeWeight(symbol); 34 | } 35 | 36 | return weight; 37 | } 38 | 39 | static int computeWeight(char letter) { 40 | // 'A' is 10 and 'Z' is 35 that's why I subtract 9 so that I can fit between 1 and 26 41 | return Character.getNumericValue(letter) - 9; 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/lecture12/exercises/task2/Task2.java: -------------------------------------------------------------------------------- 1 | package lecture12.exercises.task2; 2 | 3 | import java.util.HashSet; 4 | import java.util.Scanner; 5 | import java.util.Set; 6 | 7 | public class Task2 { 8 | 9 | public static void main(String[] args) { 10 | Scanner scanner = new Scanner(System.in); 11 | 12 | Set uniqueWords = new HashSet<>(); 13 | 14 | boolean shouldPromptUser = true; 15 | while (shouldPromptUser) { 16 | 17 | System.out.print("Въведете текст: "); 18 | String sentence = scanner.nextLine(); 19 | 20 | String[] words = sentence.split(" "); 21 | 22 | for (String currentWord : words) { 23 | 24 | if ("stop".equals(currentWord)) { 25 | shouldPromptUser = false; 26 | break; 27 | } 28 | 29 | if (uniqueWords.contains(currentWord)) { 30 | System.out.printf("Думата '%s' вече е въведена.%n", currentWord); 31 | } else { 32 | uniqueWords.add(currentWord); 33 | } 34 | } 35 | } 36 | 37 | System.out.printf("%nРезултат: "); 38 | for (String eachUniqueWord : uniqueWords) { 39 | System.out.print(eachUniqueWord + " "); 40 | } 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/lecture12/exercises/task3/Task3.java: -------------------------------------------------------------------------------- 1 | package lecture12.exercises.task3; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | import java.util.Scanner; 6 | 7 | public class Task3 { 8 | 9 | public static void main(String[] args) { 10 | 11 | Scanner scanner = new Scanner(System.in); 12 | 13 | Map wordCount = new HashMap<>(); 14 | 15 | while (true) { 16 | String word = scanner.nextLine(); 17 | 18 | if ("stop".equalsIgnoreCase(word)) { 19 | break; 20 | } 21 | 22 | Integer occurrence = wordCount.get(word); 23 | 24 | if (occurrence == null) { 25 | wordCount.put(word, 1); 26 | } else { 27 | wordCount.put(word, occurrence + 1); 28 | } 29 | } 30 | 31 | String maxWord = null; 32 | int max = 0; 33 | 34 | for (Map.Entry currentEntry : wordCount.entrySet()) { 35 | 36 | String currentWord = currentEntry.getKey(); 37 | int occurrence = currentEntry.getValue(); 38 | 39 | if (max < occurrence) { 40 | maxWord = currentWord; 41 | max = occurrence; 42 | } 43 | } 44 | 45 | System.out.println("Most frequent word is '" + maxWord + "' with " + max + " ocurrances."); 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /IDEACheatSheet.md: -------------------------------------------------------------------------------- 1 | ![intellij-logo](https://upload.wikimedia.org/wikipedia/commons/d/d5/IntelliJ_IDEA_Logo.svg) 2 | 3 | ### IntelliJ IDEA Cheat Sheet 4 | 5 | ###### Useful Shortcuts 6 | 7 | | Action |Shortcut | 8 | |---------------------------|-----------------------| 9 | |**Search for Action** |**CTRL + SHIFT + A** | 10 | 11 |
12 | 13 | | Search |Shortcut | 14 | |---------------------------|-----------------------| 15 | |View Documentation |**CTRL + Q** | 16 | |Navigate to Declaration |**CTRL + B** | 17 | |View Parameters |**CTRL + P** | 18 | |Open Class |**CTRL + N** | 19 | 20 |
21 | 22 | | Edit |Shortcut | 23 | |---------------------------|-----------------------| 24 | |Reformat Code |**CTRL + ALT + L** | 25 | |Rename |**SHIFT + F6** | 26 | |Extend Selection |**CTRL + W** | 27 | |Comment Line |**CTRL + /** | 28 | |Move Line Up |**CTRL + SHIFT + ↑** | 29 | |Move Line Down |**CTRL + SHIFT + ↓** | 30 | |Delete Line |**CTRL + Y** | 31 | |Cut Line |**CTRL + X** | 32 | |Start New Line |**SHIFT + ↵** | 33 | 34 |
35 | 36 | ![idea_multiple_selections](https://d3nmt5vlzunoa1.cloudfront.net/idea/files/2014/03/multiple_selections.gif) 37 | -------------------------------------------------------------------------------- /src/lecture14/exercises/task4/WriteDemo.java: -------------------------------------------------------------------------------- 1 | package lecture14.exercises.task4; 2 | 3 | import java.io.File; 4 | import java.io.IOException; 5 | import java.io.PrintWriter; 6 | import java.util.ArrayList; 7 | import java.util.List; 8 | import java.util.Scanner; 9 | 10 | public class WriteDemo { 11 | 12 | public static void main(String[] args) throws IOException { 13 | Scanner scanner = new Scanner(System.in); 14 | 15 | List data = new ArrayList<>(); 16 | while (true) { 17 | 18 | System.out.print("Въведете текст: "); 19 | String input = scanner.nextLine(); 20 | 21 | if ("stop".equalsIgnoreCase(input)) { 22 | break; 23 | } 24 | 25 | data.add(input); 26 | } 27 | 28 | File createdFile = createFile("echo.txt"); 29 | 30 | PrintWriter writer = new PrintWriter(createdFile); 31 | 32 | for (String eachData : data) { 33 | writer.println(eachData); 34 | } 35 | 36 | writer.flush(); 37 | writer.close(); 38 | 39 | System.out.println("Проверете съдържанеието на echo.txt"); 40 | } 41 | 42 | private static File createFile(String name) { 43 | File myFile = new File(name); 44 | 45 | try { 46 | myFile.createNewFile(); 47 | return myFile; 48 | } catch (IOException e) { 49 | throw new RuntimeException("There was an error creating the file.", e); 50 | } 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /src/lecture4/Lecture4.java: -------------------------------------------------------------------------------- 1 | package lecture4; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Lecture4 { 6 | 7 | public static void main(String[] args) { 8 | dynamicArray(); 9 | } 10 | 11 | private static void dynamicArray() { 12 | Scanner scanner = new Scanner(System.in); 13 | 14 | int stopNumber = -1; 15 | int[] array = new int[1]; 16 | 17 | System.out.println("To stop entering numbers type: " + stopNumber); 18 | 19 | int i = 0; 20 | while (true) { 21 | System.out.print("Enter number: "); 22 | int input = scanner.nextInt(); 23 | 24 | if (input == stopNumber) { 25 | break; 26 | } 27 | 28 | array[i] = input; 29 | i++; 30 | 31 | if (array.length == i) { 32 | // create new array with bigger size 33 | int[] tmpArray = new int[array.length + 1]; 34 | 35 | // copy old values in new array 36 | for (int j = 0; j < array.length; j++) { 37 | tmpArray[j] = array[j]; 38 | } 39 | 40 | // change array to new array 41 | array = tmpArray; 42 | } 43 | } 44 | 45 | // array.length - 1 because there is one extra item at the end of the array 46 | System.out.print("You entered: "); 47 | for (int j = 0; j < array.length - 1; j++) { 48 | System.out.print(array[j] + " "); 49 | } 50 | } 51 | 52 | } 53 | -------------------------------------------------------------------------------- /src/lecture10/homework/shop/TwoForOnePrice.java: -------------------------------------------------------------------------------- 1 | package lecture10.homework.shop; 2 | 3 | /** 4 | * Този клас моделира цена от тип 2 за 1, като той наследява базовия клас {@link Price}. 5 | */ 6 | public class TwoForOnePrice extends Price { 7 | 8 | public TwoForOnePrice(double price) { 9 | super(price); // извикваме super конструктора на Price, за да подадем цената 10 | } 11 | 12 | /** 13 | * Този метод презаписва функционалността от Price, тъй като логиката за продажба 14 | * на продукт в промоция е по различна. 15 | * 16 | * @param amount сумата пари на клиента. 17 | * @param quantity количеството което клиента иска да закупи. 18 | * @return true ако сумата е достатъчна, false в противен случай. 19 | */ 20 | @Override 21 | public boolean canBePaid(int amount, int quantity) { 22 | 23 | if (quantity < 2 || quantity % 2 != 0) { 24 | return false; 25 | } 26 | 27 | return calculateForQuantity(quantity) <= amount; 28 | } 29 | 30 | /** 31 | * Този метод презаписва функционалността от Price, тъй като логиката за изчисляване 32 | * на това каква сума пари трябва да се плати за да бъде закупен този продукт е по разлина. 33 | * 34 | * @param quantity количеството, което се закупува. 35 | * @return сумата пари, необходима за закупуването. 36 | */ 37 | @Override 38 | public double calculateForQuantity(int quantity) { 39 | int taxQuantity = quantity / 2; 40 | 41 | return price * taxQuantity; 42 | } 43 | 44 | @Override 45 | public String toString() { 46 | 47 | return String.format("(2 за 1 при цена %.2f)", price); 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /src/lecture6/homework/task2/ComputerDemo.java: -------------------------------------------------------------------------------- 1 | package lecture6.homework.task2; 2 | 3 | class ComputerDemo { 4 | 5 | public static void main(String[] args) { 6 | 7 | Computer laptop = new Computer(); 8 | 9 | laptop.operatingSystem = "Ubuntu 19.04"; 10 | laptop.freeMemory = 4096; 11 | laptop.hardDiskMemory = 131_072; 12 | laptop.year = 2014; 13 | laptop.price = 1000; 14 | laptop.isNotebook = true; 15 | 16 | Computer pc = new Computer(); 17 | 18 | pc.operatingSystem = "Windows 10"; 19 | pc.freeMemory = 8192; 20 | pc.hardDiskMemory = 525_288; 21 | pc.year = 2015; 22 | pc.price = 1500; 23 | pc.isNotebook = false; 24 | 25 | laptop.useMemory(1024); 26 | 27 | pc.changeOperatingSystem("Windows 7"); 28 | 29 | System.out.println("-----"); 30 | System.out.printf("Is Notebook %b\n", laptop.isNotebook); 31 | System.out.printf("Year: %d\n", laptop.year); 32 | System.out.printf("Price: %d\n", laptop.price); 33 | System.out.printf("OS: %s\n", laptop.operatingSystem); 34 | System.out.printf("Free Memory %d:\n", laptop.freeMemory); 35 | System.out.printf("HDD Memory: %d\n", laptop.hardDiskMemory); 36 | 37 | System.out.println("-----"); 38 | System.out.printf("Is Notebook %b\n", pc.isNotebook); 39 | System.out.printf("Year: %d\n", pc.year); 40 | System.out.printf("Price: %d\n", pc.price); 41 | System.out.printf("OS: %s\n", pc.operatingSystem); 42 | System.out.printf("Free Memory %d:\n", pc.freeMemory); 43 | System.out.printf("HDD Memory: %d\n", pc.hardDiskMemory); 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /lectures/bg/09-inheritance/Lecture9Homework.md: -------------------------------------------------------------------------------- 1 | # Homework Lecture 9 2 | #java course# 3 | 4 | ## Inheritance (Наследяване) 🏛️ 5 | 6 | ### Task 1 7 | 8 | Създайте програма, която симулира работата на болница. 🏥 9 | В една болница има няколко участника: 10 | - Доктори (Doctor) 11 | - Пациенти (Patient) 12 | 13 | И докторите и пациентите се характеризират с: 14 | - име (name) 15 | - възраст (age) 16 | - дали е мъж или жена (isFemale) 17 | 18 | Един пациент се характеризира с: 19 | - Диагноза (diagnose) 20 | - примерна диагноза може да е `кардиолог` (това означава че трябва да посети кардиолог) 21 | - Способността да му се поставя диагноза (setDiagnose) 22 | - Способността да му се премахва диагноза (removeDiagnose) 23 | 24 | Докторите се характеризират с: 25 | - способността да лекуват пациенти (heal) (просто премахват диагнозата на пациента) 26 | 27 | Докторите се делят на различни под типове: 28 | - Кардиолог (Cardiologist) 29 | - лекува само диагнози тип `кардиолог` 30 | - Дерматолог (Dermatologist) 31 | - лекува само диагнози тип `дерматолог` 32 | - Педиатър (Pediatrician) 33 | - лекува само пациенти на възраст под 18 години 34 | 35 | 36 | Болницата е това което навръзва докторите с пациентите. Тя се характеризира с: 37 | - множество доктори 38 | - способността да се добавя доктор 39 | - способността да се лекува пациент 40 | - за целта болницата намира лекаря, който може да излекува пациента и го лекува 41 | 42 | ###### Примерна йерархия на програмата 43 | 44 | - class Person 45 | - class Patient 46 | - class MalePatient 47 | - class FemalePatient 48 | - class Doctor 49 | - class Cardiologist 50 | - class Dermatologist 51 | - class Pediatrician 52 | -------------------------------------------------------------------------------- /src/lecture12/exercises/rpn/RPNDemo.java: -------------------------------------------------------------------------------- 1 | package lecture12.exercises.rpn; 2 | 3 | import java.util.Arrays; 4 | import java.util.Stack; 5 | 6 | public class RPNDemo { 7 | 8 | public static void main(String[] args) { 9 | 10 | Stack stack = new Stack<>(); 11 | 12 | stack.push("3"); 13 | stack.push("4"); 14 | stack.push("+"); 15 | 16 | String item = stack.pop(); 17 | 18 | handleItem(stack, item); 19 | 20 | System.out.println(Arrays.toString(stack.toArray())); 21 | } 22 | 23 | private static void handleItem(Stack stack, String operator) { 24 | 25 | if (isOperator(operator)) { 26 | 27 | String operand2 = stack.pop(); 28 | String operand1 = stack.pop(); 29 | 30 | double value1 = Double.parseDouble(operand1); 31 | double value2 = Double.parseDouble(operand2); 32 | 33 | double result = handleOperator(value1, value2, operator); 34 | 35 | stack.push(Double.toString(result)); 36 | } 37 | } 38 | 39 | private static double handleOperator(double value1, double value2, String operator) { 40 | if ("+".equals(operator)) { 41 | return value1 + value2; 42 | } 43 | 44 | if ("-".equals(operator)) { 45 | return value1 - value2; 46 | } 47 | 48 | if ("*".equals(operator)) { 49 | return value1 * value2; 50 | } 51 | 52 | return value1 / value2; 53 | } 54 | 55 | private static boolean isOperator(String item) { 56 | return "+".equals(item) 57 | || "-".equals(item) 58 | || "*".equals(item) 59 | || "/".equals(item); 60 | } 61 | } 62 | -------------------------------------------------------------------------------- /src/lecture8/Car.java: -------------------------------------------------------------------------------- 1 | package lecture8; 2 | 3 | public class Car { 4 | 5 | // полета които са final (не могат да бъдат променяни) 6 | private final String model; 7 | private final int year; 8 | private final boolean isAutomatic; 9 | 10 | // полета които могат да бъдат променяни след инстанцирането 11 | private int maxSpeed; 12 | private static String color; // пробвайте със и без ключовата дума static 13 | 14 | Car(String model, int year, boolean isAutomatic) { // конструктор със задължителните полета 15 | this.model = model; 16 | this.year = year; 17 | this.isAutomatic = isAutomatic; 18 | } 19 | 20 | Car(String model, int year, boolean isAutomatic, int maxSpeed, String color) { // конструктор с всички полета 21 | this.model = model; 22 | this.year = year; 23 | this.isAutomatic = isAutomatic; 24 | this.maxSpeed = maxSpeed; 25 | this.color = color; 26 | } 27 | 28 | /** 29 | * Методът примеа новия цвят на колата и го записва в property-то за цвят. 30 | * @param color новия цвят на колата 31 | */ 32 | void changeColor(String color) { 33 | this.color = color; 34 | } 35 | 36 | /** 37 | * Този метод принтира детайлите на колата. 38 | * Като добавя отстояние на полето color, за да може по лесно да се наблюдава. 39 | */ 40 | void printCarDetails() { 41 | System.out.println("==============="); 42 | System.out.println("model: " + model); 43 | System.out.println("year: " + year); 44 | System.out.println("isAutomatic: " + isAutomatic); 45 | System.out.println("maxSpeed: " + maxSpeed); 46 | System.out.println("color: " + color); 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /src/lecture7/homework/bank/BankDemo.java: -------------------------------------------------------------------------------- 1 | package lecture7.homework.bank; 2 | 3 | public class BankDemo { 4 | 5 | public static void main(String[] args) { 6 | 7 | // създай клиенти 8 | Customer john = new Customer("John", "Doe", 20); 9 | Customer foo = new Customer("Foo", "Doe", 30); 10 | Customer bar = new Customer("Bar", "Doe", 40); 11 | 12 | // създай банка с капацитет от 100 акаунта 13 | Bank bank = new Bank(100); 14 | 15 | // отвори 2 акаунта в различни валути на първия клиент 16 | bank.addAccount(john, 10, "EUR", Account.CREDIT); 17 | bank.addAccount(john, 55, "BGN", Account.CREDIT); 18 | 19 | // отвори 2 други акаунта на другите клиенти 20 | bank.addAccount(foo, 20, "EUR", Account.CREDIT); 21 | bank.addAccount(bar, 40, "GBP", Account.DEBIT); 22 | 23 | // принтирай общия брой пари в банката според валутата 24 | System.out.printf("Банката има EUR %.2f\n", bank.getTotalMoney("EUR")); 25 | System.out.printf("Банката има GBP %.2f\n", bank.getTotalMoney("GBP")); 26 | System.out.printf("Банката има BGN %.2f\n\n", bank.getTotalMoney("BGN")); 27 | System.out.printf("Банката има INR %.2f\n\n", bank.getTotalMoney("INR")); 28 | 29 | // принтирай акаунтите на първия клиент 30 | System.out.printf("Клиент %s има следните акаунти:\n", john.getFullName()); 31 | john.printAccountDetails(); 32 | 33 | // премахни един от акаунтите на първия клиент 34 | bank.removeAccount(john, "EUR", Account.CREDIT); 35 | 36 | // принтирай акаунтите на първия клиент 37 | System.out.printf("\nКлиент %s има следните акаунти:\n", john.getFullName()); 38 | john.printAccountDetails(); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/lecture10/homework/shop/PurchaseReceipt.java: -------------------------------------------------------------------------------- 1 | package lecture10.homework.shop; 2 | 3 | /** 4 | * Този клас моделира касова бележка. Той съдържа името на продукта, който е закупен, 5 | * цената на която е закупен, количеството което е закупено, и сумата пари платена от клиента. 6 | */ 7 | public class PurchaseReceipt { 8 | 9 | private final String productName; 10 | private final Price price; 11 | private int boughtQuantity; 12 | private final double paidAmount; 13 | 14 | /** 15 | * Конструктор на касова бележка. 16 | * 17 | * @param productName името на закупения продукт. 18 | * @param price цената на която е закупен продукта. 19 | * @param boughtQuantity количеството което е закупено. 20 | * @param paidAmount платената сума от клиента. 21 | */ 22 | PurchaseReceipt(String productName, Price price, int boughtQuantity, double paidAmount) { 23 | this.productName = productName; 24 | this.price = price; 25 | this.boughtQuantity = boughtQuantity; 26 | this.paidAmount = paidAmount; 27 | } 28 | 29 | @Override 30 | public String toString() { 31 | return "PurchaseReceipt{" + 32 | "productName='" + productName + '\'' + 33 | ", boughtQuantity=" + boughtQuantity + 34 | ", price=" + price + 35 | ", paidAmount=" + paidAmount + 36 | ", change=" + getChange() + 37 | '}'; 38 | } 39 | 40 | /** 41 | * Вътрешен метод, който изчислява рестото на клиента. 42 | * 43 | * @return сумата пари, която е върната на клиента. 44 | */ 45 | private double getChange() { 46 | return paidAmount - price.calculateForQuantity(boughtQuantity); 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /src/lecture6/exercise/Main.java: -------------------------------------------------------------------------------- 1 | package lecture6.exercise; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | Car peugeot = new Car(); 7 | 8 | peugeot.model = "Peugeot"; 9 | peugeot.color = "Green"; 10 | peugeot.currentGear = 0; 11 | peugeot.currentSpeed = 0; 12 | peugeot.maxSpeed = 220; 13 | 14 | Person gosho = new Person(); 15 | gosho.name = "Gosho"; 16 | gosho.age = 30; 17 | 18 | Person pesho = new Person(); 19 | pesho.name = "Pesho"; 20 | pesho.age = 40; 21 | 22 | gosho.friend = pesho; 23 | 24 | peugeot.owner = gosho; 25 | 26 | System.out.printf("Приятелят на %s с име %s има %s с цвят %s и максимална скорост %d\n", 27 | peugeot.owner.friend.name, 28 | peugeot.owner.name, 29 | peugeot.model, 30 | peugeot.color, 31 | peugeot.maxSpeed 32 | ); 33 | 34 | System.out.printf("Текуща предавка: %d, текуща скорост: %d\n", peugeot.currentGear, peugeot.currentSpeed); 35 | peugeot.speedUp(); 36 | peugeot.speedUp(); 37 | System.out.printf("Текуща предавка: %d, текуща скорост: %d\n", peugeot.currentGear, peugeot.currentSpeed); 38 | 39 | peugeot.shiftUp(); 40 | peugeot.shiftUp(); 41 | System.out.printf("Текуща предавка: %d, текуща скорост: %d\n", peugeot.currentGear, peugeot.currentSpeed); 42 | 43 | peugeot.speedDown(); 44 | System.out.printf("Текуща предавка: %d, текуща скорост: %d\n", peugeot.currentGear, peugeot.currentSpeed); 45 | 46 | peugeot.stop(); 47 | System.out.printf("Текуща предавка: %d, текуща скорост: %d\n", peugeot.currentGear, peugeot.currentSpeed); 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /src/lecture10/homework/shop/Price.java: -------------------------------------------------------------------------------- 1 | package lecture10.homework.shop; 2 | 3 | /** 4 | * Този клас моделира цена на даден продукт. Той е използван като super клас на промоционалните цени. 5 | * Основното нещо, което има в този клас е сумата пари която трябва да се заплати. 6 | */ 7 | public class Price { 8 | 9 | public final double price; 10 | 11 | public Price(double price) { 12 | this.price = price; 13 | } 14 | 15 | /** 16 | * Този метод проверява дали сумата, която е предоставена от клиента е достатъчна за да се закупи желаното 17 | * от него количество. 18 | * 19 | * @param amount сумата пари на клиента. 20 | * @param quantity количеството което клиента иска да закупи. 21 | * @return true ако сумата е достатъчна, false в противен случай. 22 | */ 23 | public boolean canBePaid(int amount, int quantity) { 24 | 25 | return calculateForQuantity(quantity) <= amount; 26 | } 27 | 28 | /** 29 | * Този метод изчислява каква сума пари трябва да се плати за да бъде закупен този продукт. 30 | * 31 | * @param quantity количеството, което се закупува. 32 | * @return сумата пари, необходима за закупуването. 33 | */ 34 | public double calculateForQuantity(int quantity) { 35 | return price * quantity; 36 | } 37 | 38 | @Override 39 | public String toString() { 40 | return String.format("(%.2f)", price); 41 | } 42 | 43 | /** 44 | * Този метод е презаписан, за да може да се сравняват различните цени. 45 | * 46 | * @param other другата цена с която да се сравни. 47 | * @return true ако цените са еднакви, false в противен случай. 48 | */ 49 | @Override 50 | public boolean equals(Object other) { 51 | if (this == other) return true; 52 | if (other == null || getClass() != other.getClass()) return false; 53 | 54 | Price price1 = (Price) other; 55 | 56 | return Double.compare(price1.price, price) == 0; 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /src/lecture7/exercises/task5/Task5.java: -------------------------------------------------------------------------------- 1 | package lecture7.exercises.task5; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Task5 { 6 | 7 | /** 8 | * Напишете програма, която проверява дали даден списък от числа е подреден. 9 | * Един списък е подреден, когато следващото число НЕ е по-малко от предишното. 10 | *

11 | * - Пример за подреден спиък: `-8,3,4,5,5,10` 12 | *

13 | * - Пример за неподреден списък: `-8,-10,3,4` 14 | *

15 | * Програмата, първо трябва да изисква число `n`, представляващо броя редове, които ще се въведат. 16 | * След това програмата, изисква редовете с числа. Един ред представлява числа разделени със запетая. 17 | *

18 | * Програмата, като краен резултат трябва да изпише `n` на брой пъти `true` или `false`, съответно 19 | * за сортиран или несортиран списък. 20 | */ 21 | public static void main(String[] args) { 22 | Scanner userInput = new Scanner(System.in); 23 | 24 | System.out.print("Въведете брой редове: "); 25 | int n = userInput.nextInt(); 26 | 27 | boolean[] sortedLists = new boolean[n]; 28 | 29 | for (int i = 0; i < n; i++) { 30 | System.out.println("Въведете списък с числа:"); 31 | String input = userInput.next(); 32 | String[] firstList = input.split(","); 33 | 34 | 35 | if (firstList.length == 0 || firstList.length == 1) { 36 | sortedLists[i] = true; 37 | continue; 38 | } 39 | 40 | for (int j = 1; j < firstList.length; j++) { 41 | int previous = Integer.parseInt(firstList[j - 1]); 42 | int current = Integer.parseInt(firstList[j]); 43 | 44 | if (previous <= current) { 45 | sortedLists[i] = true; 46 | } else { 47 | sortedLists[i] = false; 48 | break; 49 | } 50 | } 51 | } 52 | 53 | for (boolean isSorted : sortedLists) { 54 | System.out.println(isSorted); 55 | } 56 | } 57 | 58 | } 59 | -------------------------------------------------------------------------------- /src/lecture7/homework/bank/Customer.java: -------------------------------------------------------------------------------- 1 | package lecture7.homework.bank; 2 | 3 | public class Customer { 4 | 5 | private final String fistName; 6 | private final String lastName; 7 | private final int age; 8 | 9 | /** 10 | * Масив с акаунти, които клиента може да има. 11 | */ 12 | private Account[] accounts = new Account[10]; 13 | 14 | public Customer(String fistName, String lastName, int age) { 15 | this.fistName = fistName; 16 | this.lastName = lastName; 17 | this.age = age; 18 | } 19 | 20 | /** 21 | * Добави акаунт към клиента. 22 | * 23 | * @param account акаунта, който да бъде добавен. 24 | * @return true, при успешно добавяне, false в противен случай. 25 | */ 26 | public boolean addAccount(Account account) { 27 | 28 | for (int i = 0; i < accounts.length; i++) { 29 | if (accounts[i] == null) { 30 | accounts[i] = account; 31 | return true; 32 | } 33 | } 34 | 35 | return false; 36 | } 37 | 38 | /** 39 | * Премахва акаунта от клиента. 40 | * 41 | * @param accountCurrency валутата на акаунта. 42 | * @param accountType типът на акаунта. 43 | * @return true при успешно премахнат акаунт, false в противен случай. 44 | */ 45 | public boolean removeAccount(String accountCurrency, String accountType) { 46 | 47 | for (int i = 0; i < accounts.length; i++) { 48 | 49 | Account account = accounts[i]; 50 | 51 | if (account.hasCurrencyAndType(accountCurrency, accountType)) { 52 | accounts[i] = null; 53 | return true; 54 | } 55 | } 56 | 57 | return false; 58 | } 59 | 60 | public String getFullName() { 61 | return fistName + " " + lastName; 62 | } 63 | 64 | /** 65 | * Принтирай всички отворени акаунти на клиента. 66 | */ 67 | public void printAccountDetails() { 68 | for (Account account : accounts) { 69 | if (account != null) { 70 | System.out.println(account); 71 | } 72 | } 73 | } 74 | 75 | public int getAge() { 76 | return age; 77 | } 78 | } 79 | -------------------------------------------------------------------------------- /src/lecture7/homework/bank/Account.java: -------------------------------------------------------------------------------- 1 | package lecture7.homework.bank; 2 | 3 | public class Account { 4 | 5 | /** 6 | * Константа за тип на акаунта "ДЕБИТ" 7 | */ 8 | public final static String DEBIT = "DEBIT"; 9 | 10 | /** 11 | * Константа за тип на акаунта "КРЕДИТ" 12 | */ 13 | public final static String CREDIT = "CREDIT"; 14 | 15 | private final String currency; 16 | private final String type; 17 | 18 | private double amount; 19 | 20 | /** 21 | * Конструкорът на класът {@link Account}. 22 | * 23 | * @param currency валутата на акаунта. 24 | * @param type типът на акаунта. 25 | * @param amount първоначалния баланс на акаунта. 26 | */ 27 | public Account(String currency, String type, double amount) { 28 | this.currency = currency; 29 | this.type = type; 30 | this.amount = amount; 31 | } 32 | 33 | /** 34 | * Метод, който проверява дали валутата на акаунта е същата, като тази подадена на метода. 35 | * 36 | * @param currency валутата, срещу която ще се проверява. 37 | * @return true ако е в същата валута, false в противен случай. 38 | */ 39 | public boolean isInCurrency(String currency) { 40 | return this.currency.equalsIgnoreCase(currency); 41 | } 42 | 43 | /** 44 | * Метод връщаш текущия баланс на акаунта. 45 | * 46 | * @return баланс на акаунта. 47 | */ 48 | public double getBalance() { 49 | return amount; 50 | } 51 | 52 | /** 53 | * Проверява дали валутата на каунта и типът на акаунта са същите, като тези подадени на метода. 54 | * 55 | * @param accountCurrency валутата срещу, която ще се проверява. 56 | * @param accountType типът на акаунта срещу, който ще се проверява. 57 | * @return true ако са еднакви, false в противен случай. 58 | */ 59 | public boolean hasCurrencyAndType(String accountCurrency, String accountType) { 60 | 61 | return this.currency.equalsIgnoreCase(accountCurrency) 62 | && this.type.equalsIgnoreCase(accountType); 63 | } 64 | 65 | @Override 66 | public String toString() { 67 | return String.format("Account { %s %.2f %s }", currency, amount, type); 68 | } 69 | } 70 | -------------------------------------------------------------------------------- /TODO.md: -------------------------------------------------------------------------------- 1 | # TODO 2 | 3 | ### Restructure OOP lectures 4 | 5 | The current order seems to difficult. 6 | IMHO it will be better to start OOP in the following sequence: 7 | 8 | 1. Static Methods and reusable code 9 | 2. Classes & Properties 10 | 3. Classes & Methods 11 | 4. Classes & Constructors 12 | 5. Access Modifiers and etc... 13 | 14 | ### Separate Solutions that are present in Exercises 15 | 16 | It seems that when the students have the solutions in place 17 | they do not think that hard how to write a peace of code. 18 | 19 | Consider moving the solutions on a separate page. 20 | 21 | ### Generic things to improve 22 | 23 | - [ ] Restructure course content and separate Collections if applicable into several lectures 24 | - [ ] Add more tasks to the lectures, students complain they don't have enough tasks 25 | - [ ] Resize images that are too big to fit the lecture so that I do not have to scroll to much when presenting the lecture 26 | 27 | ### Lecture 1 28 | 29 | - [ ] First task should be without scanner 30 | - [ ] Separate task for scanner 31 | - [ ] Explain comments & scanner 32 | 33 | ### Lecture 5 34 | 35 | - [ ] We haven't gone through methods and class names but we are having Recap of it. 36 | Maybe it would make sense to substitute it with Strings. Or just start OOP. 37 | 38 | - [ ] Homework solutions for `Task 1.4` on matrices 39 | 40 | ### Lecture 11 41 | 42 | - [ ] Remove the polymorphism example with the Bird and Airplane and give a more concrete example 43 | with vehicles, cars, trucks and motorcycles. Also find an appropriate image. 44 | 45 | - [ ] Add an example for abstract classes 46 | 47 | - [ ] Explain static and dynamic polymorphism 48 | 49 | ### Lecture 12 50 | 51 | - [ ] `Task 4` needs more clarification 52 | - [ ] add solutions for sub-tasks `3`, `4` and `5` 53 | 54 | 55 | ### Lecture 14 56 | 57 | - [x] Explain Buffered Writing/Reading 58 | - [ ] Explain Serializable 59 | - [ ] Examples for Reading files 60 | - [ ] ObjectSerializer explained with examples 61 | - [ ] Solutions for all tasks 62 | 63 | 64 | ### Lecture 15 Generics 65 | 66 | - [ ] tasks 67 | - [ ] further theory 68 | - [ ] lower bound super keyword and PECS reference 69 | - [ ] multiple generic parameters 70 | - [ ] difference between generic method and generic class 71 | 72 | # Feedback 73 | 74 | ### Lecture 5 75 | - [ ] Homework explanation is missing 76 | - [ ] The lecture has only 1 task 77 | 78 | 79 | -------------------------------------------------------------------------------- /src/lecture6/exercise/Car.java: -------------------------------------------------------------------------------- 1 | package lecture6.exercise; 2 | 3 | public class Car { 4 | 5 | String model; 6 | String color; 7 | int currentGear; 8 | int maxSpeed; 9 | int currentSpeed; 10 | 11 | Person owner; 12 | 13 | /** 14 | * Този метод моделира качването на предавка, като максималната възможна предавка е 5. 15 | * Всеки път когато се вдигне предавка скоростта се увеличава. 16 | */ 17 | void shiftUp() { 18 | if (currentGear < 5) { 19 | currentGear++; 20 | 21 | speedUp(); // увеличи скоростта 22 | } 23 | } 24 | 25 | /** 26 | * Този метод моделира смъкването на предавка, като минималната възможна предавка е 0. 27 | * При всяко смъкване на предавка се намалява скоростта. 28 | */ 29 | void shiftDown() { 30 | if (currentGear == 0) { 31 | return; // не дей да правиш нищо защото вече сме на нулева предавка. 32 | } 33 | 34 | currentGear--; 35 | speedDown(); // намали скоростта 36 | } 37 | 38 | /** 39 | * Този метод моделира намаляването на текущата скорост. При извикването на метода текущата скорост 40 | * се намалява с 10 до достигането на нулева скорост. 41 | */ 42 | void speedDown() { 43 | int nextSpeed = currentSpeed - 10; 44 | 45 | if (nextSpeed >= 0) { 46 | currentSpeed = nextSpeed; 47 | } 48 | } 49 | 50 | /** 51 | * Този метод моделира увеличаването на скоростта, като към текущата скорост добавя 10. 52 | * Ако сме на 0-ва предавка превключваме на 1-ва. 53 | */ 54 | void speedUp() { 55 | if (currentGear == 0) { 56 | currentGear = 1; // ако сме биле на нулева предавка, превключи на 1-ва. 57 | } 58 | 59 | int nextSpeed = currentSpeed + 10; 60 | 61 | if (nextSpeed < maxSpeed) { 62 | currentSpeed = nextSpeed; // запиши новата скорост 63 | } 64 | } 65 | 66 | /** 67 | * Този метод моделира спирането на колата, като за currentSpeed записва 0. 68 | * Aко сме на по висока предавка намаляме предавката всеки път докато стигнем 0-ва предавка. 69 | */ 70 | void stop() { 71 | for (int i = currentGear; i >= 0; i--) { // смъкни от текущата до нулева предавка 72 | shiftDown(); // смъкни предавка 73 | } 74 | 75 | currentSpeed = 0; // занули остатъчната скорост 76 | } 77 | } 78 | -------------------------------------------------------------------------------- /lectures/bg/Contents.md: -------------------------------------------------------------------------------- 1 | # ☕ Java Course 2 | 3 | 4 | ##### 🗺️ [Table of Contents](https://gist.github.com/NewestUser/cd205412a512b3a2e0ca171875415370) 5 | 6 | #### Lecture 1 - Primitive Types 7 | 8 | - [Exercises](01-introduction/Lecture1.md) 9 | 10 | - [Homework](01-introduction/Lecture1Homework.md) 11 | 12 | - [Homework Solutions](01-introduction/Lecture1HomeworkSolutions.md) 13 | 14 | #### Lecture 2 - if/else and Loops 15 | 16 | - [Exercises](./02-control-flow/Lecture2.md) 17 | 18 | - [Homework](./02-control-flow/Lecture2Homework.md) 19 | 20 | - [Homework Solutions](./02-control-flow/Lecture2HomeworkSolutions.md) 21 | 22 | #### Lecture 3 - Recap Primitive Types 23 | 24 | - [Recap](./03-recap/Lecture3.md) 25 | 26 | #### Lecture 4 - Arrays 27 | - [Exercises](./04-arrays/Lecture4.md) 28 | 29 | - [Homework](./04-arrays/Lecture4Homework.md) 30 | 31 | - [Homework Solutions](./04-arrays/Lecture4HomeworkSolutions.md) 32 | 33 | #### Lecture 5 - Two Dimensional Arrays 34 | 35 | - [Exercises](./05-2d-arrays/Lecture5.md) 36 | 37 | - [Homework](./05-2d-arrays/Lecture5Homework.md) 38 | 39 | - [Homework Solutions](./05-2d-arrays/Lecture5HomeworkSolutions.md) 40 | 41 | #### Lecture 6 - Introduction to Object Oriented Programming 42 | 43 | - [Exercises](./06-oop-introduction/Lecture6.md) 44 | 45 | - [Homework](./06-oop-introduction/Lecture6Homework.md) 46 | 47 | #### Lecture 7 - Strings & Constructors & OOP Exercises 48 | 49 | - [Exercises](./07-strings-constructors/Lecture7.md) 50 | 51 | - [Homework](./07-strings-constructors/Lecture7Homework.md) 52 | 53 | #### Lecture 8 - Access modifiers, final, static, packages 54 | 55 | - [Exercises](./08-access-modifiers/Lecture8.md) 56 | 57 | #### Lecture 9 - Inheritance 58 | 59 | - [Exercises](./09-inheritance/Lecture9.md) 60 | 61 | - [Homework](./09-inheritance/Lecture9Homework.md) 62 | 63 | - [Homework Solutions](./09-inheritance/Lecture9HomeworkSolutions.md) 64 | 65 | #### Lecture 10 - Inheritance Exercises and Theory 66 | 67 | - [Exercises](./10-inheritance-exercises/Lecture10.md) 68 | 69 | #### Lecture 11 - Abstraction, Interfaces and Polymorphism 70 | 71 | - [Exercises](./11-abstraction/Lecture11.md) 72 | 73 | #### Lecture 12 - Collections 74 | 75 | - [Exercises](./12-collections/Lecture12.md) 76 | 77 | #### Lecture 13 - Exceptions 78 | 79 | - [Exercises](./13-exceptions/Lecture13.md) 80 | 81 | #### Lecture 14 - Files & IO 82 | 83 | - [Exercises](./14-files-io/Lecture14.md) 84 | 85 | #### Lecture 15 - Generics & Boxing/Unboxing 86 | 87 | - [Exercises](./15-generics-boxing-unboxing) 88 | 89 | ### 📚 [Further Reading](../../FurtherReading.md) 90 | 91 | ### ![intellij-small-logo](../../assets/idea_cheat_sheet/idea_small_logo.png) [IntelliJ IDEA Cheat Sheet](../../IDEACheatSheet.md) 92 | -------------------------------------------------------------------------------- /src/lecture12/exercises/chickenbarn/Chicken.java: -------------------------------------------------------------------------------- 1 | package lecture12.exercises.chickenbarn; 2 | 3 | public class Chicken { 4 | 5 | private static final int DEATH_WEEK = 9; 6 | private static final int MIN_HATCH_WEEK = 2; 7 | private static final int MAX_HATCH_WEEK = 8; 8 | 9 | /* Статична променлива, която се използва в името на кокошката. 10 | * Всеки път, когато се създаде нова кокошка, тази променлива се увеличава с 1. 11 | */ 12 | private static int ID_SEQUENCE = 1; 13 | 14 | private final String name; 15 | 16 | private int age; 17 | 18 | /** 19 | * Създай нова кокошка назначавайки и служебно име и подадаената възраст. 20 | * 21 | * @param age възрастта на кокошката в седмици. 22 | */ 23 | public Chicken(int age) { 24 | this.name = getNextName(""); 25 | this.age = age; 26 | } 27 | 28 | /** 29 | * Конструктор създадващ новородена кокошка. Конструкторът приема името на кокошката, която е снесла 30 | * яйцето. На база това име ще се определи името на тази кокошка. 31 | * 32 | * @param chickenName името на кокошката снесла яйцето. 33 | */ 34 | public Chicken(String chickenName) { 35 | this.name = getNextName(chickenName + "/"); 36 | this.age = 0; 37 | } 38 | 39 | /** 40 | * Метод връщащ името на кокошката съставено от prefix + "Chicken" + ID, където ID е поредния 41 | * номер на кокошката. 42 | * 43 | * @param prefix текст, който да бъде използван пред името на кокошката. 44 | * @return ново име на кокошка. 45 | */ 46 | private String getNextName(String prefix) { 47 | return prefix + "Chicken" + ID_SEQUENCE++; 48 | } 49 | 50 | /** 51 | * Този метод проверява дали кокошката е навършила необходимата възраст за да умре. 52 | * 53 | * @return true ако е навършила преклонна възраст, false в противен случай. 54 | */ 55 | public boolean canDie() { 56 | return age >= DEATH_WEEK; 57 | } 58 | 59 | /** 60 | * Този метод връща яйце, ако кокошката е навършила зряла възраст и може да снася яйца. 61 | * Снесеното яйце има името на кокошката, която го е снесла. 62 | * 63 | * @return снесеното яйце или null ако кокошката не може да снася. 64 | */ 65 | public Egg hatchEgg() { 66 | if (age < MIN_HATCH_WEEK || age > MAX_HATCH_WEEK) { 67 | return null; 68 | } 69 | 70 | return new Egg(name); 71 | } 72 | 73 | /** 74 | * Този метод увеличава възрастта на кокошката с една седмица. 75 | */ 76 | public void ageByOneWeek() { 77 | this.age++; 78 | } 79 | 80 | @Override 81 | public String toString() { 82 | return "Chicken{" + 83 | "name='" + name + '\'' + 84 | '}'; 85 | } 86 | } 87 | -------------------------------------------------------------------------------- /src/lecture12/exercises/chickenbarn/Barn.java: -------------------------------------------------------------------------------- 1 | package lecture12.exercises.chickenbarn; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Iterator; 5 | import java.util.List; 6 | 7 | public class Barn { 8 | 9 | private List chickens; 10 | private List eggs; 11 | 12 | /** 13 | * Конструктор, който инициализира фермата с подадените през него кокошки. 14 | * Когато се създаде нова ферма, в нея няма яйца. 15 | * 16 | * @param chickens първоначалните кокошки във фермата. 17 | */ 18 | public Barn(List chickens) { 19 | this.chickens = chickens; 20 | this.eggs = new ArrayList<>(); 21 | } 22 | 23 | /** 24 | * Този метод еволюира фермата с определен брой седмици. 25 | * 26 | * @param weeks броя седмици, с които да бъде еволюирана фермата. 27 | * @return връща списъкът с кокошки след еволюцията. 28 | */ 29 | public List evolve(int weeks) { 30 | 31 | for (int week = 0; week < weeks; week++) { 32 | 33 | hatchEggs(); 34 | 35 | growChickens(); 36 | } 37 | 38 | return chickens; 39 | } 40 | 41 | /** 42 | * Този метод репрезентира, какво се случва през една седмица с яйцата. 43 | * Методът обикаля всички налични яйца, увеличава им възрастта с 1 седмица, 44 | * излюпва яйцата, които са годни и добавя излюпените кокошки в списъка с кокошки. 45 | */ 46 | private void hatchEggs() { 47 | Iterator iterator = eggs.iterator(); 48 | 49 | while (iterator.hasNext()) { 50 | 51 | Egg currentEgg = iterator.next(); 52 | 53 | currentEgg.ageByOneWeek(); 54 | Chicken newChicken = currentEgg.hatch(); 55 | 56 | if (newChicken != null) { 57 | chickens.add(newChicken); 58 | 59 | iterator.remove(); 60 | } 61 | 62 | } 63 | } 64 | 65 | /** 66 | * Този метод репрезентира, какво се случва през една седмица с кокошките. 67 | * Методът обикаля всички налични кокошки, увеличава им възрастта с 1 седмица 68 | * Премахва кокошките на преклонна възраст и снася яйца използвайки кокошките на зряла възраст, 69 | * като добавя излюпените яйца в списъка с яйца.. 70 | */ 71 | private void growChickens() { 72 | Iterator iterator = chickens.iterator(); 73 | 74 | while (iterator.hasNext()) { 75 | Chicken currentChicken = iterator.next(); 76 | 77 | currentChicken.ageByOneWeek(); 78 | 79 | if (currentChicken.canDie()) { 80 | iterator.remove(); 81 | } 82 | 83 | Egg egg = currentChicken.hatchEgg(); 84 | if (egg != null) { 85 | eggs.add(egg); 86 | } 87 | } 88 | 89 | } 90 | } 91 | -------------------------------------------------------------------------------- /src/lecture1/Lecture1.java: -------------------------------------------------------------------------------- 1 | package lecture1; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Lecture1 { 6 | 7 | public static void main(String[] args) { 8 | 9 | Scanner scanner = new Scanner(System.in); 10 | 11 | System.out.print("Enter °F: "); 12 | double fahrenheit = scanner.nextDouble(); 13 | 14 | double celsius = (fahrenheit - 32) * 5d / 9d; 15 | 16 | System.out.println(fahrenheit + "°F = " + celsius + "°C"); 17 | } 18 | 19 | /** 20 | * Въведете 2 различни целочислени числа от конзолата. Запишете тяхната сума, разлика, произведение, 21 | * остатък от деление и целочислено деление в отделни променливи и разпечатайте тези резултати в конзолата. 22 | * Опитайте същото с числа с плаваща запетая. 23 | */ 24 | private static void arithmeticOperations() { 25 | Scanner scanner = new Scanner(System.in); 26 | 27 | System.out.print("Enter first whole number: "); 28 | int firstWholeNumber = scanner.nextInt(); 29 | System.out.print("Enter second whole number: "); 30 | int secondWholeNumber = scanner.nextInt(); 31 | 32 | int wholeSum = firstWholeNumber + secondWholeNumber; 33 | int wholeDifference = firstWholeNumber - secondWholeNumber; 34 | int wholeMultiplication = firstWholeNumber * secondWholeNumber; 35 | int wholeQuotient = firstWholeNumber / secondWholeNumber; 36 | int wholeReminder = firstWholeNumber % secondWholeNumber; 37 | 38 | System.out.println("wholeSum = " + wholeSum); 39 | System.out.println("wholeDifference = " + wholeDifference); 40 | System.out.println("wholeMultiplication = " + wholeMultiplication); 41 | System.out.println("wholeQuotient = " + wholeQuotient); 42 | System.out.println("wholeReminder = " + wholeReminder); 43 | 44 | System.out.print("Enter first rational number: "); 45 | double firstRationalNumber = scanner.nextDouble(); 46 | System.out.print("Enter second rational number: "); 47 | double secondRationalNumber = scanner.nextDouble(); 48 | 49 | double rationalSum = firstRationalNumber + secondRationalNumber; 50 | double rationalDifference = firstRationalNumber - secondRationalNumber; 51 | double rationalMultiplication = firstRationalNumber * secondRationalNumber; 52 | double rationalQuotient = firstRationalNumber / secondRationalNumber; 53 | double rationalReminder = firstRationalNumber % secondRationalNumber; 54 | 55 | System.out.println("rationalSum = " + rationalSum); 56 | System.out.println("rationalDifference = " + rationalDifference); 57 | System.out.println("rationalMultiplication = " + rationalMultiplication); 58 | System.out.println("rationalQuotient = " + rationalQuotient); 59 | System.out.println("rationalReminder = " + rationalReminder); 60 | } 61 | 62 | } 63 | -------------------------------------------------------------------------------- /src/lecture10/homework/ShopDemo.java: -------------------------------------------------------------------------------- 1 | package lecture10.homework; 2 | 3 | 4 | import lecture10.homework.shop.PurchaseReceipt; 5 | import lecture10.homework.shop.Shop; 6 | import lecture10.homework.shop.TwoForOnePrice; 7 | 8 | public class ShopDemo { 9 | 10 | public static void main(String[] args) { 11 | 12 | Shop shop = new Shop(); 13 | 14 | shop.add("banana", 20, 2); 15 | 16 | PurchaseReceipt bananaRecipe = shop.buy("banana", 20); 17 | 18 | System.out.println(bananaRecipe); 19 | 20 | shop.add("chocolate", new TwoForOnePrice(10), 2); 21 | 22 | PurchaseReceipt chocolateRecipe = shop.buy("chocolate", 10, 2); 23 | 24 | System.out.println(chocolateRecipe); 25 | 26 | PurchaseReceipt firstBananaPurchase = shop.buy("banana", 20); 27 | PurchaseReceipt secondBananaPurchase = shop.buy("banana", 25); 28 | PurchaseReceipt thirdBananaPurchase = shop.buy("banana", 30); 29 | PurchaseReceipt fourthBananaPurchase = shop.buy("banana", 20); 30 | 31 | PurchaseReceipt firstApplePurchase = shop.buy("apple", 20); 32 | PurchaseReceipt fifthBananaPurchase = shop.buy("banana", 20); 33 | 34 | System.out.println("\nPurchased ==========\n"); 35 | System.out.println(firstBananaPurchase); 36 | System.out.println(secondBananaPurchase); 37 | System.out.println(thirdBananaPurchase); 38 | System.out.println(fourthBananaPurchase); 39 | 40 | System.out.println("\nNot purchased ==========\n"); 41 | System.out.println(firstApplePurchase); 42 | System.out.println(fifthBananaPurchase); 43 | 44 | System.out.println("\n==========\n"); 45 | 46 | shop.add("carrot", 10, 5); 47 | 48 | PurchaseReceipt firstCarrotPurchase = shop.buy("carrot", 10, 1); 49 | PurchaseReceipt secondCarrotPurchase = shop.buy("carrot", 10, 4); 50 | PurchaseReceipt thirdCarrotPurchase = shop.buy("carrot", 40, 4); 51 | 52 | System.out.print("Purchased ========== "); 53 | System.out.println(firstCarrotPurchase); 54 | System.out.print("Not purchased ========== "); 55 | System.out.println(secondCarrotPurchase); 56 | System.out.print("Purchased ========== "); 57 | System.out.println(thirdCarrotPurchase); 58 | 59 | System.out.println("\n==========\n"); 60 | 61 | shop.add("chocolate", new TwoForOnePrice(10), 2); 62 | 63 | PurchaseReceipt firstChocolatePromotion = shop.buy("chocolate", 10, 2); 64 | PurchaseReceipt secondChocolatePromotion = shop.buy("chocolate", 10, 2); 65 | 66 | System.out.println(firstChocolatePromotion); 67 | System.out.println(secondChocolatePromotion); 68 | 69 | System.out.println("\n==========\n"); 70 | 71 | shop.add("peanuts", new TwoForOnePrice(10), 2); 72 | shop.add("peanuts", new TwoForOnePrice(10), 2); 73 | 74 | PurchaseReceipt firstPeanutPromotion = shop.buy("peanuts", 10, 2); 75 | 76 | System.out.println(firstPeanutPromotion); 77 | System.out.println(shop.buy("peanuts", 15, 2)); 78 | System.out.println(shop.buy("peanuts", 5, 1)); 79 | } 80 | } 81 | -------------------------------------------------------------------------------- /FurtherReading.md: -------------------------------------------------------------------------------- 1 | # Further reading 2 | 3 | Споменатите материали по-долу са по-скоро препоръчилтени, а не задължителни. 4 | Не е задължително реда на четене/гледане на материалите да е този, в който те са описани. 5 | 6 | **ВАЖНО:** По време на четене на книгите фокуса да не е в/у това книгата да бъде прочетена от край до край. 7 | Следвайте съдържанието на книгата и се чувствайте свободни да пропускате глави/графи, които смятате за нерелевантни. 8 | Препоръчително е четененто да се извършва с конкретна цел (да науча тази тема/концепция, да попълня липсващи знания, 9 | да се запозная с нещо напълно ново). В следващите две видеа се засяга именно тази тема. Препоръчвам те да бъдат изгледани, 10 | преди останалите материали. 11 | 12 | - [How to Learn to Code - Best Resources, How to Choose a Project, and more!](https://www.youtube.com/watch?v=WKuNWrxuJ9g) 13 | 14 | - [How to use Cracking the Coding Interview Effectively](https://www.youtube.com/watch?v=xAxgzrj8zgU) 15 | 16 | ___ 17 | 18 | ### Prerequisite 19 | 20 | - [ ] **How computers process a program:** 21 | - [ ] [How CPU executes a program (video)](https://www.youtube.com/watch?v=XM4lGflQFvA) 22 | - [ ] [How computers calculate - ALU (video)](https://youtu.be/1I5ZMmrOfnA) 23 | - [ ] [Registers and RAM (video)](https://youtu.be/fpnE6UAfbtU) 24 | - [ ] [The Central Processing Unit (CPU) (video)](https://youtu.be/FZGugFqdr60) 25 | - [ ] [Instructions and Programs (video)](https://youtu.be/zltgXvg6r3k) 26 | 27 | ___ 28 | 29 | ### Fundamentals 30 | 31 | Материали засягащи основите на програмирането и добри практики. 32 | 33 | 34 | #### Books 35 | 36 | ##### [Head First Java by Kathy Sierra, Bert Bates](https://s3-ap-southeast-1.amazonaws.com/tv-prod/documents/5570-HeadFirstJava2ndEdition.pdf) 37 | 38 | ![head_first_java_book_cover](https://covers.oreillystatic.com/images/9780596009205/lrg.jpg) 39 | 40 | ##### [Effective Java by Joshua Bloch](https://kea.nu/files/textbooks/new/Effective%20Java%20%282017%2C%20Addison-Wesley%29.pdf) 41 | 42 | ![effective_java_book_cover](https://images-na.ssl-images-amazon.com/images/I/516yIUucShL._SX408_BO1,204,203,200_.jpg) 43 | 44 | ##### [Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin)](https://www.investigatii.md/uploads/resurse/Clean_Code.pdf) 45 | 46 | ![clean_code_book_cover](https://images-na.ssl-images-amazon.com/images/I/515iEcDr1GL._SX385_BO1,204,203,200_.jpg) 47 | 48 | ___ 49 | 50 | ### Interviews 51 | 52 | Материали подходящи за подготовка за интервю. 53 | 54 | 55 | #### Books 56 | 57 | ##### [Programming Interviews Exposed: Secrets to Landing Your Next Job]() 58 | 59 | ![programming_interviews_exposed_book_cover](https://images-na.ssl-images-amazon.com/images/I/51NuRyiuU2L._SX396_BO1,204,203,200_.jpg) 60 | 61 | #### Videos 62 | 63 | ##### [Example Coding/Engineering Interview](https://www.youtube.com/watch?v=XKu_SEDAykw) 64 | 65 | ___ 66 | 67 | ### CV Builders 68 | 69 | 70 | #### [CV Template builder](https://www.cv-template.com/en) 71 | 72 | #### [Canva](https://www.canva.com/create/resumes/) 73 | 74 | #### [resume.io](https://resume.io/) 75 | 76 | #### [Resume Coach](https://www.resumecoach.com) 77 | 78 | ___ 79 | 80 | ### Ultimate Resource 81 | 82 | Подробен списък с теми/концепции и ресурси за четене покриващи голяма част от сферата на програмирането. 83 | 84 | #### [Coding Interview University](https://github.com/jwasham/coding-interview-university) 85 | -------------------------------------------------------------------------------- /src/lecture10/homework/shop/Shop.java: -------------------------------------------------------------------------------- 1 | package lecture10.homework.shop; 2 | 3 | /** 4 | * Този клас моделира магазин. Един магазин може да бъде зареждан с продукти на определан цена и сопределно количество 5 | * и също така да продава вече заредени продукти. 6 | */ 7 | public class Shop { 8 | 9 | /** 10 | * В този масив пазим всички вече заредени продукти. 11 | */ 12 | private final ProductStorage[] inventory = new ProductStorage[1000]; 13 | 14 | /** 15 | * С този метод можем да зареждам продукт с определено име, фиксирана цена и количество 16 | * 17 | * @param name името на продукта. 18 | * @param price цената на продукта. 19 | * @param quantity количеството на продукта. 20 | * @return true ако успешно е зареден продукта, false в противен случай. 21 | */ 22 | public boolean add(String name, double price, int quantity) { 23 | 24 | return add(name, new Price(price), quantity); 25 | } 26 | 27 | /** 28 | * С този метод, аналогично на първия може да се зарежда даден продукт, с тази разлика че 29 | * е възможно да бъде използван за зареждане на продукти на промоционални цени. 30 | * 31 | * @param name име на продукта. 32 | * @param price цена на продукта. 33 | * @param quantity количество на продукта. 34 | * @return true ако успешно е зареден продукта, false в противен случай. 35 | */ 36 | public boolean add(String name, Price price, int quantity) { 37 | 38 | for (int i = 0; i < inventory.length; i++) { 39 | 40 | ProductStorage currentStorage = inventory[i]; 41 | 42 | if (currentStorage == null) { 43 | ProductStorage item = new ProductStorage(name, price, quantity); 44 | inventory[i] = item; 45 | 46 | return true; 47 | } else if (currentStorage.tryToIncreaseQuantity(name, price, quantity)) { 48 | 49 | return true; 50 | } 51 | } 52 | 53 | return false; 54 | } 55 | 56 | /** 57 | * С този метод може да бъде закупуван/продаван даден продукт. 58 | * 59 | * @param productQuery името на продукта, който клиента иска да закупи. 60 | * @param amount цената на продукта. 61 | * @param quantity количеството от продукта. 62 | * @return при успешно закупуване се връща {@link PurchaseReceipt} в противен случай null. 63 | */ 64 | public PurchaseReceipt buy(String productQuery, int amount, int quantity) { 65 | 66 | for (int i = 0; i < inventory.length; i++) { 67 | ProductStorage item = inventory[i]; 68 | 69 | if (item == null) { 70 | continue; 71 | } 72 | 73 | PurchaseReceipt recipe = item.tryToSell(productQuery, amount, quantity); 74 | 75 | if (item.isDepleted()) { 76 | inventory[i] = null; // избягваме Memory Leak 77 | } 78 | 79 | if (recipe != null) { 80 | 81 | return recipe; 82 | } 83 | } 84 | 85 | return null; 86 | } 87 | 88 | /** 89 | * Този метод, аналогично на предходния може да се закупува продукт с тази разлика че количеството винаги е 1. 90 | * 91 | * @param productQuery името на продукта, който клиента иска да закупи. 92 | * @param amount сумата пари, която клиента има налична. 93 | * @@return при успешно закупуване се връща {@link PurchaseReceipt} в противен случай null. 94 | */ 95 | public PurchaseReceipt buy(String productQuery, int amount) { 96 | 97 | return buy(productQuery, amount, 1); 98 | } 99 | 100 | } 101 | -------------------------------------------------------------------------------- /lectures/bg/06-oop-introduction/Lecture6Homework.md: -------------------------------------------------------------------------------- 1 | # Homework Lecture 6 2 | #java course# 3 | 4 | ## Introduction to Object Oriented Programming 5 | 6 | ### Task 1 7 | 8 | Създайте клас Computer, който представя компютър. Класът да има следните полета: 9 | 10 | - `year` – числова стойност, показваща годината на производство 11 | - `price` – числова стойност (не е задължително да е цяло число), показваща цената на компютъра 12 | - `isNotebook` – булева стойност – дали компютърът е преносим или не 13 | - `hardDiskMemory` – числова стойност за размера на хард диска 14 | - `freeMemory` – числова стойност, показваща размера на свободната памет 15 | - `operatingSystem` – текстово поле за операционната система на компютъра 16 | 17 | 18 | Класът да дефинира следните методи: 19 | 20 | - метод `void changeOperatingSystem(String newOperatingSystem)`, 21 | който сменя стойността на полето `operatingSystem` със стойността, подадена като параметър. 22 | - метод `void useMemory(double memory)`, който намалява 23 | свободната памет `freeMemory` със стойността, подадена като аргумент 24 | Ако стойността на аргумента е по-голяма от свободната памет, извежда съобщение `"Not enough free memory!"` 25 | 26 | Да се създаде клас `ComputerDemo`, с `main` метод. 27 | 28 | - В рамките на main метода да се създадат 2 обекта от тип `Computer`. 29 | - Да се зададат стойности на свойствата на всеки един от компютрите: 30 | - `year` 31 | - `price` 32 | - `hardDiskMemory` 33 | - `freeMemory` 34 | - `operationSystem` 35 | - Нека единият компютър да е лаптоп. 36 | - На единия от двата компютъра да се задели памет 100 (чрез метода `useMemory`) 37 | - На другия да се смени операционната система (чрез метода `changeOperationSystem`) 38 | - Да се изведат на екрана всички полета на двата компютъра 💻 39 | 40 |

Solution 👀 41 |

42 | 43 | ```java 44 | class Computer { 45 | 46 | int year; 47 | int price; 48 | boolean isNotebook; 49 | long hardDiskMemory; 50 | long freeMemory; 51 | String operatingSystem; 52 | 53 | void changeOperatingSystem(String newOperatingSystem) { 54 | operatingSystem = newOperatingSystem; 55 | } 56 | 57 | void useMemory(long memory) { 58 | if (freeMemory < memory) { 59 | System.out.println("Not enough memory!"); 60 | } else { 61 | freeMemory -= memory; 62 | } 63 | } 64 | } 65 | ``` 66 | 67 | ```java 68 | class ComputerDemo { 69 | 70 | public static void main(String[] args) { 71 | 72 | Computer laptop = new Computer(); 73 | 74 | laptop.operatingSystem = "Ubuntu 19.04"; 75 | laptop.freeMemory = 4096; 76 | laptop.hardDiskMemory = 131_072; 77 | laptop.year = 2014; 78 | laptop.price = 1000; 79 | laptop.isNotebook = true; 80 | 81 | Computer pc = new Computer(); 82 | 83 | pc.operatingSystem = "Windows 10"; 84 | pc.freeMemory = 8192; 85 | pc.hardDiskMemory = 525_288; 86 | pc.year = 2015; 87 | pc.price = 1500; 88 | pc.isNotebook = false; 89 | 90 | laptop.useMemory(1024); 91 | 92 | pc.changeOperatingSystem("Windows 7"); 93 | 94 | System.out.println("-----"); 95 | System.out.printf("Is Notebook %b\n", laptop.isNotebook); 96 | System.out.printf("Year: %d\n", laptop.year); 97 | System.out.printf("Price: %d\n", laptop.price); 98 | System.out.printf("OS: %s\n", laptop.operatingSystem); 99 | System.out.printf("Free Memory %d:\n", laptop.freeMemory); 100 | System.out.printf("HDD Memory: %d\n", laptop.hardDiskMemory); 101 | 102 | System.out.println("-----"); 103 | System.out.printf("Is Notebook %b\n", pc.isNotebook); 104 | System.out.printf("Year: %d\n", pc.year); 105 | System.out.printf("Price: %d\n", pc.price); 106 | System.out.printf("OS: %s\n", pc.operatingSystem); 107 | System.out.printf("Free Memory %d:\n", pc.freeMemory); 108 | System.out.printf("HDD Memory: %d\n", pc.hardDiskMemory); 109 | } 110 | } 111 | ``` 112 | 113 |

114 |
115 | -------------------------------------------------------------------------------- /src/lecture10/homework/shop/ProductStorage.java: -------------------------------------------------------------------------------- 1 | package lecture10.homework.shop; 2 | 3 | /** 4 | * Този клас репрезентира зареден продукт (инвентар) в магазина. Като се пази информация за това, 5 | * какво е името на продукта, на каква цена се продава и какво е наличното количество от този продукт. 6 | */ 7 | class ProductStorage { 8 | 9 | private final String name; 10 | private final Price price; 11 | private int quantity; 12 | 13 | /** 14 | * Конструктор чрез, който можем да създадем инвентар описваш цена и количество на един продукт. 15 | * 16 | * @param name името на продукта, който бива зареден в магазина. 17 | * @param price цената на продукта, която ще бъде използвана при продажба. 18 | * @param quantity количеството от продукта, което е заредено в магазина. 19 | */ 20 | ProductStorage(String name, Price price, int quantity) { 21 | this.name = name; 22 | this.price = price; 23 | this.quantity = quantity; 24 | } 25 | 26 | /** 27 | * Този метод се опитва да издаде касова бележка, ако параметрите, които са подадени са такива, че да 28 | * удовлетворяват продажбата на продукта. 29 | * 30 | * @param productQuery името на продукта, който клиента иска да закупи. 31 | * @param amount сумата която клиента има налична. 32 | * @param quantity количеството, което клиента иска да закупи. 33 | * @return при покриване на критерия за продажба се връща {@link PurchaseReceipt} с детайлите за продажбата, 34 | * в противен случай се връща null. 35 | */ 36 | PurchaseReceipt tryToSell(String productQuery, int amount, int quantity) { 37 | 38 | if (canBeBought(productQuery, amount, quantity)) { 39 | 40 | reduceQuantity(quantity); 41 | 42 | return new PurchaseReceipt(productQuery, price, quantity, amount); 43 | } 44 | 45 | return null; 46 | } 47 | 48 | /** 49 | * Този метод се опитва да увечличи количеството от даден продукт. 50 | * Той се използва, когато магазина иска да зареди наново продукт, който все още не е изчерпан. 51 | * 52 | * @param name името на продукта. 53 | * @param price цената на продукта. 54 | * @param quantity количеството което се зарежда в магазина. 55 | * @return true при успешно зареждане, false в противен случай. 56 | */ 57 | boolean tryToIncreaseQuantity(String name, Price price, int quantity) { 58 | 59 | if (isForProduct(name, price)) { 60 | increaseQuantity(quantity); 61 | return true; 62 | } 63 | 64 | return false; 65 | } 66 | 67 | /** 68 | * Този метод проверява дали е изчерпано количеството от този продукт. 69 | * 70 | * @return true когато е изчерпано, false в противен случай. 71 | */ 72 | boolean isDepleted() { 73 | return this.quantity == 0; 74 | } 75 | 76 | /** 77 | * Вътрешен метод, който проверява дали клиента иска да закупи продукт с това име, цена и количество. 78 | * 79 | * @param productQuery името на продукта, който клиента търси. 80 | * @param amount сумата пари, която клиента има налична. 81 | * @param quantity количеството, което иска да закпуи. 82 | * @return true при успешно закупуване, false в противен случай. 83 | */ 84 | private boolean canBeBought(String productQuery, int amount, int quantity) { 85 | 86 | return name.equals(productQuery) 87 | && this.price.canBePaid(amount, quantity); 88 | } 89 | 90 | /** 91 | * Вътрешен метод, който проверява дали името и цената са еднакви с тази на вече заредения продукт. 92 | * 93 | * @param name име на продукт, който ще бъде зареждан. 94 | * @param price цената на продукта, която ще бъде зареждана. 95 | * @return true при еднакво име и цена, false в противен случай. 96 | */ 97 | private boolean isForProduct(String name, Price price) { 98 | return this.name.equals(name) 99 | && this.price.equals(price); 100 | } 101 | 102 | /** 103 | * Този метод намалява количеството на заредения продукт. 104 | * 105 | * @param quantity количеството с което да се намали. 106 | */ 107 | private void reduceQuantity(int quantity) { 108 | this.quantity -= quantity; 109 | } 110 | 111 | /** 112 | * Този метод увеличава количеството на заредения продукт. 113 | * 114 | * @param quantity количеството с което да се увеличи. 115 | */ 116 | private void increaseQuantity(int quantity) { 117 | this.quantity += quantity; 118 | } 119 | } 120 | -------------------------------------------------------------------------------- /lectures/bg/02-control-flow/Lecture2Homework.md: -------------------------------------------------------------------------------- 1 | # Homework Lecture 2 2 | #java course# 3 | 4 | ## if/else and Loops 5 | 6 | ### Task 1 7 | 8 | ```text 9 | Да се изведат съобщения към потребителя и да се прочетат 2 числа от клавиатурата A и B 10 | (може да са с плаваща запетая – double). После да се прочете 3-то число C и да се провери 11 | дали то е м/у A и B. Да се изведе подходящо съобщение за това дали C е между A и B. 12 | 13 | Пример: 14 | 15 | Въведете A: 16 | 13.2 17 | Въведете B: 18 | 29.5 19 | Въведете C: 20 | 22.1 21 | 22 | Числото 22.1 е между 13.2 и 29.5 23 | ``` 24 | 25 |
Solution 👀 26 |

27 | 28 | ```java 29 | Scanner scanner = new Scanner(System.in); 30 | 31 | System.out.print("A = "); 32 | int a = scanner.nextInt(); 33 | System.out.print("B = "); 34 | int b = scanner.nextInt(); 35 | System.out.print("C = "); 36 | int c = scanner.nextInt(); 37 | 38 | if (c > a && c < b || c > b && c < a) { 39 | System.out.println("Number C=" + c + " is between Number A=" + a + " and Number B=" + b); 40 | } else { 41 | System.out.println("Number C=" + c + " is NOT between Number A=" + a + " and Number B=" + b); 42 | } 43 | ``` 44 | 45 |

46 |
47 | 48 | ### Task 2 49 | 50 | ```text 51 | Въведете 2 различни числа от конзолата и ги разпечатайте в нарастващ ред. 📈 52 | 53 | Пример: 54 | Потребителя въвежда 10 и 3 55 | Печатате 3 и 10 56 | 57 | Потребителя въвежда 3 и 10 58 | Печатате 3 и 10 59 | ``` 60 | 61 |
Solution 👀 62 |

63 | 64 | ```java 65 | Scanner scanner = new Scanner(System.in); 66 | 67 | System.out.print("Enter first number: "); 68 | int first = scanner.nextInt(); 69 | System.out.print("Enter second number: "); 70 | int second = scanner.nextInt(); 71 | 72 | int min; 73 | int max; 74 | 75 | if (first < second) { 76 | min = first; 77 | max = second; 78 | } else { 79 | min = second; 80 | max = first; 81 | } 82 | 83 | System.out.println(min); 84 | System.out.println(max); 85 | ``` 86 | 87 |

88 |
89 | 90 | ### Task 3 91 | 92 | ```text 93 | Въведете 3 различни числа от конзолата и ги разпечатайте в низходящ ред. 📉 94 | ``` 95 | 96 | ### Task 4 97 | 98 | ```text 99 | Въведете 2 променливи от клавиатурата – сума пари (число с плаваща запетая), 100 | дали съм здрав – булев тип. Съставете програма, която взема решения 101 | на базата на тези данни по следния начин: 102 | - ако съм болен няма да излизам 103 | - ако имам пари ще си купя лекарства 104 | - ако нямам – ще стоя вкъщи и ще пия чай 105 | - ако съм здрав изведете съобщение 106 | - ако имам по-малко от 10 лв ще отида на кафе и т.н 107 | 108 | Полученото решение покажете като съобщение в конзолата. 💵 109 | ``` 110 | 111 | ### Task 5 112 | 113 | ```text 114 | Да се изведат на екрана числата от 1 до 100. 💯 115 | ``` 116 | 117 | ### Task 6 118 | 119 | ```text 120 | Да се изведат на екрана числата от -20 до 50. 121 | ``` 122 | 123 | ### Task 7 124 | 125 | ```text 126 | Да се изведат на екрана всички нечетни числа от -10 до 10. 127 | ``` 128 | 129 | ### Task 8 130 | 131 | ```text 132 | Да се изведат на екрана числата от 10 до 1 в обратен ред. 133 | ``` 134 | 135 | ### Task 9 136 | 137 | ```text 138 | Да се въведат от потребителя 2 числа. 139 | И да се изведат на екрана всички числа от по-малкото до по-голямото. 140 | ``` 141 | 142 | ### Task 10 143 | 144 | ```text 145 | Да се прочете число от екрана(конзолата) и да се изведе сбора на всички числа между 1 и въведеното число. 146 | ``` 147 | 148 | ### Task 11 149 | 150 | ```text 151 | Започвайки от 3, да се изведат на екрана първите n числа които се делят на 3. 152 | Числата да са разделени със запетая. 153 | ``` 154 | 155 | ### Task 12 156 | 157 | ```text 158 | Въведете число от клавиатурата и определете дали е просто. 159 | Просто число е това което се дели САМО на 1 и на себе си. 160 | ``` 161 | 162 | ### Task 13 163 | 164 | ```text 165 | По зададено число n, да се изведат на екрана числа по следния начин 166 | (всяко въвеждане на n е ново пускане на програмата): 167 | 168 | Пример: 169 | 170 | Въведете n: 2 171 | 11 172 | 33 173 | 174 | Въведете n: 1 175 | 0 176 | 177 | Въведете n: 4 178 | 3333 179 | 5555 180 | 7777 181 | 9999 182 | 183 | Въведете n: 3 184 | 222 185 | 444 186 | 666 187 | ``` 188 | 189 | ### Task 14 190 | 191 | ```text 192 | Да се прочетат 2 числа от клавиатурата А и В. 193 | Да се изведат всички числа от А до В на степен 2 (разделени със запетая). 194 | Ако някое число е кратно на 3, да се изведе съобщение, 195 | че числото се пропуска - „skip 3“. 196 | Ако сумата от всички изведени числа (без пропуснатите) стане по-голяма 197 | от 200, да се прекрати извеждането. 198 | ``` 199 | -------------------------------------------------------------------------------- /lectures/bg/01-introduction/Lecture1Homework.md: -------------------------------------------------------------------------------- 1 | # Homework Lecture 1 2 | #java course# 3 | 4 | ## Primitive Types 5 | 6 | ### Task 1 7 | 8 | ```text 9 | Въведете 2 различни целочислени числа от конзолата. 10 | Запишете тяхната сума, разлика, произведение, остатък от деление и 11 | целочислено деление в отделни променливи и разпечатайте тези резултати 12 | в конзолата. Опитайте същото с числа с плаваща запетая. 13 | ``` 14 | 15 |
Solution 👀 16 |

17 | 18 | ```java 19 | Scanner scanner = new Scanner(System.in); 20 | 21 | System.out.print("Enter first whole number: "); 22 | int firstWholeNumber = scanner.nextInt(); 23 | System.out.print("Enter second whole number: "); 24 | int secondWholeNumber = scanner.nextInt(); 25 | 26 | int wholeSum = firstWholeNumber + secondWholeNumber; 27 | int wholeDifference = firstWholeNumber - secondWholeNumber; 28 | int wholeMultiplication = firstWholeNumber * secondWholeNumber; 29 | int wholeQuotient = firstWholeNumber / secondWholeNumber; 30 | int wholeReminder = firstWholeNumber % secondWholeNumber; 31 | 32 | System.out.println("wholeSum = " + wholeSum); 33 | System.out.println("wholeDifference = " + wholeDifference); 34 | System.out.println("wholeMultiplication = " + wholeMultiplication); 35 | System.out.println("wholeQuotient = " + wholeQuotient); 36 | System.out.println("wholeReminder = " + wholeReminder); 37 | 38 | System.out.print("Enter first rational number: "); 39 | double firstRationalNumber = scanner.nextDouble(); 40 | System.out.print("Enter second rational number: "); 41 | double secondRationalNumber = scanner.nextDouble(); 42 | 43 | double rationalSum = firstRationalNumber + secondRationalNumber; 44 | double rationalDifference = firstRationalNumber - secondRationalNumber; 45 | double rationalMultiplication = firstRationalNumber * secondRationalNumber; 46 | double rationalQuotient = firstRationalNumber / secondRationalNumber; 47 | double rationalReminder = firstRationalNumber % secondRationalNumber; 48 | 49 | System.out.println("rationalSum = " + rationalSum); 50 | System.out.println("rationalDifference = " + rationalDifference); 51 | System.out.println("rationalMultiplication = " + rationalMultiplication); 52 | System.out.println("rationalQuotient = " + rationalQuotient); 53 | System.out.println("rationalReminder = " + rationalReminder); 54 | ``` 55 | 56 |

57 |
58 | 59 | ### Task 2 60 | 61 | ```text 62 | Въведете 2 различни числа от конзолата и разменете стойностите им. 63 | Разпечатайте новите стойности. 64 | ``` 65 | 66 |
Solution 👀 67 |

68 | 69 | ###### Solution 1 (използвайки временна променлива `int tmp`) 70 | 71 | ```java 72 | Scanner scanner = new Scanner(System.in); 73 | 74 | System.out.print("Enter first number: "); 75 | int first = scanner.nextInt(); 76 | System.out.print("Enter second number: "); 77 | int second = scanner.nextInt(); 78 | 79 | int tmp = first; 80 | 81 | first = second; 82 | second = tmp; 83 | 84 | System.out.print("first number: " + first); 85 | System.out.print("second number: " + second); 86 | ``` 87 | 88 | ###### Solution 2 (без временна променлива) 89 | 90 | ```java 91 | Scanner scanner = new Scanner(System.in); 92 | 93 | System.out.print("Enter first number: "); 94 | int first = scanner.nextInt(); 95 | System.out.print("Enter second number: "); 96 | int second = scanner.nextInt(); 97 | 98 | first = first + second; 99 | 100 | second = first - second; 101 | first = first - second; 102 | 103 | System.out.print("first number: " + first); 104 | System.out.print("second number: " + second); 105 | ``` 106 | 107 |

108 |
109 | 110 | ### Task 3 111 | 112 | ```text 113 | Въведете 3 числа от клавиатурата а1, а2 и а3. 114 | Разменете стойностите им, така че а1 да има стойността на а2, 115 | а2 да има стойността на а3, а а3 да има старата стойност на а1. 116 | ``` 117 | 118 | ### Task 4 119 | 120 | ```text 121 | Напишете конвертор на градуси от Целзий във Фаренхайт. 122 | Въвеждате едно число от конзолата. Това число ще бъдат градусите в Целзий. 123 | На конзолата трябва да бъде изведено съобщение със съответните градуси, 124 | но трансформиране във Фаренхайт. 125 | 126 | подсказка: °C * 9/5 + 32 = °F 127 | където: °C е градуси в Целзий, а °F е градуси във Фаренхайт 128 | ``` 129 | 130 | ### Task 5 131 | 132 | ```text 133 | Напишете конвертор на градуси от Фаренхайт в Целзий. Въвеждате едно число от конзолата. 134 | Това число ще бъдат градусите във Фаренхайт. На конзолата трябва да бъде изведено 135 | съобщение със съответните градуси, но трансформиране във Целзий. 136 | 137 | подсказка: (°F – 32) * 5/9=°C 138 | където: °C е градуси в Целзий, а °F е градуси във Фаренхайт 139 | ``` 140 | -------------------------------------------------------------------------------- /assets/09-lecture/intellij_idea_logo.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | icon_IntelliJIDEA 5 | Created with Sketch. 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 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | -------------------------------------------------------------------------------- /lectures/bg/05-2d-arrays/Lecture5Homework.md: -------------------------------------------------------------------------------- 1 | # Homework Lecture 5 2 | #java course# 3 | 4 | ## Two Dimensional Arrays 🐫 5 | 6 | ### Task 1 7 | 8 | Да се напише програма която изисква от потребителя да въведе 9 | 2 числа n и m. След това да се построи матрица с размер n x m по следният 10 | начин (примерите са дадени за въведени n=4 и m=4). Няма ограничение n да бъде равно на m: 11 | 12 | #### 1.1 13 | 14 | ###### Пример: 15 | 16 | ``` 17 | { 1, 5, 9, 13 } 18 | { 2, 6, 10, 14 } 19 | { 3, 7, 11, 15 } 20 | { 4, 8, 12, 16 } 21 | ``` 22 | 23 |
Solution 👀 24 |

25 | 26 | ```java 27 | Scanner scanner = new Scanner(System.in); 28 | 29 | System.out.print("Въведете брой редове: "); 30 | int row = scanner.nextInt(); 31 | 32 | System.out.print("Въведете брой колони: "); 33 | int col = scanner.nextInt(); 34 | 35 | int[][] matrix = new int[row][col]; 36 | 37 | int counter = 1; 38 | 39 | for (int i = 0; i < col; i++) { 40 | for (int j = 0; j < row; j++) { 41 | matrix[j][i] = counter; 42 | counter++; 43 | } 44 | } 45 | 46 | for (int i = 0; i < row; i++) { 47 | System.out.print("[\t"); 48 | for (int j = 0; j < col; j++) { 49 | System.out.print(matrix[i][j] + "\t"); 50 | } 51 | System.out.print("]\n"); 52 | } 53 | ``` 54 | > Обхождаме първо колоните и после редовете. За това във външния `for` итерираме `col`, 55 | а във вътрешния итерираме `row` (обратно на това което правихме до сега) 56 | 57 |

58 |
59 | 60 | #### 1.2 61 | 62 | ###### Пример: 63 | 64 | ``` 65 | { 1, 8, 9, 16 } 66 | { 2, 7, 10, 15 } 67 | { 3, 6, 11, 14 } 68 | { 4, 5, 12, 13 } 69 | ``` 70 | 71 |
Solution 👀 72 |

73 | 74 | ###### solution 1 75 | 76 | ```java 77 | Scanner scanner = new Scanner(System.in); 78 | 79 | System.out.print("Въведете брой редове: "); 80 | int rowCount = scanner.nextInt(); 81 | 82 | System.out.print("Въведете брой колони: "); 83 | int colCount = scanner.nextInt(); 84 | 85 | int[][] matrix = new int[rowCount][colCount]; 86 | 87 | int counter = 1; 88 | 89 | for (int col = 0; col < colCount; col++) { 90 | 91 | if (col % 2 == 0) { 92 | 93 | for (int j = 0; j < rowCount; j++) { 94 | matrix[j][col] = counter; 95 | counter++; 96 | } 97 | } else { 98 | for (int row = rowCount - 1; row >= 0; row--) { 99 | matrix[row][col] = counter; 100 | counter++; 101 | } 102 | } 103 | } 104 | 105 | for (int i = 0; i < rowCount; i++) { 106 | System.out.print("[\t"); 107 | for (int j = 0; j < colCount; j++) { 108 | System.out.print(matrix[i][j] + "\t"); 109 | } 110 | System.out.print("]\n"); 111 | } 112 | ``` 113 | > В зависимост от това дали ще обходим четна или нечетна колона определяме, от къде 114 | да започнем да въртим вложения цикъл. В единия случай е от `0...rowCount`, 115 | а в другия от `rowCount...0` 116 | 117 | ###### solution 2 118 | 119 | ```java 120 | Scanner scanner = new Scanner(System.in); 121 | 122 | System.out.print("Въведете брой редове: "); 123 | int rowCount = scanner.nextInt(); 124 | 125 | System.out.print("Въведете брой колони: "); 126 | int colCount = scanner.nextInt(); 127 | 128 | int[][] matrix = new int[rowCount][colCount]; 129 | 130 | int counter = 1; 131 | 132 | for (int col = 0; col < colCount; col++) { 133 | for (int row = 0; row < rowCount; row++) { 134 | 135 | int currentRow = row; 136 | 137 | if (col % 2 != 0) { 138 | currentRow = rowCount - 1 - row; 139 | } 140 | 141 | matrix[currentRow][col] = counter; 142 | 143 | counter++; 144 | } 145 | } 146 | 147 | for (int i = 0; i < rowCount; i++) { 148 | System.out.print("[\t"); 149 | for (int j = 0; j < colCount; j++) { 150 | System.out.print(matrix[i][j] + "\t"); 151 | } 152 | System.out.print("]\n"); 153 | } 154 | ``` 155 | > В зависимост от това дали сме на четна/нечетна колона определяме индеска на реда, 156 | който трябва да достъпим 157 | 158 |

159 |
160 | 161 | #### 1.3.1 162 | 163 | ###### Пример: 164 | 165 | ``` 166 | { 1, 3, 6, 10 } 167 | { 2, 5, 9, 13 } 168 | { 4, 8, 12, 15 } 169 | { 7, 11, 14, 16 } 170 | ``` 171 | 172 | #### 1.3.2 173 | 174 | ###### Пример: 175 | 176 | ``` 177 | { 7, 11, 14, 16 } 178 | { 4, 8, 12, 15 } 179 | { 2, 5, 9, 13 } 180 | { 1, 3, 6, 10 } 181 | ``` 182 | 183 | #### 1.4 184 | 185 | ###### Пример: 186 | 187 | ``` 188 | { 1, 2, 3, 4 } 189 | { 12, 13, 14, 5 } 190 | { 11, 16, 15, 6 } 191 | { 10, 9, 8, 7 } 192 | ``` 193 | 194 | ### Task 2 195 | 196 | Да се завърти двумерен масив (за по-лесно квадратен с четен брой елементи – 4х4, 6х6 и т.н.) 197 | по часовниковата стрелка: 198 | Например за дадената матрица: 199 | 200 | ``` 201 | { 1 12 13 5 } 202 | { 6 17 8 4 } 203 | { 3 2 13 8 } 204 | { 0 14 5 2 } 205 | ``` 206 | След завъртането да се получи: 207 | ``` 208 | { 0 3 6 1 } 209 | { 14 2 17 12 } 210 | { 5 13 8 13 } 211 | { 2 8 4 5 } 212 | ``` 213 | -------------------------------------------------------------------------------- /src/lecture7/homework/bank/Bank.java: -------------------------------------------------------------------------------- 1 | package lecture7.homework.bank; 2 | 3 | public class Bank { 4 | 5 | /** 6 | * Минималната сума, необходима за създаване на акаунт. 7 | */ 8 | private static final int MIN_AMOUNT = 5; 9 | 10 | /** 11 | * Всички валути, които банката поддържа. 12 | */ 13 | private static final String[] SUPPORTED_CURRENCIES = {"EUR", "GBP", "BGN", "CAD"}; 14 | 15 | /** 16 | * Списъкът с акаунти, които банката е отворила. 17 | */ 18 | private Account[] accounts; 19 | 20 | /** 21 | * Конструкторът на класът {@link Bank}. 22 | * 23 | * @param capacity броят акаунти, които ще може да поддържа тази банка. 24 | */ 25 | public Bank(int capacity) { 26 | accounts = new Account[capacity]; 27 | } 28 | 29 | /** 30 | * Този метод цели да отвори нов акаунт на клиента. 31 | * За целта се проверяват входните параметри за акаунта дали са валидни. 32 | * При успешна валидация се създава нов акаунт, който бива записан в банката и в клиента. 33 | * 34 | * @param customer клиента, на който да ще бъде отворен новия акаунт. 35 | * @param initialAmount първоначалната вноска на акаунта. 36 | * @param currency валутата на акаунта. 37 | * @param accountType типът на акаунта. 38 | * @return true при успешно създаден акаунт, false в противен случай. 39 | */ 40 | public boolean addAccount(Customer customer, double initialAmount, String currency, String accountType) { 41 | 42 | if (initialAmount < MIN_AMOUNT) { // провери за минимална вноска 43 | return false; 44 | } 45 | 46 | if (customer.getAge() < 18){ 47 | return false; 48 | } 49 | 50 | boolean currencyIsSupported = false; // провери дали валутата е поддържана от банката 51 | for (String supportedCurrency : SUPPORTED_CURRENCIES) { 52 | 53 | if (supportedCurrency.equalsIgnoreCase(currency)) { 54 | currencyIsSupported = true; // успешно установхиме че валутата е поддържана от банката 55 | break; // прекрати цикъла, няма смисъл да обикаляме повече валути 56 | } 57 | } 58 | 59 | if (!currencyIsSupported) { 60 | return false; 61 | } 62 | 63 | // провери дали типът на акаунта е валиден 64 | if (!Account.CREDIT.equalsIgnoreCase(accountType) && !Account.DEBIT.equalsIgnoreCase(accountType)) { 65 | return false; 66 | } 67 | 68 | Account newCustomerAccount = new Account(currency.toUpperCase(), accountType.toUpperCase(), initialAmount); 69 | 70 | // добави акаунта в клиента 71 | customer.addAccount(newCustomerAccount); 72 | 73 | // добави акаунта в банката 74 | addAccountToBank(newCustomerAccount); 75 | 76 | return true; 77 | } 78 | 79 | /** 80 | * Вътрешен метод, който е видим само за банката. Този метод добавя вече създадения акаунт 81 | * в масива с акаунти на банката. 82 | * 83 | * @param account акаунта, който трябва да бъде записан. 84 | * @return true при успешно записване, false в противен случай. 85 | */ 86 | private boolean addAccountToBank(Account account) { 87 | 88 | for (int i = 0; i < accounts.length; i++) { 89 | if (accounts[i] == null) { 90 | accounts[i] = account; 91 | return true; 92 | } 93 | } 94 | 95 | return false; 96 | } 97 | 98 | /** 99 | * Връща общия брой пари от всички създадени акаунти с определена валута. 100 | * 101 | * @param currency валутата за която да бъдат изчислени сумата пари. 102 | * @return общия брой пари в дадената валута. 103 | */ 104 | public double getTotalMoney(String currency) { 105 | int total = 0; 106 | 107 | for (Account account : accounts) { // обиколи всички акаунти 108 | if (account == null) { 109 | continue; // от тях вземи само тези, които са отворени 110 | } 111 | 112 | if (account.isInCurrency(currency)) { 113 | total += account.getBalance(); 114 | } 115 | } 116 | 117 | return total; 118 | } 119 | 120 | /** 121 | * Метод, който премахва вече отворен акаунт от банката и от клиента. 122 | * 123 | * @param customer клиента, на който да бъде премахнат акаунта. 124 | * @param accountCurrency валутата на акаунта, който да бъде затворен. 125 | * @param accountType типът на акаунта, който да бъде затворен. 126 | * @return true при успешно премахване на акаунт с определена валута и тип, false в противен случай. 127 | */ 128 | public boolean removeAccount(Customer customer, String accountCurrency, String accountType) { 129 | 130 | // премахни акаунта от клиента 131 | boolean accountIsRemoved = customer.removeAccount(accountCurrency, accountType); 132 | 133 | if (!accountIsRemoved) { 134 | return false; 135 | } 136 | 137 | // обиколи всички акаунти в банката 138 | for (int i = 0; i < accounts.length; i++) { 139 | Account account = accounts[i]; 140 | 141 | if (account.hasCurrencyAndType(accountCurrency, accountType)) { 142 | accounts[i] = null; // премахни акаунта от банката 143 | 144 | return true; 145 | } 146 | } 147 | 148 | return false; 149 | } 150 | } 151 | -------------------------------------------------------------------------------- /lectures/bg/01-introduction/Lecture1HomeworkSolutions.md: -------------------------------------------------------------------------------- 1 | # 👀 Homework Solutions Lecture 1 2 | #java course# 3 | 4 | ## Primitive Types 5 | 6 | ### Task 1 7 | 8 | ```text 9 | Въведете 2 различни целочислени числа от конзолата. 10 | Запишете тяхната сума, разлика, произведение, остатък от деление и 11 | целочислено деление в отделни променливи и разпечатайте тези резултати 12 | в конзолата. Опитайте същото с числа с плаваща запетая. 13 | ``` 14 | 15 |
Solution 👀 16 |

17 | 18 | ```java 19 | Scanner scanner = new Scanner(System.in); 20 | 21 | System.out.print("Enter first whole number: "); 22 | int firstWholeNumber = scanner.nextInt(); 23 | System.out.print("Enter second whole number: "); 24 | int secondWholeNumber = scanner.nextInt(); 25 | 26 | int wholeSum = firstWholeNumber + secondWholeNumber; 27 | int wholeDifference = firstWholeNumber - secondWholeNumber; 28 | int wholeMultiplication = firstWholeNumber * secondWholeNumber; 29 | int wholeQuotient = firstWholeNumber / secondWholeNumber; 30 | int wholeReminder = firstWholeNumber % secondWholeNumber; 31 | 32 | System.out.println("wholeSum = " + wholeSum); 33 | System.out.println("wholeDifference = " + wholeDifference); 34 | System.out.println("wholeMultiplication = " + wholeMultiplication); 35 | System.out.println("wholeQuotient = " + wholeQuotient); 36 | System.out.println("wholeReminder = " + wholeReminder); 37 | 38 | System.out.print("Enter first rational number: "); 39 | double firstRationalNumber = scanner.nextDouble(); 40 | System.out.print("Enter second rational number: "); 41 | double secondRationalNumber = scanner.nextDouble(); 42 | 43 | double rationalSum = firstRationalNumber + secondRationalNumber; 44 | double rationalDifference = firstRationalNumber - secondRationalNumber; 45 | double rationalMultiplication = firstRationalNumber * secondRationalNumber; 46 | double rationalQuotient = firstRationalNumber / secondRationalNumber; 47 | double rationalReminder = firstRationalNumber % secondRationalNumber; 48 | 49 | System.out.println("rationalSum = " + rationalSum); 50 | System.out.println("rationalDifference = " + rationalDifference); 51 | System.out.println("rationalMultiplication = " + rationalMultiplication); 52 | System.out.println("rationalQuotient = " + rationalQuotient); 53 | System.out.println("rationalReminder = " + rationalReminder); 54 | ``` 55 | 56 |

57 |
58 | 59 | ### Task 2 60 | 61 | ```text 62 | Въведете 2 различни числа от конзолата и разменете стойностите им. 63 | Разпечатайте новите стойности. 64 | ``` 65 | 66 |
Solution 👀 67 |

68 | 69 | ###### Solution 1 (използвайки временна променлива `int tmp`) 70 | 71 | ```java 72 | Scanner scanner = new Scanner(System.in); 73 | 74 | System.out.print("Enter first number: "); 75 | int first = scanner.nextInt(); 76 | System.out.print("Enter second number: "); 77 | int second = scanner.nextInt(); 78 | 79 | int tmp = first; 80 | 81 | first = second; 82 | second = tmp; 83 | 84 | System.out.print("first number: " + first); 85 | System.out.print("second number: " + second); 86 | ``` 87 | 88 | ###### Solution 2 (без временна променлива) 89 | 90 | ```java 91 | Scanner scanner = new Scanner(System.in); 92 | 93 | System.out.print("Enter first number: "); 94 | int first = scanner.nextInt(); 95 | System.out.print("Enter second number: "); 96 | int second = scanner.nextInt(); 97 | 98 | first = first + second; 99 | 100 | second = first - second; 101 | first = first - second; 102 | 103 | System.out.print("first number: " + first); 104 | System.out.print("second number: " + second); 105 | ``` 106 | 107 |

108 |
109 | 110 | ### Task 3 111 | 112 | ```text 113 | Въведете 3 числа от клавиатурата а1, а2 и а3. 114 | Разменете стойностите им, така че а1 да има стойността на а2, 115 | а2 да има стойността на а3, а а3 да има старата стойност на а1. 116 | ``` 117 | 118 |
Solution 👀 119 |

120 | 121 | ```java 122 | Scanner scanner = new Scanner(System.in); 123 | 124 | System.out.print("a1 = "); 125 | int a1 = scanner.nextInt(); 126 | System.out.print("a2 = "); 127 | int a2 = scanner.nextInt(); 128 | System.out.print("a3 = "); 129 | int a3 = scanner.nextInt(); 130 | 131 | int tmp = a1; 132 | 133 | a1 = a2; 134 | a2 = a3; 135 | a3 = tmp; 136 | 137 | System.out.print("a1 = " + a1); 138 | System.out.print("a2 = " + a2); 139 | System.out.print("a3 = " + a3); 140 | ``` 141 | 142 |

143 |
144 | 145 | ### Task 4 146 | 147 | ```text 148 | Напишете конвертор на градуси от Целзий във Фаренхайт. 149 | Въвеждате едно число от конзолата. Това число ще бъдат градусите в Целзий. 150 | На конзолата трябва да бъде изведено съобщение със съответните градуси, 151 | но трансформиране във Фаренхайт. 152 | 153 | подсказка: °C * 9/5 + 32 = °F 154 | където: °C е градуси в Целзий, а °F е градуси във Фаренхайт 155 | ``` 156 | 157 |
Solution 👀 158 |

159 | 160 | ```java 161 | Scanner scanner = new Scanner(System.in); 162 | 163 | System.out.print("Enter °C: "); 164 | double celsius = scanner.nextDouble(); 165 | 166 | double fahrenheit = celsius * 9d / 5d + 32; 167 | 168 | System.out.println(celsius + "°C = " + fahrenheit + "°F"); 169 | ``` 170 | 171 |

172 |
173 | 174 | ### Task 5 175 | 176 | ```text 177 | Напишете конвертор на градуси от Фаренхайт в Целзий. Въвеждате едно число от конзолата. 178 | Това число ще бъдат градусите във Фаренхайт. На конзолата трябва да бъде изведено 179 | съобщение със съответните градуси, но трансформиране във Целзий. 180 | 181 | подсказка: (°F – 32) * 5/9=°C 182 | където: °C е градуси в Целзий, а °F е градуси във Фаренхайт 183 | ``` 184 | 185 |
Solution 👀 186 |

187 | 188 | ```java 189 | Scanner scanner = new Scanner(System.in); 190 | 191 | System.out.print("Enter °F: "); 192 | double fahrenheit = scanner.nextDouble(); 193 | 194 | double celsius = (fahrenheit - 32) * 5d / 9d; 195 | 196 | System.out.println(fahrenheit + "°F = " + celsius + "°C"); 197 | ``` 198 | 199 |

200 |
-------------------------------------------------------------------------------- /src/lecture3/Lecture3.java: -------------------------------------------------------------------------------- 1 | package lecture3; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Lecture3 { 6 | 7 | public static void main(String[] args) { 8 | 9 | Scanner scanner = new Scanner(System.in); 10 | 11 | System.out.print("Enter n: "); 12 | int n = scanner.nextInt(); 13 | 14 | int[] array = {5, 6, 45, 99, 13, 5, 6}; 15 | 16 | if (n > array.length || n <= 0) { 17 | System.out.println("n is not within the range of the array"); 18 | return; 19 | } 20 | 21 | boolean areElementsEqual = true; 22 | int endIndex = n - 1; 23 | 24 | int[] equalElements = new int[n]; 25 | int[] differentElements = new int[2]; 26 | 27 | for (int i = 0, j = array.length - n; i < n; i++, j++) { 28 | 29 | if (array[i] == array[j]) { 30 | equalElements[i] = array[i]; 31 | 32 | } else { 33 | endIndex = i - 1; 34 | 35 | differentElements[0] = array[i]; 36 | differentElements[1] = array[j]; 37 | 38 | areElementsEqual = false; 39 | break; 40 | } 41 | } 42 | 43 | System.out.print(areElementsEqual + " "); 44 | for (int i = 0; i <= endIndex; i++) { 45 | System.out.print(equalElements[i] + ", "); 46 | } 47 | 48 | if (!areElementsEqual) { 49 | System.out.print(differentElements[0] + ", "); 50 | System.out.print(differentElements[1]); 51 | } 52 | } 53 | 54 | /** 55 | * Sum all the numbers between 1 and 100 but omit all the numbers between 51 and 74. 56 | */ 57 | private static void sumFrom1To100WithExclusions() { 58 | int sum = 0; 59 | 60 | for (int i = 1; i <= 100; i++) { 61 | if (i > 51 && i < 74) { 62 | continue; 63 | } 64 | 65 | sum += i; 66 | } 67 | 68 | System.out.println("sum = " + sum); 69 | } 70 | 71 | 72 | /** 73 | * Task 3: 74 | * • Calculate factorial of a number, where the numer is entered by the user 75 | * • Hint: n! = 1 * 2 * 3 ... (n - 2) * (n - 1) * n; 76 | */ 77 | private static void factorialOfN() { 78 | int n = 5; 79 | 80 | int factorial = 1; 81 | for (int i = 1; i <= n; i++) { 82 | 83 | factorial *= i; 84 | } 85 | 86 | System.out.println(n + "! = " + factorial); 87 | } 88 | 89 | /** 90 | * Task 4: 91 | * • Calculate the sum of the first n numers of the Fibonacci sequence: 92 | * • Hint: F = 0 + 1 + 1 + 2 + 3 + 5 + 8 + ... 93 | */ 94 | private static void fibonacciSum() { 95 | int n = 13; 96 | 97 | int sum = 0; 98 | 99 | int previous = 0; 100 | int current = 1; 101 | 102 | for (int i = 0; i < n; i++) { 103 | 104 | System.out.print(previous + ", "); 105 | 106 | sum += previous; 107 | int tmp = previous; 108 | previous = current; 109 | 110 | current = tmp + current; 111 | } 112 | 113 | System.out.println("\nsum fibonacci(" + n + ") = " + sum); 114 | } 115 | 116 | /** 117 | * Task 5: 118 | * • Calculate the following for user specified n: 119 | * (1!) / (1^1) + (2!) / (2^2) + ... + (n!) / (n^n) 120 | */ 121 | private static void factorialOfNDividedByPowerOfN() { 122 | int n = 10; 123 | 124 | double sum = 0; 125 | 126 | for (int i = 1; i <= n; i++) { 127 | 128 | double factorial = 1; 129 | for (int j = 1; j <= i; j++) { 130 | factorial *= j; 131 | } 132 | 133 | double power = i; 134 | for (int j = 2; j <= i; j++) { 135 | power *= i; 136 | } 137 | 138 | sum += factorial / power; 139 | } 140 | 141 | System.out.println(sum); 142 | } 143 | 144 | /** 145 | * * 146 | * * * 147 | * * * * 148 | */ 149 | private static void printTriangle() { 150 | int rows = 4; 151 | 152 | for (int i = 0; i < rows; i++) { 153 | 154 | for (int j = rows; j >= i; j--) { 155 | System.out.print(" "); 156 | } 157 | 158 | for (int j = 0; j < i; j++) { 159 | System.out.print("* "); 160 | } 161 | 162 | System.out.print("\n"); 163 | } 164 | } 165 | 166 | 167 | /** 168 | * Additional Task: 169 | *

170 | * You are given an array of numbers and a number N. If the group of N numbers at the start and end of 171 | * the array are the same return true + the equal characters, separated by comma. If they are not the 172 | * same, return false + the first pair of characters that is different. You may assume that n is in the 173 | * range 1..nums.length inclusive. 174 | *

175 | * Example: 176 | * With numbers {5, 6, 45, 99, 13, 5, 6} and N = 3 you should output the following: 177 | *

178 | * Result: 179 | * false 5,13 180 | *

181 | * Explanation: 182 | * We are comparing the first 3 and the last 3 numbers, but 5 and 13 are different. 183 | */ 184 | private static void printFrondAndBackArrayElements() { 185 | int n = 2; 186 | 187 | int[] array = {5, 6, 45, 99, 13, 5, 6}; 188 | 189 | if (n > array.length || n <= 0) { 190 | System.out.println("n is not within the range of the array"); 191 | return; 192 | } 193 | 194 | 195 | boolean areElementsEqual = true; 196 | int endIndex = n - 1; 197 | 198 | int[] equalElements = new int[n]; 199 | int[] differentElements = new int[2]; 200 | 201 | for (int i = 0, j = array.length - n; i < n; i++, j++) { 202 | 203 | if (array[i] == array[j]) { 204 | equalElements[i] = array[i]; 205 | 206 | } else { 207 | endIndex = i - 1; 208 | 209 | differentElements[0] = array[i]; 210 | differentElements[1] = array[j]; 211 | 212 | areElementsEqual = false; 213 | break; 214 | } 215 | } 216 | 217 | System.out.print(areElementsEqual + " "); 218 | for (int i = 0; i <= endIndex; i++) { 219 | System.out.print(equalElements[i] + ", "); 220 | } 221 | 222 | if (!areElementsEqual) { 223 | System.out.print(differentElements[0] + ", "); 224 | System.out.print(differentElements[1]); 225 | } 226 | } 227 | } 228 | 229 | 230 | 231 | -------------------------------------------------------------------------------- /lectures/bg/05-2d-arrays/Lecture5.md: -------------------------------------------------------------------------------- 1 | # Lecture 5 2 | #java course# 3 | 4 | ## Recap 5 | 6 | ###### variable names 7 | - имената на променливите започват с малка буква, като всяка следваща дума е с главна (camel case) 8 | 9 | - пример 10 | ```java 11 | int myVariable; 12 | ``` 13 | 14 | ###### method names 15 | - имената на методите започват с малка буква, като всяка следваща дума е с главна (camel case) 16 | 17 | - пример 18 | ```java 19 | void myMethod() { 20 | ... 21 | } 22 | ``` 23 | 24 | ###### class names 25 | - имената на класовете започват с главна буква, както и всяка следваща дума (upper case) 26 | 27 | - пример 28 | ```java 29 | class MyClass { 30 | ... 31 | } 32 | ``` 33 | 34 | ###### null value 35 | - референтните типове (reference types) могат да бъдат `null` 36 | 37 | - пример 38 | 39 | ```java 40 | int[] array = null; 41 | 42 | Scanner scanner = null; 43 | 44 | String foo = null; 45 | ``` 46 | 47 | ##### Formatting 48 | 49 | - `%d` - цели числа (**int**, **long**) 50 | - `%f` - числа с плаваща запетая (**float**, **double**) 51 | - `%.2f` - закръгляне на числа до 2-рия знак (**float**, **double**) 52 | - `%s` - текст (**String**) 53 | - `%S` - текст с главни букви (**String**) 54 | 55 | - пример 56 | ```java 57 | // Днес е Май 2019 и часът е 21.30 58 | System.out.printf("Днес е %s %d и часът е %.2f", "Май", 2019, 21.3); 59 | ``` 60 | 61 | 62 | |Format Specifier |Data Type |Output | 63 | |------------------|--------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------| 64 | |%a |floating point (except BigDecimal) |Returns Hex output of floating point number. | 65 | |%b |Any type |"true" if non-null, "false" if null | 66 | |%c |character |Unicode character | 67 | |%d |integer (incl. byte, short, int, long, bigint) |Decimal Integer | 68 | |%e |floating point |decimal number in scientific notation | 69 | |%f |floating point |decimal number | 70 | |%g |floating point |decimal number, possibly in scientific notation depending on the precision and value. | 71 | |%h |any type |Hex String of value from hashCode() method. | 72 | |%n |none |Platform-specific line separator. | 73 | |%o |integer (incl. byte, short, int, long, bigint) |Octal number | 74 | |%s |any type |String value | 75 | |%t |Date/Time (incl. long, Calendar, Date and TemporalAccessor) |%t is the prefix for Date/Time conversions. More formatting flags are needed after this. See Date/Time conversion below. | 76 | |%x |integer (incl. byte, short, int, long, bigint) |Hex string. | 77 | 78 | 79 | ##### Big O notation 🧮 80 | 81 | Big O notation е математическа нотация, която описва ограничаващото поведение на дадена функция, 82 | когато аргументът се стреми към определена стойност или безкрайност. 83 | 84 | [Time Complexity Chart](https://adrianmejia.com/images/big-o-running-time-complexity.png) 85 | 86 | [Big O Notation Cheat Sheet](https://cooervo.github.io/Algorithms-DataStructures-BigONotation/index.html) 87 | 88 | ###### O(1) constant time (константно време) 89 | 90 | - пример 91 | ```java 92 | int a = 10; 93 | int b = 20; 94 | int c = a * b; 95 | ``` 96 | 97 | ###### O(n) linear time (линейно време) 98 | 99 | - пример 100 | ```java 101 | int n = 10; 102 | 103 | int sum = 0; 104 | for (int i = 0; i < n; i++){ 105 | sum += i; 106 | } 107 | ``` 108 | 109 | ###### O(n^2) polynomial time (полиномно време) 110 | 111 | - пример 112 | ```java 113 | int n = 10; 114 | 115 | int sum = 0; 116 | for (int i = 0; i < n; i++){ 117 | for (int j =0; j < n; j++){ 118 | sum += j; 119 | } 120 | } 121 | ``` 122 | 123 | > ℹ️ За повече информация относно **Big O Notation** изгледайте това 124 | [youtube видео](https://www.youtube.com/watch?v=v4cd1O4zkGw) и това 125 | [youtube видео](https://www.youtube.com/watch?v=D6xkbGLQesk). 126 | 127 | ## Two Dimensional Arrays Exercises 🐫 128 | 129 | ### Task 1 130 | 131 | Създайте двумерен масив с 2 реда и 3 колони. 132 | Задайте стойност на клетка в ред 1-ви и колкона 2-ра. 133 | Принтирайте двумерния масив. 134 | 135 |

Solution 👀 136 |

137 | 138 | ```java 139 | int[][] matrix = new int[2][3]; 140 | 141 | matrix[0][1] = 555; 142 | 143 | for (int i = 0; i < matrix.length; i++) { 144 | System.out.print("[\t"); 145 | 146 | for (int j = 0; j < matrix[i].length; j++) { 147 | System.out.print(matrix[i][j] + "\t"); 148 | } 149 | 150 | System.out.println("]\t"); 151 | } 152 | ``` 153 | 154 |

155 |
156 | -------------------------------------------------------------------------------- /lectures/bg/04-arrays/Lecture4.md: -------------------------------------------------------------------------------- 1 | # Lecture 4 2 | #java course# 3 | 4 | ## Arrays Exercises 🐪 5 | 6 | ### Task 1 7 | 8 | ```text 9 | Създайте масив с 10 елемента. 10 | Запишете стойности на първите 3 елемента. 11 | Принтирайте втория елемент. 12 | Умножете третия елемент със 2 и го принтирайте. 13 | ``` 14 | 15 |
Solution 👀 16 |

17 | 18 | ```java 19 | int[] array = new int[10]; 20 | 21 | array[0] = 3; 22 | array[1] = 5; 23 | array[2] = 7; 24 | 25 | System.out.println("array[1] = " + array[1]); 26 | 27 | array[2] = 2 * array[2]; 28 | 29 | System.out.println("array[2] = " + array[2]); 30 | ``` 31 | 32 |

33 |
34 | 35 | ### Task 2 36 | 37 | ```text 38 | Създайте масив с дробни числа и принтирайте сойностите на масива. 39 | ``` 40 | 41 |
Solution 👀 42 |

43 | 44 | ```java 45 | double[] array = new double[]{2.5, 3, 5, 8, -12.9, 7.0}; 46 | 47 | for (int i = 0; i < array.length; i++) { 48 | System.out.print(array[i] + " "); 49 | } 50 | ``` 51 | 52 |

53 |
54 | 55 | ### Task 3 56 | 57 | ```text 58 | Запишете 10 числа от клавиатурата в масив. И после ги принтирайте. 59 | ``` 60 | 61 |
Solution 👀 62 |

63 | 64 | ```java 65 | Scanner scanner = new Scanner(System.in); 66 | 67 | int[] array = new int[10]; 68 | 69 | System.out.println("Enter 10 numbers:"); 70 | for (int i = 0; i < array.length; i++) { 71 | System.out.print("array[" + i + "] = "); 72 | array[i] = scanner.nextInt(); 73 | } 74 | 75 | System.out.println("You entered:"); 76 | for (int i = 0; i < array.length; i++) { 77 | System.out.println("array[" + i + "] = " + array[i]); 78 | } 79 | ``` 80 | 81 |

82 |
83 | 84 | ### Task 4 85 | 86 | ```text 87 | Създайте масив с големина зададена от потребителя. 88 | Въведете стойностите на масива от конзолата. 89 | Намерете най-голямото въведено число. 90 | Принтирайте най-голямото число. 91 | ``` 92 | 93 |
Solution 👀 94 |

95 | 96 | ```java 97 | Scanner scanner = new Scanner(System.in); 98 | System.out.print("Enter array size: "); 99 | 100 | int size = scanner.nextInt(); 101 | 102 | int[] array = new int[size]; 103 | 104 | System.out.println("Enter " + size + " numbers:"); 105 | for (int i = 0; i < array.length; i++) { 106 | System.out.print("array[" + i + "] = "); 107 | array[i] = scanner.nextInt(); 108 | } 109 | 110 | int max = array[0]; 111 | 112 | for (int i = 0; i < array.length; i++) { 113 | if (max < array[i]) { 114 | max = array[i]; 115 | } 116 | } 117 | 118 | System.out.println("max = " + max); 119 | ``` 120 | 121 |

122 |
123 | 124 | ### Task 5 125 | 126 | ```text 127 | Инвертирайте даден масив използвайки 2 подхода: 128 | - Използвайки втори масив 129 | - Без да използвате втори масив 130 | ``` 131 | 132 |
Solution 👀 133 |

134 | 135 | ###### Solution 1 136 | 137 | ```java 138 | int[] array = new int[]{1, 2, 3, 4, 5}; 139 | int[] inverted = new int[array.length]; 140 | 141 | for (int i = 0, j = array.length - 1; i < array.length; i++, j--) { 142 | inverted[i] = array[j]; 143 | } 144 | 145 | for (int i = 0; i < inverted.length; i++) { 146 | System.out.print(inverted[i] + " "); 147 | } 148 | ``` 149 | 150 | ###### Solution 2 151 | 152 | ```java 153 | int[] array = new int[]{1, 2, 3, 4, 5}; 154 | 155 | for (int i = 0, j = array.length - 1; i < j; i++, j--) { 156 | int tmp = array[i]; 157 | 158 | array[i] = array[j]; 159 | array[j] = tmp; 160 | } 161 | 162 | for (int i = 0; i < array.length; i++) { 163 | System.out.print(array[i] + " "); 164 | } 165 | ``` 166 | 167 |

168 |
169 | 170 | ### Task 6 171 | 172 | ```text 173 | Напишете програма, която чете стойностите на масив от конзолата. 174 | После създайте втори масив с един елемент повече от първоначалния. 175 | Всички елементи на втория масив трябва да са равни на предходния елемент от първия масив 176 | умножени по индекса на текущия елемент, с изключение на 1-вия елемент. 177 | 178 | Пример: 179 | index = 0 1 2 3 4 6 180 | array = [ 1 2 3 4 5 ] 181 | result = [ 1 1*1 2*2 3*3 4*4 5*5 ] = [ 1 1 4 9 16 25 ] 182 | 183 | Пример: 184 | index = 0 1 2 3 4 5 6 185 | array = [ 9 -2 4 -3 7 5 ] 186 | result = [ 9 9*1 -2*2 4*3 -3*4 7*5 5*6 ] = [ 9 9 4 12 -12 35 30 ] 187 | ``` 188 | 189 |
Solution 👀 190 |

191 | 192 | ```java 193 | Scanner scanner = new Scanner(System.in); 194 | System.out.print("Enter array size: "); 195 | 196 | int size = scanner.nextInt(); 197 | 198 | int[] array = new int[size]; 199 | 200 | System.out.println("Enter " + size + " numbers:"); 201 | for (int i = 0; i < array.length; i++) { 202 | System.out.print("array[" + i + "] = "); 203 | array[i] = scanner.nextInt(); 204 | } 205 | 206 | int[] derivedArray = new int[array.length + 1]; 207 | 208 | derivedArray[0] = array[0]; 209 | 210 | for (int i = 0; i < array.length; i++) { 211 | derivedArray[i + 1] = array[i] * (i + 1); 212 | } 213 | 214 | for (int i = 0; i < derivedArray.length; i++) { 215 | System.out.print(derivedArray[i] + " "); 216 | } 217 | ``` 218 | 219 |

220 |
221 | 222 | ### Task 7 223 | 224 | ```text 225 | Напишете програма която запаметява в масив въведените от конзолата числа. 226 | Броя на числата, които трябва да се запаметят е неопределен. 227 | Въвеждането прекратява при въвеждането на числото -1. 228 | Принтирайте всички въведени от потребителя числа без -1. 229 | 230 | Пример: 231 | Enter number: 10 232 | Enter number: 32 233 | Enter number: -41 234 | Enter number: -1 235 | You entered: 10 32 -41 236 | ``` 237 | 238 |
Solution 👀 239 |

240 | 241 | ```java 242 | Scanner scanner = new Scanner(System.in); 243 | 244 | int stopNumber = -1; 245 | int[] array = new int[1]; 246 | 247 | System.out.println("To stop entering numbers type: " + stopNumber); 248 | 249 | int i = 0; 250 | while (true) { 251 | System.out.print("Enter number: "); 252 | int input = scanner.nextInt(); 253 | 254 | if (input == stopNumber) { 255 | break; 256 | } 257 | 258 | array[i] = input; 259 | i++; 260 | 261 | if (array.length == i) { 262 | // create new array with bigger size 263 | int[] tmpArray = new int[array.length + 1]; 264 | 265 | // copy old values in new array 266 | for (int j = 0; j < array.length; j++) { 267 | tmpArray[j] = array[j]; 268 | } 269 | 270 | // change array to new array 271 | array = tmpArray; 272 | } 273 | } 274 | 275 | // array.length - 1 because there is one extra item at the end of the array 276 | for (int j = 0; j < array.length - 1; j++) { 277 | System.out.print(array[j] + " "); 278 | } 279 | ``` 280 | 281 |

282 |
-------------------------------------------------------------------------------- /lectures/bg/04-arrays/Lecture4Homework.md: -------------------------------------------------------------------------------- 1 | # Homework Lecture 4 2 | #java course# 3 | 4 | ## Arrays 5 | 6 | ### Task 1 7 | 8 | ```text 9 | Да се прочете масив от екрана и да се намери най-малкото число кратно на 3 от масива 10 | (за улеснение, нека първият елемент на масива, въведен от потребителя да е винаги число кратно на 3). 11 | 12 | Може да се опитате и без първото да е кратно на 3. 13 | ``` 14 | 15 |
Solution 👀 16 |

17 | 18 | ###### Solution 1 19 | 20 | ```java 21 | Scanner scanner = new Scanner(System.in); 22 | 23 | System.out.print("Enter size of the array: "); 24 | int size = scanner.nextInt(); 25 | 26 | int[] myArray = new int[size]; 27 | 28 | System.out.println("First number should be multiple of 3!"); 29 | for (int i = 0; i < myArray.length; i++) { 30 | System.out.print("array[" + i + "] = "); 31 | myArray[i] = scanner.nextInt(); 32 | } 33 | 34 | int min = myArray[0]; 35 | 36 | for (int i = 1; i < myArray.length; i++) { 37 | 38 | int currentElement = myArray[i]; 39 | 40 | if (currentElement % 3 == 0 && currentElement < min) { 41 | min = currentElement; 42 | } 43 | } 44 | 45 | System.out.println("The smallest element multiple of 3 is: " + min); 46 | ``` 47 | 48 | ###### solution 2 49 | 50 | ```java 51 | Scanner scanner = new Scanner(System.in); 52 | 53 | System.out.print("Enter size of the array: "); 54 | int size = scanner.nextInt(); 55 | 56 | int[] myArray = new int[size]; 57 | 58 | for (int i = 0; i < myArray.length; i++) { 59 | System.out.print("array[" + i + "] = "); 60 | myArray[i] = scanner.nextInt(); 61 | } 62 | 63 | int min = 0; 64 | boolean minIsInitialized = false; 65 | 66 | for (int i = 0; i < myArray.length; i++) { 67 | 68 | int currentElement = myArray[i]; 69 | 70 | if (currentElement % 3 != 0) { 71 | continue; 72 | } 73 | 74 | if (!minIsInitialized) { 75 | min = currentElement; 76 | minIsInitialized = true; 77 | } else if (min > currentElement) { 78 | min = currentElement; 79 | } 80 | } 81 | 82 | if (minIsInitialized) { 83 | System.out.println("The smallest element multiple of 3 is: " + min); 84 | } else { 85 | System.out.println("None of the numbers are multiple of 3!"); 86 | } 87 | ``` 88 | 89 |

90 |
91 | 92 | ### Task 2 93 | 94 | ```text 95 | Да се подкани потребителя да въведе размер на масива кратен на 2. 96 | След това да се подкани потребителя с подходящи съобщения да въведе половината от елементите. 97 | На останалите елементи на масива да се зададат стойности като на предишните 2. 98 | Накрая да се изведе масива на екрана. 99 | 100 | Пример: 101 | Въведете размер за масива: 8 102 | Въведете 1-я елемент: 103 | 10 104 | Въведете 2-я елемент: 105 | 12 106 | Въведете 3-я елемент: 107 | 1 108 | Въведете 4-я елемент: 109 | -4 110 | 111 | Резултат: 112 | 10 12 1 -4 10 12 1 -4 113 | ``` 114 | 115 |
Solution 👀 116 |

117 | 118 | ```java 119 | Scanner scanner = new Scanner(System.in); 120 | 121 | System.out.print("Enter size of the array multiple of 2: "); 122 | int size = scanner.nextInt(); 123 | 124 | int[] array = new int[size]; 125 | 126 | int half = array.length / 2; 127 | 128 | System.out.println("Enter " + half + " items\n"); 129 | for (int i = 0; i < half; i++) { 130 | System.out.print("array[" + i + "] = "); 131 | int value = scanner.nextInt(); 132 | 133 | array[i] = value; 134 | array[half + i] = value; 135 | } 136 | 137 | System.out.println("Here is the array: "); 138 | 139 | for (int i = 0; i < array.length; i++) { 140 | System.out.print(array[i] + ", "); 141 | } 142 | ``` 143 | 144 |

145 |
146 | 147 | ### Task 3 148 | 149 | ```text 150 | Да се въведе число от конзолата, след което да се създаде масив с 10 елемента по следния начин: 151 | Първите 2 елемента на масива са въведеното число. 152 | Всеки следващ елемент на масива е равен на сбора от предишните 2 елемента в масива. 153 | (Задачата за Фибоначи но с числа запазени в масива и започващи от число, избрано от потребителя) 154 | След това изведете масива на конзолата. 155 | 156 | Пример 1: 157 | Въведете число: 1 158 | 1 1 2 3 5 8 13 21 34 55 159 | 160 | Пример 2: 161 | Въведете число: 3 162 | 3 3 6 9 15 24 39 63 102 167 🐚 163 | ``` 164 | 165 | > Няколко интересни факта за Фибоначи: 166 | [The magic of Fibonacci numbers](https://www.youtube.com/watch?v=SjSHVDfXHQ4&fbclid=IwAR16DatoUczikQgzwQHtpBcIQe5DhGEcXWsXv0CGMZ6yjx4QMZL1y0yVOdw) 167 | [Nature by Numbers](https://www.youtube.com/watch?v=kkGeOWYOFoA&fbclid=IwAR1ClvHqnuBsG04hz7RgUZwG9D3j_mSYXCqSUuYAze1SylakjW0GMFOK5qI) 168 | [Константно намиране на n-тото число от поредицата на Фибоначи](http://www.maths.surrey.ac.uk/hosted-sites/R.Knott/Fibonacci/fibFormula.html) 169 | 170 | ### Task 4 171 | 172 | ```text 173 | Създайте масив с големина зададена от потребителя. 174 | Въведете стойностите на масива от конзолата. 175 | Да се провери дали въведения масив е огледален. 176 | 177 | Следните масиви са огледални: 178 | [3 7 7 3] 179 | [4] 180 | [1 55 1] 181 | [6 27 -1 5 7 7 5 -1 27 6] 182 | 183 | Пример: 184 | Въведете размер за масива: 5 185 | Въведете 1-я елемент: 10 186 | Въведете 2-я елемент: 66 187 | Въведете 3-я елемент: 1 188 | Въведете 4-я елемент: 66 189 | Въведете 5-я елемент: 10 190 | 191 | Масивът е огледален 192 | ``` 193 | 194 | ### Task 5 195 | 196 | ```text 197 | Напишете програма, която създава масив с 10 елемента от 198 | тип double и инициализира всеки от елементите със стойност 199 | равна на индекса на елемента умножен по 3 и разделен на сумата от индексите на всички елементи. 200 | Да се изведат елементите на екрана закръглени до втори знак след десетичната запетая. 201 | ``` 202 | 203 | ### Task 6 204 | 205 | ```text 206 | Напишете програма, която първо чете масив от клавиатурата и после 207 | създава нов масив със същия размер по следния начин: 208 | стойността на всеки елемент от втория масив да е равна на сбора от 209 | предходния и следващият елемент на съответния елемент от първия масив. 210 | Да се изведе получения масив. 211 | 212 | Пример: 213 | Въведете размер на масива: 4 214 | Въведете елементите на масива: 215 | 2 216 | 3 217 | -11 218 | 7 219 | Полученият масив е: {3, -9, 10, -11} 220 | ``` 221 | 222 | > **Обяснение:** 223 | В полученият масив числото на индекс `0` `(3)` е получено, 224 | като се сумират елементът с индекс `1` и елементът с индекс `-1`. 225 | Тъй като елемент на `-1` индекс няма `(ArrayIndexOutOfBounds)`, събираме с `0` `(0 + 3 = 3)`. 226 | Числото на индекс `1` `(-9)` е получено, като се сумират числата с 227 | индекси `0` и `2` от входния масив `(2 + -11 = 9)`. 228 | Числото на индекс `2` `(10)` е получено, като се съберат числата с индекси `1` и `3` 229 | от входния масив `(3 + 7 = 10)`. 230 | За числото на индекс `3` `(-11)` (последното), 231 | логиката е аналогична на тази при първото число. Тъй като няма елемент на индекс `4`, 232 | то е равно на числото с индекс `3` от входния масив `(-11 + 0 = -11)`. 233 | 234 | ### Task 7 235 | 236 | ```text 237 | Напишете програма, която намира и извежда най-дългата редица от еднакви поредни елементи в даден масив. 238 | Пример: 239 | Въведете размер на масива: 10 240 | Въведете елементите на масива: 241 | 2 242 | 1 243 | 1 244 | 2 245 | 3 246 | 3 247 | 2 248 | 2 249 | 2 250 | 1 251 | 252 | Максималната редица е: 2 2 2 253 | ``` 254 | 255 | ### Task 8 256 | 257 | ```text 258 | Напишете програма, която първо чете 2 масива от конзолата (от целочислен тип) 259 | и после извежда съобщение дали са еднакви и дали са с еднакъв размер. 260 | 261 | Пример: 262 | Въведете размер за първия масив: 3 263 | Въведете елементите на първия масив: 264 | 13 265 | 2 266 | 7 267 | 268 | Въведете размер за втория масив: 3 269 | Въведете елементите на втория масив: 270 | 13 271 | 5 272 | 7 273 | 274 | Масивите са различни. 275 | Масивите имат еднакъв размер. 276 | ``` 277 | -------------------------------------------------------------------------------- /src/lecture9/exercises/hospital/HospitalDemo.java: -------------------------------------------------------------------------------- 1 | package lecture9.exercises.hospital; 2 | 3 | public class HospitalDemo { 4 | 5 | public static void main(String[] args) { 6 | 7 | // Създаване на различните видове доктори 8 | Cardiologist cardiolog = new Cardiologist("Ivan", 40, false); 9 | Dermatologist dermatholog = new Dermatologist("Joana", 40, true); 10 | Pediatrician pediater = new Pediatrician("Georgi", 40, false); 11 | 12 | // Създаване на болницата 13 | Hospital hospital = new Hospital(); 14 | 15 | // Добавяне на докторите в болницата 16 | hospital.addDoctor(cardiolog); 17 | hospital.addDoctor(dermatholog); 18 | hospital.addDoctor(pediater); 19 | 20 | // Създаване на малолетен пациент 21 | Patient goshko = new MalePatient("Goshko", 15); 22 | 23 | // Създаване на пациент с диагноза 'дерматолог' 24 | Patient lyudmila = new FemalePatient("Lyudmila", 30); 25 | lyudmila.setDiagnose("дерматолог"); 26 | 27 | // Създаване на пациент с диагноза 'кардиолог' 28 | Patient parvan = new MalePatient("Parvan", 30); 29 | parvan.setDiagnose("кардиолог"); 30 | 31 | // Излекуване на пациентите 32 | hospital.heal(goshko); 33 | hospital.heal(lyudmila); 34 | hospital.heal(parvan); 35 | } 36 | } 37 | 38 | /** 39 | * Клас който представлява човек. 40 | * Този клас съдържа общите свойства м/у пациенти и лекари. 41 | */ 42 | class Person { 43 | 44 | final String name; 45 | final int age; 46 | final boolean isFemale; 47 | 48 | Person(String name, int age, boolean isFemale) { 49 | this.name = name; 50 | this.age = age; 51 | this.isFemale = isFemale; 52 | } 53 | 54 | @Override 55 | public String toString() { 56 | return "Person{ " + name + " " + age + " " + isFemale + " }"; 57 | } 58 | } 59 | 60 | /** 61 | * Клас пациент, който наследява {@link Person}. 62 | * Така пациента има достъп до името, годините и пола на човека. 63 | *

64 | * Този клас надгражда с това че добавя диагноза и няколко метода, които оперират с диагнозата. 65 | */ 66 | class Patient extends Person { 67 | 68 | private String diagnose; 69 | 70 | Patient(String name, int age, boolean isFemale) { 71 | super(name, age, isFemale); 72 | } 73 | 74 | public void setDiagnose(String diagnose) { 75 | this.diagnose = diagnose; 76 | } 77 | 78 | public String getDiagnose() { 79 | return diagnose; 80 | } 81 | 82 | public void removeDiagnose() { 83 | diagnose = null; 84 | } 85 | } 86 | 87 | /** 88 | * Клас МъжкиПациент, който наследява {@link Patient}. 89 | * Единственото, което прави този клас е да създава нов конструктор с един параметър по-малко и подава false, 90 | * като параметър за пол на super конструктора. 91 | */ 92 | class MalePatient extends Patient { 93 | 94 | MalePatient(String name, int age) { 95 | super(name, age, false); 96 | } 97 | } 98 | 99 | /** 100 | * Клас ЖенскиПациент, който наследява {@link Patient}. 101 | * Единственото, което прави този клас е да създава нов конструктор с един параметър по-малко и подава true, 102 | * като параметър за пол на super конструктора. 103 | */ 104 | class FemalePatient extends Patient { 105 | 106 | FemalePatient(String name, int age) { 107 | super(name, age, true); 108 | } 109 | } 110 | 111 | /** 112 | * Абстрактен клас доктор. Този клас наследява {@link Person}. 113 | * Класът дефинира метода heal за лекуване на пациенти, както и абстрактен метод canHeal, който ще бъде 114 | * дефиниран от всеки вид доктор. Този клас понеже е абстрактен не може да бъде инстанциран директно. 115 | * Необходимо е да има наследник на този клас за да може да бъде създаден. 116 | */ 117 | abstract class Doctor extends Person { 118 | 119 | public Doctor(String name, int age, boolean isFemale) { 120 | super(name, age, isFemale); 121 | } 122 | 123 | /** 124 | * Метод който лекува пациента, единствено ако пациента може да бъде излекуван от текущия лекар. 125 | * Този метод използва абстрактния метод {@link Doctor#canHeal(Patient)} 126 | * 127 | * @param patient пациента, който ще бъде излекуван. 128 | * @return true ако пациента е успешно излекуван, false в противен случай. 129 | */ 130 | public boolean heal(Patient patient) { 131 | 132 | if (canHeal(patient)) { 133 | patient.removeDiagnose(); 134 | return true; 135 | } 136 | 137 | return false; 138 | } 139 | 140 | @Override 141 | public String toString() { 142 | return "Doctor{ " + name + " " + age + " }"; 143 | } 144 | 145 | /** 146 | * Абстрактен метод, който ще пъде задължителен за всеки наследник на този клас. 147 | * Наследникът е длъжен да имплементира този метод. 148 | * 149 | * @param patient пациента, който ще бъде лекуван. 150 | * @return true ако пациента може да бъде излекувам от този лекар, false в противен случай. 151 | */ 152 | public abstract boolean canHeal(Patient patient); 153 | } 154 | 155 | /** 156 | * Клас който представлява специализиран доктор кардиолог. 157 | *

158 | * Този тип доктор мое да лекува пациенти само с диагноза "кардиолог". 159 | */ 160 | class Cardiologist extends Doctor { 161 | 162 | public Cardiologist(String name, int age, boolean isFemale) { 163 | super(name, age, isFemale); 164 | } 165 | 166 | @Override // класът Cardiologist имплементира абстрактния метод canHeal дефиниран в Doctor класът 167 | public boolean canHeal(Patient patient) { 168 | return "кардиолог".equals(patient.getDiagnose()); 169 | } 170 | } 171 | 172 | /** 173 | * Клас който представлява специализиран доктор дерматолог. 174 | *

175 | * Този тип доктор мое да лекува пациенти само с диагноза "дерматолог". 176 | */ 177 | class Dermatologist extends Doctor { 178 | 179 | public Dermatologist(String name, int age, boolean isFemale) { 180 | super(name, age, isFemale); 181 | } 182 | 183 | @Override // класът Dermatologist имплементира абстрактния метод canHeal дефиниран в Doctor класът 184 | public boolean canHeal(Patient patient) { 185 | return "дерматолог".equals(patient.getDiagnose()); 186 | } 187 | } 188 | 189 | /** 190 | * Клас който представлява специализиран доктор педиатър. 191 | *

192 | * Този тип доктор мое да лекува пациенти само под 18 години". 193 | */ 194 | class Pediatrician extends Doctor { 195 | 196 | public Pediatrician(String name, int age, boolean isFemale) { 197 | super(name, age, isFemale); 198 | } 199 | 200 | @Override // класът Pediatrician имплементира абстрактния метод canHeal дефиниран в Doctor класът 201 | public boolean canHeal(Patient patient) { 202 | return patient.age < 18; 203 | } 204 | } 205 | 206 | /** 207 | * Репрезентация на болница, която свързва лекарите с пациентите. 208 | */ 209 | class Hospital { 210 | 211 | private Doctor[] doctors = new Doctor[10]; 212 | 213 | /** 214 | * Метод добавяш лекари в болницата. 215 | * 216 | * @param doctor лекарят който ще бъде добавен в болницата. 217 | */ 218 | public void addDoctor(Doctor doctor) { 219 | 220 | for (int i = 0; i < doctors.length; i++) { 221 | 222 | if (doctors[i] == null) { 223 | doctors[i] = doctor; 224 | return; 225 | } 226 | } 227 | } 228 | 229 | /** 230 | * Метод приемащ пациент, който да бъде излекуван. 231 | * Този метод се грижи за това да намери доктор от съществуващите в болницата 232 | * и да го използва за да излекува пациента. 233 | * 234 | * @param patient пациента който трябва да бъде излекуван. 235 | */ 236 | public void heal(Patient patient) { 237 | 238 | for (Doctor doctor : doctors) { 239 | if (doctor == null) { 240 | continue; 241 | } 242 | 243 | boolean healed = doctor.heal(patient); 244 | 245 | if (healed) { 246 | System.out.printf("Доктор %s излекува пациент %s\n", doctor, patient); 247 | return; 248 | } 249 | } 250 | 251 | System.out.printf("Не беше намерен лекар, който да излекува %s\n", patient); 252 | 253 | } 254 | } -------------------------------------------------------------------------------- /lectures/bg/01-introduction/Lecture1.md: -------------------------------------------------------------------------------- 1 | # Lecture 1 2 | #java course# 3 | 4 | ## Въведение 5 | 6 | ### Как работи човешкия мозък? 7 | 8 | Мозъкът на човека е разделен на части, като всяка част служи за конкретна цел. 9 | Така например една част на мозъка, наричана *префронтален кортекс ([prefrontal cortex][prefrontal-cortex]*) 10 | отговаря за фокусирането в/у задачи и служи като краткотрайна памет. 11 | Друга част наричана *хипокампус ([hippocampus][hippocampus])* отговаря за спомените 12 | и служи като дълготрайна памет. 13 | *Темпоралния лоб ([temporal lobe][temporal-lobe])* служи за обработка на сетивата. 14 | Мозъкът използва него заедно с *префронталния кортекс*, както и други области, за решаването на 15 | математически проблеми. 16 | 17 | ![memory-brain](../../../assets/01-lecture/memory-brain.jpg) 18 | > Знаете ли, че *амигдалата ([amygdala][amygdala])* е отговорна за регулиране на емоциите, страхът и тревожността? 19 | [Alex Honnold][alex-honnold] смятан за най-безстрашният solo катерач дължи голяма част на успехите си 20 | на нефункциониращата си *амигдала*. 21 | Също така *амигдалата* е често отговорна за причината, поради която учениците ги е страх да задават въпроси. 22 | 23 | [prefrontal-cortex]: https://en.wikipedia.org/wiki/Prefrontal_cortex 24 | [hippocampus]: https://en.wikipedia.org/wiki/Hippocampus 25 | [temporal-lobe]: https://en.wikipedia.org/wiki/Temporal_lobe 26 | [amygdala]: https://en.wikipedia.org/wiki/Amygdala 27 | [alex-honnold]: http://nautil.us/issue/39/sport/the-strange-brain-of-the-worlds-greatest-solo-climber 28 | 29 | ### Kак работи един комютър? 30 | 31 | Сходно на [човешкият мозък](#как-работи-човешкият-мозък), компютърът също има отделни звена отговарящи за памет 32 | и изчисление. Като отново имаме няколко вида памет, *краткотрайна (RAM)* и *дълготрайна (HDD)*. 33 | Изчислителната част или така наречените инструкции за изпълнение се обработват от *процесор (CPU)* 34 | 35 | ![memory-cpu](../../../assets/01-lecture/memory-cpu.png) 36 | 37 | > Когато ние пишем програми ще ги записваме на *HDD*, 38 | при изпълнение ще ги зареждаме в *RAM* и ще биват изпълнявани от *CPU* 39 | 40 | 41 | ## Какво е Java? 42 | 43 | Java е език за програмиране от високо ниво. Това означава че използвайки този език за програмиране 44 | на нас като програмисти няма да се налага да разбираме от детайли, като какъв е процесора на компютъра, 45 | каква е операционната система и тнт... 46 | 47 | ![java-logo](../../../assets/01-lecture/java-logo.jpg) 48 | 49 | > Java e създадена от [James Gosling][james-gosling] през 1995г. 50 | Java всъщност е вид кафе. 51 | 52 | [james-gosling]: http://www.computinghistory.org.uk/det/1793/James-Gosling/ 53 | 54 | 55 | ### От какво се състои Java? 56 | 57 | Езикът Java може да се разглежда като съвкупност от инструменти/технологии 58 | 59 | - JDK (Java Development Kit) - чрез него програмистите могат да създават нови Java програми, които да бъдат 60 | изпълнявани от JRE и JVM 61 | 62 | - JRE (Java Runtime Environment) - съвкупността от библиотеки, които ще се използват по време на изпълнение на 63 | програмата заедно с нещото изпълняващо програмата 64 | 65 | - JVM (Java Virtual Machine) - това е частта, която изпълнява програмата 66 | 67 | ![jdk-jre-jvm](../../../assets/01-lecture/jdk-jre-jvm.png) 68 | 69 | 70 | ### Как една програма бива изпълнявана? 71 | 72 | Програмите, които пишем не са нищо повече от текстови файлове с разширение `.java`, 73 | докато не бъдат преведени на език разбираем за процесора. Тъй като Java е език от високо ниво това превеждане става на няколко етапа. 74 | 75 | 1. Текстовите файлове `.java` биват преведени от `компилатора (compiler)` до `bytecode`. Получения `bytecode` представлява файлове с разширение `.class` 76 | 2. Получените `.class` файлове биват зареждани от `JVM` за изпълнение 77 | 3. `JVM` изпълнява `bytecode` като го превежда на език разбираем за конкретна операционна система и конкретен процесор 78 | 79 | ![src-javac-bytecode-jre](../../../assets/01-lecture/src-javac-bytecode-jvm-os.png) 80 | 81 | #### Какво друго трябва да знаем за Java? 82 | 83 | ###### Java е мултиплатформена 84 | Това означава че една и съща програма може да бъде изпълнявана на различни операционни системи, 85 | като Windows, Linux, Mac и тнт... 86 | 87 | ###### Трябва ли ми JDK за да мога да изпълня Java програма 88 | Не е задължително на един компютър да има инсталирано `JDK` за да може да се изпълни една Java програма. 89 | Една програма може да бъде написана и компилирана на компютър с `JDK` и да бъде изпълнена на друг, 90 | който има само `JRE`. 91 | 92 | ###### Java е обектно ориентиран език 93 | Това означава че езикът има способността да моделира предмети от реалния свят. (За това ще говорим в следващите лекции). 94 | 95 | ###### Java e типизиран език 96 | Това означава че всяко едно нещо, което може да бъде моделирано от езика има конкретен тип. 97 | Пример за типове са числа, текст, дати и тнт... 98 | 99 | 100 | ## Примитивни типове (Primitive types) 101 | 102 | В езикът Java има заложени типове данни, които репрезентират различни неща. Пример за такива **primitive** типове са: 103 | *символ*, *цяло число*, *дробно число* и други. 104 | 105 | Примитивните типове данни са в основата на езика, като те се използват и ще бъдат използвани от нас за изграждането 106 | на по сложни типове данни. Един такъв пример е *текстът*, той е изграден от много на брой *символи*. 107 | 108 | ### Типове числа 109 | 110 | Числата може да ги разглеждаме като два основни вида. Цели числа като `1`, `-5` , `367` както и 111 | дробни числа `3.14159`, `2.718`, `-332.97`. Всеки един от двата вида се дели на числа с 112 | конкретен размер (максимална и минимална стойност). 113 | 114 | - Числа (Numbers) 115 | 116 | - Цели числа (Whole numbers) 117 | - `byte` 8 bit = -128…127 118 | - `short` 16 bit = -32 768….32 767 119 | - `int` 32 bit = -2 147 483 648…2 147 483 647 120 | - `long` 64 bit = -2^63…2^63 - 1 121 | 122 | - Дробни числа (Decimal numbers) 123 | - `float` 32 bit = -3.4E+38…3.4E+38 124 | - `double` 64 bit = -1.7E+308…1.7E+308 125 | 126 | ### Типове символи 127 | 128 | - Символ (Symbol) 129 | 130 | - `char` 16 bit unicode character = *a*, *$*, *4* 131 | 132 | ### Булев тип 133 | 134 | - Boolean 135 | - `boolean` = true/false 136 | 137 | 138 | ## Променливи (Variables) 139 | 140 | Чрез тези типовете данни, ние можем да създаваме **променливи**. 141 | Всяка една променлива има **тип**, **име** и **стойност**. 142 | Може да си представите това, като кутия с различна форма. Формата на кутията е **типът (type)**, 143 | Съдържанието на кутията е **стойността (value)**, а цялата кутия е **променлива (variable)**, понеже съдържанието 144 | в кутията може да се сменя. 145 | Също така си представете че има много на брой кутии, които си приличат. За да може да ги различаваме ще трябва да им 146 | дадем **име (name)**. 147 | 148 | ![variable-type-name-value-box](../../../assets/01-lecture/variable-type-name-value-box.jpg) 149 | 150 | - Пример 151 | 152 | ```java 153 | int year = 2019; 154 | 155 | double pi = 3.14; 156 | 157 | boolean isMale = true; 158 | 159 | char dollar = '$'; 160 | ``` 161 | 162 | #### Аритметични оператори 163 | 164 | - `+` — събиране (addition) 165 | - `-` — изваждане (subtraction) 166 | - `*` — умножение (multiplication) 167 | - `/` — деление (division) 168 | - `%` — деление с остатък (modulo) 169 | 170 | #### Логически оператори 171 | 172 | - `!` - отрицание (logical NOT) 173 | - `&&` — логическо И (logical AND) 174 | - `||` — логическо ИЛИ (logical OR) 175 | 176 | #### Оператори за сравнение 177 | 178 | - `==` - оператор за равенство (equal) 179 | - `!=` - различно (not equal) 180 | - `>` - по-голямо (greater than) 181 | - `>=` - по-голямо или равно (greater than or equal) 182 | - `<` - по-малко (less than) 183 | - `<=` - по-малко или равно (less than or equal) 184 | 185 | ## Hello World 186 | 187 | Първата ни Java програма, ще изпише на конзолата `Hello World`. Целта на тази програма е да илюстрира синтаксиса на 188 | езика. 189 | 190 | ```java 191 | public class Main { 192 | 193 | public static void main(String[] args) { 194 | 195 | System.out.println("Hello World"); 196 | } 197 | } 198 | ``` 199 | 200 | > Знаете ли че първата *[Hello World][hello-world]* програма е написана през 1972г. на езикът [B][b-language] 201 | 202 | [hello-world]: https://en.wikipedia.org/wiki/%22Hello,_World!%22_program 203 | [b-language]: https://en.wikipedia.org/wiki/B_(programming_language) 204 | 205 | ## Hello ... 206 | 207 | Целта на втората ни задача е да напишем програма, която поздравява с това, което е въведено от потребителя. 208 | Пример: потребителя въвежда `Alise`, а програмата изписва `Hello Alise` 209 | 210 | ```java 211 | import java.util.Scanner; // описваме кое средство ще използваме за вземане на данни от клавиатурата 212 | 213 | public class Main2 { 214 | 215 | public static void main(String[] args) { 216 | Scanner myScanner = new Scanner(System.in); // създаваме средството чрез което ще вземаме данни от клавиатурата и го кръщаваме myScanner 217 | 218 | String input = myScanner.nextLine(); // използваме myScanner за да вземем данни от клавиатурата и ги записваме в променливата input 219 | 220 | System.out.println("Hello " + input); // принтираме слято Hello и въведената стойност от потребителя 221 | } 222 | } 223 | ``` 224 | 225 | > Забележете програмата е написана във втори файл с име `Main2`. 226 | Когато стартирайте програмата въведете име от клавиатурата, след което натиснете enter. 227 | 228 | ℹ️ За повече информация относно типовете данни изгледайте това [youtube видео](https://www.youtube.com/watch?v=TBWX97e1E9g&list=PLE7E8B7F4856C9B19) 229 | и това [youtube видео](https://www.youtube.com/watch?v=yYN8u90MKCg&list=PLE7E8B7F4856C9B19&index=2). 230 | -------------------------------------------------------------------------------- /lectures/bg/14-files-io/Lecture14.md: -------------------------------------------------------------------------------- 1 | # Lecture 14 2 | #java course# 3 | 4 | ## Files & Input/Output 5 | 6 | ### Files 7 | 8 | В Java всички файлове, включително директориите са обекти. Те са част от така нареченото 9 | IO API (application programming interface). 10 | 11 | Когато искаме да прочетем/създадем един file, ние трябвад да знаем пътя до този file и неговото име. 12 | 13 | Пътищата биват два вида. 14 | 15 | - **релативни пътища** - Това са пътища спрямо нещо от файловата система. В нашия случай релативните пътища, ще са 16 | спрямо *root* директроията на проекта. Пример `./java/HelloWorld.java` 17 | 18 | - **абсолютни пътища** - Това са пътища, които еднозначно определят къде се намира даден файл. Те започват спрямо 19 | *root* на операционната система. Пример `/Projects/java/HelloWorld.java` 20 | 21 | **Важно**: Различните операционни системи репрезентират пътищата във файловата система по различен начин. 22 | Например *Unix* базираните системи използват **/**, като сепаратор, докато *Windows* базираните 23 | системи използват **\\**. Когато се упоменават пътища в Java се използва **/**. 24 | 25 | #### java.io.File 26 | 27 | `java.io.File` е класът от стандартната библиотека на Java, който моделира класове и директории. 28 | Чрез него ние можем да четем и да пишем в даден файл. Да проверяваме съдържанието на директории. 29 | Да създаваме нови файлове/директории, както и да изтрием съществуващи. 30 | 31 | ##### Операции с File 32 | 33 | Използвайки конструктора на класът `File` ние можем да упоменем пътя до директорията/файла, който искаме да четем. 34 | Като пътя до директорията/файла може да е релативен или абсолютен. 35 | 36 | ```java 37 | File file = new File("test.txt"); // релативен път до файла test.txt 38 | 39 | boolean testFileExists = file.exists(); 40 | boolean testIsFile = file.isFile(); 41 | boolean testIsDirectory = file.isDirectory(); 42 | 43 | System.out.println(file.getName()); 44 | System.out.printf("fileExists: %b isFile: %b isDirectory: %b%n%n", testFileExists, testIsFile, testIsDirectory); 45 | 46 | 47 | File directory = new File("src"); // релативен път до директорията src 48 | 49 | boolean srcFileExists = directory.exists(); 50 | boolean srcIsFile = directory.isFile(); 51 | boolean srcIsDirectory = directory.isDirectory(); 52 | 53 | System.out.println(directory.getName()); 54 | System.out.printf("fileExists: %b isFile: %b isDirectory: %b%n%n", srcFileExists, srcIsFile, srcIsDirectory); 55 | 56 | File[] files = directory.listFiles(); 57 | 58 | if (files != null) { 59 | System.out.printf("Number of files inside '%s' is %d%n", directory.getName(), files.length); 60 | } 61 | ``` 62 | 63 | > ℹ️ За повече информация отновно, това какво може да се прави с `File` класът 64 | вижте това [youtube видео](https://www.youtube.com/watch?v=o9F73FU2vzs). 65 | 66 | ### I/O 67 | 68 | ###### Streams 69 | 70 | Input и Output са механизми за четене и писане. Те намират приложение навсякъде където е необходимо да се трансферират 71 | данни. Било то комуникация м/у два сървъра до трансфериране на данни от и на файловата система. 72 | 73 | Трансферирането става чрез четене или писане на поток от данни. Този поток се нарича `Stream`. Когато четем данни, 74 | ние използваме поток за входни данни или по-точно `InputStream`. Когато пишем данни ние ползваме поток за изходни данни 75 | или `OutputStream`. 76 | 77 | > Представете си радио сигнала, той е поток от входни данни за радио станциите 📻. 78 | 79 | Един пример за писане на данни е `System.out.println()`, където `System.out` е вид `OutputStream`. 80 | 81 | ![input_vs_output_stream](../../../assets/14-lecture/input_vs_output_stream.png) 82 | 83 | Обикновенно данните, които се трансферират в stream-овете се конвертират до байтове. Тези данни са подредени т.е ако 84 | изпратим числата 1, 2 и 3 ще ги получим в същия ред. Веднъж влезли данните в потока, те не могат да бъдат пренареждани. 85 | Четенето на данните винаги е последователно, не може да се изчетат байтове на случаен принцип. 86 | При прочитането на данните от потока, те се премахват от него и не могат да бъдат прочетени втори път. 87 | 88 | ###### Data Streams 89 | 90 | Съществува I/O Stream, който е способен да записва типовете данни, независимо вида на файловата система. Така ние можем да записваме/четем 91 | примитивни типове като `int`, `char`, `boolean` и тнт. Това е така наречения `DataInputStream` и `DataOutputStream`. 92 | 93 | ![data_input_vs_data_output_stream](../../../assets/14-lecture/data_input_vs_data_output_stream.png) 94 | 95 | ###### Buffered Streams 96 | 97 | Писането и четенето на данни byte по byte може да създаде забавяне. Всяко едно писане/четене изисква програмата да се 98 | обърне към операционната система с заявка за четене/писане, която от своя страна трябва да локализира в паметта нещото, 99 | което ще се чете/пише. 100 | За да се намали бройката на тези операции, може да се използват така наречените `BufferedInputStream` за четене и съответно 101 | `BufferedOutputStream` за писане. Този вид потоци използват вътрешен буфер, който намалява обръщенията до операционната 102 | система и вместо това ги буферира, като само в определени случаи се изпълнява обръщение към операционната система. 103 | Например, когато се напълни буфера. 104 | 105 | ![buffered_writer_stream](../../../assets/14-lecture/buffered_writer_stream.jpeg) 106 | 107 | > ℹ️ За повече информация отновно **I/O** вижте това [youtube видео](https://www.youtube.com/watch?v=D_WDuwnaobg&t=558s). 108 | 109 | #### File I/O 110 | 111 | Четенето и писането на файлове се реализира с помощта на **Input** и **Output** **Stream**. 112 | 113 | Няколко неща, които трябва да знаем, когато боравим със файлове: 114 | 115 | - За прочитане на цял файл се чете от `InputStream` докато не бъде достигнат краят на файла. Края на файла се нарича 116 | **EOF (end of file)** и се репрезентира, като byte със стойност -1. 117 | 118 | - Когато четем/пишем файл се установява връзка (stream) със този файл. При приключване на операцията този stream 119 | **ТРЯБВА ДА БЪДЕ ЗАТВОРЕН**. 120 | 121 | ![stream_hierarchy](../../../assets/14-lecture/stream_hierarchy.jpg) 122 | 123 | - Пример за четене на файл byte по byte 124 | 125 | ```java 126 | File file = new File("test.txt"); 127 | 128 | FileInputStream fileStream = new FileInputStream(file); 129 | 130 | int readByte = 0; 131 | while (readByte != -1) { 132 | readByte = fileStream.read(); 133 | } 134 | 135 | fileStream.close(); 136 | ``` 137 | 138 | - Пример за писане на byte по byte 139 | 140 | ```java 141 | File file = new File("test.txt"); 142 | 143 | FileOutputStream fileStream = new FileOutputStream(file); 144 | 145 | fileStream.write('t'); 146 | fileStream.write('e'); 147 | fileStream.write('s'); 148 | fileStream.write('t'); 149 | 150 | fileStream.flush(); 151 | fileStream.close(); 152 | ``` 153 | 154 | ## Tasks 155 | 156 | ### Task 1 157 | 158 | Създайте програма, която проверява съдържанието на директорията `iotest`. 159 | Ако тази директория несъществува да се създаде от програмата. 160 | След като бъде създадена от програмата ръчно създайте файловете `a.txt`, `b.txt` и `c.txt` в тази директория. 161 | Да се принтират имената на файловете в директорията. 162 | 163 | - `iotest` се намира релативно в текущия проект 164 | 165 | > Използвайте `File.mkdir()` за създаване на директория. 166 | 167 |

Solution 👀 168 |

169 | 170 | ```java 171 | import java.io.File; 172 | 173 | public class Task1 { 174 | 175 | public static void main(String[] args) { 176 | File file = new File("iotest"); 177 | 178 | if (!file.exists()) { 179 | file.mkdir(); 180 | } 181 | 182 | for (String name : file.list()) { 183 | System.out.println(name); 184 | } 185 | } 186 | } 187 | ``` 188 | 189 |

190 |
191 | 192 | ### Task 2 193 | 194 | Създайте директория намираща се в `C:\test\iotest` чрез *Windows Explorer*. 195 | Създайте 3 файла с имена `foo.txt`, `bar.txt`, `zar.txt`, `Zab.txt`. 196 | 197 | Създайте програма, която изтрива файловете започващи със `z` без значение малки/големи букви (case insensitive). 198 | 199 | > Използвайте `File.delete()` за да изтриете файла, `String.startsWith("z")` за да проверите дали името започва със `z`. 200 | 201 | ### Task 3 202 | 203 | Напишете програма, която сравнява две снимки, дали са еднакви. 204 | 205 | > Използвайте `FileInputStream` и сравнявайте byte по byte снимките. 206 | 207 | ### Task 4 208 | 209 | Напишете програма, която взема от потребителя входни данни и ги записва във файла `exo.txt`. 210 | Програмата изисква входни данни, от потребителя, докато не бъде въведена думата `stop`. 211 | 212 | > Използвайте `PrintWriter.println()` за да записвате всяка дума на нов ред. 213 | 214 |
Solution 👀 215 |

216 | 217 | ```java 218 | import java.io.File; 219 | import java.io.IOException; 220 | import java.io.PrintWriter; 221 | import java.util.ArrayList; 222 | import java.util.List; 223 | import java.util.Scanner; 224 | 225 | public class WriteDemo { 226 | 227 | public static void main(String[] args) throws IOException { 228 | Scanner scanner = new Scanner(System.in); 229 | 230 | List data = new ArrayList<>(); 231 | while (true) { 232 | 233 | System.out.print("Въведете текст: "); 234 | String input = scanner.nextLine(); 235 | 236 | if ("stop".equalsIgnoreCase(input)) { 237 | break; 238 | } 239 | 240 | data.add(input); 241 | } 242 | 243 | File createdFile = createFile("echo.txt"); 244 | 245 | PrintWriter writer = new PrintWriter(createdFile); 246 | 247 | for (String eachData : data) { 248 | writer.println(eachData); 249 | } 250 | 251 | writer.flush(); 252 | writer.close(); 253 | 254 | System.out.println("Проверете съдържанеието на echo.txt"); 255 | } 256 | 257 | private static File createFile(String name) { 258 | File myFile = new File(name); 259 | 260 | try { 261 | myFile.createNewFile(); 262 | return myFile; 263 | } catch (IOException e) { 264 | throw new RuntimeException("There was an error creating the file.", e); 265 | } 266 | } 267 | } 268 | ``` 269 | 270 |

271 |
272 | -------------------------------------------------------------------------------- /lectures/bg/09-inheritance/Lecture9HomeworkSolutions.md: -------------------------------------------------------------------------------- 1 | # 👀 Homework Solutions Lecture 9 2 | #java course# 3 | 4 | ## Inheritance (Наследяване) 🏛️ 5 | 6 | ### Task 1 7 | 8 | Създайте програма, която симулира работата на болница. 🏥 9 | В една болница има няколко участника: 10 | - Доктори (Doctor) 11 | - Пациенти (Patient) 12 | 13 | И докторите и пациентите се характеризират с: 14 | - име (name) 15 | - възраст (age) 16 | - дали е мъж или жена (isFemale) 17 | 18 | Един пациент се характеризира с: 19 | - Диагноза (diagnose) 20 | - примерна диагноза може да е `кардиолог` (това означава че трябва да посети кардиолог) 21 | - Способността да му се поставя диагноза (setDiagnose) 22 | - Способността да му се премахва диагноза (removeDiagnose) 23 | 24 | Докторите се характеризират с: 25 | - способността да лекуват пациенти (heal) (просто премахват диагнозата на пациента) 26 | 27 | Докторите се делят на различни под типове: 28 | - Кардиолог (Cardiologist) 29 | - лекува само диагнози тип `кардиолог` 30 | - Дерматолог (Dermatologist) 31 | - лекува само диагнози тип `дерматолог` 32 | - Педиатър (Pediatrician) 33 | - лекува само пациенти на възраст под 18 години 34 | 35 | 36 | Болницата е това което навръзва докторите с пациентите. Тя се характеризира с: 37 | - множество доктори 38 | - способността да се добавя доктор 39 | - способността да се лекува пациент 40 | - за целта болницата намира лекаря, който може да излекува пациента и го лекува 41 | 42 | ###### Примерна йерархия на програмата 43 | 44 | - class Person 45 | - class Patient 46 | - class MalePatient 47 | - class FemalePatient 48 | - class Doctor 49 | - class Cardiologist 50 | - class Dermatologist 51 | - class Pediatrician 52 | 53 |
Solution 👀 54 |

55 | 56 | - Person.java 57 | ```java 58 | /** 59 | * Клас който представлява човек. 60 | * Този клас съдържа общите свойства м/у пациенти и лекари. 61 | */ 62 | class Person { 63 | 64 | final String name; 65 | final int age; 66 | final boolean isFemale; 67 | 68 | Person(String name, int age, boolean isFemale) { 69 | this.name = name; 70 | this.age = age; 71 | this.isFemale = isFemale; 72 | } 73 | 74 | @Override 75 | public String toString() { 76 | return "Person{ " + name + " " + age + " " + isFemale + " }"; 77 | } 78 | } 79 | ``` 80 | 81 | - Patient.java 82 | 83 | ```java 84 | /** 85 | * Клас пациент, който наследява {@link Person}. 86 | * Така пациента има достъп до името, годините и пола на човека. 87 | *

88 | * Този клас надгражда с това че добавя диагноза и няколко метода, които оперират с диагнозата. 89 | */ 90 | class Patient extends Person { 91 | 92 | private String diagnose; 93 | 94 | Patient(String name, int age, boolean isFemale) { 95 | super(name, age, isFemale); 96 | } 97 | 98 | public void setDiagnose(String diagnose) { 99 | this.diagnose = diagnose; 100 | } 101 | 102 | public String getDiagnose() { 103 | return diagnose; 104 | } 105 | 106 | public void removeDiagnose() { 107 | diagnose = null; 108 | } 109 | } 110 | ``` 111 | 112 | - MalePatient.java 113 | 114 | ```java 115 | /** 116 | * Клас МъжкиПациент, който наследява {@link Patient}. 117 | * Единственото, което прави този клас е да създава нов конструктор с един параметър по-малко и подава false, 118 | * като параметър за пол на super конструктора. 119 | */ 120 | class MalePatient extends Patient { 121 | 122 | MalePatient(String name, int age) { 123 | super(name, age, false); 124 | } 125 | } 126 | ``` 127 | 128 | - FemalePatient.java 129 | 130 | ```java 131 | /** 132 | * Клас ЖенскиПациент, който наследява {@link Patient}. 133 | * Единственото, което прави този клас е да създава нов конструктор с един параметър по-малко и подава true, 134 | * като параметър за пол на super конструктора. 135 | */ 136 | class FemalePatient extends Patient { 137 | 138 | FemalePatient(String name, int age) { 139 | super(name, age, true); 140 | } 141 | } 142 | ``` 143 | 144 | - Doctor.java 145 | 146 | ```java 147 | /** 148 | * Абстрактен клас доктор. Този клас наследява {@link Person}. 149 | * Класът дефинира метода heal за лекуване на пациенти, както и абстрактен метод canHeal, който ще бъде 150 | * дефиниран от всеки вид доктор. Този клас понеже е абстрактен не може да бъде инстанциран директно. 151 | * Необходимо е да има наследник на този клас за да може да бъде създаден. 152 | */ 153 | abstract class Doctor extends Person { 154 | 155 | public Doctor(String name, int age, boolean isFemale) { 156 | super(name, age, isFemale); 157 | } 158 | 159 | /** 160 | * Метод който лекува пациента, единствено ако пациента може да бъде излекуван от текущия лекар. 161 | * Този метод използва абстрактния метод {@link Doctor#canHeal(Patient)} 162 | * 163 | * @param patient пациента, който ще бъде излекуван. 164 | * @return true ако пациента е успешно излекуван, false в противен случай. 165 | */ 166 | public boolean heal(Patient patient) { 167 | 168 | if (canHeal(patient)) { 169 | patient.removeDiagnose(); 170 | return true; 171 | } 172 | 173 | return false; 174 | } 175 | 176 | @Override 177 | public String toString() { 178 | return "Doctor{ " + name + " " + age + " }"; 179 | } 180 | 181 | /** 182 | * Абстрактен метод, който ще пъде задължителен за всеки наследник на този клас. 183 | * Наследникът е длъжен да имплементира този метод. 184 | * 185 | * @param patient пациента, който ще бъде лекуван. 186 | * @return true ако пациента може да бъде излекувам от този лекар, false в противен случай. 187 | */ 188 | public abstract boolean canHeal(Patient patient); 189 | } 190 | ``` 191 | 192 | - Cardiologist.java 193 | 194 | ```java 195 | /** 196 | * Клас който представлява специализиран доктор кардиолог. 197 | *

198 | * Този тип доктор мое да лекува пациенти само с диагноза "кардиолог". 199 | */ 200 | class Cardiologist extends Doctor { 201 | 202 | public Cardiologist(String name, int age, boolean isFemale) { 203 | super(name, age, isFemale); 204 | } 205 | 206 | @Override // класът Cardiologist имплементира абстрактния метод canHeal дефиниран в Doctor класът 207 | public boolean canHeal(Patient patient) { 208 | return "кардиолог".equals(patient.getDiagnose()); 209 | } 210 | } 211 | ``` 212 | 213 | - Dermatologist.java 214 | 215 | ```java 216 | /** 217 | * Клас който представлява специализиран доктор дерматолог. 218 | *

219 | * Този тип доктор мое да лекува пациенти само с диагноза "дерматолог". 220 | */ 221 | class Dermatologist extends Doctor { 222 | 223 | public Dermatologist(String name, int age, boolean isFemale) { 224 | super(name, age, isFemale); 225 | } 226 | 227 | @Override // класът Dermatologist имплементира абстрактния метод canHeal дефиниран в Doctor класът 228 | public boolean canHeal(Patient patient) { 229 | return "дерматолог".equals(patient.getDiagnose()); 230 | } 231 | } 232 | ``` 233 | 234 | - Pediatrician.java 235 | 236 | ```java 237 | /** 238 | * Клас който представлява специализиран доктор педиатър. 239 | *

240 | * Този тип доктор мое да лекува пациенти само под 18 години". 241 | */ 242 | class Pediatrician extends Doctor { 243 | 244 | public Pediatrician(String name, int age, boolean isFemale) { 245 | super(name, age, isFemale); 246 | } 247 | 248 | @Override // класът Pediatrician имплементира абстрактния метод canHeal дефиниран в Doctor класът 249 | public boolean canHeal(Patient patient) { 250 | return patient.age < 18; 251 | } 252 | } 253 | ``` 254 | 255 | - Hospital.java 256 | 257 | ```java 258 | /** 259 | * Репрезентация на болница, която свързва лекарите с пациентите. 260 | */ 261 | class Hospital { 262 | 263 | private Doctor[] doctors = new Doctor[10]; 264 | 265 | /** 266 | * Метод добавяш лекари в болницата. 267 | * 268 | * @param doctor лекарят който ще бъде добавен в болницата. 269 | */ 270 | public void addDoctor(Doctor doctor) { 271 | 272 | for (int i = 0; i < doctors.length; i++) { 273 | 274 | if (doctors[i] == null) { 275 | doctors[i] = doctor; 276 | return; 277 | } 278 | } 279 | } 280 | 281 | /** 282 | * Метод приемащ пациент, който да бъде излекуван. 283 | * Този метод се грижи за това да намери доктор от съществуващите в болницата 284 | * и да го използва за да излекува пациента 285 | * 286 | * @param patient пациента който трябва да бъде излекуван. 287 | */ 288 | public void heal(Patient patient) { 289 | 290 | for (Doctor doctor : doctors) { 291 | if (doctor == null) { 292 | continue; 293 | } 294 | 295 | boolean healed = doctor.heal(patient); 296 | 297 | if (healed) { 298 | System.out.printf("Доктор %s излекува пациент %s\n", doctor, patient); 299 | return; 300 | } 301 | } 302 | 303 | System.out.printf("Не беше намерен лекар, който да излекува %s\n", patient); 304 | 305 | } 306 | } 307 | ``` 308 | 309 | - HospitalDemo.java 310 | 311 | ```java 312 | public class HospitalDemo { 313 | 314 | public static void main(String[] args) { 315 | 316 | // Създаване на различните видове доктори 317 | Cardiologist cardiolog = new Cardiologist("Ivan", 40, false); 318 | Dermatologist dermatholog = new Dermatologist("Joana", 40, true); 319 | Pediatrician pediater = new Pediatrician("Georgi", 40, false); 320 | 321 | // Създаване на болницата 322 | Hospital hospital = new Hospital(); 323 | 324 | // Добавяне на докторите в болницата 325 | hospital.addDoctor(cardiolog); 326 | hospital.addDoctor(dermatholog); 327 | hospital.addDoctor(pediater); 328 | 329 | // Създаване на малолетен пациент 330 | Patient goshko = new MalePatient("Goshko", 15); 331 | 332 | // Създаване на пациент с диагноза 'дерматолог' 333 | Patient lyudmila = new FemalePatient("Lyudmila", 30); 334 | lyudmila.setDiagnose("дерматолог"); 335 | 336 | // Създаване на пациент с диагноза 'кардиолог' 337 | Patient parvan = new MalePatient("Parvan", 30); 338 | parvan.setDiagnose("кардиолог"); 339 | 340 | // Излекуване на пациентите 341 | hospital.heal(goshko); 342 | hospital.heal(lyudmila); 343 | hospital.heal(parvan); 344 | } 345 | } 346 | ``` 347 |

348 |
349 | -------------------------------------------------------------------------------- /lectures/bg/09-inheritance/Lecture9.md: -------------------------------------------------------------------------------- 1 | # Lecture 9 2 | #java course# 3 | 4 | ## Inheritance (Наследяване) 🏛️ 5 | 6 | Наследяването е вторият основен принцип на ООП след енкапсулация. Проблема, който цели да реши 7 | е да направи по-лесно преизползването на логика написана в различни класове. Начина, по който се постига 8 | това преизползване чрез ООП, е като се изгражда йерархична връзка м/у отделните класове. 9 | 10 | - Например 11 | 12 | ![inheritance-illustration](../../../assets/09-lecture/inheritance-illustration.png) 13 | > Имаме една абстракция за животно, като имаме два конкретни представителя на тази абстракция и те са Куче и Котка. 14 | Или с други думи казваме че Куче и Котка наследяват абстракцията Животно 15 | 16 | ![4-pillars-of-oop](../../../assets/09-lecture/4-pillars-of-oop.png) 17 | > Четирите основни принципа на ООП 18 | 19 | При наследяването имаме `super class`, който представлява по-високото ниво в йерархията и наследяващ клас `child class`, 20 | който представлява по-ниското ниво в йерархията. Така `child` (дете) класът наследява `super` класът. 21 | 22 | В примера по-горе `Animal` е `super class`, а `Dog` и `Cat` са `child` класове на `Animal`. 23 | 24 | ### Какво може да бъде преизползвано чрез наследяване? 25 | 26 | Когато един клас наследява друг клас наследника получава достъп до: 27 | 28 | - methods (методи) 29 | - properties (свойства) 30 | - constructors (конструктори) 31 | 32 | По този начин общата логика м/у отделните наследници може да бъде написа в `super` класът, а всички наследници 33 | на този клас да я преизползват. 34 | 35 | Наследяването се осъществява чрез ключовата дума `extends`, която се изписва на нивото на класът. 36 | 37 | - Пример 38 | 39 | - Animal.java (`super class`) 40 | 41 | ```java 42 | public class Animal { 43 | 44 | public int age; 45 | 46 | public void eat() { 47 | System.out.println("Eating..."); 48 | } 49 | } 50 | ``` 51 | 52 | > `Animal` класът дефинира property `age` и method `eat()`, които ще бъдат достъпни 53 | в `child` класовете 54 | 55 | - Dog.java (`child class`) 56 | 57 | ```java 58 | public class Dog extends Animal { 59 | 60 | public String breed; 61 | 62 | public void bark() { 63 | System.out.println("Woff woff..."); 64 | } 65 | 66 | public void printDetailsAndEat() { 67 | // age е дефинирано в супер класът 68 | System.out.println("Breed: " + breed + " " + "Age: " + age); 69 | 70 | eat(); // този метод е дефиниран в супер класът 71 | } 72 | } 73 | ``` 74 | 75 | > `Dog` наследява `Animal`, като класът дефинира ново property `breed` (порода), method `bark()` (лая) 76 | и method `printDetailsAndEat()`, които са достъпни само в `Dog` класът. 77 | `Dog` също така получава достъп до `age` и `eat()` от супер класът. 78 | 79 | - Cat.java (`child class`) 80 | 81 | ```java 82 | public class Cat extends Animal { 83 | 84 | public int numberOfLives; 85 | 86 | public void purr() { 87 | System.out.println("PurRrRr..."); 88 | } 89 | 90 | public void printDetailsAndEat() { 91 | // age е дефинирано в супер класът 92 | System.out.println("Num of Lives: " + numberOfLives + " " + "Age: " + age); 93 | 94 | // този метод е дефиниран в супер класът 95 | eat(); 96 | } 97 | } 98 | ``` 99 | 100 | > `Cat` наследява `Animal`, като класът дефинира ново property `numberOfLives` (брой животи), method `purr()` (мърка) 101 | и method `printDetailsAndEat()`, които са достъпни само в `Cat` класът. 102 | `Cat` също така получава достъп до `age` и `eat()` от супер класът. 103 | 104 | 105 | ### Method Overloading 106 | В Java можем да създадем два метода с еднакво име, еднакви return типове, но различни на брой или тип входни параметри. 107 | Като методът, който ще бъде извикан се определя от входните параметри, които биват подавани. 108 | 109 | Това свойство на Java се нарича Method Overloading. 110 | 111 | - Пример 112 | 113 | ```java 114 | class Foo { 115 | void doSomething(int a) { 116 | System.out.println(a); 117 | } 118 | 119 | void doSomething(String a) { 120 | System.out.println(a); 121 | } 122 | 123 | void doSomething(int a, String b) { 124 | System.out.println(a + " " + b); 125 | } 126 | } 127 | ``` 128 | > В този случай казваме, че методът `doSomething` е overload-нат 129 | 130 | ### Constructors and chaining 131 | 132 | Ще разгледаме в повече детайли как можем да обвържем няколко конструктора на един и същи клас. 133 | Като примерите, които ще разгледаме ще са за клас, който не наследява нищо и клас, който наследява друг клас. 134 | 135 | Логически **constructor chaining** може да се разглежда, като **method overloading**. 136 | Като задължително при извикването на първия конструктор се извиква и втория и третия ако има такъв и тнт... 137 | 138 | #### Constructor chaining без наследяване 139 | 140 | Ако един клас има 2 конструктора, то ние сме задължени, когато инстанцираме класът да използваме един от 2-та конструктора. 141 | Така например единия конструктор може да приема 2 параметъра, а другия 3. 142 | Възможно е да навържем така първия конструктор, че той да предава 2-та параметъра на конструктора с 3 параметъра. 143 | Това става с помощта на ключовата дума `this`. 144 | 145 | - Пример 146 | 147 | ```java 148 | class Person { 149 | 150 | final String firstName; 151 | final String middleName; 152 | final String lastName; 153 | 154 | Person(String firstName) { 155 | this(firstName, null); // конструкторът с 1 параметър извиква конструктора с 2 параметъра 156 | } 157 | 158 | Person(String firstName, String lastName) { 159 | this(firstName, null, lastName); // конструкторът с 2 параметъра извиква конструктора с 3 параметъра 160 | } 161 | 162 | Person(String firstName, String middleName, String lastName) { 163 | this.firstName = firstName; 164 | this.middleName = middleName; 165 | this.lastName = lastName; 166 | } 167 | 168 | } 169 | ``` 170 | 171 | В случаят използваме ключовата дума `this` в 2 от конструкторите като метод `this(param1, param2)`. 172 | В третия конструктор с три параметъра използваме ключовата дума `this` за да достъпим свойствата на класа. 173 | 174 | #### Constructor chaining с наследяване 175 | 176 | Ако имаме `super class`, който дефинира 1 конструктор всички наследници са длъжни да извикат този конструктор, 177 | при тяхното инстанциране. Това става чрез ключовата дума `super` в конструктора на `child` класът. 178 | 179 | - Пример 180 | 181 | ```java 182 | class Person { 183 | 184 | final String firstName; 185 | final String lastName; 186 | final boolean isMale; 187 | 188 | Person(String firstName, String lastName, boolean isMale) { 189 | this.firstName = firstName; 190 | this.lastName = lastName; 191 | this.isMale = isMale; 192 | } 193 | } 194 | 195 | class Male extends Person { 196 | 197 | Male(String firstName, String lastName) { 198 | super(firstName, lastName, true); // извикваме конструктора на Person с ключовата дума super 199 | } 200 | } 201 | ``` 202 | 203 | В случая ползваме ключовата дума като метод `super(param1, param2, param3)`, обаче тя може да бъде ползвана и 204 | за достъпване на методи и променливи от super класът. 205 | 206 | ### Java Object class 207 | 208 | В Java всичко наследява класът `Object`. Той е супер класът на всеки един клас. 209 | 210 | От този клас получаваме няколко често използвани метода: 211 | 212 | - toString 213 | - equals 214 | - hashCode 215 | 216 | ### toString 217 | 218 | Сигнатурата на този метод е следната `String toString()`. Този метод се използва, когато искаме да получим 219 | текстова репрезентация на даден обект. Имплементацията на `toString` идваща от `Object` класът, връща текстовата 220 | репрезентация на адреса на обекта в паметта. За това когато принтираме със `System.out.println(myObject)` 221 | се принтира адреса на обекта вместо неговото съдържание. 222 | 223 | > Знаете ли че `System.out.println()` извиква `toString` метода на класът. 224 | 225 | ### equals 226 | 227 | Сигнатурата на този метод е следната `boolean equals(Object otherObject)`. Този метод се използва, когато искаме 228 | да проверим дали една инстанция на обект е равна на друга инстанция. Методът приема 1 параметър 229 | (обектът срещу който ще се сравнява) и връща `boolean` резултат. true ако са еднакви false в противен случай. 230 | Имплементацията на `equals` идваща от `Object` класът сравнява адресите на променливите вместо да сравнява съдържанието 231 | на променливите. 232 | 233 | ### hashCode 234 | 235 | Сигнатурата на този мето е следната `int hashCode()`. Този метод се използва когато [хешираме][hash-function] 236 | даден обект. Целта на това хеширане е да прекараме данните на един обект през математически функции и да получим 237 | число. Това число може да бъде използвано като числова репрезентация на данните. Като задължително крайния резултат 238 | от хеширането на една и съща променлива n на брой пъти трябва да е еднакъв. 239 | 240 | > Ще разгледаме хеширащите функции в повече детайли следващите лекции 241 | 242 | [hash-function]: https://bg.wikipedia.org/wiki/%D0%A5%D0%B5%D1%88-%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F 243 | 244 | ### Method Overriding (пренаписване на метод) 245 | 246 | Когато един клас наследява друг клас, то първия има възможността да пренапише функционалността на някои от методите 247 | на super класът. Това нещо се нарича Override (презаписване/пренаписване). 248 | Като за четимост методите, които биват пренаписани се обозначават с `@Override` над сигнатурата им. 249 | 250 | - Пример 251 | 252 | ```java 253 | class Animal { 254 | 255 | void speak() { // класът Animal дефинира метод speak 256 | System.out.println("Speaking..."); 257 | } 258 | } 259 | 260 | class Dog extends Animal { // Dog наследява Animal 261 | 262 | @Override // обозначаваме че методът е пренаписан и идва от super класът 263 | void speak() { // Класът Dog пренаписва (override) методът speak от класът Animal 264 | System.out.println("Woff woff..."); 265 | } 266 | } 267 | ``` 268 | 269 | > `new Animal().speak()` ще изпише `Speaking...`, а `new Dog().speak()` ще изпише `Woff woff...` 270 | -------------------------------------------------------------------------------- /lectures/bg/06-oop-introduction/Lecture6.md: -------------------------------------------------------------------------------- 1 | # Lecture 6 2 | #java course# 3 | 4 | ## Introduction to Object Oriented Programming 5 | 6 | ### Какво е ООП? 7 | 8 | Обектно ориентираното програмиране е концепция. 9 | Тя позволява писането на преизползваем, лесен за разбиране и поддръжка код. 10 | В основата на ООП се намират **класовете** и **обектите**. 11 | 12 | Те се изплзват за моделиране на *обекти* от реалния свят. Като *обектите* от реалния 13 | свят споделят две характеристики **състояние (state)** и **поведение (behaviour)**. 14 | 15 | - Всеки човек има име, години, пол... (**състояние**) 16 | - Всеки човек може да яде, спи, върви... (**поведение**) 17 | - Мобилния телефон има памет, цвят, може да е включен/изключен (**състояние**) 18 | - Мобилния телефон може да набира други номера, изпраща SMS, да бива включван/изключван (**поведение**) 19 | 20 | 21 | Класът `class` играе ролята на шаблон, с който описваме един обект. 22 | Класът описва **свойствата (properties)** на обекта както и неговото **поведение (methods)** 23 | 24 | - Всеки човек има `име`, `години`, `пол`, `тегло` и тнт. Ето пример за описане на **свойствата** на *обекта* човек: 25 | 26 | ```java 27 | class Person { 28 | String name; 29 | int age; 30 | boolean isFemale; 31 | double weight; 32 | } 33 | ``` 34 | 35 | > Свойствата на обектите в Java се наричат **properties**. 36 | Всяко едно **property** има тип (type) и име (name). 37 | 38 | - Всеки човек може да `говори`, да `старее` и тнт. Ето пример за описание на **поведението** на *обекта* човек: 39 | 40 | ```java 41 | class Person { 42 | String name; 43 | int age; 44 | boolean isFemale; 45 | double weight; 46 | 47 | void speak() { 48 | System.out.printf("My name is %s and I am %d years old", name, age); 49 | } 50 | 51 | void grow() { 52 | age++; 53 | } 54 | } 55 | ``` 56 | 57 | > Поведението на обектите в Java се представя чрез методи **methods**. 58 | Всеки един **method** има тип на резултат (return type), име (name) и параметри (arguments). 59 | 60 | #### Какво са обектите? 61 | 62 | Ако **класът** `class` е шаблонът, с който описваме нещо от реалния свят, 63 | то **обектът** `object` е конкретен представител на този шаблон. 64 | 65 | Пример: Знаем че една кола може да се характеризира със своята `марка`, то тогава колите 66 | Audi, Nissan, Volvo са **обекти** от типа `Car`. 67 | 68 | ![Class vs Object](../../../assets/06-lecture/class-object-featured-image.png) 69 | 70 | > Всеки един от трите **обекта** в примера е представител на **класът** Car, 71 | като има различна стойност записана в свойството `марка`. 72 | 73 | - Пример използващ по-горе създадения `class` за създаването на конкретен `object`. 74 | 75 | ```java 76 | public class Main { 77 | 78 | public static void main(String[] args) { 79 | 80 | Person john = new Person(); 81 | john.name = "John"; 82 | john.age = 30; 83 | john.isFemale = false; 84 | john.weight = 75; 85 | 86 | john.speak(); 87 | john.grow(); 88 | } 89 | } 90 | ``` 91 | 92 | #### Какво друго трябва да знаем за класовете? 93 | 94 | ###### референтни типове (reference types) 95 | Класовете са референтни типове. Това означава, че те са сложни типове данни, 96 | които обикновенно са създадени от други примитивни типове данни. 97 | 98 | ###### стойности по подразбиране (default values) 99 | **Свойствата (properties)** на класовете, могат да имат стойности по подразбирани, 100 | като тези стойности зависят от типа на свойството. 101 | Default стойността на **property** от сложен тип е `null` 102 | 103 | ###### инстанции (instances) 104 | Думата **инстанция (instance)** може да я разглеждаме като синоним на конкретен **object**. 105 | Като Audi, Nissan, Volvo. 106 | 107 | ###### инстанциране на обекти 108 | Инстанцирането (създаването) на обекти става с ключовата дума `new`. Пример `new Person()` 109 | 110 | ###### пакети (packages) 111 | Класовете могат да бъдат групирани логически в директории или по-точно **пакети**. 112 | 113 | ___ 114 | 115 | ### Exercises State 116 | 117 | #### Task 1 118 | 119 | ```text 120 | Моделирайте обекта кола (car). Всяка една кола има следните характеристики: 121 | • модел (model) 122 | • максимална скорост (max speed) 123 | • текуща предавка (current gear) 124 | • цвят (color) 125 | • текуща скорост (current speed) 126 | 127 | - Създайте програма с входна точка (main), която създава 2 инстанции на колата 128 | и записва стойности във всяка една от инстанциите. 🚗 129 | ``` 130 | 131 | #### Task 2 132 | 133 | ```text 134 | Моделирайте обекта човек (person). Всеки един човек има следните характеристики: 135 | • име (name) 136 | • години (age) 137 | 138 | - Използвайки решението от предишната задача, модифицирайте така колата, че да може 139 | да и се назначава собственик (owner). 140 | 141 | - Инстанцирайте един човек и го назначете като собственик на една от колите. 142 | 143 | - Принтирайте собственика на първата кола и собственика на втората кола. 🤸 144 | ``` 145 | 146 | #### Task 3 147 | 148 | ```text 149 | Използвайки решението от предишната задача, модифицирайте така човека (person), че да може 150 | на всеки човек да се назначава приятел (friend). Приятелят да е също от тип човек (person). 151 | 152 | - Назначете приятел на човека от предишната задача. 🤝 153 | ``` 154 | 155 | ### Exercises Behaviour 156 | 157 | #### Task 4 158 | 159 | ```text 160 | Използвайки решението от Task 1 моделирайте способността на колата да: 161 | 162 | - Сменя скорости. Скоростите могат да бъдат сменяни с по една нагоре (shift up) 163 | или една надолу (shift down), като максималната скорост е 5. 164 | 165 | - Да ускорява (speed up). Като всяко едно ускорение трябва да увеличава 166 | текущата скорост с 10. Максималната скорост не може да бъде превишавана. 167 | 168 | - Да намалява (speed down). Като всяко едно намаляне трябва да намалява 169 | текущата скорост с 10. Минималната скорост е 0. 170 | 171 | - Да спира. При текуща скорост равна на 0 колата е спряла. 🛑 172 | ``` 173 | 174 |
Solution 👀 175 |

176 | 177 | - Person.java 178 | 179 | ```java 180 | public class Person { 181 | 182 | String name; 183 | int age; 184 | 185 | Person friend; 186 | } 187 | ``` 188 | 189 | - Car.java 190 | 191 | ```java 192 | public class Car { 193 | 194 | String model; 195 | String color; 196 | int currentGear; 197 | int maxSpeed; 198 | int currentSpeed; 199 | 200 | Person owner; 201 | 202 | /** 203 | * Този метод моделира качването на предавка, като максималната възможна предавка е 5. 204 | * Всеки път когато се вдигне предавка скоростта се увеличава. 205 | */ 206 | void shiftUp() { 207 | if (currentGear < 5) { 208 | currentGear++; 209 | 210 | speedUp(); // увеличи скоростта 211 | } 212 | } 213 | 214 | /** 215 | * Този метод моделира смъкването на предавка, като минималната възможна предавка е 0. 216 | * При всяко смъкване на предавка се намалява скоростта. 217 | */ 218 | void shiftDown() { 219 | if (currentGear == 0) { 220 | return; // не дей да правиш нищо защото вече сме на нулева предавка. 221 | } 222 | 223 | currentGear--; 224 | speedDown(); // намали скоростта 225 | } 226 | 227 | /** 228 | * Този метод моделира намаляването на текущата скорост. При извикването на метода текущата скорост 229 | * се намалява с 10 до достигането на нулева скорост. 230 | */ 231 | void speedDown() { 232 | int nextSpeed = currentSpeed - 10; 233 | 234 | if (nextSpeed >= 0) { 235 | currentSpeed = nextSpeed; 236 | } 237 | } 238 | 239 | /** 240 | * Този метод моделира увеличаването на скоростта, като към текущата скорост добавя 10. 241 | * Ако сме на 0-ва предавка превключваме на 1-ва. 242 | */ 243 | void speedUp() { 244 | if (currentGear == 0) { 245 | currentGear = 1; // ако сме биле на нулева предавка, превключи на 1-ва. 246 | } 247 | 248 | int nextSpeed = currentSpeed + 10; 249 | 250 | if (nextSpeed < maxSpeed) { 251 | currentSpeed = nextSpeed; // запиши новата скорост 252 | } 253 | } 254 | 255 | /** 256 | * Този метод моделира спирането на колата, като за currentSpeed записва 0. 257 | * Aко сме на по висока предавка намаляме предавката всеки път докато стигнем 0-ва предавка. 258 | */ 259 | void stop() { 260 | for (int i = currentGear; i >= 0; i--) { // смъкни от текущата до нулева предавка 261 | shiftDown(); // смъкни предавка 262 | } 263 | 264 | currentSpeed = 0; // занули остатъчната скорост 265 | } 266 | } 267 | ``` 268 | 269 | - Main.java 270 | 271 | ```java 272 | public class Main { 273 | 274 | public static void main(String[] args) { 275 | Car peugeot = new Car(); // Инстанциране на Car 276 | 277 | peugeot.model = "Peugeot"; 278 | peugeot.color = "Green"; 279 | peugeot.currentGear = 0; 280 | peugeot.currentSpeed = 0; 281 | peugeot.maxSpeed = 220; 282 | 283 | Person gosho = new Person(); // Инстанциране на Person 284 | gosho.name = "Gosho"; 285 | gosho.age = 30; 286 | 287 | Person pesho = new Person(); // Инстанциране на Person 288 | pesho.name = "Pesho"; 289 | pesho.age = 40; 290 | 291 | gosho.friend = pesho; 292 | 293 | peugeot.owner = gosho; 294 | 295 | System.out.printf("Приятелят на %s с име %s има %s с цвят %s и максимална скорост %d\n", 296 | peugeot.owner.friend.name, 297 | peugeot.owner.name, 298 | peugeot.model, 299 | peugeot.color, 300 | peugeot.maxSpeed 301 | ); 302 | 303 | System.out.printf("Текуща предавка: %d, текуща скорост: %d\n", peugeot.currentGear, peugeot.currentSpeed); 304 | peugeot.speedUp(); 305 | peugeot.speedUp(); 306 | System.out.printf("Текуща предавка: %d, текуща скорост: %d\n", peugeot.currentGear, peugeot.currentSpeed); 307 | 308 | peugeot.shiftUp(); 309 | peugeot.shiftUp(); 310 | System.out.printf("Текуща предавка: %d, текуща скорост: %d\n", peugeot.currentGear, peugeot.currentSpeed); 311 | 312 | peugeot.speedDown(); 313 | System.out.printf("Текуща предавка: %d, текуща скорост: %d\n", peugeot.currentGear, peugeot.currentSpeed); 314 | 315 | peugeot.stop(); 316 | System.out.printf("Текуща предавка: %d, текуща скорост: %d\n", peugeot.currentGear, peugeot.currentSpeed); 317 | } 318 | } 319 | ``` 320 | 321 |

322 |
--------------------------------------------------------------------------------