Object and Class
In C#, objects and classes are core concepts of object-oriented programming (OOP). A class is a blueprint for creating objects, which are instances of that class. Classes encapsulate data and behavior, helping to organize code into modular and reusable components.
Classes
A class is a logical entity that defines a type and what it can do. A class can be thought of as a blueprint that specifies the properties and methods of a type. To declare a class in C#, use the keyword class followed by the access level and a custom name, and end with curly braces.
Objects
An object is a physical entity that is created based on a class’s blueprint. An object is a block of memory that has been configured to match the class’s definition. To create an object of a class in C#, use the new keyword followed by the name of the class.
Basics of Classes
A class in C# is defined using the class keyword followed by the class name. Inside the class, you can define fields, properties, methods, and constructors.
- Fields: Variables that store the data for the class.
- Properties: Provide controlled access to the fields.
- Methods: Functions that define the behavior of the class.
- Constructors: Special methods used to initialize objects.
Example
using System;
class Person
{
// Fields
private string firstName;
private string lastName;
private int age;
// Constructor
public Person(string firstName, string lastName, int age)
{
this.firstName = firstName;
this.lastName = lastName;
this.age = age;
}
// Properties
public string FirstName
{
get { return firstName; }
set { firstName = value; }
}
public string LastName
{
get { return lastName; }
set { lastName = value; }
}
public int Age
{
get { return age; }
set { age = value; }
}
// Method
public void DisplayDetails()
{
Console.WriteLine($"Name: {firstName} {lastName}, Age: {age}");
}
}
class Program
{
static void Main()
{
// Creating an object of the Person class
Person person1 = new Person("John", "Doe", 30);
// Accessing properties
Console.WriteLine($"First Name: {person1.FirstName}");
Console.WriteLine($"Last Name: {person1.LastName}");
Console.WriteLine($"Age: {person1.Age}");
// Modifying properties
person1.Age = 31;
// Calling a method
person1.DisplayDetails();
}
}
Explanation of the Example
- Class Definition:
- We define a Person class with three private fields: firstName, lastName, and age.
- A constructor initializes these fields when an object of the Person class is created.
- Properties:
- Properties FirstName, LastName, and Age provide access to the private fields. They use get and set accessors to read and modify the field values.
- Method:
- The DisplayDetails method prints the person’s details to the console.
- Main Method:
- We create an object person1 of the Person class and initialize it with specific values.
- We access and print the properties of person1.
- We modify the Age property of person1.
- We call the DisplayDetails method to display the person’s updated details.
Core Ideas
- Encapsulation:
- The Person class encapsulates the fields firstName, lastName, and age. These fields are private, meaning they cannot be accessed directly from outside the class.
- Access to these fields is provided through public properties, ensuring controlled access and modification.
- Object Creation:
- The new keyword is used to create an instance (object) of the Person class. The constructor is called to initialize the object’s fields.
- Methods:
- Methods define behavior that objects of the class can perform. In this example, the DisplayDetails method provides a way to display the person’s details.