Software Architecture (SOLID) & Design Patterns in Java

  • Course provided by Udemy
  • Study type: Online
  • Starts: Anytime
  • Price: See latest price on Udemy
Udemy

Course Description

This course is about software architecture and design patterns. We will talk about two man topics: SOLID principles and design patterns. We are going to implement the problems in Java, but the theoretical background is language-independent. I highly recommend typing out the implementations several times on your own in order to get a good grasp of it.

Section 1 - SOLID Principles

  • what are SOLID principles?

  • single responsibility principle

  • open closed principle

  • Liskov's substitution principle

  • interface segregation principle

  • dependency inversion principle

  • what is dependency injection?

Section 3 - Creational Design Patterns

  • what are creational design patterns?

  • singleton pattern

  • factory pattern

  • abstract factory pattern

  • builder pattern

  • prototype pattern

Section 2 - Behavioral Design Patterns

  • what are behavioral design patterns?

  • strategy pattern

  • observer pattern

  • command pattern

  • iterator pattern

  • template pattern and null object pattern

  • visitor pattern

Section 3 - Structural Design Patterns

  • what are structural design patterns?

  • decorator pattern

  • flyweight pattern

  • facade pattern

  • adapter pattern

Section 4 - Model-View-Controller (MVC) Pattern

  • the model-view-controller (MVC) model

  • an application with Java Swing

In the first part of the course we are going to learn about the SOLID principles. We are going to talk about the theory as well as the implementations.

The second part of the course is about design patterns. We should have a deep understanding of these patterns in order to be able to write reusable software components. These techniques are becoming more and more important as applications are getting more and more complex, so - in my opinion - these topics are good to know.

Thank for joining the course, let's get started!

Who this course is for:

  • This course is meant for newbies who are familiar with Java and want to be able to write reusable code

Course content

