/ /

/ /

SDK de Dispositivo Atlas

Java SDK

Datos del modelo

Define a Realm Object Model - Java SDK

Los SDK de dispositivos Atlas están obsoletos. Consulte deprecation page for details.

Definir un Objeto Realm

Para definir un objeto Realm en su aplicación, cree una subclase de RealmObject o implementar RealmModel.

Importante

All Realm objects must provide an empty constructor.
Todos los objetos de Realm deben utilizar el public modificador de visibilidad en Java o el modificador de visibilidad open en Kotlin.

Nota

Class names are limited to a maximum of 57 UTF-8 characters.

Prolongar `RealmObject`

El siguiente bloque de código muestra un objeto Realm que describe una Rana. Esta clase Rana puede ser almacenada en Realm porque extends la clase RealmObject.

import io.realm.RealmObject;
// To add an object to your Realm Schema, extend RealmObject
public class Frog extends RealmObject {
    private String name;
    private int age;
    private String species;
    private String owner;
    public Frog(String name, int age, String species, String owner) {
        this.name = name;
        this.age = age;
        this.species = species;
        this.owner = owner;
    }
    public Frog(){} // RealmObject subclasses must provide an empty constructor
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getSpecies() { return species; }
    public void setSpecies(String species) { this.species = species; }
    public String getOwner() { return owner; }
    public void setOwner(String owner) { this.owner = owner; }
}

import io.realm.RealmObject
// providing default values for each constructor parameter
// fulfills the need for an empty constructor
open class Frog(
    var name: String? = null,
    var age: Int = 0,
    var species: String? = null,
    var owner: String? = null
) : RealmObject() // To add an object to your Realm Schema, extend RealmObject

implementar `RealmModel`

The following code block shows a Realm object that describes a Frog. This Frog class can be stored in Realm because it implements the RealmModel class and uses the @RealmClass annotation:

import io.realm.RealmModel;
import io.realm.annotations.RealmClass;
@RealmClass
public class Frog implements RealmModel {
    private String name;
    private int age;
    private String species;
    private String owner;
    public Frog(String name, int age, String species, String owner) {
        this.name = name;
        this.age = age;
        this.species = species;
        this.owner = owner;
    }
    public Frog() {} // RealmObject subclasses must provide an empty constructor
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getSpecies() { return species; }
    public void setSpecies(String species) { this.species = species; }
    public String getOwner() { return owner; }
    public void setOwner(String owner) { this.owner = owner; }
}

Importante

All Realm objects must use the public visibility modifier.

import io.realm.RealmModel
import io.realm.annotations.RealmClass
@RealmClass
open class Frog : RealmModel {
    var name: String? = null
    var age = 0
    var species: String? = null
    var owner: String? = null
    constructor(name: String?, age: Int, species: String?, owner: String?) {
        this.name = name
        this.age = age
        this.species = species
        this.owner = owner
    }
    constructor() {} // RealmObject subclasses must provide an empty constructor
}

Importante

All Realm objects must use the open visibility modifier.

Tip

Using RealmObject Methods

When you create a Realm object by extending the RealmObject class, you can access RealmObject class methods dynamically on instances of your Realm object. Realm objects created by implementing RealmModel can access those same methods statically through the RealmObject class:

// With RealmObject
frogRealmObject.isValid();
frogRealmObject.addChangeListener(listener);
// With RealmModel
RealmObject.isValid(frogRealmModel);
RealmObject.addChangeListener(frogRealmModel, listener);

// With RealmObject
frogRealmObject?.isValid
frogRealmObject?.addChangeListener(listener)
// With RealmModel
RealmObject.isValid(frogRealmModel)
RealmObject.addChangeListener(frogRealmModel, listener)

Listas

Realm objects can contain lists of non-Realm-object data types:

A diferencia de las listas de objetos Realm, estas listas pueden contener valores nulos. Si no se deben permitir valores nulos, use la anotación @Required.

