Java基础篇（数据类型、运算）

数据类型，变量，数据类型转换

本篇讲解Java基础，关于变量的存储，数据类型，定义变量，以及结合运算符进行简便运算。

变量的存储

首先我们生活中数字表示以及计算方式通常都是以十进制的形式显现（也就是逢十进一）。要了解变量的存储方式，我们得先了解计算机得数据存储原理。在计算机中转化为二进制进行存储，可以说计算机只认得0与1。计算机中数据最小的组成单元：使用8个二进制位为一组，称之为一个字节（byte,简称B）。字节中的每个二进制位就称为 位（bit，简称b）, 1B = 8b。
计算机中存储数据的单位：
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB

数据类型

数据类型可划分为基本数据类型，引用数据类型。

数据类型	默认值
byte	0
short	0
int	0
long	0L
float	0.0f
double	0.0d
char	‘u0000’
String	null
boolean	false

基本数据类型分为
整型（整数）：
byte： (-128 , 127) byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 8 位
short： (-32768 , 32767) 同样的 short 类型也为节约空间，short 变量占用空间为 16 位
int： (-2,147,483,648 , 2,147,483,647) int 最常用于定义整数，整形变量一般默认为 int 类型，int 占用空间为 32 位
long： 主要用于需要比较大的整数的系统，占用空间 64 位
浮点型（小数）：
float： 与整型中的 short 类似，在浮点型中占用较小空间 32 位，节省内存
double： double最常用于定义小数，浮点型变量一般默认为 double 类型
字符型：
char： 用于存储任何单个字符，是一个单一的 16 位 Unicode 字符
布尔型：
boolean 只有两个值：true 和 false ,通常用于作标记

定义变量

了解数据类型后，我们进行变量的定义。所谓变量其实就于数学中方程的未知数类似。用于表示（存储）数据。

public class Test {
    static byte a;
    static short b;
    static int c;
    static long d;
    static float e;
    static double f;
    static char g;
    static boolean h;
    static String i;
    public static void main(String[] args) {
        System.out.println("byte a:" + a + ", short b:" + b + ", int c:" + c + ", long d:" + d);
        System.out.println("float e:" + e + ", double f:" + f + ", char g:" + g + ", boolean h:" + h);
        System.out.println("String i:" + i );
    }
}

运行后的输出结果为：
byte a:0， short b:0， int c:0， long d:0
float e:0.0， double f:0.0， char g: ， boolean h:false
String i:null

从代码中我们可以看出变量定义于类中，但在方法外面。此时的变量称为：成员变量
成员变量在堆内存中运行，是有初始值的（即默认值），作用域于整个类中，也就是说在这个类里面我们都可以不用重新定义便可以使用。

public class Test {
    public static void main(String[] args) {
        byte a = 1;
        short b = 2;
        int c = 3;
        long d = 4l;
        float e = 1.1f;
        double f = 1.2d;
        char g = 'g';
        boolean h = false;
        String str = " 字符串 "
        System.out.println("byte a:" + a + ", short b:" + b + ", int c:" + c + ", long d:" + d);
        System.out.println("float e:" + e + ", double f:" + f + ", char g:" + g + ", boolean h:" + h);
        System.out.println("String str:" + str);
    }
}

运行后输出的结果为：
byte a:1， short b:2， int c:3， long d:4
float e:1.1， double f:1.2， char g:g， boolean h:false
String str:字符串

从代码中我们可以看出变量定义于方法内。此时的变量称为局部变量
局部变量在栈内存中运行，是没有初始值的，需要我们给它一个值，作用域于定义变量的代码处到整个方法结束。在定义 long 的变量时，当数字不是特别大的时候可以不需要加 L ，double的 d 不需要。但这两者不同的是 float 必须要加 f ，上文的数据类型介绍讲述到，所有的整型变量默认为 int ，浮点型变量默认为 double ，当定义 float 类型时，数据需要加 f 。

简单数据类型转换

java数据类型转换可以分为三种（本篇包含两种）：自动类型转换，强制类型转换
了解数据类型转换前需要知道数据类型的排位机制，从低级到高级（也可视为从占用内存小的到占用内存较大的，但并不完全是）
byte < short < int <long < float < double
char > int < long < float < double
(byte，short，char)–int–long–float–double

自动类型转换： 由低级可以直接转向高级的

    public static void main(String[] args) {
        byte b = 1;
        short s = b;
        int i = b;
        long l = b;
        float f = b;
        double d = b;
        System.out.println("byte b:" + b + "， short s:" + s + "， int i:" + i);
        System.out.println("long l:" + l + "，float f:" + f + "， double d:" + d);
    }

