java语言基础（常量，进制，变量，运算符）

java语言基础（常量，进制，变量，运算符）

1.常量

在程序的执行过程中其值不发生改变的量。常量命名为大写字母组合，单词之间用_隔开，如STUDENT_NAME、WORK_DRESS等。

1.1Java中常量的分类

• 字面值常量

  • 字面值常量的分类

    • 字符串常量 用双引号""括起来的内容
    • 整数常量 所有整数
    • 小数常量 所有小数
    • 字符常量 用单引号括起来的内容
    • 布尔常量 较为特有，只有true和false
    • 空常量 null

  • 代码示例

    public class OperationsDemo {
        public static void main(String[] args) {
            System.out.println("字符串常量："+"Hello world!");
            System.out.println("整数常量："+1234);
            System.out.println("小数常量："+3.1415926);
            System.out.println("字符常量："+'A');
            System.out.println("布尔常量："+true+" or "+false);
            System.out.println("空常量："+null);
        }
    }
    

  • 结果
    

• 自定义常量

  自定义常量需要用final修饰符修饰。

  • 代码示例

    //定义常量CIRCLE_RADIUS和PI并输出结果。
    final int CIRCLE_RADIUS = 30;
    final double  PI = 3.14;
    System.out.println("半径为"+CIRCLE_RADIUS+"的圆形的面积为"+3.14*CIRCLE_RADIUS*CIRCLE_RADIUS);
    

  • 结果
    

2.进制

即进位制，是人为定义的带进位的计数方法。对于任何一种进制–X进制，就表示某一位置上的数运算时是逢X进一位。例如二进制就是逢二进一，八进制是逢八进一，十进制是逢十进一，十六进制是逢十六进一。

2.1 进制的由来

2.1.1 二进制

计算机中的电子元器件的状态位：开、关，而我们表示数据的时候也是使用这两种状态位来进行表示的。

若用这两种状态表示一个数据，则共有4种情况，即10、11、00、11。因为使用两个状态位来表示一个数据的时候远远不足以显示数字、字符和字母。因此国际化组织规定使用8个元器件来表示一个数据。数据的单位为字节。计算机中对数据的存储的最小单位就是字节。

1byte=8bit

1k=1024byte

1m=1024k

1g=1024m

1t=1024g

2.1.2 八进制

二进制表示数据时数据的表现形式相对较长，因此通过对二进制的优化，对二进制数据从右往左进行分组，每3位为一组，不够的左边补0，然后把每一组数据转换成十进制数据，再将十进制数据连接起来，就形成了八进制数据。如下所示：

2.1.3 十六进制

对二进制数据再次进行优化，依旧从右往左分组，每4位为一组，不够的左边补0，然后把每组数据包转换成十进制数据，再将十进制数据连接起来，就形成了十六进制数据。如下所示：

因此可以看出不同进制下的同一数据呈现出进制越大，表现形式越短的特点。

2.2 不同进制数据的表现形式

• 二进制的数据表现形式

  由0,1组成。 以0b开头(1.7版本开始的，b可大写)

• 八进制的数据表现形式

  由0,1,…7组成。 以0开头

• 十进制的数据表现形式

• 由0,1,…9组成。 整数默认是十进制的

• 十六进制的数据表现形式

  由0,1,…9,a,b,c,d,e,f(大小写均可)。 以0x开头(x可大写)

• 代码示例

  public class JinZhiDemo {
      public static void main(String[] args) {
          //输出不同进制下的100
          System.out.println("二进制下的100："+0B100);
          System.out.println("八进制下的100："+0100);
          System.out.println("十进制下的100："+100);
          System.out.println("十六进制下的100："+0X100);
      }
  }
  

• 结果
  

2.3 任意进制数据转换至十进制数据

使用位权展开法展开数据并得到结果。 每一组的数据由3部分组成:

名称	定义
系数	系数就是该位对应的值
基数	X进制到10进制的转换,那么这个基数就是X
权	我们可以对上边的数据的每一位给出一个编号,而这个编号是从0开始,并且是从右往左的,那么每一组的权值就是该编号的值。

例如十进制数据 12345
12345 = 10000 + 2000 + 300 + 40 + 5 = 1*10^4 + 2*10^3 + 3*10^2 + 4*10^1 + 5*10^0 = 10000 + 2000 + 300 + 40 + 5 = 12345
即 每一组的数据=系数*基数^权

二进制数据到十进制数据的转换:
0b100 = 1*2^2 ＋ 0*2^1 + 0*2^0 = 4 + 0 + 0 = 4

