Ein Memorandum, um den juckenden Ort für Java Gold zu erreichen

2017/02/09 Uhrzeit und Datum hinzugefügt

Ziel

Diejenigen, die auf JavaGold abzielen Diejenigen, die javaSilver verstehen

Überblick

Konzentrieren Sie sich auf die Teile, die dort erreicht werden können, wo es juckt Innere Klasse oder anonyme Klasse Da es auch als Memorandum dient, verzeihen Sie bitte Kommentare und Tippfehler in Variablennamen (lacht). Wird von Zeit zu Zeit aktualisiert static

static_.java

public class static_ {
    int x;
    static int y;

    //Zugriff auf statische Instanzen über dynamische Methoden
    void doA(){
        x=1; //OK
        y=2; //OK
    }

    static void doB(){
//        x=1; //NG
        y=2; //OK
    }
}

final

final_.rjava

//letzte Klasse
//Nicht vererbbar
final class final_{

    //letztes Feld
    //Kann nicht neu zugewiesen werden
    final int x = 0;

    //endgültige Methode
    //Kann nicht überschrieben werden
    final void doIt() {

        //letzte lokale Variable
        //Kann nicht neu zugewiesen werden
        final int y = 1;

        //Unten Kompilierungsfehler
        /*
        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(); //Stellen Sie sicher, dass Sie eine Zusammenfassung hinzufügen
}
/*NG abstrakte Klasse muss fest implementiert sein
public class B extends A{
}
*/

//OK
abstract class C extends A{
    void y(){
        System.out.println("###");
    }
}

Innere Klasse

naibu.java

public class naibu {

    //Unten verschachtelte Klasse

    //① statische Menba-Klasse
    static class X {}

    //② Mitgliederklasse
    private class Y{}

    void doIt(){
        //③ Lokale Klasse
        class Z{}
    }

    //Innere Klasse anrufen
    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");
            }
        }
    }
}

Schnittstelle Standard / statisch

interface_.java

public class interface_ {
    public static void main(String[] args){

        //statische Methode
        Bar bar = new Bar();
        Foo.doA();
//        Bar.doA();//NG-Implementierungsklasse → für statische
//        bar.doA();//NG-Implementierungsklasse → für statische

        //Standardmethode
        bar.doB();

    }
}

interface Foo {
    //Intern qualifiziert mit öffentlichem statischem Finale
    int interfaceMenba =10;
    public static final int interfaceMenba2 = 10;

    //Gewöhnliche abstrakte Methode
    //Intern qualifiziert mit öffentlichem Abstract
    void doZ();

    //statische Methode
    static void doA() {
        System.out.println("static");
    }

    //Standardmethode
    default void doB() {
        System.out.println("default");
    }


}
class Bar implements Foo {
     public void doZ(){
        System.out.println("doZ");
    }
}

Anonyme Klasse

anonymous.java

public interface anonymous {
    public void doIt();
}

class anonymousImpl{
    public static void main (String[] args){

        //Wird gleichzeitig mit der Deklaration durch die anonyme Klasse implementiert(Nicht laufen)
        anonymous A = new anonymous() {
            public void doIt() {
                System.out.println("Deklarieren einer Klasse mit einer anonymen Klasse");
            }
        };

        //Führen Sie es der Einfachheit halber einfach aus
        new anonymous(){
            public void doIt(){
                System.out.println("Ausführung durch anonyme Klasse");
            }
        }.doIt();
        //↑ Das ist der Punkt
    }
}

Aufzählungstyp

rekkyo.java

public class rekkyo {
    //Verschachtelter Aufzählungstyp
    public enum singou {
        GREEN, RED, YELOW
    }

    public static void main(String[] args) {
        //Zählen Sie alle Aufzählungstypen auf
        for (singou2 s : singou2.values()) {
            System.out.println(s.name() + "#");
        }

        //Aufzählungstypdeklaration und Feldreferenz
        Souldout so = Souldout.bro_hi;
        System.out.println(so.getV() + "#" + so);
    }
}

//Aufzählung der obersten Ebene
enum singou2 {
    GREEN, RED, YELOW;
    //Variablen / Methoden können in den Aufzählungstyp eingefügt werden
    private int a;
    public int b;

    public int add(int a, int b) {
        return a + b;
    }

}

enum Souldout {
    //Aufzählungstyp mit Konstruktor ↓
    diggy_mo(2), sinnosuke(3), bro_hi(5);
    private int nenrei;

    //Der Konstruktor muss privat sein
//    public Souldout(){
//    }
    private Souldout() {

    }

    private Souldout(int v) {
        this.nenrei = v;
    }