输出结果为：
byte b:1， short s:1， int i:1
long l:1，float f:1.0， double d:1.0

以此类推，按照上面的顺序，自动类型转换并不会报错，也没有什么问题。

**强制类型转换：**强制从高级转换为低级

public static void main(String[] args) {
        double d = 1.123456789;
        byte b = (byte) d;
        short s = (short) d;
        int i = (int) d;
        long l = (long) d;
        float f = (float) d;
        System.out.println("byte b:" + b + "， short s:" + s + "， int i:" + i);
        System.out.println("long l:" + l + "，float f:" + f + "， double d:" + d);
    }

输出结果为：
byte b:1， short s:1， int i:1
long l:1，float f:1.1234568， double d:1.123456789

将高级变量转换为低级变量时，情况会复杂一些，要使用强制类型转换。由上面的代码结合输出结果可以看出，强制类型的转换会导致溢出或精度的下降。

char 类型的强制转换相比前面的会特殊点，char 类型为单个字符根据 AscII 码表。

public static void main(String[] args) {
        byte b = 1;
        short s = 2;
        int i = 65;
        long l = 4;
        float f = 5.5f;
        double d = 6.5;
        char c = (char) i;
        System.out.println("char c:" + c);
    }

输出结果：char c：A
以上强制类型转换均可实现，但输出结果与所对应数据不同，需要根据 AscII 码表进行转换对应字符。因为 i 所对应数据为 65 ，转换为 char 字符时转换成对应字符 A
有兴趣的小伙伴可以搜搜 AscII 码表查看。

运算符

运算符可细分为六种类别：算术运算符，自增自减运算符，赋值运算符，关系运算符，逻辑运算符，三元运算符

算术运算符

（+， -， *， /， %） 分别对应为 加法， 减法， 乘法， 除法以及取余。加 减 乘与生活中的数学运算相同。
值得注意的是除法的 / 以及取余的 %。

public static void main(String[] args) {
        int a = 19888;
        int b = 100;
        System.out.println("a / b = " + a / b);
        double c = 20.99;
        double d = 5.1;
        System.out.println("c / d = " + c / d);
        System.out.println("b / d = " + b / d);
    }

输出结果为：
a / b = 198
c / d = 4.1156862745098035
b / d = 19.607843137254903

结合代码以及输出结果可以看出，当数据均为为整型时，也就是整数时，运算得出的结果只有整数，未出现小数。当数据均为小数则正常运算。而数据中既有小数又有整数时，结果却未小数。这其中涉及到上文描述的自动类型转换，在运算过程中系统会将低级自动转换为高级。上文亦描述整数类型一般默认为 int 类型，而浮点型（小数）则默认为 double 类型；

（+）也有其特殊的地方，它不仅仅可以表示加法，也可以用于字符串的拼接，在整篇文章的输出语句中都应用到了 + 。

public static void main(String[] args) {
        int a = 10, b = 20;
        System.out.println(a + b + " = a + b = " + a +  "+" + b);
    }

输出结果为：
30 = a + b = 10+20

（+）运用于字符串时表示拼接，其余看作正常加法。代码内前面两个（+）表示加法运算，而位于字符串内的直接输出，位于字符串后的则表示拼接。总结来说就是（串前运算，串后拼接）。

public static void main(String[] args) {
        int a = 19888;
        int b = 100;
        System.out.println("a % b = " + a % b);
        double c = 20.99;
        double d = 5.1;
        System.out.println("c % d = " + c % d);
        System.out.println("b % d = " + b % d);
    }

输出结果为：
a % b = 88
c % d = 0.5899999999999999
b % d = 3.1000000000000068

结合代码与输出结果可以看出，取余的运算。取余顾名思义，求取余数。两数相除取余数。

自增自减运算符

自增自减的运算在程序中比较有意思，由于符号位置的不同，运算方式也不同。大部分比较粗心的人可能会在这上面出错。
自增自减运算符为 ++ ， - - 。顾名思义，自身值的增加以及对应的减。

public static void main(String[] args) {
        int a = 1, b = 2;
        a++;
        System.out.println("a++ : " + a);
        ++a;
        System.out.println("++a : " + a);
        b--;
        System.out.println("b-- : " + b);
        --b;
        System.out.println("--b : " + b);
    }

输出结果为：
a++ : 2
++a : 3
b-- : 1
–b : 0

结合代码与输出结果可知，运算符++与- -放变量前后都是表示自增或者自减。但两者是否有区别呢？

public static void main(String[] args) {
        int a = 10, b = 20;
        int c = a++;
        System.out.println("c = a++ =" + c);
        c = ++a;
        System.out.println("c = ++a =" + c);
    }