import io.realm.RealmList;
import io.realm.RealmObject;
public class Frog extends RealmObject {
    private String name;
    private int age;
    private String species;
    private String owner;
    private RealmList<String> favoriteColors;
    public Frog(String name, int age, String species, String owner, RealmList<String> favoriteColors) {
        this.name = name;
        this.age = age;
        this.species = species;
        this.owner = owner;
        this.favoriteColors = favoriteColors;
    }
    public Frog(){} // RealmObject subclasses must provide an empty constructor
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getSpecies() { return species; }
    public void setSpecies(String species) { this.species = species; }
    public String getOwner() { return owner; }
    public void setOwner(String owner) { this.owner = owner; }
    public RealmList<String> getFavoriteColors() { return favoriteColors; }
    public void setFavoriteColors(RealmList<String> favoriteColors) { this.favoriteColors = favoriteColors; }
}

import io.realm.RealmList
import io.realm.RealmObject
open class Frog : RealmObject {
    var name: String? = null
    var age = 0
    var species: String? = null
    var owner: String? = null
    var favoriteColors : RealmList<String>? = null
    constructor(
        name: String?,
        age: Int,
        species: String?,
        owner: String?,
        favoriteColors: RealmList<String>?
    ) {
        this.name = name
        this.age = age
        this.species = species
        this.owner = owner
        this.favoriteColors = favoriteColors
    }
    constructor() {} // RealmObject subclasses must provide an empty constructor
}

Tip

Data Types: Lists

Definir un campo de objeto incrustado

Realm permite anidar objetos dentro de otros objetos. Esto tiene varias ventajas:

If using Sync, objects translate into MongoDB documents that follow a denormalized data model.
Cuando borras un objeto que contiene otro objeto, la operación de borrar remueve ambos objetos del realm, de modo que no se acumulan objetos no utilizados en el archivo Realm, ocupando espacio valioso en los dispositivos móviles de los usuarios.

Para incrustar un objeto, establece la propiedad embedded de la anotación @RealmClass en true en la clase que desees anidar dentro de otra clase:

import io.realm.RealmObject;
import io.realm.annotations.RealmClass;
@RealmClass(embedded=true)
public class Fly extends RealmObject {
    private String name;
    public Fly(String name) {
        this.name = name;
    }
    public Fly() {} // RealmObject subclasses must provide an empty constructor
}

import io.realm.RealmObject
import io.realm.annotations.RealmClass
@RealmClass(embedded = true)
open class Fly : RealmObject {
    private var name: String? = null
    constructor(name: String?) {
        this.name = name
    }
    constructor() {} // RealmObject subclasses must provide an empty constructor
}

Luego, cada vez que hagas referencia a esa clase desde otra clase, Realm integrará la clase referenciada dentro de la clase envolvente, como en el siguiente ejemplo:

import io.realm.RealmObject;
public class Frog extends RealmObject {
    private String name;
    private int age;
    private String species;
    private String owner;
    private Fly lastMeal;
    public Frog(String name, int age, String species, String owner, Fly lastMeal) {
        this.name = name;
        this.age = age;
        this.species = species;
        this.owner = owner;
        this.lastMeal = lastMeal;
    }
    public Frog(){} // RealmObject subclasses must provide an empty constructor
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getSpecies() { return species; }
    public void setSpecies(String species) { this.species = species; }
    public String getOwner() { return owner; }
    public void setOwner(String owner) { this.owner = owner; }
    public Fly getLastMeal() { return lastMeal; }
    public void setLastMeal(Fly lastMeal) { this.lastMeal = lastMeal; }
}

import io.realm.RealmObject
open class Frog : RealmObject {
    var name: String? = null
    var age = 0
    var species: String? = null
    var owner: String? = null
    var lastMeal: Fly? = null
    constructor(
        name: String?,
        age: Int,
        species: String?,
        owner: String?,
        lastMeal: Fly?
    ) {
        this.name = name
        this.age = age
        this.species = species
        this.owner = owner
        this.lastMeal = lastMeal
    }
    constructor() {} // RealmObject subclasses must provide an empty constructor
}

Tip

Tipos de datos: Objetos incrustados

Anotaciones

Use annotations to customize your Realm object models.

llave primaria

New in version 10.6.0: Realm automatically indexes primary key fields. Previously, Realm only indexed String primary keys automatically.

Realm trata los campos marcados con la anotación @PrimaryKey como claves principales para su esquema de objeto correspondiente. Las claves principales están sujetas a las siguientes limitaciones:

