High-Quality Classes and Class Hierarchies Best Practices in Object-Oriented Design SoftUni Team Technical Trainers Software University

Slides:



Advertisements
Similar presentations
Software Engineering Class design. Class design – ADT Abstract Data Types:  Why use ADT? Hidden implementation details Changes do not affect whole program.
Advertisements

ITEC200 – Week03 Inheritance and Class Hierarchies.
Namespaces, Cohesion and Coupling Veselin Georgiev National Academy for Software Development academy.devbg.org Svetlin Nakov Telerik Corporation
2.5 OOP Principles Part 2 academy.zariba.com 1. Lecture Content 1.Polymorphism 2.Cohesion 3.Coupling 2.
Svetlin Nakov Telerik Corporation
Software Quality Assurance QA Engineering, Testing, Bug Tracking, Test Automation Software University Technical Trainers SoftUni Team.
C# Advanced Topics Methods, Classes and Objects SoftUni Team Technical Trainers Software University
Methods Writing and using methods, overloads, ref, out SoftUni Team Technical Trainers Software University
Inheritance and Class Hierarchies Ellen Walker CPSC 201 Data Structures Hiram College.
Design Patterns: Introduction. Creational Design Patterns General and reusable solutions to common problems in software design Software University
Software Testing Lifecycle Exit Criteria Evaluation, Continuous Integration Ivan Yonkov Technical Trainer Software University.
Design Patterns: Structural Design Patterns
High-Quality Programming Code Code Correctness, Readability, Maintainability, Testability, Etc. SoftUni Team Technical Trainers Software University
JavaScript Design Patterns Private Fields, Module, Revealing Module, Revealing Prototype, … Software University Technical Trainers SoftUni.
Advanced Concepts Svetlin Nakov Telerik Corporation
Conditional Statements Implementing Control-Flow Logic in C# SoftUni Team Technical Trainers Software University
Loops Repeating Code Multiple Times SoftUni Team Technical Trainers Software University
Database APIs and Wrappers
Svetlin Nakov Technical Trainer Software University
Build Processes and Continuous Integration Automating Build Processes Software University Technical Trainers SoftUni Team.
Encapsulation and Polymorphism Encapsulation, Polymorphism, Class Hierarchies, Cohesion and Coupling SoftUni Team Technical Trainers Software University.
Defensive Programming, Assertions and Exceptions Designing Fault-Resistant Code SoftUni Team Technical Trainers Software University
Best Practices in the Object-Oriented Design Learning & Development Telerik Software Academy.
Test-Driven Development Learn the "Test First" Approach to Coding SoftUni Team Technical Trainers Software University
Good Design of Classes Classes let us create Abstract Data Types Should be well aware of benefits – Hide implementation details – Localize changes – Interface.
Defining Classes Classes, Fields, Constructors, Methods, Properties SoftUni Team Technical Trainers Software University
Static Members and Namespaces Static Members, Indexers, Operators, Namespaces SoftUni Team Technical Trainers Software University
Design Patterns Introduction General and reusable solutions to common problems in software design SoftUni Team Software University
Defining Classes Classes, Fields, Constructors, Methods, Properties Svetlin Nakov Technical Trainer Software University
Code Formatting Correctly Formatting the Source Code Svetlin Nakov Technical Trainer Software University
JavaScript Modules and Patterns Private Fields, Module, Revealing Module, Revealing Prototype, … Software University Technical Trainers.
High-Quality Programming Code Code Correctness, Readability, Maintainability Svetlin Nakov Technical Trainer Software University
Polymorphism, Class Hierarchies, Exceptions, Strong Cohesion and Loose Coupling Telerik Software Academy Object-Oriented Programming.
High-Quality Code: Course Introduction Course Introduction SoftUni Team Technical Trainers Software University
Inheritance and Class Hierarchies Chapter 3. Chapter 3: Inheritance and Class Hierarchies2 Chapter Objectives To understand inheritance and how it facilitates.
Design Patterns: Structural Design Patterns General and reusable solutions to common problems in software design Software University
Prototype Chain and Inheritance Prototype chain, Inheritance, Accessing Base Members Software University Technical Trainers SoftUni Team.
Object-Oriented Programming Course Introduction Svetlin Nakov Technical Trainer Software University
Reflection Programming under the hood SoftUni Team Technical Trainers Software University
Mocking with Moq Tools for Easier Unit Testing SoftUni Team Technical Trainers Software University
Operators and Expressions
Design Patterns: Behavioral Design Patterns General and reusable solutions to common problems in software design Software University
Code Formatting Formatting the Source Code Correctly SoftUni Team Technical Trainers Software University
Mocking Unit Testing Methods with External Dependencies SoftUni Team Technical Trainers Software University
Mocking with Moq Mocking tools for easier unit testing Svetlin Nakov Technical Trainer Software University
Lecture 12 Implementation Issues with Polymorphism.
Polymorphism, Class Hierarchies, Exceptions, Strong Cohesion and Loose Coupling.
Best Practices in the Object-Oriented Design Vesko Kolev Telerik Corporation
 Description of Inheritance  Base Class Object  Subclass, Subtype, and Substitutability  Forms of Inheritance  Modifiers and Inheritance  The Benefits.