输出结果为：
c = a++ =10
c = ++a =12

a++ 与 ++a 的区别就在于 a++ 是先使用数据后再自身 +1 ，++a 是先自身 +1 后再被使用。
第一个 c = a++表示 c = a = 10, 然后 a + 1 = 11，此时 c = 10, a = 11;
第二个 c = ++a 表示 c = a + 1 = 12, 此时 c = 12, a = 12;

同理（- -）与（++）的使用相同，比较容易出，可以试着多练习。

赋值运算符

赋值运算符：= ， += ， -=， *=， /=， %=

public static void main(String[] args) {
        int a = 10, b = 21;
        double c = 5.0;
        int num = 0;
        System.out.println("num = " + num);
        num += b;
        System.out.println("num = " + num);
        num -= c;
        System.out.println("num = " + num);
        num *= a;
        System.out.println("num = " + num);
        num /= c;
        System.out.println("num = " + num);
        num %= a;
        System.out.println("num = " + num);
    }

输出结果为：

num = 0
num = 21
num = 16
num = 160
num = 32
num = 2

结合代码与输出结果可得，（=）得作用是直接赋值。而其余得赋值运算则是先用符号左边的变量，和右边的数据先进行运算，再把结果强制转化为符号左边的类型，最后再赋值给左边的变量。
以上代码运算可以看作为 num = num + b; num = num - c;以此类推。
需要注意得是赋值运算中自带强制类型转换，因为代码中得 num 属于 int 类型，所以当 num 与 double 类型得 c 进行运算后得出得结果任是 int 类型。

关系运算符

关系运算符 > , >= , < , <= , ==, !=(即不等于) 用于比较两个数据的关系。

public static void main(String[] args) {
        int a = 10, b = 21;
        double c = 10.0;
        System.out.println(a > c);
        System.out.println(a >= c);
        System.out.println(a < c);
        System.out.println(a <= b);
        System.out.println(a == b);
        System.out.println(a != c);
    }

输出结果为：
false
true
false
true
false
false

基本上与生活中数学无差别，值得注意的是 == 与 = 的区别。赋值运算符中提到 = 在 java 中用于给变量赋值，而 == 用于判断两个数据是否相等。String 类型的比较会特殊点，并不是用 == 来比较数据值是否相同。String 类型比较用 equals() 或者 equalsIgnoreCase () (不区分大小写)。

public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("abc");
        String s4 = "abc";
        String s5 = "abc";
        System.out.println(s1 == s2);
        System.out.println(s4 == s5);
        System.out.println(s1.equals(s2));
        System.out.println(s2.equals("ABC"));
        System.out.println(s2.equalsIgnoreCase("ABC"));
    }

输出结果为：
false
true
true
false
true

第一个输出结果与第二个输出结果有所不同，刚刚提到的是 == 不能用来比较 String 类型的值，但这里却正常输出。其实这里的 == 并不是比较两数据的值，而是比较的是两者的地址值。

逻辑运算符

基础逻辑运算符：&, &&, |, ||, !, ^ (即与，或，非，异或)
&, &&（与，短路与）都表示多个条件需要同时满足，有false则false。不同的是短路与当左边判断为false的时候便不会继续执行后续的判断，可以提高程序性能，我们通常写代码也倾向于使用短路与。
|, ||（或，短路或）都表示多个条件只需要满足其中一个，有true则true。短路或同理于短路与。
！（取反）顾名思义，取与判断相反的值，判断中无非就是 true 和 false。当正常判断为 false 时，用取反则为true。
^（异或）通常情况下用的比较少。记住其判断规则即可，相同为false 不同为true。
结合代码与输出会更好理解！

public static void main(String[] args) {
        int a = 5, b = 5, c = 10;
        System.out.println(a == b & a > c);
        System.out.println(a == b && a < c);
        System.out.println(a == c | a < c);
        System.out.println(a != c || a > c);
        System.out.println(!(a == c));
        System.out.println(a == c ^ a < c);
    }

输出结果为：
false
true
true
true
true
true

三元运算符

三元运算符用于判断，并对判断的结果进行处理。先执行关系表达式，如果判断结果为true，则返回值1，如果判断结果为false，则返回值2。
格式： 数据类型 变量名 = 关系表达式 ? 值1 ： 值2;

public static void main(String[] args) {
        int a = 5, b = 10;
        int max = a > b ? a : b;
        System.out.println("最大值为：" + max);
        // 或者在输出时直接判断并返回值
        System.out.println("最大值为：" + (a > b ? a : b));
        //由于此处用了拼接，所以后面的判断用括号涵盖
    }

输出结果为：
最大值为：10
最大值为：10

未完，仍在努力学习中…