Java - 演算子

TOP > Java > 演算子

代入演算子

「=」演算子の右の値を左の識別子に代入する。代入する際、左辺の型に入る値でなければならない。

オブジェクトを参照する変数の場合、参照変数に代入されているのはオブジェクトそのものではなく、オブジェクトにたどり着くまでの道筋が入っている。もし、参照変数がオブジェクトを指していない場合、「どのオブジェクトも指していない」ということになり、値は「null」となる。

基本型の代入

基本型変数には、リテラル（値）、式の結果を代入することができる。

基本型の代入の例

    int a = 3 ;
    int b = x + 3 ;
    int c = x + y ;

byte型に式の結果を代入する例

class Test{
    public static void main(String[] args){
        byte b = 23 ;
        byte c = 25 ;
        byte d = b + c ;
    }
}

このコードはコンパイルできない。b + cの結果は「48」でbyte型の範囲になるが、コンパイラはこの値をint型と判断し、int型のリテラルをbyte型に代入する際にエラーが起きる。右辺を明示的に以下のようにキャストすると、エラーは起きない。

浮動小数点の代入

浮動小数点はデフォルトでは、double型となるので、float型を使う際にはサフィックスを使うか、明示的にキャストをしなければならない。

float型に代入する例

class Test{
    public static void main(String[] args){
        float a = 123 ;//int型なので問題ない
        float b = 123.2F ;//サフックスを付ける
        float c = (float) 234.34 ;//明示的にキャストする
    }
}

複合演算子

複合演算子を使うと明示的にキャストをしなくても、自動的にキャストをしてくれる。

複合演算子

    byte b = 3 ;
    b += 3 ;
    //これは、以下と同じ
    byte b = 3 ;
    b = (byte) (b + 3) ;

基本型変数を他の基本型変数に代入する

ある基本型変数を他の基本型変数に代入すると、値をコピーする事になる。

変数の代入の例

class Test{
    public static void main(String[] args){
        int a = 5 ;
        int b = a ;
        System.out.println("a=" + a) ;
        System.out.println("b=" + b) ;
    }
}

参照変数への代入

新しく作成したオブジェクトへ代入するには以下のようにする。

(書式) Test t = new Test() ;

この式は以下の3つの事をしている。

tというTest型の参照変数を作成する。

ヒープ上に新しくTestオブジェクトを生成する。

新しく作成したTestオブジェクトを参照変数に代入する。

またオブジェクト参照変数にnullを入れることもできる。この場合、この参照変数はどのオブジェクトも指していない事になる。

Test t = null ;

更に参照変数は、その参照変数を宣言する際に指定した型のサブクラスのオブジェクトを参照することができる。

オブジェクト参照変数の例

class Super{
    void superMethod(){
        System.out.println("superMethod") ;
    }
}

class Sub extends Super{
    //独自のメソッド
    void subMethod(){
        System.out.println("subMethod") ;
    }
    //オーバーライド
    void superMethod(){
        System.out.println("オーバーライドsuperMethod") ;
    }
}

class Test{
    public static void main(String[] args){
        Super s1 = new Super() ;
        Super s2 = new Sub() ;
        Sub s3 = new Sub() ;
        //これは、コンパイルエラー
        //Subクラス参照変数に対して、subMethod()を呼び出す事はできるが、
        //参照先のオブジェクトが実際はSuper()だった場合(この場合)は、
        //Superオブジェクトはこのメソッドに対してSubクラスのメソッドを
        //呼び出す事はできない。何故なら、Superクラスには、subMethod()
        //が無いため。
//      Sub s4 = new Super() ;
        s1.superMethod() ;
        s2.superMethod() ;
        s3.subMethod() ;
    }
}

参照変数を参照変数に代入する

これは、参照先を代入するという事。参照変数が保管しているのは、オブジェクトまでの道のりである。

参照変数に参照変数を代入する例

class A{
    int a ;
    A(int i){
        a = i ;
    }
}
class Test{
    public static void main(String[] args){
        A a = new A(1) ;
        A b = a ;//①
        System.out.println(b.a) ;
        System.out.println(a.a) ;
        b = new A(2) ;//②
        System.out.println(b.a) ;
        System.out.println(a.a) ;
    }
}

①で新しい参照変数を宣言し、参照変数を代入している。よって、最初の値は同じ参照先なので、両方とも1を指す。

②で新しいオブジェクトを生成して、そのオブジェクトを参照変数bに代入している。この工程は、参照変数bが指すオブジェクトが参照変数aが指すオブジェクトと異なってしまう。よって、最後の値は「2」と「1」となる。

比較演算子

比較演算子は常に結果としてブール値を返す。

>（より大きい）

>=（以上）

<（より小さい）

<=（以下）

比較演算子の例

if(x > 3){
    //何らかの処理
}

instanceof比較