Advanced Tree Structures Binary Trees, AVL Tree, Red-Black Tree, B-Trees, Heaps SoftUni Team Technical Trainers Software University
Functional Programming Data Aggregation and Nested Queries Ivan Yonkov Technical Trainer Software University
Classes CS 162 (Summer 2009). Parts of a Class Instance Fields Methods.
Inheritance Class Hierarchies SoftUni Team Technical Trainers Software University
Stacks and Queues Processing Sequences of Elements SoftUni Team Technical Trainers Software University
Generics SoftUni Team Technical Trainers Software University
High-Quality Programming Code Code Correctness, Readability, Maintainability, Testability, Etc. SoftUni Team Technical Trainers Software University
Encapsulation and Polymorphism
Abstract Classes, Abstract Methods, Override Methods
Interface Segregation / Dependency Inversion
OCP and Liskov Principles
Object-Oriented Programming Concepts
Mocking tools for easier unit testing
OOP Course - Virtual Trip
Repeating Code Multiple Times
Inheritance Class Hierarchies SoftUni Team Technical Trainers C# OOP
Java OOP Overview Classes and Objects, Members and Class Definition, Access Modifier, Encapsulation Java OOP Overview SoftUni Team Technical Trainers.
Abstraction, Interface, Inheritance, Polymorphism, Override / Overload
MPCS – Advanced java Programming
Polymorphism, Interfaces, Abstract Classes
What is Encapsulation, Benefits, Implementation in Java
Presentation transcript:

High-Quality Classes and Class Hierarchies Best Practices in Object-Oriented Design SoftUni Team Technical Trainers Software University

Table of Contents 1.Basic Principles  Cohesion, Coupling  Abstraction, Encapsulation, Inheritance, Polymorphism 2.High-Quality Classes  Correct Use of OOP Principles  Class Methods, Constructors, Data  Good Reasons to Create a Class 3.Typical Mistakes to Avoid in OO Design 2

Basic Principles Cohesion, Coupling, Inheritance and Polymorphism

Cohesion  Cohesion measures how closely are all the routines in a class/module  Cohesion must be strong  Classes must contain strongly related functionality and aim for a single purpose  Strong cohesion is a useful tool for managing complexity  Well-defined abstractions keep cohesion strong  Bad abstractions have weak cohesion 4

Good and Bad Cohesion  Good: hard disk, CD-ROM, floppy  Bad: spaghetti code 5

6  Strong cohesion example  Class System.Math  Sin(), Cos(), Asin()  Sqrt(), Pow(), Exp()  Math.PI, Math.E Strong Cohesion double sideA = 40, sideB = 69; double angleAB = Math.PI / 3; double sideC = Math.Pow(sideA, 2) + Math.Pow(sideB, 2) - 2 * sideA * sideB * Math.Cos(angleAB); 2 * sideA * sideB * Math.Cos(angleAB); double sidesSqrtSum = Math.Sqrt(sideA) + Math.Sqrt(sideB) + Math.Sqrt(sideC); Math.Sqrt(sideA) + Math.Sqrt(sideB) + Math.Sqrt(sideC);