Puede definir solo una clave principal por esquema de objeto.
Los valores de clave primaria deben ser únicos en todas las instancias de un objeto en un realm. Intentar insertar un valor de clave primaria duplicado da como resultado una RealmPrimaryKeyConstraintException.
Los valores de la llave primaria son inmutables. Para cambiar el valor de la clave primaria de un objeto, se debe borrar el objeto original e insertar uno nuevo con un valor de clave primaria diferente.
Los objetos incrustados no pueden definir una clave principal.

You can create a primary key with any of the following types:

String
UUID
ObjectId
Integer or int
Long or long
Short or short
Byte or byte[]

Los tipos no primitivos pueden contener un valor de null como clave principal, pero solo para un objeto de un tipo específico, ya que cada valor de clave principal debe ser único. Intentar insertar un objeto con una clave principal existente en un dominio generará una excepción RealmPrimaryKeyConstraintException.

Realm indexa automáticamente los campos de clave principal, lo que le permite leer y modificar objetos de manera eficiente en función de su clave principal.

No puedes cambiar el campo de llave primaria de un tipo de objeto Realm después de añadir cualquier objeto de ese tipo a un realm. Si usas Sync, no puedes cambiar el campo llave primaria de un objeto tras definir la llave primaria en tu backend esquema.

Embedded objects cannot contain primary keys.

You may optionally define a primary key for an object type as part of the object schema with the @PrimaryKey annotation:

import io.realm.RealmObject;
import io.realm.annotations.PrimaryKey;
public class Frog extends RealmObject {
    @PrimaryKey private String name;
    private int age;
    private String species;
    private String owner;
    public Frog(String name, int age, String species, String owner) {
        this.name = name;
        this.age = age;
        this.species = species;
        this.owner = owner;
    }
    public Frog(){} // RealmObject subclasses must provide an empty constructor
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getSpecies() { return species; }
    public void setSpecies(String species) { this.species = species; }
    public String getOwner() { return owner; }
    public void setOwner(String owner) { this.owner = owner; }
}

import io.realm.RealmObject
import io.realm.annotations.PrimaryKey
open class Frog : RealmObject {
    @PrimaryKey var name : String? = null
    var age = 0
    var species: String? = null
    var owner: String? = null
    constructor(name: String?, age: Int, species: String?, owner: String?) {
        this.name = name
        this.age = age
        this.species = species
        this.owner = owner
    }
    constructor() {} // RealmObject subclasses must provide an empty constructor
}

Campos obligatorios

import io.realm.RealmObject;
import io.realm.annotations.Required;
public class Frog extends RealmObject {
    @Required private String name;
    private int age;
    private String species;
    private String owner;
    public Frog(String name, int age, String species, String owner) {
        this.name = name;
        this.age = age;
        this.species = species;
        this.owner = owner;
    }
    public Frog(){} // RealmObject subclasses must provide an empty constructor
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getSpecies() { return species; }
    public void setSpecies(String species) { this.species = species; }
    public String getOwner() { return owner; }
    public void setOwner(String owner) { this.owner = owner; }
}

import io.realm.RealmObject
import io.realm.annotations.Required
open class Frog : RealmObject {
    @Required var name: String? = null
    var age = 0
    var species: String? = null
    var owner: String? = null
    constructor(name: String?, age: Int, species: String?, owner: String?) {
        this.name = name
        this.age = age
        this.species = species
        this.owner = owner
    }
    constructor() {} // RealmObject subclasses must provide an empty constructor
}

Campos opcionales

Los campos marcados con objetos de tipo Java y tipos nulos de Kotlin (terminados en ?) son nulos por defecto. Todos los demás tipos (primitivos, tipos de objetos de Kotlin no nulos) son obligatorios por defecto. Puedes marcar un campo anulable con la anotación @Requerido para evitar que ese campo contenga un valor nulo. RealmLists nunca son nulos, pero puedes usar la anotación @Required para evitar que los objetos en una lista tengan un valor nulo, incluso si el tipo base lo permitiría. No puedes marcar un RealmList de subtipos RealmObject como obligatorio.

Puedes realizar cualquiera de los siguientes tipos requeridos:

String
UUID
ObjectId
Integer
Long
Short
Byte or byte[]
Boolean
Float
Double
Date
RealmList