八进制数据到十进制数据的转换:
0100 = 1*8^2 + 0*8^1 ＋ 0*8^0 = 64 + 0 + 0 = 64

十六进制数据到十进制数据的转换:
0x100 = 1*16^2 + 0*16^1 + 0*16^0 = 256 + 0 + 0 = 256

2.4 十进制数据转换至任意进制数据

除基取余，直到商为0，余数反转。
例如十进制数据 12345

转换为十进制

被除数	除数（进制）	商	余数
12345	10	1234	5
1234	10	123	4
123	10	12	3
12	10	1	2
1	10	0	1

结果为：12345

十进制52转换为二进制

被除数	除数（进制）	商	余数
52	2	26	0
26	2	13	0
13	2	6	1
6	2	3	0
3	2	1	1
1	2	0	1

结果为：0b110100

十进制52转换为八进制

被除数	除数（进制）	商	余数
52	8	6	4
6	8	0	6

结果为：064

十进制52转换为十六进制

被除数	除数（进制）	商	余数
52	16	3	4
3	16	0	3

结果为：0x34

2.5 原码、反码与补码

原码、反码、补码是机器存储一个具体数字的编码方式。所有数据的运算都是采用补码进行的。

• 原码

  即二进制定点表示法。最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。

• 反码

  正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。

• 补码

  正数的补码与其原码相同；负数的补码是在其反码的末位加1。

3. 变量

即在程序执行的过程中，在某个范围内其值可以发生改变的量(例如：苹果的价钱)，变量其实是内存中的一小块区域。变量可以用来不断的存放同一类型的常量并重复使用。变量定义的格式为： 数据类型 变量名 = 变量值 ;

3.1 数据类型

变量其实就是内存中的一小块区域。我们定义一个变量，其实就是开辟了一个内存空间。为了解决开辟空间的大小问题，特引入数据类型。java提供了多种数据类型，针对不同的数据类型，在内存中分配了不同大小的内存空间。

数据类型的分类

• 基本数据类型

  • 数值型:

    整数型	字节数	范围
    byte	1(8bit)	-128 ~ 127
    short	2(16bit)	-2^15 ~ 2^15 - 1
    int	4(32bit)	-2^31 ~ 2^31 - 1
    long	8(64bit)	-2^63 ~ 2^63 - 1

    浮点型	字节数	范围
    float	4(32bit)	-3.403*10^38 ~ 3.403*10^38
    double	8(64bit)	-1.798*10^308 ~ 1.798*10^308

  • 字符型：

    字符型	字节数	范围
    char	2(16bit)	0 ~ 2^16 - 1 = 65535

  • 布尔型：

    布尔型	字节数	范围
    boolean	1（8bit）	false、true

  整数默认是int类型的 ， 浮点数默认是 double类型的。

  Java语言中的字符char可以存储一个中文汉字，Java语言采用的是Unicode编码。Unicode编码中的每个字符占用两个字节。

• 引用数据类型：数组，类，接口

3.1.1 使用变量的注意事项

• 作用域问题

  public class VariableDemo {
      public static void main(String[] args) {
          int i = 2;
          int i = 3;//同一作用域内不能定义同名变量
          int a = 5;
          //变量重新赋值
          i = 8;
          System.out.println(i);
      }
  }
  

• 初始化值问题

  public class VariableDemo {
      public static void main(String[] args) {
          int i;
          System.out.println(i);//变量未初始化，将会报错。
      }
  }
  

3.1.2 数据类型的隐式转换

隐式转换是指低级到高级的自动类型转换。

• boolean类型不能转换为其他的数据类型
• byte,short,char—int—long—float—double
• byte,short,char之间不转换,他们参与运算首先转换为int类型

代码示例：

• int + int = int

  public class TypeDemo {
      public static void main(String[] args) {
          int a = 2;
          int b = 4;
          boolean result =(Object)(a + b) instanceof Integer;//判断是否为int型
          System.out.println(a+b+"----"+result);
      }
  }
  

  输出结果为 6----true

• int + byte = int

  public class TypeDemo {
      public static void main(String[] args) {
          int a = 10;
          byte b = 120;//byte的范围为-128  ~  127
          boolean result =(Object)(a + b) instanceof Integer;//判断是否为int型
          System.out.println(a+b+"----"+result);
      }
  }
  

输出结果为 130----true

