【Java基础知识 4】Java数据类型之间的转换、运算符

public class SimpleTesting {
    public static void main(String[] args) {
        int value_int = 65;
        char value_char  = (char) value_int;
        System.out.println(value_char);
    }
}

A    //65在 ASCII 码中对应的字符是A

🍃02、自动类型转换

规则从小到大低字节向高字节自动提升

顺序

byte(1字节) – > short(2字节)-- > int(4字节) – > long(8字节) --> float(4字节) – > double(8字节)

char (2字节)-- > int(4字节) – > long(8字节) --> float(4字节) – > double(8字节)

画图分析

🍃03、什么时候会发生类型转换

答赋值 | 运算时两边数据类型不一致时就会发生类型转换

🌲引用数据类型

基本数据类型在作为成员变量和静态变量的时候有默认值引用数据类型也有的。

String 是最典型的引用数据类型所以我们就拿 String 类举例看下面这段代码

public class LocalRef {
    private String a;
    static String b;

    public static void main(String[] args) {
        LocalRef lv = new LocalRef();
        System.out.println(lv.a);
        System.out.println(b);
    }
}

输出结果如下所示

null
null

null 在编程语言中是一个很神奇的存在在你以后的程序生涯中见它的次数不会少尤其是伴随着令人烦恼的“空指针异常open in new window”也就是所谓的 NullPointerException。

也就是说引用数据类型的默认值为 null包括数组和接口。

你可能会问为什么数组和接口也是引用数据类型啊

先来看数组

public class ArrayDemo {
    public static void main(String[] args) {
        int [] arrays = {1,2,3};
        System.out.println(arrays);
    }
}

arrays 是一个 int 类型的数组对吧打印结果如下所示

[I@2d209079

[I 表示数组是 int 类型的@ 后面是十六进制的 hashCode——这样的打印结果太“人性化”了一般人表示看不懂为什么会这样显示呢查看一下 java.lang.Object 类的 toString() 方法就明白了。

数组虽然没有显式定义成一个类但它的确是一个对象继承了祖先类 Object 的所有方法。那为什么数组不单独定义一个类来表示呢就像字符串 String 类那样呢

一个合理的解释是 Java 将其隐藏了。假如真的存在一个 Array.java我们也可以假想它真实的样子它必须要定义一个容器来存放数组的元素就像 String 类那样。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];
}

数组内部定义数组没必要的

再来看接口

public class IntefaceDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        System.out.println(list);
    }
}

List 是一个非常典型的接口

public interface List<E> extends Collection<E> {}

而 ArrayList 是 List 接口的一个实现

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{}

对于接口类型的引用变量来说你没法直接 new 一个

只能 new 一个实现它的类的对象——那自然接口也是引用数据类型了。

来看一下基本数据类型和引用数据类型之间最大的差别。

基本数据类型

1、变量名指向具体的数值。
2、基本数据类型存储在栈上。

引用数据类型

1、变量名指向的是存储对象的内存地址在栈上。
2、内存地址指向的对象存储在堆上。

堆是堆heap栈是栈stack如果看到“堆栈”的话请不要怀疑自己那是翻译的错堆栈也是栈。

堆是在程序运行时在内存中申请的空间可理解为动态的过程程序员自己new出来的切记不是在编译时因此Java 中的对象就放在这里这样做的好处就是

当需要一个对象时只需要通过 new 关键字写一行代码即可当执行这行代码时会自动在内存的“堆”区分配空间——这样就很灵活。

栈能够和处理器CPU也就是脑子直接关联因此访问速度更快。既然访问速度快要好好利用啊Java 就把对象的引用放在栈里。为什么呢因为引用的使用频率高吗

不是的因为 Java 在编译程序时必须明确的知道存储在栈里的东西的生命周期否则就没法释放旧的内存来开辟新的内存空间存放引用——空间就那么大。

🌲Java 运算符

🍐01、算数运算符

算术运算符除了最常见的加减乘除还有一个取余的运算符用于得到除法运算后的余数。

        int a = 10;
        int b = 5;

        System.out.println(a + b);//15
        System.out.println(a - b);//5
        System.out.println(a * b);//50
        System.out.println(a / b);//2
        System.out.println(a % b);//0

        b = 3;
        System.out.println(a + b);//13
        System.out.println(a - b);//7
        System.out.println(a * b);//30
        System.out.println(a / b);//3
        System.out.println(a % b);//1

对于初学者来说加法+、减法-、乘法*很好理解但除法/和取余%会有一点点疑惑。在以往的认知里10/3 是除不尽的结果应该是 3.333333...而不应该是 3。相应的余数也不应该是 1。这是为什么呢

因为数字在程序中可以分为两种一种是整型一种是浮点型整型和整型的运算结果就是整型不会出现浮点型。否则就会出现浮点型。

🍐02、关系运算符

关系运算符用来比较两个操作数返回结果为 true 或者 false。

🍐 03、位运算符