7  Coupling describes how tightly a class or routine is related to other classes or routines  Coupling must be kept loose  Modules must depend little on each other  All classes and routines must have  Small, direct, visible, and flexible relationships to other classes and routines  One module must be easily used by other modules, without complex dependencies Coupling

8  Loose Coupling  Easily replace old HDD  Easily place this HDD to another motherboard  Tight Coupling  Where is the video adapter?  Can you change the video controller on this MB? Loose and Tight Coupling

9 Loose Coupling – Example class Report { public bool LoadFromFile(string fileName) {…} public bool LoadFromFile(string fileName) {…} public bool SaveToFile(string fileName) {…} public bool SaveToFile(string fileName) {…}} class Printer { public static int Print(Report report) {…} public static int Print(Report report) {…}} class Program { static void Main() static void Main() { Report myReport = new Report(); Report myReport = new Report(); myReport.LoadFromFile("C:\\DailyReport.rep"); myReport.LoadFromFile("C:\\DailyReport.rep"); Printer.Print(myReport); Printer.Print(myReport); }}

10 Tight Coupling – Example class MathParams { public static double operand; public static double operand; public static double result; public static double result;} class MathUtil { public static void Sqrt() public static void Sqrt() { MathParams.result = CalcSqrt(MathParams.operand); MathParams.result = CalcSqrt(MathParams.operand); }}… MathParams.operand = 64; MathUtil.Sqrt();Console.WriteLine(MathParams.result);

11  Inheritance is the ability of a class to implicitly gain all members from another class  Inheritance is principal concept in OOP  The class whose methods are inherited is called base (parent) class  The class that gains new functionality is called derived (child) class  Use inheritance to:  Reuse repeating code: data and program logic  Simplify code maintenance Inheritance

12  Polymorphism is a principal concept in OOP  The ability to handle the objects of a specific class as instances of its parent class  To call abstract functionality  Polymorphism allows to create hierarchies with more valuable logical structure  Polymorphism is a tool to enable code reuse  Common logic is taken to the base class  Specific logic is implemented in the derived class in a overridden method Polymorphism

13  In C# polymorphism is implemented through:  virtual methods  abstract methods  interface s  override overrides a virtual method Polymorphism

14 Polymorphism – Example class Person { public virtual void PrintName() public virtual void PrintName() { Console.Write("I am a person."); Console.Write("I am a person."); }} class Trainer : Person { public override void PrintName() public override void PrintName() { Console.Write( Console.Write( "I am a trainer. " + base.PrintName()); "I am a trainer. " + base.PrintName()); }} class Student : Person { public override void PrintName() public override void PrintName() { Console.WriteLine("I am a student."); Console.WriteLine("I am a student."); }}

High-Quality Classes How to Design High-Quality Classes? Abstraction, Cohesion and Coupling

16  Present a consistent level of abstraction in the class contract (publicly visible members)  What abstraction the class is implementing?  Does it represent only one thing?  Does the class name well describe its purpose?  Does the class define clear and easy to understand public interface?  Does the class hide all its implementation details? High-Quality Classes: Abstraction

17 Good Abstraction – Example public class Font { public string Name { get; set; } public string Name { get; set; } public float SizeInPoints { get; set; } public float SizeInPoints { get; set; } public FontStyle Style { get; set; } public FontStyle Style { get; set; } public Font(string name, float sizeInPoints, FontStyle style) public Font(string name, float sizeInPoints, FontStyle style) { this.Name = name; this.Name = name; this.SizeInPoints = sizeInPoints; this.SizeInPoints = sizeInPoints; this.Style = style; this.Style = style; } public void DrawString(DrawingSurface surface, public void DrawString(DrawingSurface surface, string str, int x, int y) { … } string str, int x, int y) { … } public Size MeasureString(string str) { … } public Size MeasureString(string str) { … }}