Primitive types such as int and the RealmList type are implicitly required. Fields with the RealmObject type are always nullable, and cannot be made required.

Importante

Tipos y anulabilidad de Kotlin

In Kotlin, types are non-nullable by default unless you explicitly add a ? suffix to the type. You can only annotate nullable types. Using the @Required annotation on non-nullable types will fail compilation.

Nullable fields are optional by default in Realm, unless otherwise specified with the @Required annotation. The following types are nullable:

String
Date
UUID
ObjectId
Integer
Long
Short
Byte or byte[]
Boolean
Float
Double

Los tipos primitivos como int y long no pueden ser nulos por defecto y no se pueden hacer anulables, ya que no se les puede asignar un valor nulo.

En Kotlin, los campos se consideran nulos solo si un campo está marcado como nulo con el operador Kotlin ? excepto los siguientes tipos:

String
Date
UUID
ObjectId
Decimal128
RealmAny

You can require any type that ends with the Kotlin ? operator, such as Int?.

El tipo RealmList no es nulo de manera predeterminada y no se puede convertir en nulo.

Default Field Values

To assign a default value to a field, use the built-in language features to assign default values.

Use the class constructor(s) to assign default values:

import io.realm.RealmObject;
public class Frog extends RealmObject {
    private String name = "Kitty";
    private int age;
    private String species;
    private String owner;
    public Frog(String name, int age, String species, String owner) {
        this.name = name;
        this.age = age;
        this.species = species;
        this.owner = owner;
    }
    public Frog(){} // RealmObject subclasses must provide an empty constructor
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getSpecies() { return species; }
    public void setSpecies(String species) { this.species = species; }
    public String getOwner() { return owner; }
    public void setOwner(String owner) { this.owner = owner; }
}

Assign default values in the field declaration:

import io.realm.RealmObject
open class Frog : RealmObject {
    var name = "Kitty"
    var age = 0
    var species: String? = null
    var owner: String? = null
    constructor(name: String, age: Int, species: String?, owner: String?) {
        this.name = name
        this.age = age
        this.species = species
        this.owner = owner
    }
    constructor() {} // RealmObject subclasses must provide an empty constructor
}

Nota

Valores por defecto y anulabilidad

Si bien los valores predeterminados garantizan que un objeto recién creado no pueda contener un valor de null (a menos que especifique un valor predeterminado null de), no afectan la nulidad de un campo. Para que un campo no sea nulo, consulte Campos obligatorios.

Index a Field

Los índices facilitan la ejecución eficiente de consultas en Realm. Sin índices, Realm debe realizar un análisis de colección (es decir, analizar todos los documentos de una colección) para seleccionar los que coinciden con una consulta. Si existe un índice adecuado para una consulta, Realm puede usarlo para limitar el número de documentos que debe inspeccionar.

Los índices son estructuras de datos especiales que almacenan una pequeña porción de los datos de un dominio de forma fácil de recorrer. El índice almacena el valor de un campo específico, ordenado según su valor. La ordenación de las entradas del índice facilita la realización de búsquedas de igualdad eficientes y consultas basadas en rangos.

Adding an index can speed up some queries at the cost of slightly slower write times and additional storage and memory overhead. Indexes require space in your realm file, so adding an index to a property will increase disk space consumed by your realm file. Each index entry is a minimum of 12 bytes.

You can index fields with the following types:

String
UUID
ObjectId
Integer or int
Long or long
Short or short
Byte or byte[]
Boolean or bool
Date
RealmAny

Realm crea índices para campos anotados con @Index.

Para indexar un campo, utiliza la anotación @Index:

import io.realm.RealmObject;
import io.realm.annotations.Index;
public class Frog extends RealmObject {
    private String name;
    private int age;
    @Index private String species;
    private String owner;
    public Frog(String name, int age, String species, String owner) {
        this.name = name;
        this.age = age;
        this.species = species;
        this.owner = owner;
    }
    public Frog(){} // RealmObject subclasses must provide an empty constructor
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getSpecies() { return species; }
    public void setSpecies(String species) { this.species = species; }
    public String getOwner() { return owner; }
    public void setOwner(String owner) { this.owner = owner; }
}

