Calendar Classe
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
<strong>[icu enhancement]</strong> ICU remplacement de l’ICU pour java.util.Calendar.
[Android.Runtime.Register("android/icu/util/Calendar", ApiSince=24, DoNotGenerateAcw=true)]
public abstract class Calendar : Java.Lang.Object, IDisposable, Java.IO.ISerializable, Java.Lang.ICloneable, Java.Lang.IComparable
[<Android.Runtime.Register("android/icu/util/Calendar", ApiSince=24, DoNotGenerateAcw=true)>]
type Calendar = class
inherit Object
interface ISerializable
interface IJavaObject
interface IDisposable
interface IJavaPeerable
interface ICloneable
interface IComparable
- Héritage
- Dérivé
- Attributs
- Implémente
Remarques
<strong>[icu enhancement]</strong> ICU’s replacement for java.util.Calendar. ; Les méthodes, les champs et d’autres fonctionnalités spécifiques à l’ICU sont étiquetées «< strong>[icu]</strong> ».
Calendarest une classe de base abstraite pour la conversion entre un Date objet et un ensemble de champs entiers tels que YEAR, , MONTHDAY, HOUR, etc. (Un Date objet représente un instant spécifique dans le temps avec une précision en millisecondes. Pour Date plus d’informations sur la Date classe,)
Sous-classes d’interprétation CalendarDate selon les règles d’un système de calendrier spécifique. ICU4J contient plusieurs sous-classes implémentant différents systèmes de calendrier internationaux.
Comme d’autres classes sensibles aux paramètres régionaux, Calendar fournit une méthode de classe, getInstancepour obtenir un objet généralement utile de ce type.
Calendarla méthode renvoie getInstance un calendrier d’un type approprié aux paramètres régionaux, dont les champs d’heure ont été initialisés avec la date et l’heure actuelles : <blockquote>
Calendar rightNow = Calendar.getInstance()
</blockquote>
Lorsqu’un ULocale est utilisé par getInstance, sa balise et sacalendar valeur sont récupérées si elles sont présentes. Si une valeur reconnue est fournie, un calendrier est fourni et configuré selon les besoins. Les balises actuellement reconnues sont « bouddhistes », « chinois », « copte », « échiopice », « grégorien », « hébreu », « islamique », « islamique-civil », « japonais » et « roc ». Par exemple : <blockquote>
Calendar cal = Calendar.getInstance(new ULocale("en_US@calendar=japanese"));
</blockquote> retourne une instance de JapaneseCalendar (à l’aide de conventions en_US pour les jours minimum dans la première semaine, le jour de début de la semaine, etc.).
Un Calendar objet peut produire toutes les valeurs de champ d’heure nécessaires pour implémenter la mise en forme date-heure pour un style de langue et de calendrier particulier (par exemple, japonais-grégorien, Japanese-Traditional).
Calendar définit la plage de valeurs retournées par certains champs, ainsi que leur signification. Par exemple, le premier mois de l’année a la valeur MONTH == JANUARY de tous les calendriers. D’autres valeurs sont définies par la sous-classe concrète, telle que ERA et YEAR. Pour plus d’informations, consultez la documentation sur les champs individuels et la sous-classe.
Lorsqu’un Calendar est <lenient></em>, il accepte une plus large gamme de valeurs de champ qu’elle produit. Par exemple, une interprétation léniente GregorianCalendarMONTH == JANUARY, DAY_OF_MONTH == 32 comme le 1er février. Un non-lenient GregorianCalendar lève une exception lorsqu’il reçoit des paramètres de champ hors plage. Lorsque les calendriers récomputent les valeurs de champ pour le retour get(), ils les normalisent. Par exemple, un GregorianCalendar produit toujours des valeurs comprises DAY_OF_MONTH entre 1 et la durée du mois.
Calendar définit une semaine de sept jours spécifique aux paramètres régionaux à l’aide de deux paramètres : le premier jour de la semaine et les jours minimaux de la première semaine (de 1 à 7). Ces nombres sont extraits des données de ressources de paramètres régionaux lorsqu’une Calendar construction est effectuée. Ils peuvent également être spécifiés explicitement via l’API.
Lorsque vous définissez ou obtenez les WEEK_OF_MONTHWEEK_OF_YEAR champs, Calendar vous devez déterminer la première semaine du mois ou de l’année comme point de référence. La première semaine d’un mois ou d’une année est définie comme la période de sept jours la plus ancienne commençant et getFirstDayOfWeek() contenant au moins getMinimalDaysInFirstWeek() les jours de ce mois ou de l’année. Semaines numérotées ..., -1, 0 précèdent la première semaine ; semaines numérotées 2, 3,... suivez-le. Notez que la numérotation normalisée retournée par get() peut être différente. Par exemple, une sous-classe spécifique Calendar peut désigner la semaine avant la semaine 1 d’un an comme semaine <em>n</em> de l’année précédente.
Lorsque vous calculez un Date champ de temps, certaines circonstances spéciales peuvent survenir : il peut y avoir des informations insuffisantes pour calculer le Date (par exemple, seulement l’année et le mois, mais pas le jour du mois), il peut y avoir des informations incohérentes (par exemple, « mardi, 15 juillet 1996 » -- Le 15 juillet 1996 est en fait un lundi) ou l’heure d’entrée peut être ambiguë en raison de la transition de fuseau horaire.
<informations insuffisantes>.</strong> Le calendrier utilise les informations par défaut pour spécifier les champs manquants. Cela peut varier selon le calendrier ; pour le calendrier grégorien, la valeur par défaut d’un champ est la même que celle du début de l’époque : c’est-à-dire YEAR = 1970, MONTH = JANVIER, DATE = 1, etc.
<informations incohérentes fortes>.</strong> Si les champs sont en conflit, le calendrier donne la préférence aux champs définis plus récemment. Par exemple, lorsque vous déterminez le jour, le calendrier recherche l’une des combinaisons suivantes de champs. La combinaison la plus récente, telle que déterminée par le champ unique défini le plus récemment, sera utilisée.
<blockquote>
MONTH + DAY_OF_MONTH
MONTH + WEEK_OF_MONTH + DAY_OF_WEEK
MONTH + DAY_OF_WEEK_IN_MONTH + DAY_OF_WEEK
DAY_OF_YEAR
DAY_OF_WEEK + WEEK_OF_YEAR
</blockquote>
Pour l’heure de la journée :
<blockquote>
HOUR_OF_DAY
AM_PM + HOUR
</blockquote>
<forte>heure de l’horloge murale ambiguë.</strong> Lorsque le décalage horaire par rapport à l’heure UTC a changé, il produit un intervalle de temps ambigu autour de la transition. Par exemple, de nombreux emplacements américains observent l’heure d’été. À la date de passage à l’heure d’été aux États-Unis, l’heure du mur passe de 12h59 (standard) à 2h00 (jour). Par conséquent, l’heure du mur de 1h00 à 1h59 n’existe pas à la date. Lorsque l’heure du mur d’entrée tombe dans cet intervalle de temps manquant, l’ICU Calendar résout l’heure à l’aide du décalage UTC avant la transition par défaut. Dans cet exemple, 1:30 AM est interprété comme une heure standard de 1:30 (inexistante), donc le résultat final sera de 2h30 à l’heure d’été.
À la date de retour à l’heure standard, l’heure de l’horloge murale est déplacée d’une heure à 2h00. Ainsi, l’heure du mur de 1h00 à 1h59 se produit deux fois. Dans ce cas, l’ICU Calendar résout l’heure à l’aide du décalage UTC après la transition par défaut. Par exemple, 1h30 à la date est résolue comme heure standard 1:30.
Les comportements de résolution de temps de l’horloge mur ambigu peuvent être personnalisés par les #setRepeatedWallTimeOption(int) API calendrier et #setSkippedWallTimeOption(int). Ces méthodes sont disponibles dans iCU 49 ou versions ultérieures.
< >forte remarque :</forte> pour certains calendriers non grégoriens, différents champs peuvent être nécessaires pour la désambiguation complète. Par exemple, une spécification complète du calendrier astronomique arabe historial nécessite l’année, le mois, le jour du mois <, em>et</em> jour de semaine dans certains cas.
< >forte Note :</forte> Il existe certaines ambiguïtés possibles dans l’interprétation de certaines époques singulières, qui sont résolues de la manière suivante : <ol><li> 24:00:00 « appartient » au jour suivant. Autrement dit, 23:59 sur Dec 31, 1969 < 24:00 le 1er janvier 1970 < 24:01:00 le 1er janvier 1970
Les chaînes de format de date ou d’heure ne font pas partie de la définition d’un calendrier, car elles doivent être modifiables ou substituables par l’utilisateur au moment de l’exécution. Permet DateFormat de mettre en forme des dates.
<méthodes>< de manipulation de champs fortes/forte>
Calendar les champs peuvent être modifiés à l’aide de trois méthodes : set(), add()et roll().
<champ > forteset(f, value)<>/fortef modification à .value En outre, il définit une variable membre interne pour indiquer que le champ f a été modifié. Bien que le champ f soit modifié immédiatement, les millisecondes du calendrier ne sont pas recomputées tant que l’appel suivant n’est get()getTime()pas effectué, ou getTimeInMillis() est effectué. Par conséquent, plusieurs appels pour set() ne pas déclencher plusieurs calculs inutiles. En raison de la modification d’un champ à l’aide set()de , d’autres champs peuvent également changer, en fonction du champ, de la valeur du champ et du système de calendrier. En outre, get(f) ne retournera value pas nécessairement une fois les champs recomputés. Les spécificités sont déterminées par la classe de calendrier concrète.
<em>Example</em> : Considérez une GregorianCalendar valeur initiale définie sur le 31 août 1999. L’appel set(Calendar.MONTH, Calendar.SEPTEMBER) définit le calendrier au 31 septembre 1999. Il s’agit d’une représentation interne temporaire qui se résout au 1er octobre 1999 si getTime()elle est alors appelée. Toutefois, un appel avant l’appel pour set(Calendar.DAY_OF_MONTH, 30)getTime() définir le calendrier sur le 30 septembre 1999, car aucune recomputation ne se produit après set() elle-même.
<des ajouts forts/forts>add(f, delta)<> au champ .deltaf Cela équivaut à appeler set(f, get(f) + delta) avec deux ajustements :
<blockquote>
<strong>Add rule 1</strong>. Valeur du champ après l’appel moins la valeur du champ ff avant l’appel est delta, modulo tout dépassement de capacité qui s’est produit dans le champ f. Le dépassement de capacité se produit lorsqu’une valeur de champ dépasse sa plage et, par conséquent, le champ plus grand suivant est incrémenté ou décrémenté et la valeur du champ est ajustée dans sa plage.
<strong>Add rule 2</strong>. Si un champ plus petit est censé être invariant, mais ; il est impossible qu’elle soit égale à sa valeur antérieure en raison des modifications apportées à sa valeur minimale ou maximale après la modification du champ f , alors sa valeur est ajustée pour être aussi proche que possible de sa valeur attendue. Un champ plus petit représente une unité de temps plus petite.
HOUR est un champ plus petit que DAY_OF_MONTH. Aucun ajustement n’est apporté à des champs plus petits qui ne sont pas censés être invariants. Le système de calendrier détermine les champs qui sont censés être invariants.
</blockquote>
En outre, contrairement set()à , add() force une recomputation immédiate des millisecondes du calendrier et de tous les champs.
<em>Example</em> : Considérez une GregorianCalendar valeur initiale définie sur le 31 août 1999. L’appel add(Calendar.MONTH, 13) définit le calendrier sur le 30 septembre 2000.
<
>fort Ajouter une règle 1</forte> définit le MONTH champ à septembre, car l’ajout de 13 mois au mois d’août donne septembre de l’année suivante. Étant donné que DAY_OF_MONTH ne peut pas être 31 en septembre dans une GregorianCalendarrègle <d’ajout forte 2>/forte<> définit la DAY_OF_MONTH valeur 30, la valeur la plus proche possible. Bien qu’il s’agit d’un champ plus petit, DAY_OF_WEEK n’est pas ajusté par la règle 2, car il est prévu de changer lorsque le mois change dans un GregorianCalendar.
<des ajouts forts/forts>roll(f, delta)<> au champ delta sans modifier de champs plus volumineux.f Cela équivaut à appeler add(f, delta) avec l’ajustement suivant :
<blockquote>
<
>forte règle< de roll/strong>. Les champs plus volumineux sont inchangés après l’appel. Un champ plus grand représente une unité de temps plus grande.
DAY_OF_MONTH est un champ plus grand que HOUR.
</blockquote>
<em>Example</em> : Considérez une GregorianCalendar valeur initiale définie sur le 31 août 1999. L’appel roll(Calendar.MONTH, 8) définit le calendrier au 30 avril, <fort>1999</fort>. Ajouter la règle 1 définit le MONTH champ sur avril. L’utilisation d’un GregorianCalendar, ne DAY_OF_MONTH peut pas être 31 dans le mois d’avril. Ajoutez la règle 2 la définit à la valeur la plus proche possible, 30. Enfin, la <règle> de roulement forte</forte> maintient la YEAR valeur de champ de 1999.
<em>Example</em> : Considérez une GregorianCalendar valeur initiale définie sur dimanche 6 juin 1999. L’appel définit le calendrier le mardi 1er juin 1999, tandis que l’appel roll(Calendar.WEEK_OF_MONTH, -1)add(Calendar.WEEK_OF_MONTH, -1) définit le calendrier le dimanche 30 mai 1999. Cela est dû au fait que la règle de roll impose une contrainte supplémentaire : il MONTH ne doit pas changer lorsque l’opération WEEK_OF_MONTH est déployée. Prise conjointement avec la règle 1, la date résultante doit être comprise entre le mardi 1er juin et le samedi 5 juin. Selon l’ajout de la règle 2, le DAY_OF_WEEK, invariant lors de la modification du WEEK_OF_MONTH, est défini sur mardi, la valeur la plus proche possible du dimanche (où dimanche est le premier jour de la semaine).
<modèle>< d’utilisation fort/fort>. Pour motiver le comportement et , considérez un composant d’interface add()roll()utilisateur avec des boutons incrément et décrémentation pour le mois, le jour et l’année, et un sous-jacent GregorianCalendar. Si l’interface lit le 31 janvier 1999 et que l’utilisateur appuie sur le bouton incrément du mois, qu’est-ce qu’il doit lire ? Si l’implémentation sous-jacente utilise set(), elle peut lire le 3 mars 1999. Un meilleur résultat serait le 28 février 1999. En outre, si l’utilisateur appuie à nouveau sur le bouton incrément du mois, il doit lire le 31 mars 1999, et non le 28 mars 1999. En enregistrant la date d’origine et en utilisant l’un ou l’autre add() des roll()champs plus volumineux, l’interface utilisateur peut se comporter comme la plupart des utilisateurs s’attendent intuitivement.
<b>Remarque :</b> Vous devez toujours utiliser #roll roll et #add add plutôt que de tenter d’effectuer des opérations arithmétiques directement sur les champs d’un Calendar. Il est tout à fait possible que Calendar les sous-classes aient des champs avec un comportement non linéaire, par exemple des mois ou des jours manquants pendant des années non bissextiles. Les sous-classes et addroll les méthodes prennent cela en compte, tandis que des manipulations arithmétiques simples peuvent donner des résultats non valides.
<Grande><architecture><de calendrier b>dans ICU4J</b></big/big><>
Récemment, l’implémentation a Calendar changé de manière significative afin de mieux prendre en charge la sous-classe. La classe d’origine Calendar a été conçue pour prendre en charge la sous-classe, mais elle n’avait qu’une seule sous-classe implémentée. GregorianCalendar Avec l’implémentation de plusieurs sous-classes de calendrier, y compris l’API de sous-classification, y compris l’API BuddhistCalendarChineseCalendarHebrewCalendarIslamicCalendarJapaneseCalendarde sous-classe, a été retravaillée de manière approfondie. Cette section détaille la nouvelle API de sous-classe et d’autres façons qui android.icu.util.Calendar diffèrent de java.util.Calendar.
<big><b>Changes</b></big>
Vue d’ensemble des modifications entre l’architecture classique Calendar et la nouvelle architecture.
<ul>
<li>Le fields[] tableau est private maintenant au lieu de protected. Les sous-classes doivent y accéder à l’aide des méthodes #internalSet et #internalGet.
<b>Motivation :</b> Les sous-classes ne doivent pas accéder directement aux membres de données.</li>
<li>Le time long mot est private maintenant au lieu de protected. Les sous-classes peuvent y accéder à l’aide de la méthode #internalGetTimeInMillis, ce qui ne provoque pas de mise à jour.
<b>Motivation :</b> Les sous-classes ne doivent pas accéder directement aux membres de données.</li>
<li>L’étendue de la responsabilité des sous-classes a été considérablement réduite. Autant de fonctionnalités que possible sont implémentées dans la Calendar classe de base. Par conséquent, il est beaucoup plus facile de sous-classe Calendar.
<b>Motivation :</b> Les sous-classes ne doivent pas avoir à réémettre le code commun. Certains comportements sont communs entre les systèmes de calendrier : la définition et le comportement des champs et des champs de temps liés à la semaine, le comportement arithmétique (#add(int, int) add et #roll(int, int) roll) de nombreux champs et le système de validation de champ.</li>
<li>L’API de sous-classe a été entièrement repensée.</li>
<li>La Calendar classe de base contient une prise en charge algorithmique du calendrier grégorien que les sous-classes peuvent utiliser (en particulier dans #handleComputeFields). Les sous-classes peuvent utiliser les méthodes getGregorianXxx() pour obtenir des valeurs précomputées.
<b>Motivation :</b> Ceci est requis par toutes les Calendar sous-classes afin d’implémenter un comportement de fuseau horaire cohérent, et les systèmes dérivés grégoriens peuvent utiliser les données déjà calculées.</li>
<li>La FIELD_COUNT constante a été supprimée. Utilisez #getFieldCount. En outre, l’API framework a été ajoutée pour permettre aux sous-classes de définir des champs supplémentaires.
<Motivation b>: </b>Le nombre de champs n’est pas constant entre les systèmes de calendrier.</li>
<li>La plage de dates gérées a été réduite de +/- ~300 000 000 ans à +/- ~5 000 000 ans. En pratique, cela ne devrait pas affecter les clients. Toutefois, cela signifie que le code client ne peut pas être garanti de résultats bien comportementés avec des dates telles que Date(Long.MIN_VALUE) ou Date(Long.MAX_VALUE). Au lieu de cela, les Calendar constantes protégées doivent être utilisées.
<b>Motivation :</b> Avec l’ajout du #JULIAN_DAY champ, les numéros de jour julian doivent être limités à un nombre 32 bits int. Cela limite la plage globale prise en charge. En outre, la restriction de la plage prise en charge simplifie les calculs en supprimant le code de cas spécial utilisé pour prendre en charge le dépassement arithmétique à millis près Long.MIN_VALUE et Long.MAX_VALUE.</li>
<Les>nouveaux champs sont implémentés : #JULIAN_DAY définit la spécification à champ unique de la date.
#MILLISECONDS_IN_DAY définit une spécification à champ unique de l’heure du mur.
#DOW_LOCAL et #YEAR_WOY implémenter le comportement de jour de semaine et de semaine localisés et hebdomadaires d’année.</li>
<les sous-classes li>peuvent accéder aux constantes de millisecondes protégées définies dans Calendar.</li>
<Li>New API a été ajoutée pour prendre en charge les sous-classes spécifiques au calendrier de DateFormat.</li>
<li>Plusieurs sous-classes ont été implémentées, représentant différents systèmes de calendrier internationaux.</li>
</ul>
< ><API> big b<subclasse/b></big>
L’API d’origine Calendar était basée sur l’expérience d’implémentation d’une seule sous-classe. GregorianCalendar Par conséquent, tous les kinks de sous-classe n’avaient pas été élaborés. La nouvelle API de sous-classe a été affinée en fonction de plusieurs sous-classes implémentées. Cela inclut les méthodes qui doivent être substituées et les méthodes pour les sous-classes à appeler. Les sous-classes n’ont plus d’accès direct à fields et stamp. Au lieu de cela, ils disposent d’une nouvelle API pour y accéder. Les sous-classes sont en mesure d’allouer le fields tableau via une méthode de framework protégée ; cela permet aux sous-classes de spécifier des champs supplémentaires.
D’autres fonctionnalités ont été déplacées dans la classe de base. La classe de base contient désormais une grande partie de la machine de calcul pour prendre en charge le calendrier grégorien. Ceci est basé sur deux choses : (1) De nombreux calendriers sont basés sur le calendrier grégorien (comme les calendriers bouddhistes et impériaux japonais). (2) <Tous>les< calendriers em> nécessitent une prise en charge grégorienne de base pour gérer les calculs de fuseau horaire.
Les calculs courants ont été déplacés vers Calendar. Les sous-classes ne calculent plus les champs associés à la semaine et les champs associés à l’heure. Ils sont couramment gérés pour tous les calendriers par la classe de base.
<b>Calcul de sous-classe des champs=> de temps</b>
Les #ERAchamps , , #YEAR#EXTENDED_YEAR#MONTH#DAY_OF_MONTH et #DAY_OF_YEARles champs sont calculés par la sous-classe, en fonction du jour julian. Tous les autres champs sont calculés par Calendar.
<ul>
<les sous-classes li>doivent être implémentées #handleComputeFields pour calculer les #ERAchamps , , #YEAR#EXTENDED_YEAR#MONTH#DAY_OF_MONTHet #DAY_OF_YEAR les champs, en fonction de la valeur du #JULIAN_DAY champ. S’il existe des champs spécifiques au calendrier non définis par Calendar, ils doivent également être calculés. Il s’agit des seuls champs que la sous-classe doit calculer. Tous les autres champs sont calculés par la classe de base, de sorte que les champs de temps et de semaine se comportent de manière cohérente dans tous les calendriers. La version par défaut de cette méthode implémente Calendar un calendrier grégorien proleptique. Dans cette méthode, les sous-classes peuvent appeler getGregorianXxx() pour obtenir le mois calendrier grégorien, le jour du mois et l’année prolongée pour la date donnée.</li>
</ul>
<b>Calcul de sous-classe des champs => time</b>
L’interprétation de la plupart des valeurs de champ est gérée entièrement par Calendar.
Calendar détermine quels champs sont définis, qui ne sont pas, qui sont définis plus récemment, etc. En outre, Calendar gère le calcul de l’heure à partir des champs de temps et gère les champs liés à la semaine. La seule chose que la sous-classe doit faire est de déterminer l’année prolongée, en fonction des champs d’année, puis, en fonction d’une année prolongée et d’un mois, il doit retourner un numéro de jour Julian.
<ul>
<li>Subclasses doit implémenter #handleGetExtendedYear pour retourner l’année prolongée pour ce système de calendrier, en fonction du #YEAR, #EXTENDED_YEARet tous les champs que le système de calendrier utilise qui sont supérieurs à un an, tels que #ERA.</li>
<les sous-classes li>doivent être implémentées #handleComputeMonthStart pour retourner le numéro de jour julian associé à un mois et une année prolongée. C’est le numéro de jour julian du jour avant le premier jour du mois. Le nombre de mois est de base zéro. Ce calcul ne doit pas dépendre des valeurs de champ.</li>
</ul>
<b>Autres méthodes</b>
<ul>
<les sous-classes li>doivent être implémentées #handleGetMonthLength pour retourner le nombre de jours dans un mois donné d’une année prolongée donnée. Le nombre de mois, comme toujours, est de base zéro.</li>
<les sous-classes li>doivent être implémentées #handleGetYearLength pour retourner le nombre de jours de l’année prolongée donnée. Cette méthode est utilisée pour computeWeekFields calculer les champs et #WEEK_OF_YEAR les #YEAR_WOY champs.</li>
<les sous-classes li>doivent être implémentées #handleGetLimit pour retourner les valeurs protégées d’un champ, en fonction de la valeur de limitType. Cette méthode doit uniquement gérer les champs #ERA, #YEAR#MONTH#WEEK_OF_YEAR#WEEK_OF_MONTH#DAY_OF_MONTH, #DAY_OF_YEAR, #DAY_OF_WEEK_IN_MONTHet . #YEAR_WOY#EXTENDED_YEAR D’autres champs sont invariants (par rapport au système de calendrier) et sont gérés par la classe de base.</li>
<li>Facultatif, les sous-classes peuvent remplacer #validateField pour vérifier les champs spécifiques à une sous-classe. Si la valeur du champ est hors limites, la méthode doit lever un IllegalArgumentException. La méthode peut appeler super.validateField(field) pour gérer les champs de manière générique, autrement dit, pour les comparer à la plage getMinimum(field)...getMaximum(field)</li>
<Li>Facultatif, les sous-classes peuvent remplacer #handleCreateFields pour créer un int[] tableau suffisamment grand pour contenir les champs du calendrier. Cela n’est nécessaire que si le calendrier définit des champs supplémentaires au-delà de ceux définis par Calendar. La longueur du résultat doit être comprise entre le nombre de champs de base et maximal.</li>
<li>Facultatif, les sous-classes peuvent remplacer #handleGetDateFormat pour créer un DateFormat calendrier approprié. Cela n’est nécessaire que si une sous-classe de calendrier redéfinit l’utilisation d’un champ (par exemple, modifie le #ERA champ d’un champ symbolique en un champ numérique) ou définit un champ supplémentaire.</li>
<li>Facultatif, les sous-classes peuvent remplacer #roll roll et #add add gérer les champs qui sont discontinus. Par exemple, dans le calendrier hébreu, le mois " Adar I" ne se produit que dans les années bissextiles ; dans les autres années, le calendrier passe de Shevat (mois #4) à Adar (mois #6). Les HebrewCalendar#add HebrewCalendar.add méthodes prennent HebrewCalendar#roll HebrewCalendar.roll cela en compte, de sorte que l’ajout d’un mois à Shevat donne le résultat approprié (Adar) dans une année non bissextile. La méthode #pinField pinField utilitaire protégée est souvent utile lors de l’implémentation de ces deux méthodes.
</li>
</ul>
<comportement><> normalisé big b</b></big>
Le comportement de certains champs a été rendu cohérent dans tous les systèmes de calendrier et implémenté dans Calendar.
<ul>
<li>Time est normalisé. Même si certains systèmes de calendrier passent entre les jours au coucher du soleil ou à d’autres moments, tous les calendriers ICU4J passent entre les jours à <la>zone locale em minuit</em>. Cela permet à ICU4J de centraliser les calculs de temps dans Calendar et de maintenir des correspondances de base entre les systèmes de calendrier. Champs affectés : #AM_PM, , #HOUR, #HOUR_OF_DAY#MINUTE, #SECOND#MILLISECOND#ZONE_OFFSETet .#DST_OFFSET</li>
<Le comportement li>DST est normalisé. Le comportement du temps d’été est calculé de la même façon pour tous les systèmes de calendrier, et dépend de la valeur de plusieurs GregorianCalendar champs : le #YEAR, #MONTHet #DAY_OF_MONTH. Par conséquent, Calendar calcule toujours ces champs, même pour les systèmes de calendrier non grégoriens. Ces champs sont disponibles pour les sous-classes.</li>
<li>Weeks est normalisé. Bien que les paramètres régionaux définissent la semaine différemment, en ce qui concerne le jour où elle commence, et la désignation du numéro de semaine numéro un d’un mois ou d’une année, ils utilisent tous un mécanisme commun. En outre, le jour de la semaine a une définition simple et cohérente tout au long de l’histoire. Par exemple, bien que le calendrier grégorien ait introduit une discontinuité lors de la première institutée, le jour de la semaine n’a pas été perturbé. Pour cette raison, les champs #DAY_OF_WEEK, , WEEK_OF_YEAR, WEEK_OF_MONTH#DAY_OF_WEEK_IN_MONTH, #DOW_LOCAL, , #YEAR_WOY sont tous calculés de manière cohérente dans la classe de base, en fonction du #EXTENDED_YEAR, #DAY_OF_YEAR, #MONTHet #DAY_OF_MONTH, qui sont calculés par la sous-classe.</li>
</ul>
<Grande><plage>< prise en charge/b></big>
La plage autorisée d’a Calendar été réduite.
GregorianCalendarutilisé pour tenter de prendre en charge la plage de dates avec des valeurs de millisecondes à Long.MIN_VALUEpartir de Long.MAX_VALUE . Cela a introduit des constructions maladroites (hacks) qui ralentissaient les performances. Il a également introduit un comportement non uniforme aux limites. Le nouveau Calendar protocole spécifie la plage maximale de dates pouvant être prise en charge, car celles ayant des nombres de jours julians à -0x7F000000+0x7F000000. Cela correspond aux années comprises entre ~5 800 000 BCE et ~5 800 000 CE. Les programmeurs doivent utiliser les constantes protégées pour Calendar spécifier une date extrêmement précoce ou extrêmement tardive.
<Big><b>Notes générales</b></big>
<ul>
<les implémentations li Calendars sont >proleptiques<>/em<.> Par exemple, même si le calendrier grégorien n’a pas été créé jusqu’au 16e siècle, la GregorianCalendar classe prend en charge les dates avant le début historique du calendrier en étendant le système de calendrier à l’arrière dans le temps. De même, le HebrewCalendar recul s’étend avant le début de son époque en années nulles et négatives. Les sous-classes ne lèvent pas d’exceptions, car une date précède le début historique d’un système de calendrier. Au lieu de cela, ils implémentent #handleGetLimit pour retourner les limites appropriées sur #YEAR, #ERA, etc. champs. Ensuite, si le calendrier n’est pas lent, les valeurs de champ hors plage déclenchent une exception.</li>
<les sous-classes système li>Calendar calculent une <année>/em étendue em<>. Cela diffère du #YEAR champ dans lequel il s’étend sur toutes les valeurs entières, y compris les valeurs nulles et négatives, et encapsule les informations du #YEAR champ et de tous les champs plus grands. Ainsi, pour le calendrier grégorien, il #EXTENDED_YEAR est calculé comme ERA==AD ? YEAR : 1-YEAR. Un autre exemple est le nombre long maya, qui a des années (KUN) et des cycles imbriqués d’années (KATUN et BAKTUN). Le Maya #EXTENDED_YEAR est calculé comme TUN + 20 * (KATUN + 20 * BAKTUN). La Calendar classe de base utilise le #EXTENDED_YEAR champ pour calculer les champs liés à la semaine.</li>
</ul>
Java documentation pour android.icu.util.Calendar.
Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la Creative Commons 2.5 Attribution License.
Constructeurs
| Nom | Description |
|---|---|
| Calendar() |
Construit un calendrier avec le fuseau horaire par défaut et les paramètres régionaux par défaut |
| Calendar(IntPtr, JniHandleOwnership) |
Crée une instance managée qui représente un objet Java existant. |
| Calendar(TimeZone, Locale) |
Construit un calendrier avec le fuseau horaire et les paramètres régionaux spécifiés. |
| Calendar(TimeZone, ULocale) |
Construit un calendrier avec le fuseau horaire et les paramètres régionaux spécifiés. |
Champs
| Nom | Description |
|---|---|
| Am |
Valeur du |
| AmPm |
Obsolète.
Numéro de champ pour |
| April |
Valeur du |
| August |
Valeur du |
| BaseFieldCount |
Nombre de champs définis par cette classe. |
| Date |
Obsolète.
Numéro de champ pour |
| DayOfMonth |
Obsolète.
Numéro de champ pour |
| DayOfWeek |
Obsolète.
Numéro de champ pour |
| DayOfWeekInMonth |
Obsolète.
Numéro de champ pour |
| DayOfYear |
Obsolète.
Numéro de champ pour |
| December |
Valeur du |
| DowLocal |
Obsolète.
<strong>[icu]</strong> Field number for |
| DstOffset |
Obsolète.
Numéro de champ pour |
| EpochJulianDay |
Le jour julien de l’époque, c’est-à-dire le 1er janvier 1970 sur le calendrier grégorien. |
| Era |
Obsolète.
Numéro de champ pour |
| ExtendedYear |
Obsolète.
<strong>[icu]</strong> Field number for |
| February |
Valeur du |
| Friday |
Valeur du |
| GreatestMinimum |
Type limite pour |
| Hour |
Obsolète.
Numéro de champ pour |
| HourOfDay |
Obsolète.
Numéro de champ pour |
| InternallySet |
Valeur de l’horodatage |
| IsLeapMonth |
<strong>[icu]</strong> Field indiquant si le mois en cours est un mois bissextile ou non. |
| Jan11JulianDay |
Jour julien de l’époque grégorienne, c’est-à-dire le 1er janvier 1 sur le calendrier grégorien. |
| January |
Valeur du |
| JulianDay |
Obsolète.
<strong>[icu]</strong> Field number for |
| July |
Valeur du |
| June |
Valeur du |
| LeastMaximum |
Type limite pour |
| March |
Valeur du |
| MaxFieldCount |
Nombre maximal de champs possibles. |
| Maximum |
Type de limite pour |
| MaxJulian |
Le maximum pris en charge par Julian day. |
| MaxMillis |
Nombre maximal de millisecondes d’époque prises en charge. |
| May |
Valeur du |
| Millisecond |
Obsolète.
Numéro de champ pour |
| MillisecondsInDay |
Obsolète.
<strong>[icu]</strong> Field number for |
| Minimum |
Type de limite pour |
| MinimumUserStamp |
Si l’horodatage |
| MinJulian |
Jour julian minimum pris en charge. |
| MinMillis |
Millisecondes d’époque minimale prises en charge. |
| Minute |
Obsolète.
Numéro de champ pour |
| Monday |
Valeur du |
| Month |
Obsolète.
Numéro de champ pour |
| November |
Valeur du |
| October |
Valeur du |
| OneDay |
Nombre de millisecondes en un jour. |
| OneHour |
Nombre de millisecondes en une heure. |
| OneMinute |
Nombre de millisecondes en une minute. |
| OneSecond |
Nombre de millisecondes en une seconde. |
| OneWeek |
Nombre de millisecondes en une semaine. |
| OrdinalMonth |
<strong>[icu]</strong> Field indiquant le mois. |
| Pm |
Valeur du |
| ResolveRemap |
Valeur vers OR par rapport aux valeurs de champ de table de résolution pour le remapping. |
| Saturday |
Valeur du |
| Second |
Obsolète.
Numéro de champ pour |
| September |
Valeur du |
| Sunday |
Valeur du |
| Thursday |
Valeur du |
| Tuesday |
Valeur du |
| Undecimber |
Valeur du |
| Unset |
Valeur de l’horodatage |
| WalltimeFirst |
Obsolète.
<strong>[icu]</strong>Option utilisée par |
| WalltimeLast |
Obsolète.
<strong>[icu]</strong>Option utilisée par |
| WalltimeNextValid |
Obsolète.
<strong>[icu]</strong>Option utilisée en |
| Wednesday |
Valeur du |
| WeekOfMonth |
Obsolète.
Numéro de champ pour |
| WeekOfYear |
Obsolète.
Numéro de champ pour |
| Year |
Obsolète.
Numéro de champ pour |
| YearWoy |
Obsolète.
<strong>[icu]</strong> Field number for |
| ZoneOffset |
Obsolète.
Numéro de champ pour |
Propriétés
| Nom | Description |
|---|---|
| Class |
Retourne la classe runtime de ce |
| FieldCount |
<strong>[icu]</strong> Renvoie le nombre de champs définis par ce calendrier. |
| FirstDayOfWeek |
Retourne le premier jour de la semaine, où 1 = |
| GregorianDayOfMonth |
Retourne le jour du mois (basé sur 1) sur le calendrier grégorien comme calculé par |
| GregorianDayOfYear |
Retourne le jour de l’année (basé sur 1) sur le calendrier grégorien comme calculé par |
| GregorianMonth |
Retourne le mois (basé sur 0) sur le calendrier grégorien comme calculé par |
| GregorianYear |
Retourne l’année prolongée sur le calendrier grégorien comme calculé par |
| Handle |
Handle de l’instance Android sous-jacente. (Hérité de Object) |
| Instance |
Retourne un calendrier à l’aide du fuseau horaire et des paramètres régionaux par défaut. |
| IsWeekend |
<strong>[icu]</strong> Renvoie true si la date et l’heure actuelles de ce calendrier se situent dans le week-end dans ce système de calendrier. |
| JniIdentityHashCode |
Obtient le code de hachage d’identité affecté à cet homologue Java par le runtime d’interopérabilité. (Hérité de Object) |
| JniManagedPeerState |
<strong>[icu enhancement]</strong> ICU remplacement de l’ICU pour |
| JniPeerMembers |
Obtient les métadonnées JNI utilisées pour accéder aux membres de cette liaison Java. |
| Lenient |
Indiquez si l’interprétation de date/heure doit être léniente. -ou- Spécifiez si l’interprétation date/heure doit être léniente ou non. |
| MaxDate |
Maximum pris en charge |
| MinDate |
Minimum pris en charge |
| MinimalDaysInFirstWeek |
Retourne les jours minimaux requis dans la première semaine de l’année. -ou- Définit les jours minimaux requis dans la première semaine de l’année. |
| PeerReference |
Obtient la référence d’objet JNI pour cet homologue Java. (Hérité de Object) |
| RepeatedWallTimeOption |
<strong>[icu]</strong>Obtient le comportement pour la gestion du temps mur répétant plusieurs fois les transitions de décalage de fuseau horaire négatif. -ou- <strong>[icu]</strong>Définit le comportement de gestion du temps mur répétant plusieurs fois à des transitions de décalage de fuseau horaire négatif. |
| SkippedWallTimeOption |
<strong>[icu]</strong>Obtient le comportement de gestion du temps mur ignoré lors des transitions de décalage de fuseau horaire positif. -ou- <strong>[icu]</strong>Définit le comportement de gestion du temps mur ignoré lors des transitions de décalage de fuseau horaire positif. |
| TemporalMonthCode |
Obtient la valeur temporal monthCode correspondant au mois pour la date. -ou- Définit le monthCode temporel, qui est un identificateur de chaîne qui commence par le graphe littéral « M », suivi de deux graphèmes représentant le numéro de mois sans remplissage du mois en cours dans une année normale (non bissextile) et suffixe par un graphe littéral facultatif « L » s’il s’agit d’un mois bissextile dans un calendrier lunisolar. |
| ThresholdClass |
Obtient la classe Java utilisée pour la distribution de méthode virtuelle. |
| ThresholdType |
Obtient le type managé qui déclare cette liaison Java. |
| Time |
Retourne l’heure actuelle de ce calendrier. -ou- Définit l’heure actuelle de ce calendrier avec la date donnée. |
| TimeInMillis |
Retourne l’heure actuelle de ce calendrier tant qu’elle est longue. -ou- Définit l’heure actuelle de ce calendrier à partir de la valeur longue donnée. |
| TimeZone |
Retourne le fuseau horaire. -ou- Définit le fuseau horaire avec la valeur de fuseau horaire donnée. |
| Type |
<strong>[icu]</strong> Renvoie la chaîne de nom de type de calendrier pour cet objet Calendar. |
Méthodes
| Nom | Description |
|---|---|
| Add(CalendarField, Int32) |
Ajoutez une quantité signée à un champ spécifié, à l’aide des règles de ce calendrier. |
| After(Object) |
Compare les enregistrements de champ de temps. |
| Before(Object) |
Compare les enregistrements de champ de temps. |
| Clear() |
Efface les valeurs de tous les champs de temps. |
| Clear(CalendarField) |
Efface la valeur dans le champ de temps donné. |
| Clone() |
Substitue cloneable |
| CompareTo(Calendar) |
Compare les heures (en millis) représentées par deux |
| Complete() |
Renseigne tous les champs non défini dans la liste des champs de temps. |
| ComputeFields() |
Convertit la valeur |
| ComputeGregorianFields(Int32) |
Calculez l’année civile grégorienne, le mois et le jour du mois à partir du jour julien. |
| ComputeGregorianMonthStart(Int32, Int32) |
Calculez le jour julien d’un mois du calendrier grégorien. |
| ComputeJulianDay() |
Calculez le numéro de jour julian tel que spécifié par les champs de ce calendrier. |
| ComputeMillisInDay() |
Calculez les millisecondes du jour à partir des champs. |
| ComputeTime() |
Convertit les valeurs de champ actuelles en |
| ComputeZoneOffset(Int64, Int32) |
Cette méthode peut supposer que EXTENDED_YEAR a été définie. |
| Construct(JniObjectReference, JniObjectReferenceOptions) |
<strong>[icu enhancement]</strong> ICU remplacement de l’ICU pour |
| Dispose() |
Libère les ressources détenues par cet homologue Java. (Hérité de Object) |
| Dispose(Boolean) |
Libère les ressources détenues par cet homologue Java. (Hérité de Object) |
| DisposeUnlessReferenced() |
<strong>[icu enhancement]</strong> ICU remplacement de l’ICU pour |
| Equals(Object) |
<strong>[icu enhancement]</strong> ICU remplacement de l’ICU pour |
| Equals(Object) |
Indique si un autre objet est « égal à » celui-ci. (Hérité de Object) |
| FieldDifference(Date, CalendarField) |
<strong>[icu]</strong> Renvoie la différence entre l’heure donnée et l’heure à laquelle cet objet calendrier est défini. |
| FieldName(CalendarField) |
Retourne un nom de chaîne pour un champ, pour le débogage et les exceptions. |
| FloorDivide(Int32, Int32, Int32[]) |
Divisez deux entiers, retournant le plancher du quotient et le reste du module. |
| FloorDivide(Int32, Int32) |
Divisez deux entiers, en retournant le plancher du quotient. |
| FloorDivide(Int64, Int32, Int32[]) |
Divisez deux entiers, retournant le plancher du quotient et le reste du module. |
| FloorDivide(Int64, Int64) |
Divisez deux entiers longs, en retournant le plancher du quotient. |
| Get(CalendarField) |
Retourne la valeur d’un champ de temps donné. |
| GetActualMaximum(CalendarField) |
Retourne la valeur maximale que ce champ peut avoir, en fonction de la date actuelle. |
| GetActualMinimum(CalendarField) |
Retourne la valeur minimale que ce champ peut avoir, en fonction de la date actuelle. |
| GetAvailableLocales() |
Retourne la liste des paramètres régionaux pour lesquels les calendriers sont installés. |
| GetDateTimeFormat(DateFormatStyle, Int32, Locale) |
<strong>[icu]</strong Renvoie une > valeur |
| GetDateTimeFormat(DateFormatStyle, Int32, ULocale) |
<strong>[icu]</strong Renvoie une > valeur |
| GetDisplayName(Locale) |
Retourne le nom de ce calendrier dans la langue des paramètres régionaux donnés. |
| GetDisplayName(ULocale) |
Retourne le nom de ce calendrier dans la langue des paramètres régionaux donnés. |
| GetFieldResolutionTable() |
Retourne le tableau de résolution de champs pour ce calendrier. |
| GetGreatestMinimum(CalendarField) |
Retourne la valeur minimale la plus élevée pour le champ donné si elle varie. |
| GetHashCode() |
Retourne une valeur de code de hachage pour l’objet. (Hérité de Object) |
| GetInstance(Locale) |
Retourne un calendrier à l’aide du fuseau horaire par défaut et des paramètres régionaux spécifiés. |
| GetInstance(TimeZone, Locale) |
Retourne un calendrier avec le fuseau horaire et les paramètres régionaux spécifiés. |
| GetInstance(TimeZone, ULocale) |
Retourne un calendrier avec le fuseau horaire et les paramètres régionaux spécifiés. |
| GetInstance(TimeZone) |
Retourne un calendrier à l’aide du fuseau horaire spécifié et des paramètres régionaux par défaut. |
| GetInstance(ULocale) |
Retourne un calendrier à l’aide du fuseau horaire par défaut et des paramètres régionaux spécifiés. |
| GetKeywordValuesForLocale(String, ULocale, Boolean) |
<strong>[icu]</strong> Given a key and a locale, retourne un tableau de valeurs de chaîne dans un ordre préféré qui ferait une différence. |
| GetLeastMaximum(CalendarField) |
Retourne la valeur maximale la plus basse pour le champ donné si elle varie. |
| GetLimit(CalendarField, Int32) |
Retourne une limite pour un champ. |
| GetMaximum(CalendarField) |
Retourne la valeur maximale pour le champ de temps donné. |
| GetMinimum(CalendarField) |
Retourne la valeur minimale pour le champ d’heure donné. |
| GetStamp(CalendarField) |
Retourne l’horodatage d’un champ. |
| GetWeekData() |
[icu] Retournez une classe de type struct simple et immuable pour accéder aux données de semaine dans ce calendrier. |
| GetWeekDataForRegion(String) |
[icu] Retourne une classe simple et immuable de type struct pour accéder aux données de semaine CLDR. |
| GregorianMonthLength(Int32, Int32) |
Retourne la longueur d’un mois du calendrier grégorien. |
| GregorianPreviousMonthLength(Int32, Int32) |
Retourne la longueur d’un mois précédent du calendrier grégorien. |
| HandleComputeFields(Int32) |
Les sous-classes peuvent remplacer cette méthode pour calculer plusieurs champs spécifiques à chaque système de calendrier. |
| HandleComputeJulianDay(Int32) |
Les sous-classes peuvent remplacer cela. |
| HandleComputeMonthStart(Int32, Int32, Boolean) |
Retourne le nombre de jours julians avant le premier jour du mois donné dans l’année donnée prolongée. |
| HandleCreateFields() |
Les sous-classes qui utilisent des champs supplémentaires au-delà de ceux définis dans |
| HandleGetDateFormat(String, Locale) |
Crée un |
| HandleGetDateFormat(String, String, Locale) |
Crée un |
| HandleGetDateFormat(String, ULocale) |
Crée un |
| HandleGetExtendedYear() |
Retourne l’année étendue définie par les champs actuels. |
| HandleGetLimit(CalendarField, Int32) |
API de sous-classe pour définir des limites de différents types. |
| HandleGetMonthLength(Int32, Int32) |
Retourne le nombre de jours dans le mois donné de l’année prolongée donnée de ce système de calendrier. |
| HandleGetYearLength(Int32) |
Retourne le nombre de jours dans l’année prolongée donnée de ce système de calendrier. |
| InTemporalLeapYear() |
<strong>[icu]</strong> Renvoie true si la date est dans une année bissextile. |
| InternalGet(CalendarField, Int32) |
Retourne la valeur d’un champ de temps donné ou retourne la valeur par défaut donnée si le champ n’est pas défini. |
| InternalGet(CalendarField) |
Retourne la valeur d’un champ de temps donné. |
| InternalGetTimeInMillis() |
Retourne les millisecondes actuelles sans recomputer. |
| InternalSet(CalendarField, Int32) |
Définissez un champ sur une valeur. |
| InvokeIsWeekend(Date) |
<strong>[icu]</strong> Renvoie true si la date et l’heure spécifiées se situent dans le week-end dans ce système de calendrier. |
| IsEquivalentTo(Calendar) |
<strong>[icu]</strong> Renvoie true si l’objet Calendar donné est équivalent à celui-ci. |
| IsGregorianLeapYear(Int32) |
Détermine si l’année donnée est une année bissextile. |
| IsSet(CalendarField) |
Détermine si le champ de temps donné a une valeur définie. |
| JavaFinalize() |
Obsolète.
Appelé par le garbage collector sur un objet lorsque le garbage collection détermine qu’il n’y a plus de références à l’objet. (Hérité de Object) |
| JulianDayToDayOfWeek(Int32) |
Retourne le jour de la semaine, du DIMANCHE au SAMEDI, en fonction d’un jour julian. |
| JulianDayToMillis(Int32) |
Convertit le jour julian en millisecondes. |
| MillisToJulianDay(Int64) |
Convertit l’heure en millisecondes en jour julian. |
| NewerField(Int32, Int32) |
Retourne le champ plus récent, defaultField ou alternateField. |
| NewestStamp(Int32, Int32, Int32) |
Retourne le tampon le plus récent d’une plage donnée de champs. |
| Notify() |
Réveille un thread unique qui attend le moniteur de cet objet. (Hérité de Object) |
| NotifyAll() |
Réveille tous les threads qui attendent le moniteur de cet objet. (Hérité de Object) |
| PinField(CalendarField) |
Ajustez le champ spécifié afin qu’il se trouve dans la plage autorisée pour la date à laquelle ce calendrier est défini. |
| PrepareGetActual(CalendarField, Boolean) |
Préparez ce calendrier pour calculer le minimum ou le maximum réel. |
| ResolveFields(Int32[][][]) |
En fonction d’une table de précédence, retournez la combinaison de champs la plus récente dans la table ou -1 si aucune valeur n’est trouvée. |
| Roll(CalendarField, Boolean) |
Rolls (up/down) une unité de temps unique sur le champ donné. |
| Roll(CalendarField, Int32) |
Rolls (up/down) une durée spécifiée sur le champ donné. |
| Set(CalendarField, Int32) |
Définit le champ d’heure avec la valeur donnée. |
| Set(Int32, Int32, Int32, Int32, Int32, Int32) |
Définit les valeurs des champs année, mois, date, heure, minute et seconde. |
| Set(Int32, Int32, Int32, Int32, Int32) |
Définit les valeurs des champs année, mois, date, heure et minute. |
| Set(Int32, Int32, Int32) |
Définit les valeurs des champs année, mois et date. |
| SetHandle(IntPtr, JniHandleOwnership) |
Définit la propriété Handle. (Hérité de Object) |
| SetPeerReference(JniObjectReference, JniObjectReferenceOptions) |
<strong>[icu enhancement]</strong> ICU remplacement de l’ICU pour |
| SetWeekData(Calendar+WeekData) |
[icu] Définissez des données dans ce calendrier en fonction de l’entrée WeekData. |
| ToArray<T>() |
Crée un tableau managé à partir de ce wrapper de tableau Java. (Hérité de Object) |
| ToString() |
Retourne une représentation sous forme de chaîne de l’objet. (Hérité de Object) |
| UnregisterFromRuntime() |
Annule l’inscription de cet homologue Java à partir du runtime d’interopérabilité. (Hérité de Object) |
| ValidateField(CalendarField, Int32, Int32) |
Validez un seul champ de ce calendrier en fonction de sa valeur minimale et maximale autorisée. |
| ValidateField(CalendarField) |
Validez un seul champ de ce calendrier. |
| ValidateFields() |
Vérifiez que chaque champ se trouve dans sa plage valide en appelant |
| Wait() |
Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti par em ou><em>interrompu</em>.<> (Hérité de Object) |
| Wait(Int64, Int32) |
Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti> par< em>ou <em>interrompu/em<,> ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object) |
| Wait(Int64) |
Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti> par< em>ou <em>interrompu/em<,> ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object) |
| WeekNumber(Int32, Int32, Int32) |
Retourne le numéro de semaine d’un jour, dans une période. |
| WeekNumber(Int32, Int32) |
Retourne le numéro de semaine d’un jour, dans une période. |
Implémentations d’interfaces explicites
| Nom | Description |
|---|---|
| IComparable.CompareTo(Object) |
Compare cet objet à l’objet spécifié pour l’ordre. |
| IJavaPeerable.Disposed() |
<strong>[icu enhancement]</strong> ICU remplacement de l’ICU pour |
| IJavaPeerable.Finalized() |
<strong>[icu enhancement]</strong> ICU remplacement de l’ICU pour |
| IJavaPeerable.JniObjectReferenceControlBlock |
<strong>[icu enhancement]</strong> ICU remplacement de l’ICU pour |
| IJavaPeerable.SetJniIdentityHashCode(Int32) |
<strong>[icu enhancement]</strong> ICU remplacement de l’ICU pour |
| IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates) |
<strong>[icu enhancement]</strong> ICU remplacement de l’ICU pour |
| IJavaPeerable.SetPeerReference(JniObjectReference) |
<strong>[icu enhancement]</strong> ICU remplacement de l’ICU pour |
| IJavaPeerable.UnregisterFromRuntime() |
Supprime cette instance de la recherche d'objets Java du runtime. |
Méthodes d’extension
| Nom | Description |
|---|---|
| GetJniTypeName(IJavaPeerable) |
Obtient le nom JNI du type de l’instance |
| JavaAs<TResult>(IJavaPeerable) |
Essayez de forcer |
| JavaCast<TResult>(IJavaObject) |
Effectue une conversion de type vérifiée par le runtime Android. |
| JavaCast<TResult>(IJavaObject) |
<strong>[icu enhancement]</strong> ICU remplacement de l’ICU pour |
| TryJavaCast<TResult>(IJavaPeerable, TResult) |
Essayez de forcer |