18 Bad Abstraction – Example public class Program { public string title; public string title; public int size; public int size; public Color color; public Color color; public void InitializeCommandStack(); public void InitializeCommandStack(); public void PushCommand(Command command); public void PushCommand(Command command); public Command PopCommand(); public Command PopCommand(); public void ShutdownCommandStack(); public void ShutdownCommandStack(); public void InitializeReportFormatting(); public void InitializeReportFormatting(); public void FormatReport(Report report); public void FormatReport(Report report); public void PrintReport(Report report); public void PrintReport(Report report); public void InitializeGlobalData(); public void InitializeGlobalData(); public void ShutdownGlobalData(); public void ShutdownGlobalData();} Does this class really represents a "program"? Is this name good? Does this class really have a single purpose?

19  Define operations along with their opposites, e.g.  Open() and Close()  Move unrelated methods in another class, e.g.  In class Employee if you need to calculate Age by given DateOfBirth  Create а static method CalcAgeByBirthDate(…) in a separate class DateUtils  Group related methods into a single class  Does the class name correspond to the class content? Establishing Good Abstraction

20  Beware of breaking the interface abstraction due to evolution  Don't add public members inconsistent with abstraction  Example: in class called Employee at some time we add method for accessing the DB with SQL Establishing Good Abstraction (2) class Employee { public string FirstName { get; set; } public string FirstName { get; set; } public string LastName; { get; set; } public string LastName; { get; set; } … public SqlCommand FindByPrimaryKeySqlCommand(int id); public SqlCommand FindByPrimaryKeySqlCommand(int id);}

21  Minimize visibility of classes and members  In C# start from private and move to internal, protected and public if required  Classes should hide their implementation details  A principle called encapsulation in OOP  Anything which is not part of the class interface should be declared private  Classes with good encapsulated classes are: less complex, easier to maintain, more loosely coupled  Classes should keep their state clean  throw an exception if invalid data is being assigned Encapsulation

22  Never declare fields public (except constants)  Use properties / methods to access the fields  Don't put private implementation details in the public interface  All public members should be consistent with the abstraction represented by the class  Don't make a method public just because it calls only public methods  Don't make assumptions about how the class will be used or will not be used Encapsulation (2)

23  Don't violate encapsulation semantically!  Don't rely on non-documented internal behavior or side effects  Wrong example:  Skip calling ConnectToDB() because you just called FindEmployeeById() which should open connection  Another wrong example:  Use String.Empty instead of Titles.NoTitle because you know both values are the same Encapsulation (3)

24  Containment is "has a" relationship  Example: Keyboard has a set of Keys  Inheritance is "is a" relationship  Design for inheritance: make the class abstract  Disallow inheritance: make the class sealed / final  Subclasses must be usable through the base class interface  Without the need for the user to know the difference  Declare utility classes static Inheritance or Containment?

25  Don't hide methods in a subclass  Example: if the class Timer has private method Start(), don't define Start() in AtomTimer  Move common interfaces, data, and behavior as high as possible in the inheritance tree  This maximizes the code reuse  Be suspicious of base classes of which there is only one derived class  Do you really need this additional level of inheritance? Inheritance

26  Be suspicious of classes that override a routine and do nothing inside  Is the overridden routine used correctly?  Avoid deep inheritance trees  Don't create more than 6 levels of inheritance  Avoid using a base class’s protected data fields in a derived class  Provide protected accessor methods or properties instead Inheritance (2)

27  Prefer inheritance to extensive type checking:  Consider inheriting Circle and Square from Shape and override the abstract action Draw() Inheritance (3) switch (shape.Type) { case Shape.Circle: case Shape.Circle: shape.DrawCircle(); shape.DrawCircle(); break; break; case Shape.Square: case Shape.Square: shape.DrawSquare(); shape.DrawSquare(); break; break;......}

