> For the complete documentation index, see [llms.txt](https://university-west.gitbook.io/programming-paradigms/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://university-west.gitbook.io/programming-paradigms/programming-fundamentals/datatypes/composite-datatypes/classes.md).

# Classes

#### Classes in Computer Programming

A class in computer programming is a blueprint for creating objects. Objects are instances of classes and encapsulate data for the object and methods to manipulate that data. Essentially, a class combines data and functions that operate on the data under a single name, enabling the developer to define a new data type that models real-world entities or concepts in a program. Classes support the principles of encapsulation, inheritance, and polymorphism, making them foundational to object-oriented programming (OOP).

#### Example in Python

In Python, defining a class is simple and straightforward. Here's an example of a basic class named `Car` that models a car's properties and behaviors:

```python
class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

    def display_car(self):
        return f"{self.year} {self.make} {self.model}"

# Creating an instance of Car
my_car = Car("Toyota", "Corolla", "2015")
print(my_car.display_car())
```

#### Example in C\#

C# is a strongly typed, object-oriented programming language, and creating classes in C# is also straightforward. Here's how you might define a similar `Car` class in C#:

```csharp
using System;

public class Car
{
    public string Make;
    public string Model;
    public string Year;

    public Car(string make, string model, string year)
    {
        Make = make;
        Model = model;
        Year = year;
    }

    public void DisplayCar()
    {
        Console.WriteLine($"{Year} {Make} {Model}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Car myCar = new Car("Ford", "Focus", "2018");
        myCar.DisplayCar();
    }
}
```

In both examples, the `Car` class is defined with attributes to hold data (like make, model, and year) and methods to perform operations on the data (like displaying the car's details). Instances of the class are then created with specific values, demonstrating how classes serve as templates for creating objects in programming.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://university-west.gitbook.io/programming-paradigms/programming-fundamentals/datatypes/composite-datatypes/classes.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.