import io.realm.RealmObject
import io.realm.annotations.Index
open class Frog : RealmObject {
    var name: String? = null
    var age = 0
    @Index var species : String? = null
    var owner: String? = null
    constructor(name: String?, age: Int, species: String?, owner: String?) {
        this.name = name
        this.age = age
        this.species = species
        this.owner = owner
    }
    constructor() {} // RealmObject subclasses must provide an empty constructor
}

Ignorar un campo

If you don't want to save a field in your model to a realm, you can ignore a field.

Ignore a field from a Realm object model with the @Ignore annotation:

import io.realm.RealmObject;
import io.realm.annotations.Ignore;
public class Frog extends RealmObject {
    private String name;
    private int age;
    private String species;
    // can you ever really own a frog persistently?
    @Ignore private String owner;
    public Frog(String name, int age, String species, String owner) {
        this.name = name;
        this.age = age;
        this.species = species;
        this.owner = owner;
    }
    public Frog(){} // RealmObject subclasses must provide an empty constructor
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getSpecies() { return species; }
    public void setSpecies(String species) { this.species = species; }
    public String getOwner() { return owner; }
    public void setOwner(String owner) { this.owner = owner; }
}

import io.realm.RealmObject
import io.realm.annotations.Ignore
open class Frog : RealmObject {
    var name: String? = null
    var age = 0
    var species: String? = null
    // can you ever really own a frog persistently?
    @Ignore var owner  : String? = null
    constructor(name: String?, age: Int, species: String?, owner: String?) {
        this.name = name
        this.age = age
        this.species = species
        this.owner = owner
    }
    constructor() {} // RealmObject subclasses must provide an empty constructor
}

Nota

El SDK ignora los campos estáticos y transitorios

Fields marked static or transient are always ignored, and do not need the @Ignore annotation.

Renombrar un campo

Por defecto, Realm utiliza el nombre definido en la clase del modelo para representar los campos internamente. En algunos casos, puede que desee cambiar este comportamiento:

Para facilitar el trabajo en todas las plataformas, ya que las convenciones de nomenclatura difieren.
To change a field name in Kotlin without forcing a migration.

Choosing an internal name that differs from the name used in model classes has the following implications:

Migrations must use the internal name when creating classes and fields.
Los errores de esquema reportados utilizarán el nombre interno.

Utilice la anotación @RealmField para cambiar el nombre de un campo:

import io.realm.RealmObject;
import io.realm.annotations.RealmField;
public class Frog extends RealmObject {
    private String name;
    private int age;
    @RealmField("latinName") private String species;
    private String owner;
    public Frog(String name, int age, String species, String owner) {
        this.name = name;
        this.age = age;
        this.species = species;
        this.owner = owner;
    }
    public Frog(){} // RealmObject subclasses must provide an empty constructor
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getSpecies() { return species; }
    public void setSpecies(String species) { this.species = species; }
    public String getOwner() { return owner; }
    public void setOwner(String owner) { this.owner = owner; }
}

import io.realm.RealmObject
import io.realm.annotations.RealmField
open class Frog : RealmObject {
    var name: String? = null
    var age = 0
    @RealmField("latinName") var species: String? = null
    var owner: String? = null
    constructor(name: String?, age: Int, species: String?, owner: String?) {
        this.name = name
        this.age = age
        this.species = species
        this.owner = owner
    }
    constructor() {} // RealmObject subclasses must provide an empty constructor
}

De manera alternativa, también puedes asignar una política de nomenclatura a nivel de módulo o de clase para cambiar la forma en que Realm interpreta los nombres de los campos.

You can define a naming policy at the module level, which will affect all classes included in the module:

import io.realm.annotations.RealmModule;
import io.realm.annotations.RealmNamingPolicy;
@RealmModule(
        allClasses = true,
        classNamingPolicy = RealmNamingPolicy.LOWER_CASE_WITH_UNDERSCORES,
        fieldNamingPolicy = RealmNamingPolicy.LOWER_CASE_WITH_UNDERSCORES
)
public class MyModule {
}

import io.realm.annotations.RealmModule
import io.realm.annotations.RealmNamingPolicy
@RealmModule(
    allClasses = true,
    classNamingPolicy = RealmNamingPolicy.LOWER_CASE_WITH_UNDERSCORES,
    fieldNamingPolicy = RealmNamingPolicy.LOWER_CASE_WITH_UNDERSCORES
)
open class MyModule

