二、操作符

1.赋值

对基本类型的赋值是直接将一个地方的内容复制到另一个地方。

为对象进行赋值造作的时候，真正操作的是对象的引用，如果“将一个对象赋值给另一个对象”，实际上是将“引用”从一个地方复制到另一个地方：

class Tank{
    int level;
}
public class Test{
    public static void main(String[] args){
        Tank t1 = new Tank();
        Tank t2 = new Tank();
        t1.level = 10;
        t2.level = 20;
        System.out.println("t1.level:" + t1.level + ",t2.level:" + t2.level);
        t1 = t2;
         System.out.println("t1.level:" + t1.level + ",t2.level:" + t2.level);
        t1.level = 30;
         System.out.println("t1.level:" + t1.level + ",t2.level:" + t2.level);
    }
}/*Output:
t1.level:10,t2.level:20
t1.level:20,t2.level:20
t1.level:30,t2.level:30
*/

由于赋值操作是对象的引用，所以修改t1的同时也改变了t2。t1和t2包含相同的引用，即指向相同的对象，t1原本的引用将会丢失，会被“垃圾回收器”自动清理。

如果想避免上述问题，可以使用：

t1.leval = t2.level;

这样就可以保持两个对象相互独立。

但注意不要轻易为对象赋值（还不清楚为什么。。。）

2.别名问题，方法参数

java总是采用按值调用！！！！！方法得到的是所有参数值的一个拷贝，方法不能修改传递给它的任何参数变量的内容！

1）方法不能修改数值型参数

public class Test{
    public static void tripleValue(int x){
        x = 3 * x;
        System.out.println("End of method：" + x);
    }
    public static void main(String[] args){
        int a = 1;
        System.out.println("Before：a=" + a);
        tripleValue(a);
        System.out.println("After：a=" + a);
    }
}/*Output:
Before：a=1
End of method：3
After：a=1
*/

2）方法可以改变一个对象参数的状态

方法得到的是对象引用的拷贝，对象引用及其他的拷贝同时引用同一个对象：

class Employee{
    private String name;
    private double salary;
    public Employee(String n, double s){
        name = n;
        salary = s;
    }
    public String getName(){
        return name;
    }
    public double getSalary(){
        return salary;
    }
    public void raiseSalary(double byPercent){
        double raise = salary * byPercent / 100;
        salary += raise;
    }
}
public class Test{
   public static void main(String[] args) {
       Employee tom = new Employee("Tom",5000);
       System.out.println("Before:salary=" + tom.getSalary());
       tripSalary(tom);
       System.err.println("After:salary=" + tom.getSalary());
       
   }
   public static void tripSalary(Employee x){
       x.raiseSalary(300);
       System.out.println("End of method:salary=" + x.getSalary());
   }
}/*Output:
Before:salary=5000.0
End of method:salary=20000.0
After:salary=20000.0
*/

3）方法不能让调用它的对象引用新的对象

class Employee{
    private String name;
    public Employee(String n){
        name = n;
    }
    public String getName(){
        return name;
    }
}
public class Test{
   public static void main(String[] args) {
       Employee a = new Employee("Tom");
       Employee b = new Employee("Jerry");
       System.out.println("before: a=" + a.getName());
       System.out.println("before: b=" + b.getName());
       swap(a,b);
       System.out.println("After: a=" + a.getName());
       System.out.println("After: b=" + b.getName());
   }
   public static void swap(Employee x, Employee y){
       Employee temp = x;
       x = y;
       y = temp;
       System.out.println("End of method: x=" + x.getName());
       System.out.println("End of method: y=" + y.getName());
   }
}/*Output:
before: a=Tom
before: b=Jerry
End of method: x=Jerry
End of method: y=Tom
After: a=Tom
After: b=Jerry
*/

3.==和equals()

==和!=比较的是对象的引用！

如果比较两个对象的实际内容，使用equals()方法，但此方法不适用于基本类型，基本类型直接使用==和!=即可。

但是equals()默认也是比较引用，所以要在自己新类中覆盖equals()方法。

test1:虽然内容相同，但是引用不同：

public class Test{
    public static void main(String[] args) {
        Integer n1 = new Integer(47);
        Integer n2 = new Integer(47);
        System.out.println(n1 != n2);
        System.out.println(n1 == n2);
    }
}/*Output:
true
false*/

test2:使用equals()比较内容：

public class Test{
    public static void main(String[] args) {
        Integer n1 = new Integer(47);
        Integer n2 = new Integer(47);
        System.out.println(n1.equals(n2));
    }
}/*Output:
true
*/

test3:当新类中没有覆盖equals()方法时，equals()仍然是比较引用：

class Value{
    int i;
}
public class Test{
    public static void main(String[] args) {
        Value v1 = new Value();
        Value v2 = new Value();
        v1.i = v2.i = 100;
        System.out.println(v1.equals(v2));
    }
}/*Output:
false
*/

总结test2、test3，由于在Integer类中覆盖了equals()方法，所以实现了内容的比较，而test3中由于Value类没有覆盖equals()方法，所以仍然比较的是引用。类似的还有String类中对equals()方法的覆盖。（由于还没有完全搞懂，此处先不讨论String。关于Object中的equals()方法及在其他类中覆盖将在后续的Object章节再阐述。）

4、Last but not least

1)随机数

Random，位于java.util.Random:

Random rand = new Random();
//或者
Random rand = new Random(47);

构造器中的参数，对于特定的种子，总产生相同的随机数序列。

通过Tandom对象，可以商城许多不同类型的随机数字，需调用方法nextInt()、nextLong()、nextFloat()、nextDouble()等方法，传递给nextInt()等方法的参数何止了随机数的上限，即[0,n)，如果对于某些随机数想避免产生0，可对产生的结果进行加1（或者其他数字）的操作。

2)三元操作符if-else

三元操作符（或称条件操作符）与if-else的区别除了形式不同外，条件操作符还会产生一个值。

3)字符串连接 + 、 +=

public class Demo {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a+b+"");
        System.out.println(""+a+b);
    }
}/*Output:
3
12
*/

4)截尾和舍入

当将float或double转换为整型时，总是执行截尾操作，如果想得到舍入的结果，需要调用java.lang.Math中的round()方法：

public static int round(float a)
public static long round(double a)

转载于:https://www.cnblogs.com/mvplzl/p/4415396.html