28  Keep the number of methods in a class as small as possible  reduce complexity  Minimize direct methods calls to other classes  Minimize indirect methods calls to other classes  Less external method calls == less coupling  Also known as "fan-out"  Minimize the extent to which a class collaborates with other classes  Reduce the coupling between classes Class Methods and Data

29  Initialize all member data in all constructors, if possible  Uninitialized data is error prone  Partially initialized data is even more evil  Incorrect example: assign FirstName in class Person but leave LastName empty  Initialize data members in the same order in which they are declared  Prefer deep copies to shallow copies ( ICloneable should make deep copy) Class Constructors

30  Use private constructors to prohibit direct class instantiation  Use design patterns for common design situations  Creational patterns like Singleton, Factory Method, Abstract Factory  Structural patterns like Adapter, Bridge, Composite, Decorator, Façade  Behavioral patterns like Command, Iterator, Observer, Strategy, Template Method Use Design Patterns

31  Model real-world objects with OOP classes  Model abstract objects, processes, etc.  Reduce complexity  Work at higher level  Isolate complexity  Hide it in a class  Hide implementation details  encapsulation  Limit effects of changes  Changes affect only their class Top Reasons to Create a Class

32  Hide global data  Work through methods  Group variables that are used together  Make central points of control  Single task should be done at single place  Avoid duplicating code  Facilitate code reuse  Use class hierarchies and virtual methods  Package related operations together Top Reasons to Create a Class (2)

33  Group related classes together in namespaces  Follow consistent naming convention Namespaces namespace Utils { class MathUtils { … } class MathUtils { … } class StringUtils { … } class StringUtils { … }} namespace DataAccessLayer { class GenericDAO { … } class GenericDAO { … } class EmployeeDAO { … } class EmployeeDAO { … } class AddressDAO { … } class AddressDAO { … }}

Typical Mistakes to Avoid

35  Never use plural nouns in class names  Unless they hold some kind of collection!  Bad example:  Good example: Plural Used for a Class Name public class Teachers : ITeacher { public string Name { get; set; } public string Name { get; set; } public List Courses { get; set; } public List Courses { get; set; }} public class GameFieldConstants { public const int MinX = 100; public const int MinX = 100; public const int MaxX = 700; public const int MaxX = 700;} Singular: Teacher (a single teacher, not several)

36  Don't throw exceptions without parameters: Throwing an Exception without Parameters public ICourse CreateCourse(string name, string town) { if (name == null) if (name == null) { throw new ArgumentNullException(); throw new ArgumentNullException(); } if (town == null) if (town == null) { throw new ArgumentNullException(); throw new ArgumentNullException(); } return new Course(name, town); return new Course(name, town);} Which parameter is null here?

37  Check for invalid data in the setters and constructors  Not in the getter! Parameters Checked in the Getter public string Town { get get { if (string.IsNullOrWhiteSpace(this.town)) if (string.IsNullOrWhiteSpace(this.town)) throw new ArgumentNullException(); throw new ArgumentNullException(); return this.town; return this.town; } set set { this.town = value; this.town = value; }} Put this check in the setter!

38  Always use this.XXX instead of XXX to access members within the class:  StyleCop checks this and issues a warning Missing this for Local Members public class Course { public string Name { get; set; } public string Name { get; set; } public Course(string name) public Course(string name) { Name = name; Name = name; }} Use this.Name

39  Use null when a value is missing, not 0 or ""  Make a field / property nullable to access null values or just disallow missing values  Bad example:  Correct alternatives: Empty String for Missing Values Teacher teacher = new Teacher(""); Teacher teacher = new Teacher(); Teacher teacher = new Teacher(null); Empty name is a very bad idea! Use null

40  Don't use "magic" numbers  Especially when the class has members related to those numbers: Magic Numbers in the Classes public class Wolf : Animal { … bool TryEatAnimal(Animal animal) bool TryEatAnimal(Animal animal) { if (animal.Size <= 4) if (animal.Size <= 4) { return true; return true; } }} This if statement is very wrong. 4 is the size of the Wolf, which has a Size property inherited from Animal. Why not use this.Size instead of 4 ?

