---
title: "Classes"
url: https://docs.zeroc.com/ice/3.8/slice/user-defined-types/classes
language: java
docs_index: https://docs.zeroc.com/llms.txt
---

> For an index of every page, see [llms.txt](https://docs.zeroc.com/llms.txt).

# Classes

Programming language: Java. Other languages: [C++](https://docs.zeroc.com/ice/3.8/slice/user-defined-types/classes/cpp.md), [C#](https://docs.zeroc.com/ice/3.8/slice/user-defined-types/classes/csharp.md), [JavaScript](https://docs.zeroc.com/ice/3.8/slice/user-defined-types/classes/js.md), [MATLAB](https://docs.zeroc.com/ice/3.8/slice/user-defined-types/classes/matlab.md), [PHP](https://docs.zeroc.com/ice/3.8/slice/user-defined-types/classes/php.md), [Python](https://docs.zeroc.com/ice/3.8/slice/user-defined-types/classes/python.md), [Ruby](https://docs.zeroc.com/ice/3.8/slice/user-defined-types/classes/ruby.md), [Swift](https://docs.zeroc.com/ice/3.8/slice/user-defined-types/classes/swift.md).

A class is a user-defined type that holds a list of fields, like a [struct](https://docs.zeroc.com/ice/3.8/slice/user-defined-types/structures/java.md). You define a class with the `class` keyword:

```slice
module M
{
    class TimeOfDay
    {
        short hour;         // 0 - 23
        short minute;       // 0 - 59
        short second;       // 0 - 59
    }
}
```

Unlike a struct, a class can be empty.

Classes offer capabilities that structs do not:

- **Extensibility** You can extend a class through [inheritance](https://docs.zeroc.com/ice/3.8/slice/user-defined-types/classes/class-inheritance.md) and [optional fields](https://docs.zeroc.com/ice/3.8/slice/fields/java.md#optional-fields).
- **Graph preservation** Ice preserves the references between class instances: two references to the same instance in a [class graph](https://docs.zeroc.com/ice/3.8/slice/user-defined-types/classes/self-referential-classes/java.md) still refer to one instance after unmarshaling.
- **Null value** A class parameter or field can be null, whereas a struct parameter or field cannot.
- **Slicing** With the [sliced format](https://docs.zeroc.com/ice/3.8/slice/user-defined-types/classes/slicing-values-and-exceptions/java.md#slice-formats), a receiver can unmarshal an instance of a derived class it does not know as the most-derived base class it knows.

Marshaling a class takes more time and space than marshaling a struct, so use a class only when you need one of these capabilities.

> **Note**
>
> A class represents data that you transmit over the wire, just like a struct. You can't define operations on a Slice class or implement an interface with a Slice class.

## Language Mapping

A Slice class is mapped to a Java class with the same name. The generated class contains a public field for each Slice field (just as for structures and exceptions). Consider the following class definition:

```slice
class TimeOfDay
{
    short hour;         // 0 - 23
    short minute;       // 0 - 59
    short second;       // 0 - 59
    string tz;          // e.g. GMT, PST, EDT...
}
```

The Slice compiler generates the following code for this definition:

```java
public class TimeOfDay extends com.zeroc.Ice.Value {
    public short hour;
    public short minute;
    public short second;
    public String tz;

    public TimeOfDay() {
        this.tz = "";
    }

    public TimeOfDay(short hour, short minute, short second, String tz) {
        this.hour = hour;
        this.minute = minute;
        this.second = second;
        this.tz = tz;
    }

    public TimeOfDay clone() {
        return (TimeOfDay) super.clone();
    }

    // ...
}
```

There are several things to note about the generated code:

1. The generated class `TimeOfDay` inherits from `com.zeroc.Ice.Value`. This means that all classes implicitly inherit from `Value`, which is the ultimate ancestor of all classes.
2. The generated class contains a public field for each Slice field.
3. The generated class has a constructor with a parameter for each field, and a parameterless constructor.

### Generated Constructors

A generated class has the following constructors:

- a constructor with a parameter for each field of the class
- a parameterless constructor that initializes all fields to their default values (see [Fields](https://docs.zeroc.com/ice/3.8/slice/fields/java.md))

An empty class has only the parameterless constructor.

When a Slice class declares both optional and non-optional fields, the mapped Java class provides a third constructor that accepts arguments for just the non-optional fields; the optional fields are left unset.

The constructor with a parameter for each field allows you to create and initialize an instance in a single statement, for example:

```java
TimeOfDay tod = new TimeOfDay((short) 14, (short) 45, (short) 0, "PST"); // 2:45pm PST
```

For a derived class, this constructor has a parameter for every field of the class, including inherited fields. For example, consider the definition from [Class Inheritance](https://docs.zeroc.com/ice/3.8/slice/user-defined-types/classes/class-inheritance.md) once more:

```slice
class TimeOfDay
{
    short hour;         // 0 - 23
    short minute;       // 0 - 59
    short second;       // 0 - 59
}

class DateTime extends TimeOfDay
{
    short day;          // 1 - 31
    short month;        // 1 - 12
    short year;
}
```

The constructors for the generated classes are as follows:

```java
public class TimeOfDay extends ... {
    public TimeOfDay() {}

    public TimeOfDay(short hour, short minute, short second) {
        this.hour = hour;
        this.minute = minute;
        this.second = second;
    }

    // ...
}

public class DateTime extends TimeOfDay {
    public DateTime() {}

    public DateTime(
        short hour,
        short minute,
        short second,
        short day,
        short month,
        short year) {
        super(hour, minute, second);
        this.day = day;
        this.month = month;
        this.year = year;
    }

    // ...
}
```