instansof演算子は、オブジェクト参照変数に対してのみ使う。

参照変数 instanceof 型(クラス・インタフェース)

上記の式によりIS-Aテストに合格するかどうか調べる。

継承におけるinstanceofの例

class Zoo{}

class Super{}
class Test extends Super{
    public static void main(String[] args){
        Test t = new Test() ;
        if(t instanceof Test){
            System.out.println("t IS-A Test") ;
        }

        if(t instanceof Super){
            System.out.println("t IS-A Super") ;
        }

        Super s = new Test() ;
        if(s instanceof Test){
            System.out.println("s IS-A Test") ;
        }
        //このコードは表示されない。
        //すなわち、IS-Aテストに不合格である。
        Super s2 = new Super() ;
        if(s2 instanceof Test){
            System.out.println("s2 IS-A Test") ;
        }

        Zoo z = new Zoo() ;
        //コンパイルできない
        if(z instanceof Test){
            System.out.println("z IS-A Test") ;
        }

        //スーパークラスObjectにおける結果は常にtrueになる
        if(z instanceof Object){
            System.out.println("z IS-A Object") ;
        }
    }
}

インタフェースにおけるinstanceofの例

interface Inter{}
class Sub implements Inter{
}
class Test extends Sub{
    public static void main(String[] args){
        Test t = new Test() ;
        if(t instanceof Test){
            System.out.println("t IS-A Test") ;
        }
        if(t instanceof Sub){
            System.out.println("t IS-A Sub") ;
        }
        if(t instanceof Inter){
            System.out.println("t IS-A Inter") ;
        }
        if(t instanceof Object){
            System.out.println("t IS-A Object") ;
        }

        Sub s = new Sub() ;
        if(s instanceof Test){
            System.out.println("s IS-A Test") ;
        }
    }
}

nullとinstanceofの例

class Test{
    public static void main(String[] args){
        Test t = null ;
        boolean b = null instanceof Test ;
        System.out.println(b) ;
        boolean b2 = t instanceof Test ;
        System.out.println(b) ;
    }
}

等価性演算子

等価性は以下の2つの演算子を使って、比較できる。等価性は、型の異なるもの同士は比較できない。（例えば、int型とオブジェクト型）

==・・・等価、等しい

!=・・・非等価、等しくない

比較できるもの

数値

文字

ブール値

オブジェクト参照変数

等価性演算子を用いて比較するのは、ビットパターン。

等価性演算子の例

class Test{
    public static void main(String[] args){
        int a = 3 ;
        double b = 3.0 ;
        char c = 'c' ;
        char d = 'd' ;
        Test t = new Test() ;
        Test s = t ;
        Test u = new Test() ;
        if(a == b){
            System.out.println("a == b") ;
        } else {
            System.out.println("a != b") ;
        }
        if(c != d){
            System.out.println("c != d") ;
        } else {
            System.out.println("c == d") ;
        }
        if(s == t){
            System.out.println("s == t") ;
        } else {
            System.out.println("s != t") ;
        }
        if(s == u){
            System.out.println("s == u") ;
        } else {
            System.out.println("s != u") ;
        }
    }
}

算術演算子

加・減・乗・除算を行う演算子。馴染みにくいのが余りを求める演算子。

+・・・加算、足す

-・・・減算、引く

*・・・乗算、掛ける

/・・・除算、割る

%・・・余り、割ったときの余り(剰余演算子)

整数を0で割ったとき、ランタイム例外（ArithmeticException）が発生する。また、0で割ったときの余りを求めた時もランタイム例外（ArithmeticException）が発生する。

小数を0で割ったときは、例外は発生しない。正の数を0で割った時は、正の無限大(フィールド定数：Infinity)になる。負の数を0で割った時は、負の無限大(フィールド定数：-Infinity)になる。また、浮動小数点を0で割った余りは、非数「NaN」になる。

算術演算子の例

    public static void main(String[] args){
        System.out.println(2+1) ;//3
        System.out.println(3%2) ;//1
        System.out.println(4.0/0) ;//Infinity
        System.out.println(-4.0/0) ;//-Infinity
        System.out.println(0.0/0) ;//NaN
        System.out.println(-4.0%0) ;//NaN
        //これは、ランタイム例外
        System.out.println(4%0) ;
        //これも、ランタイム例外
        System.out.println(4/0) ;
    }
}

文字列連結演算子

文字と文字を連結する演算子。加算演算子と同じ符号なので、注意が必要。「+」演算子のオペランドが文字列(char型ではなく)の場合、「+」演算子は「文字列連結演算子」となる。演算子には優先順位があるが、通常左から処理される。処理の順序を変えるには、()を使う。

文字列連結演算子の例