41  Call the base constructor to reuse the object's state initialization: Base Constructor Not Called public class Course { public string Name { get; set; } public string Name { get; set; } public Course(string name) public Course(string name) { this.Name = name; } { this.Name = name; }} public class LocalCourse : Course { public string Lab { get; set; } public string Lab { get; set; } public Course(string name, string lab) public Course(string name, string lab) { this.Name = name; this.Name = name; this.Lab = lab; this.Lab = lab; }} : base (name) Call the base constructor instead!

42  Never copy-paste the code of the base in the inherited class Repeating Code in the Base and Child Classes public class Course { public string Name { get; set; } public string Name { get; set; } public ITeacher Teacher { get; set; } public ITeacher Teacher { get; set; }} public class LocalCourse : Course { public string Name { get; set; } public string Name { get; set; } public ITeacher Teacher { get; set; } public ITeacher Teacher { get; set; } public string Lab { get; set; } public string Lab { get; set; }} Why are these fields duplicated and not inherited?

43  Be careful to keep fields well encapsulated Broken Encapsulation by Parameterless Constructor public class Course { public string Name { get; private set; } public string Name { get; private set; } public ITeacher Teacher { get; private set; } public ITeacher Teacher { get; private set; } public Course(string name, ITeacher teacher) public Course(string name, ITeacher teacher) { if (name == null) if (name == null) throw ArgumentNullException("name"); throw ArgumentNullException("name"); if (teacher == null) if (teacher == null) throw ArgumentNullException("teacher"); throw ArgumentNullException("teacher"); this.Name = name; this.Name = name; this.Teacher = teacher; this.Teacher = teacher; } public Course() { } public Course() { }} Breaks encapsulation: Name & Teacher can be left null.

44  Base class should never know about its children! Coupling the Base Class with Its Child Classes public class Course { public override string ToString() public override string ToString() { StringBuilder result = new StringBuilder(); StringBuilder result = new StringBuilder(); … if (this is ILocalCourse) if (this is ILocalCourse) { result.Append("Lab = " + ((ILocalCourse)this).Lab); result.Append("Lab = " + ((ILocalCourse)this).Lab); } if (this is IOffsiteCourse) if (this is IOffsiteCourse) { result.Append("Town = " + ((IOffsiteCourse)this).Town); result.Append("Town = " + ((IOffsiteCourse)this).Town); } return result.ToString(); return result.ToString(); }}

45  Don't define IEnumerable fields and use them as List (broken abstraction) Hidden Interpretation of Base Class as Its Specific Child Class public class Container public class Container { public IEnumerable Items { get; } public IEnumerable Items { get; } public Container() public Container() { this.Items = new List (); this.Items = new List (); } public void AddItem (T item) public void AddItem (T item) { (this.Items as List ).Add(item); (this.Items as List ).Add(item); }} Bad practice: hidden List Bad practice: hidden List

46  Use List in the field and return it where IEnumerable is required: Hidden Interpretation of Base Class as Its Specific Child Class (2) public class Container public class Container { private List items = new List (); private List items = new List (); public IEnumerable Items public IEnumerable Items { get { return this.items; } get { return this.items; } } public void AddItem (T item) public void AddItem (T item) { this.Items.Add(item); this.Items.Add(item); }} This partially breaks encapsulation. Think about cloning to keep your items safe.

47 Repeating Code Not Moved Upper in the Class Hierarchy public abstract class Course : ICourse { public string Name { get; set; } public string Name { get; set; } public ITeacher Teacher { get; set; } public ITeacher Teacher { get; set; }} public class LocalCourse : Course, ILocalCourse { public string Lab { get; set; } public string Lab { get; set; } public override string ToString() public override string ToString() { StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder(); sb.Append(this.GetType().Name); sb.Append(this.GetType().Name); sb.AppendFormat("(Name={0}", this.Name); sb.AppendFormat("(Name={0}", this.Name); if (!(this.Teacher == null)) if (!(this.Teacher == null)) sb.AppendFormat("; Teacher={0}", this.Teacher.Name); sb.AppendFormat("; Teacher={0}", this.Teacher.Name); sb.AppendFormat("; Lab={0})", this.Lab); sb.AppendFormat("; Lab={0})", this.Lab); return sb.ToString(); return sb.ToString(); }} // continues at the next slide Repeating code