You can also define a naming policy at the class level, which overrides module level settings:

import io.realm.RealmObject;
import io.realm.annotations.RealmClass;
import io.realm.annotations.RealmNamingPolicy;
@RealmClass(fieldNamingPolicy = RealmNamingPolicy.PASCAL_CASE)
public class Frog extends RealmObject {
    private String name;
    private int age;
    private String species;
    private String owner;
    public Frog(String name, int age, String species, String owner) {
        this.name = name;
        this.age = age;
        this.species = species;
        this.owner = owner;
    }
    public Frog(){} // RealmObject subclasses must provide an empty constructor
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getSpecies() { return species; }
    public void setSpecies(String species) { this.species = species; }
    public String getOwner() { return owner; }
    public void setOwner(String owner) { this.owner = owner; }
}

import io.realm.RealmObject
import io.realm.annotations.RealmClass
import io.realm.annotations.RealmNamingPolicy
@RealmClass(fieldNamingPolicy = RealmNamingPolicy.PASCAL_CASE)
open class Frog : RealmObject {
    var name: String? = null
    var age = 0
    var species: String? = null
    var owner: String? = null
    constructor(name: String?, age: Int, species: String?, owner: String?) {
        this.name = name
        this.age = age
        this.species = species
        this.owner = owner
    }
    constructor() {} // RealmObject subclasses must provide an empty constructor
}

Rename a Class

Por defecto, Realm utiliza el nombre definido en la clase del modelo para representar internamente las clases. En algunos casos, es posible que desees cambiar este comportamiento:

To support multiple model classes with the same simple name in different packages.
Para facilitar el trabajo en todas las plataformas, ya que las convenciones de nomenclatura difieren.
To use a class name that is longer than the 57 character limit enforced by Realm.
To change a class name in Kotlin without forcing a migration.

Utilice la anotación @RealmClass para cambiar el nombre de una clase:

import io.realm.RealmObject;
import io.realm.annotations.RealmClass;
@RealmClass(name = "ShortBodiedTaillessAmphibian")
public class Frog extends RealmObject {
    private String name;
    private int age;
    private String species;
    private String owner;
    public Frog(String name, int age, String species, String owner) {
        this.name = name;
        this.age = age;
        this.species = species;
        this.owner = owner;
    }
    public Frog(){} // RealmObject subclasses must provide an empty constructor
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getSpecies() { return species; }
    public void setSpecies(String species) { this.species = species; }
    public String getOwner() { return owner; }
    public void setOwner(String owner) { this.owner = owner; }
}

import io.realm.RealmObject
import io.realm.annotations.RealmClass
@RealmClass(name = "Short_Bodied_Tailless_Amphibian")
open class Frog : RealmObject {
    var name: String? = null
    var age = 0
    var species: String? = null
    var owner: String? = null
    constructor(name: String?, age: Int, species: String?, owner: String?) {
        this.name = name
        this.age = age
        this.species = species
        this.owner = owner
    }
    constructor() {} // RealmObject subclasses must provide an empty constructor
}

Omitir clases de su esquema de reino

By default, your application's Realm Schema includes all classes that extend RealmObject. If you only want to include a subset of classes that extend RealmObject in your Realm Schema, you can include that subset of classes in a module and open your realm using that module:

import io.realm.annotations.RealmModule;
@RealmModule(classes = { Frog.class, Fly.class })
public class MyModule {
}

import io.realm.annotations.RealmModule
@RealmModule(classes = [Frog::class, Fly::class])
open class MyModule

Volver

Datos del modelo

Relaciones

Definir un Objeto Realm

Importante

Nota

Prolongar RealmObject

implementar RealmModel

Importante

Importante

Tip

Using RealmObject Methods

Listas

Tip

Definir un campo de objeto incrustado

Tip

Anotaciones

llave primaria

Campos obligatorios

Campos opcionales

Importante

Tipos y anulabilidad de Kotlin

Default Field Values

Nota

Valores por defecto y anulabilidad

Index a Field

Ignorar un campo

Nota

El SDK ignora los campos estáticos y transitorios

Renombrar un campo

Rename a Class

Omitir clases de su esquema de reino

Prolongar `RealmObject`

implementar `RealmModel`