public class BitOperator {
    public static void main(String[] args) {
        int a = 60, b = 13;
        System.out.println("a 的二进制" + Integer.toBinaryString(a)); // 111100
        System.out.println("b 的二进制" + Integer.toBinaryString(b)); // 1101

        int c = a & b;
        System.out.println("a & b" + c + "二进制是" + Integer.toBinaryString(c));

        c = a | b;
        System.out.println("a | b" + c + "二进制是" + Integer.toBinaryString(c));

        c = a ^ b;
        System.out.println("a ^ b" + c + "二进制是" + Integer.toBinaryString(c));

        c = ~a;
        System.out.println("~a" + c + "二进制是" + Integer.toBinaryString(c));

        c = a << 2;
        System.out.println("a << 2" + c + "二进制是" + Integer.toBinaryString(c));

        c = a >> 2;
        System.out.println("a >> 2" + c + "二进制是" + Integer.toBinaryString(c));

        c = a >>> 2;
        System.out.println("a >>> 2" + c + "二进制是" + Integer.toBinaryString(c));
    }
}

1按位左移运算符

public class LeftShiftOperator {
    public static void main(String[] args) {
        System.out.println(10<<2);//10*2^2=10*4=40  
        System.out.println(10<<3);//10*2^3=10*8=80  
        System.out.println(20<<2);//20*2^2=20*4=80  
        System.out.println(15<<4);//15*2^4=15*16=240  
    }
}

10<<2 等于 10 乘以 2 的 2 次方10<<3 等于 10 乘以 2 的 3 次方。

2按位右移运算符

public class RightShiftOperator {
    public static void main(String[] args) {
        System.out.println(10>>2);//10/2^2=10/4=2
        System.out.println(20>>2);//20/2^2=20/4=5
        System.out.println(20>>3);//20/2^3=20/8=2
    }
}

10>>2 等于 10 除以 2 的 2 次方20>>2 等于 20 除以 2 的 2 次方。

🍐04、逻辑运算符

逻辑与运算符&&多个条件中只要有一个为 false 结果就为 false。

逻辑或运算符||多个条件只要有一个为 true 结果就为 true。

public class LogicalOperator {
    public static void main(String[] args) {
        int a=10;
        int b=5;
        int c=20;
        System.out.println(a<b&&a<c);//false && true = false

        System.out.println(a>b||a<c);//true || true = true
    }
}

逻辑非运算符!用来反转条件的结果如果条件为 true则逻辑非运算符将得到 false。

单逻辑与运算符&很少用因为不管第一个条件为 true 还是 false依然会检查第二个。

单逻辑或运算符|也会检查第二个条件。

也就是说& 和 | 性能不如 && 和 ||但用法一样

public class LogicalOperator1 {
    public static void main(String[] args) {
        int a=10;
        int b=5;
        int c=20;
        System.out.println(a<b&a<c);//false & true = false

        System.out.println(a>b|a<c);//true | true = true  
    }
}

🍐05、赋值运算符

赋值操作符恐怕是 Java 中使用最频繁的操作符了它就是把操作符右侧的值赋值给左侧的变量。来看示例

public class AssignmentOperator {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        a+=4;//a=a+4 (a=10+4)  
        b-=4;//b=b-4 (b=20-4)  
        System.out.println(a);
        System.out.println(b);
    }
}

不过在进行数值的赋值时需要小点心比如说下面这种情况

编译器之所以提示错误是因为 = 右侧的算术表达式默认为 int 类型左侧是 short 类型的时候需要进行强转。

public class AssignmentOperator1 {
    public static void main(String[] args) {
        short a = 10;
        short b = 10;
//a+=b;//a=a+b internally so fine
        a = (short)(a + b);
        System.out.println(a);
    }
}

除此之外还会有边界问题比如说两个非常大的 int 相乘结果可能就超出了 int 的范围

public class BigIntMulti {
    public static void main(String[] args) {
        int a = Integer.MAX_VALUE;
        int b = 10000;
        int c = a * b;
        System.out.println(c); // -10000
    }
}

程序输出的结果为 -10000这个答案很明显不是我们想要的结果虽然可以通过右侧表达式强转 long 的方法解决

public class BigIntMulti {
    public static void main(String[] args) {
        int a = Integer.MAX_VALUE;
        int b = 10000;
        long c = (long)a * b;
        System.out.println(c); // 21474836470000
    }
}

但尽量不要这样做结果非常大的时候尽量提前使用相应的类型进行赋值。

long a = Integer.MAX_VALUE - 1;
long b = 10000;
long c = a * b;
System.out.println(c); // 21474836460000

🍐06、三元运算符

三元运算符用于替代 if-else可以使用一行代码完成条件判断的要求。来看示例

public class TernaryOperator {
    public static void main(String[] args) {
        int a=2;
        int b=5;
        int min=(a<b)?a:b;
        System.out.println(min);
    }
}

如果 ? 前面的条件为 true则结果为 : 前的值否则为 : 后的值。这个可以用 if 语句来替代。