Course Outline BSCS-413 Object Oriented Programming
Week # 1:
Theory:
1. Introduction of OOP paradigm.
2. Comparison with procedural programming paradigm.
3. Assignment
Lab:
1. Object-Oriented Programming
2. Encapsulation
3. Polymorphism
4. Inheritance
5. A First Simple Program
6. Using csc.exe, the C# Command-Line Compiler
7. Using the Visual Studio IDE
8. The First Sample Program, Line by Line
Week # 2: (Chapter 5)
Theory:
1. Introduction to System Analysis.
2. Model Driven Analysis Methods
a. Model Driven Approaches.
Lab:
1. Handling Syntax Errors
2. A Small Variation
3. A Second Simple Program
4. Another Data Type
5. Two Control Statements
6. The if Statement
7. The for Loop
8. Using Code Blocks
9. Semicolons, Positioning, and Indentation
10. The C# Keywords
Week # 3: (Chapter 7)
1. Introduction to Object Oriented Analysis and Design
2. An Introduction to Use-Case Modeling
3. System Concepts of Use-Case Modeling
4. Use-Case And Project Management
5. The .Net Framework class Library
Lab:
1. Data Types, Literals, and Variables
2. Why Data Types Are Important
3. C#’s Value Types
4. Integers
5. Floating-Point Types
6. The decimal Type
7. Characters
8. The bool Type
9. Some Output Options
10. Literals
11. Hexadecimal Literals
12. Character Escape Sequences
13. String Literals
14. A Closer Look at Variables
15. Initializing a Variable
16. Dynamic Initialization
17. Implicitly Typed Variables
Week # 4: (Chapter 10)
1. Introduction to Object Modeling
2. Introduction to Unified Modeling Language (UML)
Lab:
1. The Scope and Lifetime of Variables
2. Type Conversion and Casting
3. Automatic Conversions
4. Casting Incompatible Types
5. Type Conversion in Expressions
6. Using Casts in Expressions
Week # 3 (Chapter 10)
1. System Concepts of Use-Case Modeling
a. Objects and attributes
b. Objects and object instances
Lab:
2. Operators
3. Arithmetic Operators
4. Increment and Decrement
5. Relational and Logical Operators
6. Short-Circuit Logical Operators
7. The Assignment Operator
8. Compound Assignments
9. The Bitwise Operators
10. The Bitwise AND, OR, XOR, and NOT Operators
11. The Shift Operators
12. Bitwise Compound Assignments
13. The ? Operator
14. Spacing and Parentheses
15. Operator Precedence
Week # 4: (Chapter 10)
1. Behavior and Encapsulation
2. Object classes
Lab:
1. Program Control Statements
2. The if Statement
3. Nested ifs
4. The if-else-if Ladder
5. The switch Statement
6. Nested switch Statements
7. The for Loop
8. Some Variations on the for Loop
Week # 5 (Chapter 10)
1. Inheritance
2. Generalizations / specialization
a. UML representation
b. Object Class Relationship
Lab:
1. The while Loop
2. The do-while Loop
3. The foreach Loop
4. Using break to Exit a Loop
5. Using continue
6. return
7. The goto
Week # 6: (Chapter 10)
1. UML Multiplicity Notations
2. Aggregation
3. Composition
4. Messages
Lab:
1. Introducing Classes and Objects
2. Class Fundamentals
3. The General Form of a Class
4. Define a Class
5. How Objects Are Created
6. Reference Variables and Assignment
Week # 7 (Chapter 10)
1. Polymorphism
2. UML 2.0 Diagrams
Lab:
1. Methods
2. Add a Method to the Building Class
3. Return from a Method
4. Return a Value
5. Use Parameters
6. Add a Parameterized Method to Building
7. Avoiding Unreachable Code
Week # 8 (Mid Term Quiz)
Week # 9 (Chapter 10)
1. UML 2.0 Diagrams (Cont..)
2. The Process of Object Modeling
Lab:
1. Constructors
2. Parameterized Constructors
3. Add a Constructor to the Building Class
4. The new Operator Revisited
5. Using new with Value Types
6. Garbage Collection and Destructors
7. Destructors
8. The this Keyword
Week # 10 (Chapter 10)
1. The Process of object Modeling (Cont…)
Lab:
1. Arrays and Strings
2. Arrays
3. One-Dimensional Arrays
4. Multidimensional Arrays
5. Two-Dimensional Arrays
6. Arrays of Three or More Dimensions
7. Initializing Multidimensional Arrays
8. Jagged Arrays
9. Assigning Array References
10. Using the Length Property
11. Using Length with Jagged Arrays
12. Implicitly Typed Arrays
13. The foreach Loop
14. Strings
15. Constructing Strings
16. Operating on Strings
17. Arrays of Strings
18. Strings Are Immutable
19. Strings Can Be Used in switch Statements
Week # 11 (Chapter 10)
1. Modeling Use-Case Activities
2. Drawing System Sequence Diagrams
Lab:
1. A Closer Look at Methods and Classes
2. Controlling Access to Class Members
3. C#’s Access Modifi ers
4. Applying Public and Private Access
5. Controlling Access: A Case Study
6. Pass References to Methods
7. How Arguments Are Passed
8. Use ref and out Parameters
9. Use ref
10. Use out
11. Use ref and out on References
12. Use a Variable Number of Arguments
13. Return Objects
14. Return an Array
15. Method Overloading
16. Overload Constructors
17. Invoke an Overloaded Constructor Through this
18. Object Initializers
19. The Main( ) Method
20. Return Values from Main( )
21. Pass Arguments to Main( )
22. Recursion
23. Understanding static
24. Static Constructors
25. Static Classes
Week # 12 (Chapter 10)
1. Finding and Identifying the business objects
2. Class Diagrams
Lab:
1. Inheritance
2. Inheritance Basics
3. Member Access and Inheritance
4. Using Protected Access
5. Constructors and Inheritance
6. Calling Base Class Constructors
7. Inheritance and Name Hiding
8. Using base to Access a Hidden Name
9. Creating a Multilevel Hierarchy
10. When Are Constructors Called?
11. Base Class References and Derived Objects
12. Virtual Methods and Overriding
13. Why Overridden Methods?
14. Applying Virtual Methods
15. Using Abstract Classes
16. Using sealed to Prevent Inheritance
17. The object Class
18. Boxing and Unboxing
19. Is object a Universal Data Type?
Week # 13 (Chapter 18)
1. The Process of Object Oriented Design
2. Design Use-Case
3. Modeling Class Interactions Behaviors and States
Lab:
1. 12 Interfaces, Structures, and Enumerations
2. Interfaces
3. Implementing Interfaces
4. Using Interface References
5. Interface Properties
6. Interface Indexers
7. Interfaces Can Be Inherited
8. Name Hiding with Interface Inheritance
9. Explicit Implementations
10. Choosing Between an Interface and an Abstract Class
11. The .NET Standard Interfaces
12. Structures
13. Enumerations
14. Initialize an Enumeration
15. Specify the Underlying Type of an Enumeration
16. Use Enumerations