• byte + byte = int

  public class TypeDemo {
      public static void main(String[] args) {
          byte a = 10;
          byte b = 20;//byte的范围为-128  ~  127
          boolean result =(Object)(a + b) instanceof Integer;//判断是否为int型
          System.out.println(a+b+"----"+result);
      }
  }
  

输出结果为 30----true

• 字符和字符串

  public class TypeDemo3 {
      public static void main(String[] args) {
          System.out.println('a');
          System.out.println('a' + 1);//a的ASCII码是97
      }
  }
  

  结果为 a ；98

  public class TypeDemo3 {
      public static void main(String[] args) {
          System.out.println("hello" + 'a' + 1);
          System.out.println('a' + 1 + "hello");
      }
  }
  

  结果为 helloa1 ；98hello

  "+"号两端任意一端是字符串时，+号做连接作用，从左到右依次计算，（括号例外）

• 变量相加与常量相加的区别

  public class TypeDemo {
      public static void main(String[] args) {
          //byte的范围为-128  ~  127 超出范围将会报错
          byte a = 3 + 4;
          boolean result1 = (Object)(a) instanceof Integer;//判断是否为int型
          boolean result2 = (Object)(3 + 4) instanceof Integer;//判断是否为int型
          boolean result3 = (Object)(120 + 30) instanceof Integer;//判断是否为int型
          boolean result4 = (Object)(120 + 30) instanceof Byte;//判断是否为byte型
          System.out.println(result1+"----"+result2+"----"+result3+"----"+result4);
      }
  }
  

输出结果为 false----true----true----false

3.1.3 数据类型的强制转换

目标数据类型 变量名=(目标数据类型)(被转换的数据); 代码示例：

public class TypeDemo2 {
    public static void main(String[] args) {
        //byte的范围为-128  ~  127
        byte a = 10;
        int b = 200;
        byte t = (byte) (a + b);//强制类型转换到byte
        System.out.println(t);
    }
}

结果为 -46

4.运算符

对常量和变量进行操作的符号称为运算符。

4.1 运算符的分类

• 算术运算符
• 赋值运算符
• 比较运算符
• 逻辑运算符
• 位运算符
• 三目运算符

4.2 算术运算符

算数运算符包括 + , - , * , / , % , ++ , –

4.2.1 注意事项

• 整数相除只能得到整数。如果想得到小数，请使用浮点数。
• / 获取的是除法操作的商，%获取的是除法操作的余数。
• % 运算结果的符号，取决于参与运算是左边的符号

4.2.2 算术运算符++和–的用法

自加（++）: 自加。对原有的数据进行+1 自减（–）: 自减。对原有的数据进行-1

代码示例： 1.单独使用

public class OperationsDemo2 {
    public static void main(String[] args) {
        int i = 1;
        i++;
        int j = 1;
        ++j;
        System.out.println("i++="+i);
        System.out.println("++j="+j);
    }
}

放在操作数的前面和后面效果一样。自减同理。

2.参与运算使用

• 放在操作数的前面，先自增或者自减，然后再参与运算。
• 放在操作数的后面，先参与运算，再自增或者自减

public class OperationsDemo4 {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        int c = 10;
        a = b++;//先让a变成b，再给b+1，a=10，b=11
        c = --a;//先给a-1，再让c变成a，a=9，c=9
        b = ++a;//先给a+1，再让b变成a，a=10，b=10
        a = c--;//先让a变成c，再给c-1，a=9，c=8
        System.out.println(a);//a=9
        System.out.println(b);//b=10
        System.out.println(c);//c=8
    }
}

4.3 赋值运算符

赋值运算符包括 =， +=,-=,*=,/=,%=

4.3.1 注意事项

• 基本的赋值运算符 = ：把=右边的数据赋值给左边。
• 扩展的赋值运算符：+=,-=,*=,/=,%= ：+= 把左边和右边做加法，然后赋值给左边。
• 赋值运算符要求左边的数据必须是一个变量。

4.3.2 代码示例

public class OperationsDemo5 {
    public static void main(String[] args) {
        int i = 1;
        i += 1;
        System.out.println("i = "+i);
        i /= 2;
        System.out.println("i = "+i);
    }
}

结果为 i = 2；i = 1

4.4 关系运算符

关系运算符有== ,!= , < , > , <= , >= , instanceof

4.4.1 注意事项

• 无论你的操作是简单还是复杂，结果是boolean类型。
• “==“不能写成”=”。

4.4.2 代码示例

public class OperationsDemo6 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a==b);
        System.out.println(a!=b);
    }

结果为 false；true

4.5 逻辑运算符

