JavaGoldのためのかゆいところに手が届く備忘録

2017/02/09 時間・日付　を追加


##対象
javaGoldを狙う方
javaSilverの理解はできている方

##概要
かゆいところに手が届く部分を中心にまとめる
内部クラスとか匿名クラスとか
備忘録を兼ねてますので、コメントや変数名の誤字脱字はご容赦ください(笑)
随時更新予定
##static

```java:static_.java
public class static_ {
    int x;
    static int y;

    //動的メソッドからstaticインスタンスへのアクセス
    void doA(){
        x=1; //OK
        y=2; //OK
    }

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

##final

```java:final_.rjava
//finalクラス
//継承不可
final class final_{

    //finalフィールド
    //再代入不可
    final int x = 0;

    //finalメソッド
    //オーバーライド不可
    final void doIt() {

        //finalローカル変数
        //再代入不可
        final int y = 1;

        //以下、コンパイルエラー
        /*
        x = 10;
        y = 10;
    }
}
class temp extends finalMethod {

    @Override
    public void doIt(){

    }
    */
    }
}
```

##abstract

```java:abstract_.rjava
abstract class A{
    void X (){};
    abstract void y();
//    void Z(); //abstractは必ずつけること
}
/* NG 抽象クラスはしっかり実装していないといけない
public class B extends A{
}
*/

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

```

##内部クラス
```java:naibu.java
public class naibu {

    //以下、入れ子クラス

    //①staticめんばー・クラス
    static class X {}

    //②メンバークラス
    private class Y{}

    void doIt(){
        //③ローカルクラス
        class Z{}
    }

    //内部クラスの呼び出し
    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のdefault・static
```java:interface_.java
public class interface_ {
    public static void main(String[] args){

        //staticメソッド
        Bar bar = new Bar();
        Foo.doA();
//        Bar.doA();//NG 実装クラス→staticのため
//        bar.doA();//NG 実装クラス→staticのため

        //defaultメソッド
        bar.doB();

    }
}

interface Foo {
    //内部でpublic static finalで修飾されている
    int interfaceMenba =10;
    public static final int interfaceMenba2 = 10;

    //通常の抽象メソッド
    //内部でpublic abstractで修飾されている
    void doZ();

    //staticメソッド
    static void doA() {
        System.out.println("static");
    }

    //defaultメソッド
    default void doB() {
        System.out.println("default");
    }


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

##匿名クラス
```java:anonymous.java
public interface anonymous {
    public void doIt();
}

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

        //匿名クラスによて、宣言と同時に実装(実行はしていない)
        anonymous A = new anonymous() {
            public void doIt() {
                System.out.println("匿名クラスによるクラスの宣言");
            }
        };

        // 実行するだけだと、より簡略化
        new anonymous(){
            public void doIt(){
                System.out.println("匿名クラスによる実行");
            }
        }.doIt();
        //↑ここがポイント
    }
}
```

##列挙型
```java:rekkyo.java
public class rekkyo {
    //入れ子の列挙型
    public enum singou {
        GREEN, RED, YELOW
    }

    public static void main(String[] args) {
        //列挙型をすべて列挙
        for (singou2 s : singou2.values()) {
            System.out.println(s.name() + "#");
        }

        //列挙型の宣言とフィールドの参照
        Souldout so = Souldout.bro_hi;
        System.out.println(so.getV() + "#" + so);
    }
}

//トップレベルの列挙型
enum singou2 {
    GREEN, RED, YELOW;
    //列挙型内に変数・メソッドを置くことができる
    private int a;
    public int b;

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

}

enum Souldout {
    //コンストラクタ付きの列挙型↓
    diggy_mo(2), sinnosuke(3), bro_hi(5);
    private int nenrei;

    //コンストラクタはprivateでなければならない
//    public Souldout(){
//    }
    private Souldout() {

    }

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

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

//インターフェースを実装することは可能
interface temp {
    void doItIt();
}
enum singou3 implements temp {
    GREEN, RED, YELOW;

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

//ただし、クラスの継承は不可
class temp2 {
    int a;
}
/*
enum singu4 extends temp2{
}
*/
```


##時間・日付
2017/02/06更新

```java: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
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        //インスタンス作成は、以下の方法がある
        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メソッド
        //isAfterメソッド
        //System.out.println(ldt.isAfter(ld));  //NG  LocalDate と LocalDateTime
        //System.out.println(ld.isAfter(ldt));  //NG　LocalDateTime と LocalDate
        System.out.println(LocalDate.now().isAfter(ld)); //OK

        //ldt = LocalDateTime.from(ld);  //NG LocalDateからLocalDateTimeにするには時間情報が必要！
        ld = LocalDate.from(ldt);       //OK   LocalDateTimeからLocalDateは時間情報は不要

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

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
        //Temporal ←(継承)― TemporalAccessor ←(実装)― ChronoUnit
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
        TemporalAccessor ta =ChronoUnit.DAYS.addTo(LocalDate.now(),10);
        Temporal t =ChronoUnit.DAYS.addTo(LocalDate.now(),10);

        //LocalDateTimeとLocalDateTimeの互換性はない
        //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

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        //Period 日付の期間をあらわす
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        Period p = Period.between(LocalDate.now(),LocalDate.now().plus(5,WEEKS));
        //Periodの中身をみる
        System.out.println(p.getDays());
        //さらにPeriodに期間を追加・削除も可能
        Period newP = p.minusDays(10);
        //Periodからaddすることもsubtractも可能
        LocalDate ld2 =(LocalDate) p.addTo(ld);
        ld2 =(LocalDate) p.subtractFrom(ld);
        //Period同士の加算・減算も可能
        Period p2 = p.plus(Period.ofDays(5));
        Period p3 = p.minus(Period.ofDays(5));

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        //Duration 日付の期間をあらわす
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        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"); //独自の表示形式を定義

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


        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        //Instant  ある時点からの累計の秒数・ミリ秒数・ナノ秒数を持つクラス
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        //ある時点とは↓
        System.out.println(Instant.EPOCH);  //1970年1月1日0時0分0秒

        //インスタンス取得
        Instant i1 = Instant.ofEpochMilli(51455414);
        Instant i2 = Instant.ofEpochSecond(51455414);
        Instant i3 = Instant.ofEpochSecond(51455414,2515);  //　第二引数はミリ秒
        //Instant instant = Instant.from(LocalTime.now());   //NG Unsupported

        //秒数・ミリ秒数・ナノ秒数の取得
        System.out.println(Instant.now().getEpochSecond());  //get
        System.out.println(Instant.now().toEpochMilli());    //to (なぜこれだけto？)
        System.out.println(Instant.now().getNano());         //get

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

        //各種TemporalからInstantへ
        //OffsetDateTimeから、toInstant()で取得
        OffsetDateTime odt = OffsetDateTime.now();
        System.out.println(odt.toInstant());
        //ZonedDateTimeから、toInstant()で取得
        System.out.println(ZonedDateTime.now(ZoneId.systemDefault()).toInstant());
        //LocalDateはoffsetを持たないので、instantを計算する際に、設定する必要あり
        System.out.println(LocalDateTime.now().toInstant(ZoneOffset.UTC));
    }
}

```