2017/02/09 Heure et date ajoutées
Ceux qui visent javaGold Ceux qui comprennent javaSilver
Concentrez-vous sur les parties qui peuvent être atteintes là où il y a des démangeaisons Classe intérieure ou classe anonyme Puisqu'il sert également de mémorandum, veuillez pardonner les commentaires et les erreurs typographiques dans les noms de variables (rires) Sera mis à jour de temps en temps static
static_.java
public class static_ {
int x;
static int y;
//Accéder aux instances statiques à partir de méthodes dynamiques
void doA(){
x=1; //OK
y=2; //OK
}
static void doB(){
// x=1; //NG
y=2; //OK
}
}
final
final_.rjava
//classe finale
//Non héritable
final class final_{
//champ final
//Ne peut pas être réaffecté
final int x = 0;
//méthode finale
//Ne peut pas être remplacé
final void doIt() {
//variable locale finale
//Ne peut pas être réaffecté
final int y = 1;
//Ci-dessous, erreur de compilation
/*
x = 10;
y = 10;
}
}
class temp extends finalMethod {
@Override
public void doIt(){
}
*/
}
}
abstract
abstract_.rjava
abstract class A{
void X (){};
abstract void y();
// void Z(); //Assurez-vous d'ajouter un résumé
}
/*La classe abstraite NG doit être implémentée fermement
public class B extends A{
}
*/
//OK
abstract class C extends A{
void y(){
System.out.println("###");
}
}
naibu.java
public class naibu {
//Ci-dessous, classe imbriquée
//① classe menba statique
static class X {}
//② Classe de membres
private class Y{}
void doIt(){
//③ Classe locale
class Z{}
}
//Appel de la classe interne
public static void main(String args[]){
Outer.Inner in = new Outer().new Inner();
in.doIt();
Outer.Inner.Inner2 in2 = new Outer().new Inner().new Inner2();
in2.doIt();
}
}
class Outer{
public class Inner{
public void doIt(){
System.out.println("Outer->Inner");
}
public class Inner2{
public void doIt(){
System.out.println("Outer->Inner->Inner2");
}
}
}
}
interface_.java
public class interface_ {
public static void main(String[] args){
//méthode statique
Bar bar = new Bar();
Foo.doA();
// Bar.doA();//Classe d'implémentation NG → pour statique
// bar.doA();//Classe d'implémentation NG → pour statique
//méthode par défaut
bar.doB();
}
}
interface Foo {
//Qualifié en interne avec finale publique statique
int interfaceMenba =10;
public static final int interfaceMenba2 = 10;
//Méthode abstraite ordinaire
//Qualifié en interne avec résumé public
void doZ();
//méthode statique
static void doA() {
System.out.println("static");
}
//méthode par défaut
default void doB() {
System.out.println("default");
}
}
class Bar implements Foo {
public void doZ(){
System.out.println("doZ");
}
}
anonymous.java
public interface anonymous {
public void doIt();
}
class anonymousImpl{
public static void main (String[] args){
//Implémenté en même temps que la déclaration par la classe anonyme(Ne pas courrir)
anonymous A = new anonymous() {
public void doIt() {
System.out.println("Déclarer une classe avec une classe anonyme");
}
};
//Exécutez-le simplement pour plus de simplicité
new anonymous(){
public void doIt(){
System.out.println("Exécution par classe anonyme");
}
}.doIt();
//↑ C'est le point
}
}
rekkyo.java
public class rekkyo {
//Type d'énumération imbriqué
public enum singou {
GREEN, RED, YELOW
}
public static void main(String[] args) {
//Énumérer tous les types d'énumération
for (singou2 s : singou2.values()) {
System.out.println(s.name() + "#");
}
//Déclaration de type d'énumération et référence de champ
Souldout so = Souldout.bro_hi;
System.out.println(so.getV() + "#" + so);
}
}
//Énumération de niveau supérieur
enum singou2 {
GREEN, RED, YELOW;
//Les variables / méthodes peuvent être placées dans le type d'énumération
private int a;
public int b;
public int add(int a, int b) {
return a + b;
}
}
enum Souldout {
//Type d'énumération avec constructeur ↓
diggy_mo(2), sinnosuke(3), bro_hi(5);
private int nenrei;
//Le constructeur doit être privé
// public Souldout(){
// }
private Souldout() {
}
private Souldout(int v) {
this.nenrei = v;
}
public int getV() {
return nenrei * 100;
}
}
//Il est possible d'implémenter une interface
interface temp {
void doItIt();
}
enum singou3 implements temp {
GREEN, RED, YELOW;
public void doItIt() {
System.out.println("####");
}
}
//Cependant, l'héritage de classe n'est pas possible
class temp2 {
int a;
}
/*
enum singu4 extends temp2{
}
*/
Mise à jour du 06/02/2017
DATE.java
import java.time.*;
import java.time.temporal.ChronoUnit;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAccessor;
import static java.time.temporal.ChronoUnit.DAYS;
import static java.time.temporal.ChronoUnit.MONTHS;
import static java.time.temporal.ChronoUnit.WEEKS;
public class DATE {
public static void main(String[] args){
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//LocalDate / LocalDateTime
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Il existe les méthodes suivantes pour créer une instance
LocalDate ld = LocalDate.now();
ld = LocalDate.of(2016, Month.MARCH,10); // Month.MARCH ⇔ 2
ld = LocalDate.parse("2016-12-12");
//ld = new LocalDate(); //NG
LocalDateTime ldt = LocalDateTime.now();
//Méthode isBefore
//Méthode isAfter
//System.out.println(ldt.isAfter(ld)); //NG LocalDate et LocalDateTime
//System.out.println(ld.isAfter(ldt)); //NG LocalDateTime et LocalDate
System.out.println(LocalDate.now().isAfter(ld)); //OK
//ldt = LocalDateTime.from(ld); //Les informations d'heure sont nécessaires pour passer de NG LocalDate à LocalDateTime!
ld = LocalDate.from(ldt); //OK LocalDateTime à LocalDate ne nécessitent pas d'informations de temps
System.out.println(ldt.plus(5,MONTHS)
+ "#" + ldt.minus(365,DAYS)
+ "#" + ldt.until(ldt.plus(10,WEEKS),WEEKS));
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Temporal ←(Héritage)― TemporalAccessor ←(la mise en oeuvre)― ChronoUnit
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
TemporalAccessor ta =ChronoUnit.DAYS.addTo(LocalDate.now(),10);
Temporal t =ChronoUnit.DAYS.addTo(LocalDate.now(),10);
//LocalDateTime et LocalDateTime ne sont pas compatibles
//long days = ChronoUnit.DAYS.between(LocalDateTime.now(),LocalDate.now().plus(5,DAYS)); //NG
long days = ChronoUnit.DAYS.between(LocalDate.now(),LocalDate.now().plus(5,DAYS)); //OK
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Période Représente la période de la date
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Period p = Period.between(LocalDate.now(),LocalDate.now().plus(5,WEEKS));
//Voir le contenu de la période
System.out.println(p.getDays());
//Vous pouvez également ajouter / supprimer des périodes à la période
Period newP = p.minusDays(10);
//Peut être ajouté ou soumis à partir de la période
LocalDate ld2 =(LocalDate) p.addTo(ld);
ld2 =(LocalDate) p.subtractFrom(ld);
//L'addition / soustraction entre les périodes est également possible
Period p2 = p.plus(Period.ofDays(5));
Period p3 = p.minus(Period.ofDays(5));
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Durée Représente la durée de la date
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Duration d = Duration.between(LocalDateTime.now(),LocalDateTime.now().plusDays(1));
System.out.println(d);
d = Duration.of(1,ChronoUnit.MINUTES);
System.out.println("nanos" + d.getNano());
System.out.println("seconds" + d.getSeconds());
DateTimeFormatter dtf_bid = DateTimeFormatter.BASIC_ISO_DATE;
DateTimeFormatter dtf_idt = DateTimeFormatter.ISO_DATE_TIME;
DateTimeFormatter dtf_ii = DateTimeFormatter.ISO_INSTANT;
DateTimeFormatter dtf_original = DateTimeFormatter.ofPattern("yyyy_MM_dd_hh_mm_ss"); //Définissez votre propre format d'affichage
System.out.println(
dtf_bid.format(LocalDateTime.now())
+ "#" +dtf_idt.format(LocalDateTime.now())
//+ "#" + dtf_ii.format(LocalDateTime.now()) //NG
+ "#" + dtf_original.format(LocalDateTime.now()));
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Classe A instantanée avec secondes, millisecondes et nanosecondes cumulées à partir d'un certain point dans le temps
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Qu'est-ce qu'un certain point ↓
System.out.println(Instant.EPOCH); //1 janvier 1970 0:00:00
//Obtenir l'instance
Instant i1 = Instant.ofEpochMilli(51455414);
Instant i2 = Instant.ofEpochSecond(51455414);
Instant i3 = Instant.ofEpochSecond(51455414,2515); //Le deuxième argument est en milliseconde
//Instant instant = Instant.from(LocalTime.now()); //NG Unsupported
//Acquisition de secondes, millisecondes et nanosecondes
System.out.println(Instant.now().getEpochSecond()); //get
System.out.println(Instant.now().toEpochMilli()); //to (Pourquoi tout cela?)
System.out.println(Instant.now().getNano()); //get
System.out.println(Instant.ofEpochMilli(500000));
//De divers temporels à instantanés
//De OffsetDateTime àInstant()Entrer
OffsetDateTime odt = OffsetDateTime.now();
System.out.println(odt.toInstant());
//De ZonedDateTime àInstant()Entrer
System.out.println(ZonedDateTime.now(ZoneId.systemDefault()).toInstant());
//LocalDate n'a pas de décalage, vous devez donc le définir lors du calcul de l'instant
System.out.println(LocalDateTime.now().toInstant(ZoneOffset.UTC));
}
}
Recommended Posts