逻辑运算符包括&(并且) , |(或者) , !(非) , ^(异或) , &&(短路与) , ||(短路或)

4.5.1 注意事项

• 逻辑运算符一般用于连接boolean类型的表达式或者值。例如x>3 & x<6。

• 表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。例如

  • 算术表达式：a + b
  • 关系表达式：a == b

• 双运算符和单运算符的区别（以&&和&为例）

  • 最终结果一致
  • &&具有短路效果。左边是false，右边不执行。

• 结论

  运算符	含义	判定结果
  &	逻辑与	有false则false
  |	逻辑或	有true则true
  ^	逻辑异或	相同为false，不同为true
  !	逻辑非	非false则true，非true则false

4.5.2 代码示例

public class OperationsDemo7 {
    public static void main(String[] args) {
        System.out.println(true&true);//true
        System.out.println(true&false);//false
        int a = 2;
        int b = 10;
        boolean c = (a == 3) && (++b > 10 );//右侧(++b > 10 )不执行
        System.out.println(c);//false
        System.out.println(b);//10
        System.out.println(true^true);//false
        System.out.println(false^false);//false
        System.out.println(true^false);//true
        System.out.println(!true);//false
    }
}

4.6 位运算符

位运算符包括&(与)，|(或)，^(异或) , ~(按位取反) , <<(左移) ,>>(右移) ,>>>(无符号右移),>>>(无符号右移) 位运算是直接对二进制补码进行运算。运算效率高一些

4.6.1 注意事项

• &:有0则0
• |:有1则1
• ^:相同则0，不同则1
• ~:按位取反 0变1 1变0 符号位也包含在内取反
• 由于正数的原码、反码、补码相同，运算时可不用转换。负数参与运算时首先需将其原码转换至补码，再将运算结果转换成原码输出。

4.6.2 代码示例

正数情况

public class OperationsDemo8 {
    public static void main(String[] args) {
        int a = 6;//                  二进制形式为 00000110
        int b = 13;//                  二进制形式为 00001101
        System.out.println(a&b);//             结果为 00000100 转换至十进制为4
        System.out.println(a|b);//             结果为 00001111 转换至十进制为15
        System.out.println(a^b);//             结果为 00001011 转换至十进制为11
        System.out.println(~a);//              结果为 11111001 转换至原码为10000111 转换至十进制为-7
    }
}

负数情况

public class OperationsDemo9 {
    public static void main(String[] args) {
        int a = -6;//                      原码二进制形式为 10000110 补码为 11111010
        int b = -13;//                     原码二进制形式为 10001101 补码为 11110011
        System.out.println(a&b);//              结果为 11110010 转换至原码为 10001110 即十进制为-14
        System.out.println(a|b);//              结果为 11111011 转换至原码为 10000101 即十进制为-5
        System.out.println(a^b);//              结果为 00001001 转换至十进制为9
        System.out.println(~a);//               结果为 00000101 转换至十进制为5
    }
}

^的特点

• 一个数据被另一个数据位异或两次，该数本身不变。
• 自己位异或自己是0。

public class OperationsDemo10 {
    public static void main(String[] args) {
        int a = 8;
        System.out.println(2^a^2);//8
        System.out.println(a^2^2);//8
        System.out.println(2^2^a);//8
        System.out.println(a^a);//0
    }
}

左移和右移

• <<:左移 空位补0，被移除的高位丢弃。
• >>:右移 被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，高位补1。
• >>>:无符号右移 被移位二进制最高位无论是0或者是1，空缺位都用0补。
• << : 把<<左边的数据乘以2的移动次幂 例如 10<<3 结果 10*2^3=80
• >> : 把>>左边的数据除以2的移动次幂 例如 40>>3 结果 40/2^3=5

public class OperationsDemo11 {
    public static void main(String[] args) {
        System.out.println(10<<3);//10*2^3 = 80
        System.out.println(40>>3);//40/2^3 = 5
    }
}

4.7 三元运算符

格式为 (关系表达式) ？ 表达式1 ： 表达式2；例如 int a=(10>20)?30:50;

4.7.1 注意事项

• 关系表达式为true，执行表达式1
• 关系表达式为false，执行表达式2

4.7.2 代码示例

获取三个数中的最大值

public class OperationsDemo12 {
    public static void main(String[] args) {
        int a = 50;
        int b = 23;
        int c = 100;
        int max = a > b ? a:b;
        max = c > max ? c:max;
        System.out.println("最大值是"+max);//最大值是100
    }
}