class Test{
    public static void main(String[] args){
        String s = "Test" ;
        System.out.println(s + 3 + 3) ;//Test33
        System.out.println(s + (3 + 3)) ;//Test6
        System.out.println(3 + 3 + s) ;//6Test
        System.out.println(3 + (3 + s)) ;//33Test
        System.out.println("a + b=" + 3 + 3) ;//a + b =33
        System.out.println("a + b=" + (3 + 3)) ;//a + b =6
    }
}

インクリメントとデクリメント

インクリメントもデクリメントも両方とも前置型と後置型がある。前置型(演算子を前に置く:++i、--i)は、変数の値がが使われる前にインクリメント(デクリメント)される。後置型(演算子を後ろに置く:i++、i--)を使用すると、次の変数の値を使った後となる。

インクリメント(++)・・・1ずつ増算する演算子。

デクリメント(--)・・・1ずつ減算する演算子。

class Test{
    public static void main(String[] args){
        int a = 0 ;
        System.out.println(a++) ;//後置型次の呼び出し時にインクリメントされる。「0」
        System.out.println(a) ;//ここは「1」と表示される。
        System.out.println(a++) ;//後置型次の呼び出し時にインクリメントされる。「1」
        System.out.println(++a) ;//前置型この時点でインクリメントされる。「3」
        System.out.println(--a) ;//前置型この時点でデクリメントされる。「2」
        System.out.println(a--) ;//前置型次の呼び出し時にデクリメントされる。「2」
        System.out.println(a) ;//ここは「1」と表示される。
    }
}

シフト演算子

シフト演算子は、数値のビットを左、右に動かす演算子。当然、ビットを動かすので値が変わる事がある。この演算子は整数にしか使えない。使おうとするとコンパイルエラーが起きる。

シフト演算子の例

class Test{
    public static void main(String[] args){
        int a = 0 ;
        System.out.println(8 >>> 1) ;//4
        System.out.println(16 >> 5) ;//0
        System.out.println(16 << 33) ;//64
        System.out.println(32 << 1) ;//64
    }
}

ビット演算子

ビット演算子は、2つのビット値を受け取り演算する演算子。

「&」・・・AND。比較する値が両方とも「1」の時、「1」

「|」・・・OR。比較する値の片方が「0」でない時、「1」

「^」・・・排他OR。比較する値が「1」と「0」の時、「1」

ビット演算子の例

class Test{
    public static void main(String[] args){
        int a = 0 ;
        System.out.println(8 & 5) ;//0
        System.out.println(8 | 5) ;//13
        System.out.println(8 ^ 5) ;//13
    }
}

ビット補数演算子

ビット補数演算子(~)は、全て「1」を「0」に「0」を「1」にします。

ビット補数演算子の例

class Test{
    public static void main(String[] args){
        int a = 0 ;
        System.out.println(~8) ;//-9
    }
}

条件演算子

条件演算子は、ブール式を評価するための3項演算子。

(書式) 変数 = (ブール式) ? trueの場合に代入する値 : falseの場合に代入する値

条件演算子の例

class Test{
    public static void main(String[] args){
        int a = 1 ;
        String s ;
        s = (a == 0) ? "s == 0" : (a == 1) ? "a == 1" : " a != 0 " ;
        System.out.println(s) ;
    }
}

短絡論理演算子

短絡論理演算子とは、ブール値を評価する。

&&・・・AND。かつ

||・・・OR。もしくは

短絡演算子は最初のブール式で、式の結果がわかる場合、次の式は評価しない。すなわち「&&」の場合、最初のブール式が「false」の場合、次の式は行わない。この時点で、falseとなるから。また、「||」の場合、最初のブール式が「true」となった場合、次のブール式は行わない。この時点で「true」になる事が明らかだから。

短絡論理演算子の例

class Test{
    public static void main(String[] args){
        int a = 0 ;
        int b = 0 ;
        for(int i = 0 ; i < 4 ; i++){
            if( a++ > 1 && ++b > 1){
                System.out.println("a=" + a + " b=" + b ) ;
            }
        }
    }
}

非短絡論理演算子

ビット演算子(&と|)は、論理演算子としても使える。この二つは、上記の短絡演算子と異なり、最初の式の結果でブール式が決まったとしても、次のブール式を行う。尚、論理演算子の優先順位は、「&」→「|」→「&&」→「||」となる。よって、左から順にブールテストを行う訳ではない。

論理演算子の例

class Test{
    public static void main(String[] args){
        int s= 0 ;
        boolean[] b = {true,false,true,false} ;
        if(++s > 0 && b[1] | b[0]){
            System.out.println("true") ;
        } else {
            System.out.println("false") ;
        }

        if(b[0] & b[1] | b[2] & b[3] | b[2]){
            System.out.println("true") ;
        } else {
            System.out.println("false") ;
        }

        if(b[0] && b[1] | b[2] & b[3] | b[2]){
            System.out.println("true") ;
        } else {
            System.out.println("false") ;
        }
    }
}