48  When overriding methods, call the base method if you need its functionality, don't copy-paste it! Repeating Code Not Moved Upper in the Class Hierarchy (2) public class OffsiteCourse : Course, ILocalCourse { public string Town { get; set; } public string Town { get; set; } public override string ToString() public override string ToString() { StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder(); sb.Append(this.GetType().Name); sb.Append(this.GetType().Name); sb.AppendFormat("(Name={0}", this.Name); sb.AppendFormat("(Name={0}", this.Name); if (!(this.Teacher == null)) if (!(this.Teacher == null)) sb.AppendFormat("; Teacher={0}", this.Teacher.Name); sb.AppendFormat("; Teacher={0}", this.Teacher.Name); sb.AppendFormat("; Town={0})", this.Town); sb.AppendFormat("; Town={0})", this.Town); return sb.ToString(); return sb.ToString(); }} Repeating code

49 Move the Repeating Code Upper in the Class Hierarchy public abstract class Course : ICourse { public string Name { get; set; } public string Name { get; set; } public ITeacher Teacher { get; set; } public ITeacher Teacher { get; set; } public override string ToString() public override string ToString() { StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder(); sb.Append(this.GetType().Name); sb.Append(this.GetType().Name); sb.AppendFormat("(Name={0}", this.Name); sb.AppendFormat("(Name={0}", this.Name); if (!(this.Teacher == null)) if (!(this.Teacher == null)) sb.AppendFormat("; Teacher={0}", this.Teacher.Name); sb.AppendFormat("; Teacher={0}", this.Teacher.Name); return sb.ToString(); return sb.ToString(); }} continues on the next slide

50 Move the Repeating Code in Upper in the Class Hierarchy (2) public class LocalCourse : Course, ILocalCourse { public string Lab { get; set; } public string Lab { get; set; } public override string ToString() public override string ToString() { return base.ToString() + "; Lab=" + this.Lab + ")"; return base.ToString() + "; Lab=" + this.Lab + ")"; }} public class OffsiteCourse : Course, ILocalCourse { public string Town { get; set; } public string Town { get; set; } public override string ToString() public override string ToString() { return base.ToString() + "; Town=" + this.Town + ")"; return base.ToString() + "; Town=" + this.Town + ")"; }}

High-Quality Classes Exercises in Class

52 1.Designing classes  Use OOP principles correctly  Abstraction – use a consistent level of abstraction throughout the project  Inheritance – don’t repeat code  Encapsulation – ensure the object state is always valid  Polymorphism – show the logical structure of the code more clearly  Ensure strong cohesion and loose coupling  Use design patterns if needed Summary

? ? ? ? ? ? ? ? ? High-Quality Classes

License  This course (slides, examples, demos, videos, homework, etc.) is licensed under the "Creative Commons Attribution- NonCommercial-ShareAlike 4.0 International" licenseCreative Commons Attribution- NonCommercial-ShareAlike 4.0 International 54  Attribution: this work may contain portions from  "Fundamentals of Computer Programming with C#" book by Svetlin Nakov & Co. under CC-BY-SA licenseFundamentals of Computer Programming with C#CC-BY-SA  "C# Part I" course by Telerik Academy under CC-BY-NC-SA licenseC# Part ICC-BY-NC-SA

Free Software University  Software University Foundation – softuni.orgsoftuni.org  Software University – High-Quality Education, Profession and Job for Software Developers  softuni.bg softuni.bg  Software Facebook  facebook.com/SoftwareUniversity facebook.com/SoftwareUniversity  Software YouTube  youtube.com/SoftwareUniversity youtube.com/SoftwareUniversity  Software University Forums – forum.softuni.bgforum.softuni.bg