Java中的运算符

Posted 2020-12-04 真正的小明被占用了

一。Java中的运算优先级

Java中的运算顺序与数学中的运算顺序相同：先乘除后加减。

        int x = 1;
        int y = 2;
        int z = 3;
        int a = x + y - 2 / 2 + z;
        int b = x + (y - 2) / (2 + z);
        System.out.println("a=" + a + "b=" + b);// a=5,b=1

在输出语句中有一个特点就是在输出字符串时，使用+拼接符拼接非字符串类型是他将自动转化为字符串类型后在拼接。

例子如下：

        System.out.println("运行结果为："+6+9);//运行结果为：69
        System.out.println("运行结果为："+(6+9));//运行结果为：15

二.Java中的赋值问题

1.Java中对于常量和基本类型的变量赋值如下

        final int a = 10;// 常量赋值
        int b=11;//定义一个变量
        int c= b;// 变量赋值
        b=12;//变量b更改
        System.out.println("c:"+c);//c:11

 

 

基本类型当变量b改变是c未改变，但是引用对象时却不同。

2.对象赋值

首先创建一个Car类,代码如下：

class Car {
    String name;
    int num;

    public Car(String name, int num) {
        this.name = name;
        this.num = num;
    }

    @Override
    public String toString() {
        return "车名:" + name + "     号码:" + num;
    }

    public boolean equals(Car c) {
        if (this.name == c.name && this.num == c.num) {
            return true;
        } else {
            return false;
        }
    }

}

 

        Car car1 = new Car("凯迪拉克", 1);
        Car car2 = new Car("福特", 2);
        System.out.println(car1);// 车名:凯迪拉克 号码:1
        System.out.println(car2);// 车名:福特 号码:2
        car1 = car2;// car1引用指向了car2引用指向的对象,原来car1指向的对象没有被引用，将被垃圾回收
        System.out.println(car1);// 车名:福特 号码:2,

 

此时car1和car2指向同一个对象，当我们更改car1的值是那么car2也会改变

        car1.name = "福特改";// 现在car1和car2的name字段均改变
        System.out.println(car1);// 车名:福特改 号码:2
        System.out.println(car2);// 车名:福特改 号码:2

 

 三.在方法中调用对象更改

在Java中函数的形参若为类类型，则传递方式为引用传递：

即在函数中的变动会直接改变在传入的对象中。

例如：

package com.cjm.operator;

/**
 * 对象交换和对象在函数中的引用
 * @author 小明
 *
 */
public class ObjectChange {
    /*
     * f()方法将给形参c重新赋值
     */
    static void f(Car c) {
        c.name="在f函数中变成了桑塔纳！！！";
        c.num=0;
    }
    
    public static void main(String[] args) {
        Car car1=new Car("别克君威",1);
        Car car2=new Car("别克君越",2);
        /*
         * 在这里的f()函数是引用传递，将改变引用指向的对象
         */
        f(car1);
        f(car2);
        System.out.println(car1);//车名:在f函数中变成了桑塔纳！！！     号码:0
        System.out.println(car2);//车名:在f函数中变成了桑塔纳！！！     号码:0
    }
}

 

四.对象比较问题

1.基本类型：

直接采用！=或==

2.对象比较

对象比较采用==或！=，比较的是其地址值，而想要比较其对象的值，则需要采用函数equals。

由于Java中的所有类都是object类的子类所以，都从object类中继承了equals方法，但是object类的equals方法运用了==来比较地址值的，所以你自己创造的类必须要重写equals方法。

在上面的Car类中已经重写了equals方法

Java很多库类都重写了equals方法，比如常见的String类

代码如下：

package com.cjm.operator;

/**
 * 基本类型比较和对象比较
 * 
 * @author 小明
 *
 */
public class ObjectCompare {
    public static void main(String[] args) {
        /*
         * 基本类型的比较直接采用==或者！=
         */
        int a = 10;
        int b = 10;
        System.out.println(a == b);// true
        /*
         * 对象比较
         * 
         */
        int i = new Integer(1);
        Integer num1 = new Integer(10);
        Integer num2 = new Integer(10);
        System.out.println(num1 == num2);// false
        System.out.println(num1.equals(num2));//true
        num1 = num2;
        // 此时的num1指向num2指向的对象
        System.out.println(num1 == num2);// true
        Car car1=new Car("别克君威", 0);
        Car car2=new Car("别克君威", 0);
        System.out.println(car1.equals(car2));//false，重写后为true
    }
}