    public int getV() {
        return nenrei * 100;
    }
}

//Es ist möglich, eine Schnittstelle zu implementieren
interface temp {
    void doItIt();
}
enum singou3 implements temp {
    GREEN, RED, YELOW;

    public void doItIt() {
        System.out.println("####");
    }
}

//Eine Klassenvererbung ist jedoch nicht möglich
class temp2 {
    int a;
}
/*
enum singu4 extends temp2{
}
*/

Zeit Datum

Update 2017/02/06

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
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        //Es gibt die folgenden Methoden zum Erstellen einer Instanz
        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();

        //isBefore-Methode
        //isAfter-Methode
        //System.out.println(ldt.isAfter(ld));  //NG LocalDate und LocalDateTime
        //System.out.println(ld.isAfter(ldt));  //NG LocalDateTime und LocalDate
        System.out.println(LocalDate.now().isAfter(ld)); //OK

        //ldt = LocalDateTime.from(ld);  //Zeitinformationen sind erforderlich, um von NG LocalDate zu LocalDateTime zu wechseln!
        ld = LocalDate.from(ldt);       //OK LocalDateTime bis LocalDate benötigen keine Zeitinformationen

        System.out.println(ldt.plus(5,MONTHS)
                + "#" + ldt.minus(365,DAYS)
                + "#" + ldt.until(ldt.plus(10,WEEKS),WEEKS));

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
        //Temporal ←(Erbe)― TemporalAccessor ←(Implementierung)― ChronoUnit
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
        TemporalAccessor ta =ChronoUnit.DAYS.addTo(LocalDate.now(),10);
        Temporal t =ChronoUnit.DAYS.addTo(LocalDate.now(),10);

        //LocalDateTime und LocalDateTime sind nicht kompatibel
        //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

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        //Zeitraum Stellt den Zeitraum des Datums dar
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        Period p = Period.between(LocalDate.now(),LocalDate.now().plus(5,WEEKS));
        //Siehe den Inhalt von Periode
        System.out.println(p.getDays());
        //Sie können Perioden auch Perioden hinzufügen / entfernen
        Period newP = p.minusDays(10);
        //Kann zum Zeitraum hinzugefügt oder von diesem abgezogen werden
        LocalDate ld2 =(LocalDate) p.addTo(ld);
        ld2 =(LocalDate) p.subtractFrom(ld);
        //Addition / Subtraktion zwischen Perioden ist ebenfalls möglich
        Period p2 = p.plus(Period.ofDays(5));
        Period p3 = p.minus(Period.ofDays(5));

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        //Dauer Stellt die Dauer des Datums dar
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        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"); //Definieren Sie Ihr eigenes Anzeigeformat

        System.out.println(
                dtf_bid.format(LocalDateTime.now())
                + "#" +dtf_idt.format(LocalDateTime.now())
                //+ "#" + dtf_ii.format(LocalDateTime.now())  //NG
                + "#" + dtf_original.format(LocalDateTime.now()));


        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        //Sofort Eine Klasse mit kumulativen Sekunden, Millisekunden und Nanosekunden ab einem bestimmten Zeitpunkt
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        //Was ist ein bestimmter Punkt ↓
        System.out.println(Instant.EPOCH);  //1. Januar 1970 0:00:00

        //Bekomme Instanz
        Instant i1 = Instant.ofEpochMilli(51455414);
        Instant i2 = Instant.ofEpochSecond(51455414);
        Instant i3 = Instant.ofEpochSecond(51455414,2515);  //Das zweite Argument ist Millisekunde
        //Instant instant = Instant.from(LocalTime.now());   //NG Unsupported

        //Erfassung von Sekunden, Millisekunden und Nanosekunden
        System.out.println(Instant.now().getEpochSecond());  //get
        System.out.println(Instant.now().toEpochMilli());    //to (Warum ist das alles zu?)
        System.out.println(Instant.now().getNano());         //get

        System.out.println(Instant.ofEpochMilli(500000));

        //Von verschiedenen zeitlichen bis zu sofortigen
        //Von OffsetDateTime bis Instant()Reinkommen
        OffsetDateTime odt = OffsetDateTime.now();
        System.out.println(odt.toInstant());
        //Von ZonedDateTime zu Instant()Reinkommen
        System.out.println(ZonedDateTime.now(ZoneId.systemDefault()).toInstant());
        //LocalDate hat keinen Versatz, daher müssen Sie ihn bei der Berechnung des Augenblicks festlegen
        System.out.println(LocalDateTime.now().toInstant(ZoneOffset.UTC));
    }
}