SWENG3101 Object Oriented Programming Chapter 3

SWENG3101 Object Oriented Programming

• This course covers Object Oriented Programming concepts at AASTU's Software Engineering Department.
• The course structure includes Chapter 3: Classes and Objects.

Chapter 3: Classes and Objects

• Objectives: Describe objects and classes, use classes to model objects, access object data and methods, distinguish between instance and static variables/methods, create objects using constructors, and use the keyword 'this'.
• Content: Classes and Objects, Access Control (private, protected, public), Attributes and Methods, and Constructors.
• Objects: Entities in the real world, are tangible and intangible, and distinctly identifiable (e.g., student, room, account). Objects consist of data and operations that manipulate that data.
  • Example (Student): Data includes name, gender, birth date, address, phone number, and age; operations assign and change these data values.
  • Example (Dog): Data includes name, breed, color; operations include barking, wagging, running.
• Class: A template or blueprint that defines the properties and behaviors of objects. Java classes use variables to define data fields and methods to define actions. Each object can have different data, but all objects of a class share the same data types and methods. A class functions as a mold or template dictating object capabilities.
  • Objects are instances of a class. Many instances of a class can be created. Creating an instance is called instantiation.
  • Example: A class called "Circle" can have instances "circle1", "circle2", "circle3", all sharing the same method 'getArea' but having different radii.

Declaring and Creating Classes

• Syntax: The format for declaring a class in Java. A class is a blueprint/template from which object are created
• Creating Objects: How to create and instantiate objects from classes. The syntax involved in object creation.
  • Example Syntax: ClassName objectName = new ClassName(); (or with parameters)

Accessing Data Members

• Access data members and methods using the dot (.) operator.
  • Example: objectName.dataMember or objectName.methodName().

Example Code (GradeBook, Circle)

• Examples of defining classes and how to implement related functions/methods
  • GradeBook Example: Demonstrates a class for representing grade books with methods to show display messages.
  • Circle Example: A template/class used to create circles with methods like 'area()' and 'circumf()'.

Declaring Variables (Local, Instance, Static)

• Local Variables: Declared inside methods/constructors/blocks, visible only within that section, and destroyed when the method completes. No default values. Must be initialized before use.
• Instance Variables: Declared inside a class but outside any method. Created when an object is created, destroyed when object is destroyed. Have default values (0 for numbers, false for booleans, null for object references).
• Static Variables (Class Variables): Declared with the 'static' keyword inside a class and outside any method. Only one copy exists per class regardless of number of objects. Typically used as constants(rare). Created and destroyed with the program.

Instance Variables (cont'd)

• Instance variables have default values. Their values can be assigned during declaration or within a constructor. Access modifiers can be applied.

Example Code (Local Variables, Static Variables)

• Examples demonstrating local variables, their limitations, and static variables
• Example 1: Implementing examples using pupAge() to illustrate the local scope of a variable
• Example 2: Creating variable examples including methods, to access a class's instance/static variables.

Example Code (BankAccount)

• Demonstrating basic bank account functionality using variables.
• Demonstrates deposit and withdrawal functions
• Includes constructor initialization of the bank account balance.

Example Code (Predicting Output)

• Example with sample variable/method declarations to demonstrate the use of instance and static variables/methods and their scope.
  • Shows how to declare methods that accept parameters, how to call/define methods that take parameters.

Methods Explained

• Defining Methods: The structure/syntax of a method declaration. Includes return type and parameters
• Parameters & Arguments: Explained together to understand parameter passing.
  • Arguments are the values passed to a method's parameters when the method is called.
• Return Statements: To understand that a method that return a value must include a return statement.
• Example Codes (Circle, GradeBook2): These examples demonstrate the use of methods with parameters and return values

Constructors

• Special methods that are fundamental to instantiating/creating new objects of an object from a class definition.
• Purpose: To initialize instance variables of a class when creating an object.
  • Includes constructor format, no-argument/no-arg constructor format
• Example Codes(Circle Constructor, Employee, Account): demonstrate various types of constructor implementation.

Accessors and Mutators

• Accessors: Public methods to access private instance variables.
• Mutators: Public methods to change the values of a variable. Used to set private class-level variables' values.

The this Keyword

• Purpose: Use to resolve naming conflicts between local variables and instance variables, or call another constructor.
• Example Codes: Detailed example uses of this keyword to demonstrate its use to refer to current object.

Packages

• Purpose: Organize related classes, avoid naming conflicts, enhance reusability.
  • Include built-in packages (lang, util), user-defined packages.
• Structure example: A diagram showing different structures of Java packages.

Subpackages

• How subpackages are organized. Subpackages are nested packages within a package. Explains explicitly importing relevant sub-packages.
• Example Code (importing specific packages/subpackages): Explains the syntax for importing relevant sub-packages to use in any code.

Static Import

• Purpose: Directly access static members of a class without using the class name.
• Syntax: import static packageName.ClassName.*;

Exercises (Included)

• Sample/Illustrative exercises on Object-Oriented Programming
  • Demonstrates different ways of using relevant concepts

Additional Information/Topics

• Wrapper Classes, JAR files (Creating). These are not comprehensively covered in this summary.

This quiz covers the foundational concepts of Classes and Objects in Object Oriented Programming, tailored for AASTU's Software Engineering Department. You'll explore access control, attributes, methods, and constructors, as well as practical examples like students and dogs. Test your knowledge and understanding of the essential aspects of OOP.