Think in Java 第三章操作符

赋值

对象赋值

我们真正操作的是对对象的引用。所以倘若”将一个对象赋值给另一个对象“，实际上是将”引用“从一个地方复制到另一个地方。倘如对对象使用 c= d 那么c和d都指向原本d指向的那个引用。

别名机制

修改c 的同时也会改变d 他们不是相互独立的指向相同的对象而c原本指向的对象，会被垃圾回收自动清理

正确做法

t1.level = t2.level

保持两个对象相互独立，而不是将t1 和 t2 绑到相同对象身上

算数操作符

练习3

class VelocityCalculator1{

    static float velocity(float d,float t)

    {

        if(t == 0) return 0f;

        else  return d/t;

    }

}

public class VelocityCalculator {

    public static void main(String[] args) {

        float d = 902.3f;

        float t = 100.4f;

        System.out.println("Distance =" +d);

        System.out.println("time =" + t);

        float a = VelocityCalculator1.velocity(d,t);

        System.out.println("Velocity =" + a);

    }

}

对象的等价

== !=

比较的是对象的引用

若想比较对象的实际内容是否相同，应该使用特殊方法 equals（）

练习五

class Doog{

    String name;

    String say;

    void setName(String n){

        name = n;

    }

    void setSay(String s){

        say = s;

    }

    void showName(){

        System.out.println(name);

    }

    void showSay(){

        System.out.println(say);

    }

}

public class dog {

    public static void main(String[] args) {

        Doog dog1 = new Doog();

        Doog dog2 = new Doog();

        dog1.setName("spot");

        dog1.setSay("Ruff");

        dog2.setName("Scrufy");

        dog2.setSay("Ruff");

        dog1.showName();

        dog1.showSay();

        dog2.showName();

        dog2.showSay();

    }

}

练习七抛硬币simulates_coin_flipping

nextInt()用法：

会随机生成一个整数，这个整数的范围就是int类型的范围-2^31 ~ 2^31-1,但是如果在nextInt()括号中加入一个整数a那么，这个随机生成的随机数范围就变成[0,a)。

import java.util.*;

import org.greggordon.tools.*;

public class CoinToss {

	public static void main(String[] args) {

		Random rand = new Random();

		int coin = rand.nextInt();

		if(coin % 2 == 0) P.rintln("heads");

		else P.rintln("tails");

	}

}

移位操作符

有符号移位 >> 左移低位补0 右移

正数高位插入0

负数高位插1

无符号移位 >>> 无论正负高位插0

练习11

public class RightShiftTest {

    public static void main(String[] args) {

        int h = 0x10000000;

        System.out.println(Integer.toBinaryString(h));

        for (int i=1;i<28;i++){

            h >>>= 1;

            System.out.println(Integer.toBinaryString(h));

        }

    }

}

======================================================

10000000000000000000000000000

1000000000000000000000000000

100000000000000000000000000

10000000000000000000000000

1000000000000000000000000

100000000000000000000000

10000000000000000000000

1000000000000000000000

100000000000000000000

10000000000000000000

1000000000000000000

100000000000000000

10000000000000000

1000000000000000

100000000000000

10000000000000

1000000000000

100000000000

10000000000

1000000000

100000000

10000000

1000000

100000

10000

1000

100

10

练习12

public class RightShiftTest {

    public static void main(String [] args) {

        int h = -1;

        System.out.println(Integer.toBinaryString(h));

        h <<= 10;

        System.out.println(Integer.toBinaryString(h));

        for(int i = 0; i < 32; i++) {

            h >>>= 1;

            System.out.println(Integer.toBinaryString(h));

        }

    }

}

=============================================================

11111111111111111111111111111111

11111111111111111111110000000000

1111111111111111111111000000000

111111111111111111111100000000

11111111111111111111110000000

1111111111111111111111000000

111111111111111111111100000

11111111111111111111110000

1111111111111111111111000

111111111111111111111100

11111111111111111111110

1111111111111111111111

111111111111111111111

11111111111111111111

1111111111111111111

111111111111111111

11111111111111111

1111111111111111

111111111111111

11111111111111

1111111111111

111111111111

11111111111

1111111111

111111111

11111111

1111111

111111

11111

1111

111

11

1

0

习题13

 public static void main(String [] args) {

        char c = 'a';

        System.out.println(Integer.toBinaryString(c));

        c = 'b';

        System.out.println(Integer.toBinaryString(c));

        c = 'c';

        System.out.println(Integer.toBinaryString(c));

        c = 'd';

        System.out.println(Integer.toBinaryString(c));

        c +=1;

        System.out.println(Integer.toBinaryString(c));

        c = 'A';

        System.out.println(Integer.toBinaryString(c));

        for(int i = 0; i < 6; i++) {

            c +=1;

            System.out.println(Integer.toBinaryString(c));

        }

    }

====================================================

1100001

1100010

1100011

1100100

1100101

1000001

1000010

1000011

1000100

1000101

1000110

1000111

提升

如果对 基本类型 执行算数运算或者按位运算，只要比int小（char，byte，short），在运算之前就 自动转换成int。最终结果就是int类型。如果把结果赋值给较小的类型，需要使用类型转换。通常表达式中出现大的数据类型决定了表达式最终结果的数据类型。 folat值与一个double值相乘，结果是double

练习14

import org.greggordon.tools.*;

public class StringCompare {

	static void f(boolean b) {if(b == true) P.rintln(true);

		else P.rintln(false);}

	static void stringTest(String s, String t) {

		f(s == t);

		f(s.equals(t));

		f(t.equals(s));

		f(s != t);

		// f(!s);

		//f(!t);

		// s = s && t;

		// s = s || t;

		// s = ~t;

		// s = s  & t;

		// s = s | t;

		// s = s ^ t;

		// s &= t;

		// s ^= t;

		// s |= t;

	}

	public static void main(String[] args) {

		String s = "one", t = "two";

		StringWork.stringTest(s, t);

	}

}

========================================================

false

false

false

true