29 sections • 83 lectures • 6h 38m total length

    Expected Outcomes

    1. understand SOLID principles understand the core of design patterns undertand object oriented design understand the single responsibility principle understand the open / closed principle understand the Liskov substitution principle understand the interface segregation principle understand the dependency inversion principle understand creational design patterns (singleton pattern, factory pattern, builder pattern and prototype pattern) understand behavioral design patterns (strategy pattern, command pattern, visitor pattern and template pattern) understand structural design patterns (adapter pattern, facade pattern and decorator pattern) Show more Show less Curated for the Udemy Business collection Requirements Basic Java Object oriented programming Description This course is about software architecture and design patterns. We will talk about two man topics: SOLID principles and design patterns . We are going to implement the problems in Java, but the theoretical background is language-independent. I highly recommend typing out the implementations several times on your own in order to get a good grasp of it. Section 1 - SOLID Principles what are SOLID principles? single responsibility principle open closed principle Liskov's substitution principle interface segregation principle dependency inversion principle what is dependency injection? Section 3 - Creational Design Patterns what are creational design patterns? singleton pattern factory pattern abstract factory pattern builder pattern prototype pattern Section 2 - Behavioral Design Patterns what are behavioral design patterns? strategy pattern observer pattern command pattern iterator pattern template pattern and null object pattern visitor pattern Section 3 - Structural Design Patterns what are structural design patterns? decorator pattern flyweight pattern facade pattern adapter pattern Section 4 - Model-View-Controller (MVC) Pattern the model-view-controller (MVC) model an application with Java Swing In the first part of the course we are going to learn about the SOLID principles . We are going to talk about the theory as well as the implementations. The second part of the course is about design patterns . We should have a deep understanding of these patterns in order to be able to write reusable software components. These techniques are becoming more and more important as applications are getting more and more complex, so - in my opinion - these topics are good to know. Thank for joining the course, let's get started! Who this course is for: This course is meant for newbies who are familiar with Java and want to be able to write reusable code Show more Show less Featured review Nadir Basalamah 17 courses 9 reviews Rating: 4.5 out of 5 2 years ago This course is a good choice for learning design pattern with code example. The course is easy to understand. Maybe in the future courses, can be added with some assignments and quizzes for enhancing the learning experience. Show more Show less Course content 29 sections • 83 lectures • 6h 38m total length Expand all sections Introduction 1 lecture • 2min Introduction Preview 01:55 SOLID Principles 1 lecture • 3min What are SOLID principles? Preview 02:48 S - Single Responsibility Principle 4 lectures • 27min Single responsibility principle introduction Preview 04:17 Single responsibility principle example 13:33 Exercise 00:33 Solution Preview 08:24 Single Responsible Principle Quiz 3 questions O - Open/Closed Principle 4 lectures • 22min The open/closed principle introduction 06:25 The open/closed principle example 11:16 Exercise 00:17 Solution 03:35 Open/Closed Principle Quiz 2 questions L - Liskov Substitution Principle 2 lectures • 15min Liskov substitution principle 03:51 Liskov substitution principle example 11:04 I - Interface Segregation Principle 4 lectures • 17min Interface segregation principle 02:29 Interface segregation principle example 08:22 Example 00:22 Solution 05:42 Interface Segregation Quiz 2 questions D - Dependency Inversion 5 lectures • 30min Dependency inversion principle introduction I 05:52 Inversion of control - dependency injection 05:59 Dependency inversion principle example 10:16 Exercise 00:14 Solution 07:21 Dependency Inversion Principle Quiz 2 questions Design Patterns 1 lecture • 3min What are design patterns? 02:56 CREATIONAL DESIGN PATTERNS 1 lecture • 1min Creational design patterns 00:10 Singleton Pattern 3 lectures • 13min What is the singleton pattern? 01:52 Singleton pattern example 07:40 Singleton pattern with enums 03:29 Singleton Pattern Quiz 2 questions 19 more sections Instructor Holczer Balazs Software Engineer 4.4 Instructor Rating 24,607 Reviews 199,548 Students 31 Courses Hi! My name is Balazs Holczer. I am from Budapest, Hungary. I am qualified as a physicist. At the moment I am working as a simulation engineer at a multinational company. I have been interested in algorithms and data structures and its implementations especially in Java since university. Later on I got acquainted with machine learning techniques, artificial intelligence, numerical methods and recipes such as solving differential equations, linear algebra, interpolation and extrapolation. These things may prove to be very very important in several fields: software engineering, research and development or investment banking. I have a special addiction to quantitative models such as the Black-Scholes model, or the Merton-model. Take a look at my website if you are interested in these topics! Show more Show less Udemy Business Teach on Udemy Get the app About us Contact us Careers Blog Help and Support Affiliate Impressum Kontakt Terms Privacy policy Cookie settings Sitemap © 2021 Udemy, Inc. window.handleCSSToggleButtonClick = function (event) { var target = event.currentTarget; var cssToggleId = target && target.dataset && target.dataset.cssToggleId; var input = cssToggleId && document.getElementById(cssToggleId); if (input) { if (input.dataset.type === 'checkbox') { input.dataset.checked = input.dataset.checked ? '' : 'checked'; } else { input.dataset.checked = input.dataset.allowToggle && input.dataset.checked ? '' : 'checked'; var radios = document.querySelectorAll('[name="' + input.dataset.name + '"]'); for (var i = 0; i (function(){window['__CF$cv$params']={r:'677cbba24dad5434',m:'0536c454a67e5c805fbeb16823ea532fe0819da7-1627796440-1800-Afc1VYK1FRZYc1omVJufdijFMATvoL6Ihd1ew02NjeP9MmbOIJKDc0xMAnOsgMwqUVGAcD8Fq8ZQ1s+wRfVL2plXtETI8Uos/Vf5crD+mJzTs7XncqDlIPyy0pn23nftHjLo0unB+GXKHnJ+LjTH9Ts6IIhyo24tZ/aYbBEWi26+HgaTg2mTeG6gZOZ2pZjPyw==',s:[0x4437828a32,0x6545db9ddf],}})();
    2. understand the core of design patterns undertand object oriented design understand the single responsibility principle understand the open / closed principle understand the Liskov substitution principle understand the interface segregation principle understand the dependency inversion principle understand creational design patterns (singleton pattern, factory pattern, builder pattern and prototype pattern) understand behavioral design patterns (strategy pattern, command pattern, visitor pattern and template pattern) understand structural design patterns (adapter pattern, facade pattern and decorator pattern) Show more Show less Curated for the Udemy Business collection Requirements Basic Java Object oriented programming Description This course is about software architecture and design patterns. We will talk about two man topics: SOLID principles and design patterns . We are going to implement the problems in Java, but the theoretical background is language-independent. I highly recommend typing out the implementations several times on your own in order to get a good grasp of it. Section 1 - SOLID Principles what are SOLID principles? single responsibility principle open closed principle Liskov's substitution principle interface segregation principle dependency inversion principle what is dependency injection? Section 3 - Creational Design Patterns what are creational design patterns? singleton pattern factory pattern abstract factory pattern builder pattern prototype pattern Section 2 - Behavioral Design Patterns what are behavioral design patterns? strategy pattern observer pattern command pattern iterator pattern template pattern and null object pattern visitor pattern Section 3 - Structural Design Patterns what are structural design patterns? decorator pattern flyweight pattern facade pattern adapter pattern Section 4 - Model-View-Controller (MVC) Pattern the model-view-controller (MVC) model an application with Java Swing In the first part of the course we are going to learn about the SOLID principles . We are going to talk about the theory as well as the implementations. The second part of the course is about design patterns . We should have a deep understanding of these patterns in order to be able to write reusable software components. These techniques are becoming more and more important as applications are getting more and more complex, so - in my opinion - these topics are good to know. Thank for joining the course, let's get started! Who this course is for: This course is meant for newbies who are familiar with Java and want to be able to write reusable code Show more Show less Featured review Nadir Basalamah 17 courses 9 reviews Rating: 4.5 out of 5 2 years ago This course is a good choice for learning design pattern with code example. The course is easy to understand. Maybe in the future courses, can be added with some assignments and quizzes for enhancing the learning experience. Show more Show less Course content 29 sections • 83 lectures • 6h 38m total length Expand all sections Introduction 1 lecture • 2min Introduction Preview 01:55 SOLID Principles 1 lecture • 3min What are SOLID principles? Preview 02:48 S - Single Responsibility Principle 4 lectures • 27min Single responsibility principle introduction Preview 04:17 Single responsibility principle example 13:33 Exercise 00:33 Solution Preview 08:24 Single Responsible Principle Quiz 3 questions O - Open/Closed Principle 4 lectures • 22min The open/closed principle introduction 06:25 The open/closed principle example 11:16 Exercise 00:17 Solution 03:35 Open/Closed Principle Quiz 2 questions L - Liskov Substitution Principle 2 lectures • 15min Liskov substitution principle 03:51 Liskov substitution principle example 11:04 I - Interface Segregation Principle 4 lectures • 17min Interface segregation principle 02:29 Interface segregation principle example 08:22 Example 00:22 Solution 05:42 Interface Segregation Quiz 2 questions D - Dependency Inversion 5 lectures • 30min Dependency inversion principle introduction I 05:52 Inversion of control - dependency injection 05:59 Dependency inversion principle example 10:16 Exercise 00:14 Solution 07:21 Dependency Inversion Principle Quiz 2 questions Design Patterns 1 lecture • 3min What are design patterns? 02:56 CREATIONAL DESIGN PATTERNS 1 lecture • 1min Creational design patterns 00:10 Singleton Pattern 3 lectures • 13min What is the singleton pattern? 01:52 Singleton pattern example 07:40 Singleton pattern with enums 03:29 Singleton Pattern Quiz 2 questions 19 more sections Instructor Holczer Balazs Software Engineer 4.4 Instructor Rating 24,607 Reviews 199,548 Students 31 Courses Hi! My name is Balazs Holczer. I am from Budapest, Hungary. I am qualified as a physicist. At the moment I am working as a simulation engineer at a multinational company. I have been interested in algorithms and data structures and its implementations especially in Java since university. Later on I got acquainted with machine learning techniques, artificial intelligence, numerical methods and recipes such as solving differential equations, linear algebra, interpolation and extrapolation. These things may prove to be very very important in several fields: software engineering, research and development or investment banking. I have a special addiction to quantitative models such as the Black-Scholes model, or the Merton-model. Take a look at my website if you are interested in these topics! Show more Show less Udemy Business Teach on Udemy Get the app About us Contact us Careers Blog Help and Support Affiliate Impressum Kontakt Terms Privacy policy Cookie settings Sitemap © 2021 Udemy, Inc. window.handleCSSToggleButtonClick = function (event) { var target = event.currentTarget; var cssToggleId = target && target.dataset && target.dataset.cssToggleId; var input = cssToggleId && document.getElementById(cssToggleId); if (input) { if (input.dataset.type === 'checkbox') { input.dataset.checked = input.dataset.checked ? '' : 'checked'; } else { input.dataset.checked = input.dataset.allowToggle && input.dataset.checked ? '' : 'checked'; var radios = document.querySelectorAll('[name="' + input.dataset.name + '"]'); for (var i = 0; i (function(){window['__CF$cv$params']={r:'677cbba24dad5434',m:'0536c454a67e5c805fbeb16823ea532fe0819da7-1627796440-1800-Afc1VYK1FRZYc1omVJufdijFMATvoL6Ihd1ew02NjeP9MmbOIJKDc0xMAnOsgMwqUVGAcD8Fq8ZQ1s+wRfVL2plXtETI8Uos/Vf5crD+mJzTs7XncqDlIPyy0pn23nftHjLo0unB+GXKHnJ+LjTH9Ts6IIhyo24tZ/aYbBEWi26+HgaTg2mTeG6gZOZ2pZjPyw==',s:[0x4437828a32,0x6545db9ddf],}})();
    3. undertand object oriented design understand the single responsibility principle understand the open / closed principle understand the Liskov substitution principle understand the interface segregation principle understand the dependency inversion principle understand creational design patterns (singleton pattern, factory pattern, builder pattern and prototype pattern) understand behavioral design patterns (strategy pattern, command pattern, visitor pattern and template pattern) understand structural design patterns (adapter pattern, facade pattern and decorator pattern) Show more Show less Curated for the Udemy Business collection Requirements Basic Java Object oriented programming Description This course is about software architecture and design patterns. We will talk about two man topics: SOLID principles and design patterns . We are going to implement the problems in Java, but the theoretical background is language-independent. I highly recommend typing out the implementations several times on your own in order to get a good grasp of it. Section 1 - SOLID Principles what are SOLID principles? single responsibility principle open closed principle Liskov's substitution principle interface segregation principle dependency inversion principle what is dependency injection? Section 3 - Creational Design Patterns what are creational design patterns? singleton pattern factory pattern abstract factory pattern builder pattern prototype pattern Section 2 - Behavioral Design Patterns what are behavioral design patterns? strategy pattern observer pattern command pattern iterator pattern template pattern and null object pattern visitor pattern Section 3 - Structural Design Patterns what are structural design patterns? decorator pattern flyweight pattern facade pattern adapter pattern Section 4 - Model-View-Controller (MVC) Pattern the model-view-controller (MVC) model an application with Java Swing In the first part of the course we are going to learn about the SOLID principles . We are going to talk about the theory as well as the implementations. The second part of the course is about design patterns . We should have a deep understanding of these patterns in order to be able to write reusable software components. These techniques are becoming more and more important as applications are getting more and more complex, so - in my opinion - these topics are good to know. Thank for joining the course, let's get started! Who this course is for: This course is meant for newbies who are familiar with Java and want to be able to write reusable code Show more Show less Featured review Nadir Basalamah 17 courses 9 reviews Rating: 4.5 out of 5 2 years ago This course is a good choice for learning design pattern with code example. The course is easy to understand. Maybe in the future courses, can be added with some assignments and quizzes for enhancing the learning experience. Show more Show less Course content 29 sections • 83 lectures • 6h 38m total length Expand all sections Introduction 1 lecture • 2min Introduction Preview 01:55 SOLID Principles 1 lecture • 3min What are SOLID principles? Preview 02:48 S - Single Responsibility Principle 4 lectures • 27min Single responsibility principle introduction Preview 04:17 Single responsibility principle example 13:33 Exercise 00:33 Solution Preview 08:24 Single Responsible Principle Quiz 3 questions O - Open/Closed Principle 4 lectures • 22min The open/closed principle introduction 06:25 The open/closed principle example 11:16 Exercise 00:17 Solution 03:35 Open/Closed Principle Quiz 2 questions L - Liskov Substitution Principle 2 lectures • 15min Liskov substitution principle 03:51 Liskov substitution principle example 11:04 I - Interface Segregation Principle 4 lectures • 17min Interface segregation principle 02:29 Interface segregation principle example 08:22 Example 00:22 Solution 05:42 Interface Segregation Quiz 2 questions D - Dependency Inversion 5 lectures • 30min Dependency inversion principle introduction I 05:52 Inversion of control - dependency injection 05:59 Dependency inversion principle example 10:16 Exercise 00:14 Solution 07:21 Dependency Inversion Principle Quiz 2 questions Design Patterns 1 lecture • 3min What are design patterns? 02:56 CREATIONAL DESIGN PATTERNS 1 lecture • 1min Creational design patterns 00:10 Singleton Pattern 3 lectures • 13min What is the singleton pattern? 01:52 Singleton pattern example 07:40 Singleton pattern with enums 03:29 Singleton Pattern Quiz 2 questions 19 more sections Instructor Holczer Balazs Software Engineer 4.4 Instructor Rating 24,607 Reviews 199,548 Students 31 Courses Hi! My name is Balazs Holczer. I am from Budapest, Hungary. I am qualified as a physicist. At the moment I am working as a simulation engineer at a multinational company. I have been interested in algorithms and data structures and its implementations especially in Java since university. Later on I got acquainted with machine learning techniques, artificial intelligence, numerical methods and recipes such as solving differential equations, linear algebra, interpolation and extrapolation. These things may prove to be very very important in several fields: software engineering, research and development or investment banking. I have a special addiction to quantitative models such as the Black-Scholes model, or the Merton-model. Take a look at my website if you are interested in these topics! Show more Show less Udemy Business Teach on Udemy Get the app About us Contact us Careers Blog Help and Support Affiliate Impressum Kontakt Terms Privacy policy Cookie settings Sitemap © 2021 Udemy, Inc. window.handleCSSToggleButtonClick = function (event) { var target = event.currentTarget; var cssToggleId = target && target.dataset && target.dataset.cssToggleId; var input = cssToggleId && document.getElementById(cssToggleId); if (input) { if (input.dataset.type === 'checkbox') { input.dataset.checked = input.dataset.checked ? '' : 'checked'; } else { input.dataset.checked = input.dataset.allowToggle && input.dataset.checked ? '' : 'checked'; var radios = document.querySelectorAll('[name="' + input.dataset.name + '"]'); for (var i = 0; i (function(){window['__CF$cv$params']={r:'677cbba24dad5434',m:'0536c454a67e5c805fbeb16823ea532fe0819da7-1627796440-1800-Afc1VYK1FRZYc1omVJufdijFMATvoL6Ihd1ew02NjeP9MmbOIJKDc0xMAnOsgMwqUVGAcD8Fq8ZQ1s+wRfVL2plXtETI8Uos/Vf5crD+mJzTs7XncqDlIPyy0pn23nftHjLo0unB+GXKHnJ+LjTH9Ts6IIhyo24tZ/aYbBEWi26+HgaTg2mTeG6gZOZ2pZjPyw==',s:[0x4437828a32,0x6545db9ddf],}})();
    4. understand the single responsibility principle understand the open / closed principle understand the Liskov substitution principle understand the interface segregation principle understand the dependency inversion principle understand creational design patterns (singleton pattern, factory pattern, builder pattern and prototype pattern) understand behavioral design patterns (strategy pattern, command pattern, visitor pattern and template pattern) understand structural design patterns (adapter pattern, facade pattern and decorator pattern) Show more Show less Curated for the Udemy Business collection Requirements Basic Java Object oriented programming Description This course is about software architecture and design patterns. We will talk about two man topics: SOLID principles and design patterns . We are going to implement the problems in Java, but the theoretical background is language-independent. I highly recommend typing out the implementations several times on your own in order to get a good grasp of it. Section 1 - SOLID Principles what are SOLID principles? single responsibility principle open closed principle Liskov's substitution principle interface segregation principle dependency inversion principle what is dependency injection? Section 3 - Creational Design Patterns what are creational design patterns? singleton pattern factory pattern abstract factory pattern builder pattern prototype pattern Section 2 - Behavioral Design Patterns what are behavioral design patterns? strategy pattern observer pattern command pattern iterator pattern template pattern and null object pattern visitor pattern Section 3 - Structural Design Patterns what are structural design patterns? decorator pattern flyweight pattern facade pattern adapter pattern Section 4 - Model-View-Controller (MVC) Pattern the model-view-controller (MVC) model an application with Java Swing In the first part of the course we are going to learn about the SOLID principles . We are going to talk about the theory as well as the implementations. The second part of the course is about design patterns . We should have a deep understanding of these patterns in order to be able to write reusable software components. These techniques are becoming more and more important as applications are getting more and more complex, so - in my opinion - these topics are good to know. Thank for joining the course, let's get started! Who this course is for: This course is meant for newbies who are familiar with Java and want to be able to write reusable code Show more Show less Featured review Nadir Basalamah 17 courses 9 reviews Rating: 4.5 out of 5 2 years ago This course is a good choice for learning design pattern with code example. The course is easy to understand. Maybe in the future courses, can be added with some assignments and quizzes for enhancing the learning experience. Show more Show less Course content 29 sections • 83 lectures • 6h 38m total length Expand all sections Introduction 1 lecture • 2min Introduction Preview 01:55 SOLID Principles 1 lecture • 3min What are SOLID principles? Preview 02:48 S - Single Responsibility Principle 4 lectures • 27min Single responsibility principle introduction Preview 04:17 Single responsibility principle example 13:33 Exercise 00:33 Solution Preview 08:24 Single Responsible Principle Quiz 3 questions O - Open/Closed Principle 4 lectures • 22min The open/closed principle introduction 06:25 The open/closed principle example 11:16 Exercise 00:17 Solution 03:35 Open/Closed Principle Quiz 2 questions L - Liskov Substitution Principle 2 lectures • 15min Liskov substitution principle 03:51 Liskov substitution principle example 11:04 I - Interface Segregation Principle 4 lectures • 17min Interface segregation principle 02:29 Interface segregation principle example 08:22 Example 00:22 Solution 05:42 Interface Segregation Quiz 2 questions D - Dependency Inversion 5 lectures • 30min Dependency inversion principle introduction I 05:52 Inversion of control - dependency injection 05:59 Dependency inversion principle example 10:16 Exercise 00:14 Solution 07:21 Dependency Inversion Principle Quiz 2 questions Design Patterns 1 lecture • 3min What are design patterns? 02:56 CREATIONAL DESIGN PATTERNS 1 lecture • 1min Creational design patterns 00:10 Singleton Pattern 3 lectures • 13min What is the singleton pattern? 01:52 Singleton pattern example 07:40 Singleton pattern with enums 03:29 Singleton Pattern Quiz 2 questions 19 more sections Instructor Holczer Balazs Software Engineer 4.4 Instructor Rating 24,607 Reviews 199,548 Students 31 Courses Hi! My name is Balazs Holczer. I am from Budapest, Hungary. I am qualified as a physicist. At the moment I am working as a simulation engineer at a multinational company. I have been interested in algorithms and data structures and its implementations especially in Java since university. Later on I got acquainted with machine learning techniques, artificial intelligence, numerical methods and recipes such as solving differential equations, linear algebra, interpolation and extrapolation. These things may prove to be very very important in several fields: software engineering, research and development or investment banking. I have a special addiction to quantitative models such as the Black-Scholes model, or the Merton-model. Take a look at my website if you are interested in these topics! Show more Show less Udemy Business Teach on Udemy Get the app About us Contact us Careers Blog Help and Support Affiliate Impressum Kontakt Terms Privacy policy Cookie settings Sitemap © 2021 Udemy, Inc. window.handleCSSToggleButtonClick = function (event) { var target = event.currentTarget; var cssToggleId = target && target.dataset && target.dataset.cssToggleId; var input = cssToggleId && document.getElementById(cssToggleId); if (input) { if (input.dataset.type === 'checkbox') { input.dataset.checked = input.dataset.checked ? '' : 'checked'; } else { input.dataset.checked = input.dataset.allowToggle && input.dataset.checked ? '' : 'checked'; var radios = document.querySelectorAll('[name="' + input.dataset.name + '"]'); for (var i = 0; i (function(){window['__CF$cv$params']={r:'677cbba24dad5434',m:'0536c454a67e5c805fbeb16823ea532fe0819da7-1627796440-1800-Afc1VYK1FRZYc1omVJufdijFMATvoL6Ihd1ew02NjeP9MmbOIJKDc0xMAnOsgMwqUVGAcD8Fq8ZQ1s+wRfVL2plXtETI8Uos/Vf5crD+mJzTs7XncqDlIPyy0pn23nftHjLo0unB+GXKHnJ+LjTH9Ts6IIhyo24tZ/aYbBEWi26+HgaTg2mTeG6gZOZ2pZjPyw==',s:[0x4437828a32,0x6545db9ddf],}})();
    5. understand the open / closed principle understand the Liskov substitution principle understand the interface segregation principle understand the dependency inversion principle understand creational design patterns (singleton pattern, factory pattern, builder pattern and prototype pattern) understand behavioral design patterns (strategy pattern, command pattern, visitor pattern and template pattern) understand structural design patterns (adapter pattern, facade pattern and decorator pattern) Show more Show less Curated for the Udemy Business collection Requirements Basic Java Object oriented programming Description This course is about software architecture and design patterns. We will talk about two man topics: SOLID principles and design patterns . We are going to implement the problems in Java, but the theoretical background is language-independent. I highly recommend typing out the implementations several times on your own in order to get a good grasp of it. Section 1 - SOLID Principles what are SOLID principles? single responsibility principle open closed principle Liskov's substitution principle interface segregation principle dependency inversion principle what is dependency injection? Section 3 - Creational Design Patterns what are creational design patterns? singleton pattern factory pattern abstract factory pattern builder pattern prototype pattern Section 2 - Behavioral Design Patterns what are behavioral design patterns? strategy pattern observer pattern command pattern iterator pattern template pattern and null object pattern visitor pattern Section 3 - Structural Design Patterns what are structural design patterns? decorator pattern flyweight pattern facade pattern adapter pattern Section 4 - Model-View-Controller (MVC) Pattern the model-view-controller (MVC) model an application with Java Swing In the first part of the course we are going to learn about the SOLID principles . We are going to talk about the theory as well as the implementations. The second part of the course is about design patterns . We should have a deep understanding of these patterns in order to be able to write reusable software components. These techniques are becoming more and more important as applications are getting more and more complex, so - in my opinion - these topics are good to know. Thank for joining the course, let's get started! Who this course is for: This course is meant for newbies who are familiar with Java and want to be able to write reusable code Show more Show less Featured review Nadir Basalamah 17 courses 9 reviews Rating: 4.5 out of 5 2 years ago This course is a good choice for learning design pattern with code example. The course is easy to understand. Maybe in the future courses, can be added with some assignments and quizzes for enhancing the learning experience. Show more Show less Course content 29 sections • 83 lectures • 6h 38m total length Expand all sections Introduction 1 lecture • 2min Introduction Preview 01:55 SOLID Principles 1 lecture • 3min What are SOLID principles? Preview 02:48 S - Single Responsibility Principle 4 lectures • 27min Single responsibility principle introduction Preview 04:17 Single responsibility principle example 13:33 Exercise 00:33 Solution Preview 08:24 Single Responsible Principle Quiz 3 questions O - Open/Closed Principle 4 lectures • 22min The open/closed principle introduction 06:25 The open/closed principle example 11:16 Exercise 00:17 Solution 03:35 Open/Closed Principle Quiz 2 questions L - Liskov Substitution Principle 2 lectures • 15min Liskov substitution principle 03:51 Liskov substitution principle example 11:04 I - Interface Segregation Principle 4 lectures • 17min Interface segregation principle 02:29 Interface segregation principle example 08:22 Example 00:22 Solution 05:42 Interface Segregation Quiz 2 questions D - Dependency Inversion 5 lectures • 30min Dependency inversion principle introduction I 05:52 Inversion of control - dependency injection 05:59 Dependency inversion principle example 10:16 Exercise 00:14 Solution 07:21 Dependency Inversion Principle Quiz 2 questions Design Patterns 1 lecture • 3min What are design patterns? 02:56 CREATIONAL DESIGN PATTERNS 1 lecture • 1min Creational design patterns 00:10 Singleton Pattern 3 lectures • 13min What is the singleton pattern? 01:52 Singleton pattern example 07:40 Singleton pattern with enums 03:29 Singleton Pattern Quiz 2 questions 19 more sections Instructor Holczer Balazs Software Engineer 4.4 Instructor Rating 24,607 Reviews 199,548 Students 31 Courses Hi! My name is Balazs Holczer. I am from Budapest, Hungary. I am qualified as a physicist. At the moment I am working as a simulation engineer at a multinational company. I have been interested in algorithms and data structures and its implementations especially in Java since university. Later on I got acquainted with machine learning techniques, artificial intelligence, numerical methods and recipes such as solving differential equations, linear algebra, interpolation and extrapolation. These things may prove to be very very important in several fields: software engineering, research and development or investment banking. I have a special addiction to quantitative models such as the Black-Scholes model, or the Merton-model. Take a look at my website if you are interested in these topics! Show more Show less Udemy Business Teach on Udemy Get the app About us Contact us Careers Blog Help and Support Affiliate Impressum Kontakt Terms Privacy policy Cookie settings Sitemap © 2021 Udemy, Inc. window.handleCSSToggleButtonClick = function (event) { var target = event.currentTarget; var cssToggleId = target && target.dataset && target.dataset.cssToggleId; var input = cssToggleId && document.getElementById(cssToggleId); if (input) { if (input.dataset.type === 'checkbox') { input.dataset.checked = input.dataset.checked ? '' : 'checked'; } else { input.dataset.checked = input.dataset.allowToggle && input.dataset.checked ? '' : 'checked'; var radios = document.querySelectorAll('[name="' + input.dataset.name + '"]'); for (var i = 0; i (function(){window['__CF$cv$params']={r:'677cbba24dad5434',m:'0536c454a67e5c805fbeb16823ea532fe0819da7-1627796440-1800-Afc1VYK1FRZYc1omVJufdijFMATvoL6Ihd1ew02NjeP9MmbOIJKDc0xMAnOsgMwqUVGAcD8Fq8ZQ1s+wRfVL2plXtETI8Uos/Vf5crD+mJzTs7XncqDlIPyy0pn23nftHjLo0unB+GXKHnJ+LjTH9Ts6IIhyo24tZ/aYbBEWi26+HgaTg2mTeG6gZOZ2pZjPyw==',s:[0x4437828a32,0x6545db9ddf],}})();
    6. understand the Liskov substitution principle understand the interface segregation principle understand the dependency inversion principle understand creational design patterns (singleton pattern, factory pattern, builder pattern and prototype pattern) understand behavioral design patterns (strategy pattern, command pattern, visitor pattern and template pattern) understand structural design patterns (adapter pattern, facade pattern and decorator pattern) Show more Show less Curated for the Udemy Business collection Requirements Basic Java Object oriented programming Description This course is about software architecture and design patterns. We will talk about two man topics: SOLID principles and design patterns . We are going to implement the problems in Java, but the theoretical background is language-independent. I highly recommend typing out the implementations several times on your own in order to get a good grasp of it. Section 1 - SOLID Principles what are SOLID principles? single responsibility principle open closed principle Liskov's substitution principle interface segregation principle dependency inversion principle what is dependency injection? Section 3 - Creational Design Patterns what are creational design patterns? singleton pattern factory pattern abstract factory pattern builder pattern prototype pattern Section 2 - Behavioral Design Patterns what are behavioral design patterns? strategy pattern observer pattern command pattern iterator pattern template pattern and null object pattern visitor pattern Section 3 - Structural Design Patterns what are structural design patterns? decorator pattern flyweight pattern facade pattern adapter pattern Section 4 - Model-View-Controller (MVC) Pattern the model-view-controller (MVC) model an application with Java Swing In the first part of the course we are going to learn about the SOLID principles . We are going to talk about the theory as well as the implementations. The second part of the course is about design patterns . We should have a deep understanding of these patterns in order to be able to write reusable software components. These techniques are becoming more and more important as applications are getting more and more complex, so - in my opinion - these topics are good to know. Thank for joining the course, let's get started! Who this course is for: This course is meant for newbies who are familiar with Java and want to be able to write reusable code Show more Show less Featured review Nadir Basalamah 17 courses 9 reviews Rating: 4.5 out of 5 2 years ago This course is a good choice for learning design pattern with code example. The course is easy to understand. Maybe in the future courses, can be added with some assignments and quizzes for enhancing the learning experience. Show more Show less Course content 29 sections • 83 lectures • 6h 38m total length Expand all sections Introduction 1 lecture • 2min Introduction Preview 01:55 SOLID Principles 1 lecture • 3min What are SOLID principles? Preview 02:48 S - Single Responsibility Principle 4 lectures • 27min Single responsibility principle introduction Preview 04:17 Single responsibility principle example 13:33 Exercise 00:33 Solution Preview 08:24 Single Responsible Principle Quiz 3 questions O - Open/Closed Principle 4 lectures • 22min The open/closed principle introduction 06:25 The open/closed principle example 11:16 Exercise 00:17 Solution 03:35 Open/Closed Principle Quiz 2 questions L - Liskov Substitution Principle 2 lectures • 15min Liskov substitution principle 03:51 Liskov substitution principle example 11:04 I - Interface Segregation Principle 4 lectures • 17min Interface segregation principle 02:29 Interface segregation principle example 08:22 Example 00:22 Solution 05:42 Interface Segregation Quiz 2 questions D - Dependency Inversion 5 lectures • 30min Dependency inversion principle introduction I 05:52 Inversion of control - dependency injection 05:59 Dependency inversion principle example 10:16 Exercise 00:14 Solution 07:21 Dependency Inversion Principle Quiz 2 questions Design Patterns 1 lecture • 3min What are design patterns? 02:56 CREATIONAL DESIGN PATTERNS 1 lecture • 1min Creational design patterns 00:10 Singleton Pattern 3 lectures • 13min What is the singleton pattern? 01:52 Singleton pattern example 07:40 Singleton pattern with enums 03:29 Singleton Pattern Quiz 2 questions 19 more sections Instructor Holczer Balazs Software Engineer 4.4 Instructor Rating 24,607 Reviews 199,548 Students 31 Courses Hi! My name is Balazs Holczer. I am from Budapest, Hungary. I am qualified as a physicist. At the moment I am working as a simulation engineer at a multinational company. I have been interested in algorithms and data structures and its implementations especially in Java since university. Later on I got acquainted with machine learning techniques, artificial intelligence, numerical methods and recipes such as solving differential equations, linear algebra, interpolation and extrapolation. These things may prove to be very very important in several fields: software engineering, research and development or investment banking. I have a special addiction to quantitative models such as the Black-Scholes model, or the Merton-model. Take a look at my website if you are interested in these topics! Show more Show less Udemy Business Teach on Udemy Get the app About us Contact us Careers Blog Help and Support Affiliate Impressum Kontakt Terms Privacy policy Cookie settings Sitemap © 2021 Udemy, Inc. window.handleCSSToggleButtonClick = function (event) { var target = event.currentTarget; var cssToggleId = target && target.dataset && target.dataset.cssToggleId; var input = cssToggleId && document.getElementById(cssToggleId); if (input) { if (input.dataset.type === 'checkbox') { input.dataset.checked = input.dataset.checked ? '' : 'checked'; } else { input.dataset.checked = input.dataset.allowToggle && input.dataset.checked ? '' : 'checked'; var radios = document.querySelectorAll('[name="' + input.dataset.name + '"]'); for (var i = 0; i (function(){window['__CF$cv$params']={r:'677cbba24dad5434',m:'0536c454a67e5c805fbeb16823ea532fe0819da7-1627796440-1800-Afc1VYK1FRZYc1omVJufdijFMATvoL6Ihd1ew02NjeP9MmbOIJKDc0xMAnOsgMwqUVGAcD8Fq8ZQ1s+wRfVL2plXtETI8Uos/Vf5crD+mJzTs7XncqDlIPyy0pn23nftHjLo0unB+GXKHnJ+LjTH9Ts6IIhyo24tZ/aYbBEWi26+HgaTg2mTeG6gZOZ2pZjPyw==',s:[0x4437828a32,0x6545db9ddf],}})();
    7. understand the interface segregation principle understand the dependency inversion principle understand creational design patterns (singleton pattern, factory pattern, builder pattern and prototype pattern) understand behavioral design patterns (strategy pattern, command pattern, visitor pattern and template pattern) understand structural design patterns (adapter pattern, facade pattern and decorator pattern) Show more Show less Curated for the Udemy Business collection Requirements Basic Java Object oriented programming Description This course is about software architecture and design patterns. We will talk about two man topics: SOLID principles and design patterns . We are going to implement the problems in Java, but the theoretical background is language-independent. I highly recommend typing out the implementations several times on your own in order to get a good grasp of it. Section 1 - SOLID Principles what are SOLID principles? single responsibility principle open closed principle Liskov's substitution principle interface segregation principle dependency inversion principle what is dependency injection? Section 3 - Creational Design Patterns what are creational design patterns? singleton pattern factory pattern abstract factory pattern builder pattern prototype pattern Section 2 - Behavioral Design Patterns what are behavioral design patterns? strategy pattern observer pattern command pattern iterator pattern template pattern and null object pattern visitor pattern Section 3 - Structural Design Patterns what are structural design patterns? decorator pattern flyweight pattern facade pattern adapter pattern Section 4 - Model-View-Controller (MVC) Pattern the model-view-controller (MVC) model an application with Java Swing In the first part of the course we are going to learn about the SOLID principles . We are going to talk about the theory as well as the implementations. The second part of the course is about design patterns . We should have a deep understanding of these patterns in order to be able to write reusable software components. These techniques are becoming more and more important as applications are getting more and more complex, so - in my opinion - these topics are good to know. Thank for joining the course, let's get started! Who this course is for: This course is meant for newbies who are familiar with Java and want to be able to write reusable code Show more Show less Featured review Nadir Basalamah 17 courses 9 reviews Rating: 4.5 out of 5 2 years ago This course is a good choice for learning design pattern with code example. The course is easy to understand. Maybe in the future courses, can be added with some assignments and quizzes for enhancing the learning experience. Show more Show less Course content 29 sections • 83 lectures • 6h 38m total length Expand all sections Introduction 1 lecture • 2min Introduction Preview 01:55 SOLID Principles 1 lecture • 3min What are SOLID principles? Preview 02:48 S - Single Responsibility Principle 4 lectures • 27min Single responsibility principle introduction Preview 04:17 Single responsibility principle example 13:33 Exercise 00:33 Solution Preview 08:24 Single Responsible Principle Quiz 3 questions O - Open/Closed Principle 4 lectures • 22min The open/closed principle introduction 06:25 The open/closed principle example 11:16 Exercise 00:17 Solution 03:35 Open/Closed Principle Quiz 2 questions L - Liskov Substitution Principle 2 lectures • 15min Liskov substitution principle 03:51 Liskov substitution principle example 11:04 I - Interface Segregation Principle 4 lectures • 17min Interface segregation principle 02:29 Interface segregation principle example 08:22 Example 00:22 Solution 05:42 Interface Segregation Quiz 2 questions D - Dependency Inversion 5 lectures • 30min Dependency inversion principle introduction I 05:52 Inversion of control - dependency injection 05:59 Dependency inversion principle example 10:16 Exercise 00:14 Solution 07:21 Dependency Inversion Principle Quiz 2 questions Design Patterns 1 lecture • 3min What are design patterns? 02:56 CREATIONAL DESIGN PATTERNS 1 lecture • 1min Creational design patterns 00:10 Singleton Pattern 3 lectures • 13min What is the singleton pattern? 01:52 Singleton pattern example 07:40 Singleton pattern with enums 03:29 Singleton Pattern Quiz 2 questions 19 more sections Instructor Holczer Balazs Software Engineer 4.4 Instructor Rating 24,607 Reviews 199,548 Students 31 Courses Hi! My name is Balazs Holczer. I am from Budapest, Hungary. I am qualified as a physicist. At the moment I am working as a simulation engineer at a multinational company. I have been interested in algorithms and data structures and its implementations especially in Java since university. Later on I got acquainted with machine learning techniques, artificial intelligence, numerical methods and recipes such as solving differential equations, linear algebra, interpolation and extrapolation. These things may prove to be very very important in several fields: software engineering, research and development or investment banking. I have a special addiction to quantitative models such as the Black-Scholes model, or the Merton-model. Take a look at my website if you are interested in these topics! Show more Show less Udemy Business Teach on Udemy Get the app About us Contact us Careers Blog Help and Support Affiliate Impressum Kontakt Terms Privacy policy Cookie settings Sitemap © 2021 Udemy, Inc. window.handleCSSToggleButtonClick = function (event) { var target = event.currentTarget; var cssToggleId = target && target.dataset && target.dataset.cssToggleId; var input = cssToggleId && document.getElementById(cssToggleId); if (input) { if (input.dataset.type === 'checkbox') { input.dataset.checked = input.dataset.checked ? '' : 'checked'; } else { input.dataset.checked = input.dataset.allowToggle && input.dataset.checked ? '' : 'checked'; var radios = document.querySelectorAll('[name="' + input.dataset.name + '"]'); for (var i = 0; i (function(){window['__CF$cv$params']={r:'677cbba24dad5434',m:'0536c454a67e5c805fbeb16823ea532fe0819da7-1627796440-1800-Afc1VYK1FRZYc1omVJufdijFMATvoL6Ihd1ew02NjeP9MmbOIJKDc0xMAnOsgMwqUVGAcD8Fq8ZQ1s+wRfVL2plXtETI8Uos/Vf5crD+mJzTs7XncqDlIPyy0pn23nftHjLo0unB+GXKHnJ+LjTH9Ts6IIhyo24tZ/aYbBEWi26+HgaTg2mTeG6gZOZ2pZjPyw==',s:[0x4437828a32,0x6545db9ddf],}})();
    8. understand the dependency inversion principle understand creational design patterns (singleton pattern, factory pattern, builder pattern and prototype pattern) understand behavioral design patterns (strategy pattern, command pattern, visitor pattern and template pattern) understand structural design patterns (adapter pattern, facade pattern and decorator pattern) Show more Show less Curated for the Udemy Business collection Requirements Basic Java Object oriented programming Description This course is about software architecture and design patterns. We will talk about two man topics: SOLID principles and design patterns . We are going to implement the problems in Java, but the theoretical background is language-independent. I highly recommend typing out the implementations several times on your own in order to get a good grasp of it. Section 1 - SOLID Principles what are SOLID principles? single responsibility principle open closed principle Liskov's substitution principle interface segregation principle dependency inversion principle what is dependency injection? Section 3 - Creational Design Patterns what are creational design patterns? singleton pattern factory pattern abstract factory pattern builder pattern prototype pattern Section 2 - Behavioral Design Patterns what are behavioral design patterns? strategy pattern observer pattern command pattern iterator pattern template pattern and null object pattern visitor pattern Section 3 - Structural Design Patterns what are structural design patterns? decorator pattern flyweight pattern facade pattern adapter pattern Section 4 - Model-View-Controller (MVC) Pattern the model-view-controller (MVC) model an application with Java Swing In the first part of the course we are going to learn about the SOLID principles . We are going to talk about the theory as well as the implementations. The second part of the course is about design patterns . We should have a deep understanding of these patterns in order to be able to write reusable software components. These techniques are becoming more and more important as applications are getting more and more complex, so - in my opinion - these topics are good to know. Thank for joining the course, let's get started! Who this course is for: This course is meant for newbies who are familiar with Java and want to be able to write reusable code Show more Show less Featured review Nadir Basalamah 17 courses 9 reviews Rating: 4.5 out of 5 2 years ago This course is a good choice for learning design pattern with code example. The course is easy to understand. Maybe in the future courses, can be added with some assignments and quizzes for enhancing the learning experience. Show more Show less Course content 29 sections • 83 lectures • 6h 38m total length Expand all sections Introduction 1 lecture • 2min Introduction Preview 01:55 SOLID Principles 1 lecture • 3min What are SOLID principles? Preview 02:48 S - Single Responsibility Principle 4 lectures • 27min Single responsibility principle introduction Preview 04:17 Single responsibility principle example 13:33 Exercise 00:33 Solution Preview 08:24 Single Responsible Principle Quiz 3 questions O - Open/Closed Principle 4 lectures • 22min The open/closed principle introduction 06:25 The open/closed principle example 11:16 Exercise 00:17 Solution 03:35 Open/Closed Principle Quiz 2 questions L - Liskov Substitution Principle 2 lectures • 15min Liskov substitution principle 03:51 Liskov substitution principle example 11:04 I - Interface Segregation Principle 4 lectures • 17min Interface segregation principle 02:29 Interface segregation principle example 08:22 Example 00:22 Solution 05:42 Interface Segregation Quiz 2 questions D - Dependency Inversion 5 lectures • 30min Dependency inversion principle introduction I 05:52 Inversion of control - dependency injection 05:59 Dependency inversion principle example 10:16 Exercise 00:14 Solution 07:21 Dependency Inversion Principle Quiz 2 questions Design Patterns 1 lecture • 3min What are design patterns? 02:56 CREATIONAL DESIGN PATTERNS 1 lecture • 1min Creational design patterns 00:10 Singleton Pattern 3 lectures • 13min What is the singleton pattern? 01:52 Singleton pattern example 07:40 Singleton pattern with enums 03:29 Singleton Pattern Quiz 2 questions 19 more sections Instructor Holczer Balazs Software Engineer 4.4 Instructor Rating 24,607 Reviews 199,548 Students 31 Courses Hi! My name is Balazs Holczer. I am from Budapest, Hungary. I am qualified as a physicist. At the moment I am working as a simulation engineer at a multinational company. I have been interested in algorithms and data structures and its implementations especially in Java since university. Later on I got acquainted with machine learning techniques, artificial intelligence, numerical methods and recipes such as solving differential equations, linear algebra, interpolation and extrapolation. These things may prove to be very very important in several fields: software engineering, research and development or investment banking. I have a special addiction to quantitative models such as the Black-Scholes model, or the Merton-model. Take a look at my website if you are interested in these topics! Show more Show less Udemy Business Teach on Udemy Get the app About us Contact us Careers Blog Help and Support Affiliate Impressum Kontakt Terms Privacy policy Cookie settings Sitemap © 2021 Udemy, Inc. window.handleCSSToggleButtonClick = function (event) { var target = event.currentTarget; var cssToggleId = target && target.dataset && target.dataset.cssToggleId; var input = cssToggleId && document.getElementById(cssToggleId); if (input) { if (input.dataset.type === 'checkbox') { input.dataset.checked = input.dataset.checked ? '' : 'checked'; } else { input.dataset.checked = input.dataset.allowToggle && input.dataset.checked ? '' : 'checked'; var radios = document.querySelectorAll('[name="' + input.dataset.name + '"]'); for (var i = 0; i (function(){window['__CF$cv$params']={r:'677cbba24dad5434',m:'0536c454a67e5c805fbeb16823ea532fe0819da7-1627796440-1800-Afc1VYK1FRZYc1omVJufdijFMATvoL6Ihd1ew02NjeP9MmbOIJKDc0xMAnOsgMwqUVGAcD8Fq8ZQ1s+wRfVL2plXtETI8Uos/Vf5crD+mJzTs7XncqDlIPyy0pn23nftHjLo0unB+GXKHnJ+LjTH9Ts6IIhyo24tZ/aYbBEWi26+HgaTg2mTeG6gZOZ2pZjPyw==',s:[0x4437828a32,0x6545db9ddf],}})();
    9. understand creational design patterns (singleton pattern, factory pattern, builder pattern and prototype pattern) understand behavioral design patterns (strategy pattern, command pattern, visitor pattern and template pattern) understand structural design patterns (adapter pattern, facade pattern and decorator pattern) Show more Show less Curated for the Udemy Business collection Requirements Basic Java Object oriented programming Description This course is about software architecture and design patterns. We will talk about two man topics: SOLID principles and design patterns . We are going to implement the problems in Java, but the theoretical background is language-independent. I highly recommend typing out the implementations several times on your own in order to get a good grasp of it. Section 1 - SOLID Principles what are SOLID principles? single responsibility principle open closed principle Liskov's substitution principle interface segregation principle dependency inversion principle what is dependency injection? Section 3 - Creational Design Patterns what are creational design patterns? singleton pattern factory pattern abstract factory pattern builder pattern prototype pattern Section 2 - Behavioral Design Patterns what are behavioral design patterns? strategy pattern observer pattern command pattern iterator pattern template pattern and null object pattern visitor pattern Section 3 - Structural Design Patterns what are structural design patterns? decorator pattern flyweight pattern facade pattern adapter pattern Section 4 - Model-View-Controller (MVC) Pattern the model-view-controller (MVC) model an application with Java Swing In the first part of the course we are going to learn about the SOLID principles . We are going to talk about the theory as well as the implementations. The second part of the course is about design patterns . We should have a deep understanding of these patterns in order to be able to write reusable software components. These techniques are becoming more and more important as applications are getting more and more complex, so - in my opinion - these topics are good to know. Thank for joining the course, let's get started! Who this course is for: This course is meant for newbies who are familiar with Java and want to be able to write reusable code Show more Show less Featured review Nadir Basalamah 17 courses 9 reviews Rating: 4.5 out of 5 2 years ago This course is a good choice for learning design pattern with code example. The course is easy to understand. Maybe in the future courses, can be added with some assignments and quizzes for enhancing the learning experience. Show more Show less Course content 29 sections • 83 lectures • 6h 38m total length Expand all sections Introduction 1 lecture • 2min Introduction Preview 01:55 SOLID Principles 1 lecture • 3min What are SOLID principles? Preview 02:48 S - Single Responsibility Principle 4 lectures • 27min Single responsibility principle introduction Preview 04:17 Single responsibility principle example 13:33 Exercise 00:33 Solution Preview 08:24 Single Responsible Principle Quiz 3 questions O - Open/Closed Principle 4 lectures • 22min The open/closed principle introduction 06:25 The open/closed principle example 11:16 Exercise 00:17 Solution 03:35 Open/Closed Principle Quiz 2 questions L - Liskov Substitution Principle 2 lectures • 15min Liskov substitution principle 03:51 Liskov substitution principle example 11:04 I - Interface Segregation Principle 4 lectures • 17min Interface segregation principle 02:29 Interface segregation principle example 08:22 Example 00:22 Solution 05:42 Interface Segregation Quiz 2 questions D - Dependency Inversion 5 lectures • 30min Dependency inversion principle introduction I 05:52 Inversion of control - dependency injection 05:59 Dependency inversion principle example 10:16 Exercise 00:14 Solution 07:21 Dependency Inversion Principle Quiz 2 questions Design Patterns 1 lecture • 3min What are design patterns? 02:56 CREATIONAL DESIGN PATTERNS 1 lecture • 1min Creational design patterns 00:10 Singleton Pattern 3 lectures • 13min What is the singleton pattern? 01:52 Singleton pattern example 07:40 Singleton pattern with enums 03:29 Singleton Pattern Quiz 2 questions 19 more sections Instructor Holczer Balazs Software Engineer 4.4 Instructor Rating 24,607 Reviews 199,548 Students 31 Courses Hi! My name is Balazs Holczer. I am from Budapest, Hungary. I am qualified as a physicist. At the moment I am working as a simulation engineer at a multinational company. I have been interested in algorithms and data structures and its implementations especially in Java since university. Later on I got acquainted with machine learning techniques, artificial intelligence, numerical methods and recipes such as solving differential equations, linear algebra, interpolation and extrapolation. These things may prove to be very very important in several fields: software engineering, research and development or investment banking. I have a special addiction to quantitative models such as the Black-Scholes model, or the Merton-model. Take a look at my website if you are interested in these topics! Show more Show less Udemy Business Teach on Udemy Get the app About us Contact us Careers Blog Help and Support Affiliate Impressum Kontakt Terms Privacy policy Cookie settings Sitemap © 2021 Udemy, Inc. window.handleCSSToggleButtonClick = function (event) { var target = event.currentTarget; var cssToggleId = target && target.dataset && target.dataset.cssToggleId; var input = cssToggleId && document.getElementById(cssToggleId); if (input) { if (input.dataset.type === 'checkbox') { input.dataset.checked = input.dataset.checked ? '' : 'checked'; } else { input.dataset.checked = input.dataset.allowToggle && input.dataset.checked ? '' : 'checked'; var radios = document.querySelectorAll('[name="' + input.dataset.name + '"]'); for (var i = 0; i (function(){window['__CF$cv$params']={r:'677cbba24dad5434',m:'0536c454a67e5c805fbeb16823ea532fe0819da7-1627796440-1800-Afc1VYK1FRZYc1omVJufdijFMATvoL6Ihd1ew02NjeP9MmbOIJKDc0xMAnOsgMwqUVGAcD8Fq8ZQ1s+wRfVL2plXtETI8Uos/Vf5crD+mJzTs7XncqDlIPyy0pn23nftHjLo0unB+GXKHnJ+LjTH9Ts6IIhyo24tZ/aYbBEWi26+HgaTg2mTeG6gZOZ2pZjPyw==',s:[0x4437828a32,0x6545db9ddf],}})();
    10. understand behavioral design patterns (strategy pattern, command pattern, visitor pattern and template pattern) understand structural design patterns (adapter pattern, facade pattern and decorator pattern) Show more Show less Curated for the Udemy Business collection Requirements Basic Java Object oriented programming Description This course is about software architecture and design patterns. We will talk about two man topics: SOLID principles and design patterns . We are going to implement the problems in Java, but the theoretical background is language-independent. I highly recommend typing out the implementations several times on your own in order to get a good grasp of it. Section 1 - SOLID Principles what are SOLID principles? single responsibility principle open closed principle Liskov's substitution principle interface segregation principle dependency inversion principle what is dependency injection? Section 3 - Creational Design Patterns what are creational design patterns? singleton pattern factory pattern abstract factory pattern builder pattern prototype pattern Section 2 - Behavioral Design Patterns what are behavioral design patterns? strategy pattern observer pattern command pattern iterator pattern template pattern and null object pattern visitor pattern Section 3 - Structural Design Patterns what are structural design patterns? decorator pattern flyweight pattern facade pattern adapter pattern Section 4 - Model-View-Controller (MVC) Pattern the model-view-controller (MVC) model an application with Java Swing In the first part of the course we are going to learn about the SOLID principles . We are going to talk about the theory as well as the implementations. The second part of the course is about design patterns . We should have a deep understanding of these patterns in order to be able to write reusable software components. These techniques are becoming more and more important as applications are getting more and more complex, so - in my opinion - these topics are good to know. Thank for joining the course, let's get started! Who this course is for: This course is meant for newbies who are familiar with Java and want to be able to write reusable code Show more Show less Featured review Nadir Basalamah 17 courses 9 reviews Rating: 4.5 out of 5 2 years ago This course is a good choice for learning design pattern with code example. The course is easy to understand. Maybe in the future courses, can be added with some assignments and quizzes for enhancing the learning experience. Show more Show less Course content 29 sections • 83 lectures • 6h 38m total length Expand all sections Introduction 1 lecture • 2min Introduction Preview 01:55 SOLID Principles 1 lecture • 3min What are SOLID principles? Preview 02:48 S - Single Responsibility Principle 4 lectures • 27min Single responsibility principle introduction Preview 04:17 Single responsibility principle example 13:33 Exercise 00:33 Solution Preview 08:24 Single Responsible Principle Quiz 3 questions O - Open/Closed Principle 4 lectures • 22min The open/closed principle introduction 06:25 The open/closed principle example 11:16 Exercise 00:17 Solution 03:35 Open/Closed Principle Quiz 2 questions L - Liskov Substitution Principle 2 lectures • 15min Liskov substitution principle 03:51 Liskov substitution principle example 11:04 I - Interface Segregation Principle 4 lectures • 17min Interface segregation principle 02:29 Interface segregation principle example 08:22 Example 00:22 Solution 05:42 Interface Segregation Quiz 2 questions D - Dependency Inversion 5 lectures • 30min Dependency inversion principle introduction I 05:52 Inversion of control - dependency injection 05:59 Dependency inversion principle example 10:16 Exercise 00:14 Solution 07:21 Dependency Inversion Principle Quiz 2 questions Design Patterns 1 lecture • 3min What are design patterns? 02:56 CREATIONAL DESIGN PATTERNS 1 lecture • 1min Creational design patterns 00:10 Singleton Pattern 3 lectures • 13min What is the singleton pattern? 01:52 Singleton pattern example 07:40 Singleton pattern with enums 03:29 Singleton Pattern Quiz 2 questions