Java 变量 数据类型

二. 数据类型、变量、运算符

2.1 标识符 和 关键字

  • 标识符:代码中代表了各种数据的名字。通过标识符来访问操作各种数据。

  • 标识符是有命名规则的:

    • 首字符必须是 大小写字符、_、$。

    • 从第二个字符开始,可以使用数字。

    • 长度没有限制。

    • 大小写敏感。区分大小写。

    • 不能使用java的关键字。

      • class public static void

  • 标识符的命名规范:

    • 见名知意,必须通过名字体现出数据的内容来。

      • age name studentAge studentName

    • 使用驼峰命名法:

      • 多个单词构成的标识符,单词的首字符大写。

    • 不要使用拼音。

    • 不要使用单字符标识符。(个别情况例外)。

2.2 变量(variable)

  • 变量是一种标识符。

  • 变量的概念:变量的本质是一块有名字的内存区域。内存中的数据可以被修改。

  • 定义变量的语法:数据类型 变量名 = 初始值;

    • int age = 21;

    • 数据类型:代表了变量所能保存的数据的种类:整数、浮点数、字符串...

    • 变量名:是一种标识符,要符合标识符的规则规范。

  • 变量的特有的命名规范:首字符小写,多个单词构成,从第二个单词开始,每个单词的首字符大写。

2.3 java支持的数据类型

  • java 程序可以处理的哪些种类的数据。

  • java 支持的数据的类型分为2大类:

    • 基本数据类型|简单数据类型|java的内置类型(模拟表示现实世界中简单的数据)

      • 数值型

        • 整数类型

          • byte 字节型 使用1 byte 表示整数。取值范围[-128~127] 256

          • short 短整型 使用2 bytes 表示整数。取值范围[-2^15~ 2^15-1] 65536

          • int 整型 使用4 bytes 表示整数。取值范围[-2^31~ 2^31-1]

          • long 长整型 使用8 bytes 表示整数。取值范围[-2^63~ 2^63-1]

        • 浮点数类型

          • float 单精度型 使用4 bytes 表示浮点数。小数点后最多保留7位左右。

          • double 双精度 使用8 bytes 表示浮点数。小数点后最多保留16位左右。

        • 字符类型

          • char 占用 2bytes。在java中使用单引号 表示一个字符 'A'; 本质上字符是一个整数。【0-65535】

      • 布尔类型

        • boolean 用来表示现实世界中的真假对错的。true false。 true:真的,对的。false:假的,错的。

        • 官方没有指出 boolean类型变量占用的内存空间。本质上只占用了一个bit,1对应true,0对应false。

    • 引用数据类型|复杂数据类型(模拟表示现实世界中复杂的数据)

      • 数组 []

      • 类 class

      • 接口 interface

  • 数据类型对于变量的意义:

    • 约束了变量的取值范围。

    • 约束了变量的内存空间。

    • 约束了变量底层的存储格式。

    • 最终数据展示的形式。

2.4 字符类型介绍

  • 字符数据 使用 单引号 '字符'。

  • 字符在硬件上存储的时候,保存的是字符对应的一个整数的二进制形式。

  • 字符的使用,任何的字符都依赖于某一个字符集,每个国家都有自己的字符集。

  • 常见的字符集

    • ASCII:美国标准信息交换码。单字节字符集,一共收录了128个字符。

      • 0:48 A:65 a:97

      • 世界上所有的其他的字符集都兼容了ASCII。

    • gb2312:

    • gbk 是 gb2312 的超集。

    • big5:繁体中文字符集。

    • iso8859-1:西欧那边使用的字符集。

    • unicode:utf-8(万国码)

  • class TestChar{

    public static void main(String[] args){
    //字符 0
    System.out.println('0'+0);//48
    //
    char ch = 'A';
    ch += 32;
    //ch = ch + 32;
    System.out.println(ch);//a

    //int 你好 = 10;
    //System.out.println(你好);//a

    //定义字符变量的多种形式。
    char ch1 = 'A';
    char ch2 = 97;
    char ch3 = '\u005a';//Z
    System.out.println(ch2);//a
    System.out.println(ch3);//Z
    }
    }
  • 转义字符:

    • class TestChar1{

      public static void main(String[] args){
      //转义字符
      //都是字符,但是主要用于控制其他的内容显示的格式的字符。
      //需要使用特殊的表示形式来表达这些特殊的字符。
      /*
      \t: tab 键 水平制表符。
      作用:输出8个半角符号位的倍数。占用的空间大小[1-8]个半角位。补齐8的倍数半角位。

      【\r: 回车符: 让光标回到当前行的行首。】
      \n: 换行符:让光标回去到下一行。
      回车键对应着两个转义字符:\r\n  
      【\b: 对应着backspace 键。】

      \': 代表了单引号 字符。
      \" : 代表了双引号 字符。
      \\ : 代表了反斜杠 字符。

      */

      System.out.println("123456789");
      System.out.println("\t123456789");
      System.out.println("123\t456789");
      System.out.println("1234567\t89");
      System.out.println("12345678\t9");

      System.out.println("123\"456\r789");
      System.out.println("123456\n789");

      System.out.println('\'');//
      System.out.println('\\');//
      }
      }

2.5 字符串类型介绍

  • class TestString{

    public static void main(String[] args){
    //字符串类型简介
    int age = 10;

    //定义字符串类型的变量
    String str = "abc";
    str = "\u005a\u0041";
    System.out.println(str);

    //字符串可以和java支持的任意类型做 + 连接,会得到一个新的字符串。
    System.out.println(str + 0);
    System.out.println(str + true);
    System.out.println(str + 1.1111111111111);
    }

    }

2.6 变量扩展

  • 变量的声明和定义

    • 定义变量 等价于 声明变量 + 赋值。

    • class Test1{

      public static void main(String[] args){
      //变量的定义。
      int num = 10;
      int num1 = 10,num2 = 20,num3 = 30;

      //变量的声明
      int num4;
      //赋初始值。变量的初始化
      num4 = 100;

      System.out.println(num1+num3);//40
      System.out.println(num4);//100

      //一次性声明多个变量
      int num5,num6,num7;
      ;;;;;;;;;;;;;
      num5 = 100;
      num6 = 200;
      num7 = 600;

      int num8,num9=100;
      num8=100;
      System.out.println(num8);//100
      System.out.println(num9);//100

      }
      }
  • 变量的作用域

    • 变量可以被访问的范围。

    • 变量的作用域从定义的位置开始,到所在的大括号的结尾处。

2.7 运算符

  • java中可以使用哪些符号(运算符)对java支持的数据类型(8+3)进行运算。

  • 概念

    • 运算符:java 中 对数据进行运算的符号。

      • +-*/ ....

    • 操作数:运算符操作的数据。

      • 1+2 1 he 2 就是操作数。

    • 表达式:使用运算符 操作 操作数的整体式子。

      • 1+3 表达式。

    • 一元运算符|单目运算符:只需要一个操作数的。

      • +1 -1

    • 二元运算符|双目运算符:需要两个操作数的运算符

      • 1+1 2*5

    • 三元运算符|三目运算符:需要三个操作数的运算符

    • 表达式的返回值:

      • 表达式计算的结果的值称为 表达式的返回值。

      • 表达式在程序中使用的时候,都是表达式的返回值来参与的。

  • 运算符的分类:

    • 算数运算符

    • class ArthmaticTest{
      //算数运算符学习:对数值型的数据进行算数运算的符号。
      // +   - * / % ++ --
      public static void main(String[] args){
      //+ 一元运算符 ,代表了正数。
      System.out.println(+1);//1
      // + 也是一个二元运算符,对两个操作数进行 加 运算。
      System.out.println(2+1);//3
      //- 一元运算符 ,代表了负数数。
      System.out.println(-1);//-1
      // - 也是一个二元运算符,两个操作数进行 减法 运算。
      System.out.println(2-1);//1

      // * 是一个二元运算符,两个操作数进行 乘法 运算。
      System.out.println(2*1);//2
      System.out.println(-2*1);//-2
      System.out.println(2*-1);//-2
      System.out.println(-2*-1);//2

      // / 是一个二元运算符,两个操作数进行 除法 运算。整数除法结果是整数。
      System.out.println(5/2);//2
      System.out.println(5/-2);//-2
      System.out.println(-5/2);//-2
      System.out.println(-5/-2);//2

      // % 取余、模运算。是一个二元运算符   a%b:   a除以b 得到的余数。
      //结果的符号位和 左边的操作数一致。
      System.out.println(5%2);//1
      System.out.println(5%-2);//1
      System.out.println(-5%2);//-1
      System.out.println(-5%-2);//-1

      // / % 应用:获取一个任意的数字的每个位置上的值。
      int num = 682;
      int unit = num%10;
      int decade = num/10%10;
      int hundred = num /100;
      System.out.println(num + "百位:"+ hundred + " 十位:" + decade + " 个位:"+unit);

      //++: 自增运算符。可以实现对一个变量自增1的操作。
      //语法: num ++;(后缀模式)   ++ num;(前缀模式)
      num = 0;
      num ++;
      ++ num;
      System.out.println(num);//2
      // ++ 后缀模式的特点:先返回,后自增。num ++; 返回值是 num 自增之前的值。
      num = 0;
      System.out.println(num++);//0
      System.out.println(num);//1

      num = 0;
      num = num ++;
      System.out.println(num);//0

      num = 0;
      System.out.println(num++ + num++ + num++);//3
      System.out.println(num);//3

      num = 0;
      // ++ 前缀模式的特点:先自增,后返回。num ++; 返回值是 num 自增之前的值。
      System.out.println(++num);//1
      num = 0;
      System.out.println(num++ - ++num + num++);//0

      //-- 前缀模式:先自减,后返回。 后缀模式:先返回,后自减。
      num = 0;
      System.out.println(--num + num++ + num-- + ++num);//-2
      }
      }
    • 赋值运算符

    • class TestOperator{
      public static void main(String[] args){
      //赋值运算符 =
      //二元运算符,作用:将右边表达式的返回值赋值给左边的变量。
      int num = 10;
      num = num * num + num * 10 + 10*100;

      num = 10;

      //复合赋值运算符 += -= *= /= %=
      num = num + 5;
      num += 5;

      num = num -5;
      num -= 5;

      num = num * 5;
      num *= 5;

      num = num / 5;
      num /= 5;

      num = num % 5;
      num %= 5;

      System.out.println(num);
      }
      }
    • 关系运算符

    • class TestOperator1{

      public static void main(String[] args){
      //关系运算符:> < >= <= == !=
      //都是二元运算符
      //作用:用来比较两个操作数的关系是否成立的。
      //关系表达式的返回值是 boolean 类型的:成立true,不成立false。
      //> < >= <= 只能使用 数值型操作数。
      //== != 适用于java支持的所有的数据类型。8+3

      int num = 0;
      System.out.println(++num > num);//false
      System.out.println(num++ >= num);//false
      System.out.println(++num == num);//true
      System.out.println(num++ != num);//true

      System.out.println('A' > 'a');//false

      System.out.println(true > false);//报错
      }
      }
    • 逻辑运算符

      • class TestLogic{
        public static void main(String[] args){
        /*
        逻辑运算符: & | ^ ! && ||
        特点:操作数的类型必须是boolean值。逻辑表达式的返回值也是 boolean 值。
        */
        //& 逻辑与: 二元运算符。 a&b 。表达的是现实世界中的并且的关系。
        //规则:有假则假,全真则真。
        System.out.println(true&true);//true
        System.out.println(true&false);//false
        System.out.println(false&true);//false
        System.out.println(false&false);//false

        //| 逻辑或: 二元运算符。 a|b 。表达的是现实世界中的或者的关系。
        //规则:有真则真,全假则假
        System.out.println(true|true);//true
        System.out.println(true|false);//true
        System.out.println(false|true);//true
        System.out.println(false|false);//false

        // ^ 逻辑异或:a^b 。表达的是现实世界中两者是否相同。
        //规则:相异为真,相同为假。
        System.out.println(true^true);//false
        System.out.println(true^false);//true
        System.out.println(false^true);//true
        System.out.println(false^false);//false

        // ! 逻辑非|逻辑取反。 一元运算符。 !a
        System.out.println(!true);//false
        System.out.println(!false);//true

        System.out.println(!(Math.random()>0.5));

        int num = 0;
        System.out.println(!((num ++ >0) | (num ++ == 1)));//false

        //短路与:&& :运算的结果和规则和 & 一致。
        num = 0;
        System.out.println(num<0 & num++>1);//false
        System.out.println(num);//1

        //短路与的特点:如果一旦有一个操作数是false,那么后面的操作数将不再被执行,被短路了。直接返回false。
        num = 0;
        System.out.println(num<0 && num++>1);//false
        System.out.println(num);//1

        //短路或 || 特点:如果一旦有一个操作数是true,那么后面的操作数将不再被执行,被短路了。直接返回true。
        }
        }
    • 位运算符

    • class TestBit{

      public static void main(String[] args){
      /*
      位运算符:& | ^ ~ << >> >>>
      要求掌握的:^ << >>。
      特点:可以直接操作数据底层的二进制位,执行效率高于其他的运算符。
      在某些场合下可以使用位运算替代其他的运算,来提高效率。

      操作数类型:整型int。
      */

      //&:按位与:规则:对应的位按位& 操作,全1则1,有0 则0.
      System.out.println(5&3);//1

      //| :按位或:规则:对应的位按位 | 操作,全0则0,有1 则1.
      // 如果两个操作数对应的位上没有全1 ,那么 | 操作和 + 结果一致。
      System.out.println(5|3);//7
      System.out.println(1|2);//3
      System.out.println(2|4);//6
      System.out.println(1|6);//7
      System.out.println(3|8);//11
      System.out.println(6|9);//15

      //^ : 按位异或:规则:对应的位按位 ^ 操作,相异为1,相同为0。
      System.out.println(5^3);//6
      //特点:一个数先后异或 另外一个数2次,结果是它自身。
      System.out.println(15^31^31);//15

      //应用1:实现简单的加密:
      char ch1 = '我';
      char ch2 = '爱';
      char ch3 = '你';

      int key = 520;
      //加密
      ch1 ^= key;
      ch2 ^= key;
      ch3 ^= key;
      System.out.println(""+ch1+ch2+ch3);//

      //解密
      ch1 ^= key;
      ch2 ^= key;
      ch3 ^= key;
      System.out.println(""+ch1+ch2+ch3);//

      //2:交换两个变量的值。
      int num1 = 10;
      int num2 = 20;
      System.out.println("num1 = "+ num1 + "\tnum2 = " + num2);
      int temp = num1;
      num1 = num2;
      num2 = temp;
      System.out.println("num1 = "+ num1 + "\tnum2 = " + num2);
      //使用 ^ 实现。
      num1 = num1 ^ num2;//num1 变了。
      num2 = num1 ^ num2;//num2 报存了原始的num1.
      num1 = num1 ^ num2;
      System.out.println("num1 = "+ num1 + "\tnum2 = " + num2);

      //~ 对所有的二进制位,全部取反。包括符号位。
      System.out.println(~0);//-1

      //<< 左移运算符。a<<n 等价于 a*2^n.
      //规则:高位被移走,低位补0.  
      //应用:可以使用 << n 替代 乘以 2的n次幂。对于一般比较小的数,都是成立的。
      System.out.println(3<<2);//12
      System.out.println(1<<3);//8

      System.out.println(1<<31);//

      //>> 带符号右移运算符。a>>n 等价于 a/2^n.
      //规则:低位被移走,高位补符号位。正数补0,负数补1.
      //应用:可以使用 >> n 替代 除以 2的n次幂。对于一般的数,都是成立的。
      System.out.println(23>>2);//5
      System.out.println(31>>3);//3
      System.out.println(-1>>3);//-1

      //无符号右移:>>> a>>>n
      //规则:低位被移走,高位补0.
      System.out.println(-1>>>1);//
      }
      }
    • 条件运算符

    • class Test2{

      public static void main(String[] args){
      /*
      条件运算符:
      运算符部分唯一的一个三元运算符。
      语法:操作数1 ? 操作数2 : 操作数3;

      操作数1:必须是一个boolean 表达式。返回值是布尔值的表达式。
      操作数2、操作数3:可以是返回值是任意类型的表达式。返回值的类型需要兼容。

      执行过程:
      1:计算操作数1的结果。
      2:如果结果为true,那么就计算操作数2的结果,并将该结果作为整个条件表达式的返回值。
      3:如果结果为false,那么就计算操作数3的结果,并将该结果作为整个条件表达式的返回值。
      */

      //求两个随机数的最大值。
      int min = 0;
      int max = 100;

      int num1 = (int)(Math.random()*(max-min)+min);
      int num2 = (int)(Math.random()*(max-min)+min);
      int num3 = (int)(Math.random()*(max-min)+min);

      System.out.println("num1 = " +num1 + "\tnum2 = "+ num2+ "\tnum3 = "+ num3);

      //int maxNum = num1 > num2 ? num1 : num2;
      //System.out.println("maxNum = " +maxNum);

      //打印一个随机数的奇偶性。
      String result = num1 % 2 == 0 ? "偶数":"奇数";
      System.out.println(num1 + "\t是:"+result);

      //求三个数的最大值。先求两个数的最大值,然后再用2个数的最大值和第三个数比较即可。
      //三目嵌套
      int maxNum = num1 > num2 ? (num1 > num3 ? num1 : num3) :(num2 > num3 ? num2 : num3);
      System.out.println("maxNum = " +maxNum);
      }
      }
  • 运算符的优先级

    • 一元运算符高于二元运算符。

    • 二元运算符高于三元运算符。

    • 乘除取余大于加减。

    • 小括号的优先级最高。

    • 赋值运算符优先级最低。

2.8 类型转换

  • 算数运算的类型转换

  • 赋值时候的转换

  • 强制类型转换

  • 字符串连接时的转换

  • class TestType{
    public static void main(String[] args){
    /*
    类型转换:
    java 语言的规则:java 语言不允许不同类型的数据进行运算。

    如果不同类型的数据进行运算,编译器会将不同类型的数据转换为同类型,然后再做运算。

    自动类型转换的规则:(转换安全)
    1:如果一个表达式中的操作数是如下类型:byte char short int。那么所有的操作数都转换为int,然后再做运算。结果为int。
    编译器不能确定变量再编译期的值。
    2: 如果一个表达式中的操作数是如下类型:byte char short int long。并且有一个操作数是long,那么所有的操作数都转换为long,然后再做运算。结果为long。
    3:如果一个表达式中的操作数是如下类型:byte char short int long float。并且有一个操作数是float,那么所有的操作数都转换为float,然后再做运算。结果为float。
    4:如果一个表达式中的操作数是如下类型:byte char short int long float double。并且有一个操作数是double,那么所有的操作数都转换为double,
    然后再做运算。结果为double。

    自动向上类型转换,自动的,编译器来完成的,向范围更大的类型转换。转换时安全的。

    强制向下类型转换:
    将大类型的数据转换小类型。
    语法:(转换的类型)(被转换的值)。
    这样的转换是不安全的。
    强转的类型需要兼容。
    整数之间的强转,之间砍掉高位字节。
    浮点数往整数转,先砍掉小数部分,然后保留低位字节。

    字符串连接中的类型转换:
    java 中只允许 字符串 和 字符串连接。
    所有的其他的类型的数据都要先转换为字符串,然后再做连接。
    "abc"+1
    */
    byte b1 = 1;
    int b2 = 2;
    int b3 = b1 + b2;

    b1 = 1+2;
    //b1 = b1 + 1;

    float f1 = 1.0f + 2011111111;
    System.out.println(f1);

    char ch1 = '你';
    ch1 = (char)(ch1 + 0);

    System.out.println((byte)0b11111111111111);//

    byte num = 127;
    //num = num + 1;
    num ++;
    num += 1;
    System.out.println(num);//
    }
    }

2.9 常量

  • 不能改变的量。

  • 常量的分类:

    • 字面常量:1,1.1 true,false,'a', "abc".

    • 符号常量|只读变量

2.10 常量练习


  • //如果在代码中使用到了jdk 中提供的功能,那么必须在源代码中使用import 关键 声明,使用到的内容,来自于哪里?
    import java.util.Scanner;
    //下面的代码是编译器默认会添加的。* 通配符,代表了所有的内容。lang 包是jdk 的核心包。默认引入的。
    import java.lang.*;

    class TestFinal{

    public static void main(String[] args){
    /*
    常量:不能改变的量。

    常量的分类:
      1:字面常量:1,1.1 true,false,'a', "abc".
      2:符号常量|只读变量
    在定义变量的数据类型前添加关键字 final。让变量成为只读变量。
    只读变量只能赋值一次。
    命名规范:所有的字符全部大写,多个单词中间使用 _ 分割。
    */
    //final int NUMBER = 10;
    //final int MAX_AGE = 150;

    //需求:从键盘输入一个圆的半径,求圆的周长和面积。

    //定义个扫描器对象,扫描键盘的输入的。
    Scanner scanner =  new Scanner(System.in);

    System.out.println("请您输入一个圆的半径:");
    //使用扫描器接受键盘输入的一个整数。作为圆的半径。
    //阻塞式方法。会导致程序在此暂停,必须输入内容回车才能继续。
    int radius = scanner.nextInt();

    final double PI = 3.1416;

    //求圆的周长和面积
    double perimeter = 2 * PI * radius;
    double area = PI * radius * radius;

    //打印结果。
    System.out.println("半径是"+radius+"\t的圆的周长是:"+perimeter+"\t面积是:"+area);
    }
    }

 

总结

  • 原码、反码、补码。

    • -5:1000 0101 1111 1010 1111 1011

  • 标识符

    • 规范

    • 规则

    • 作用:标识程序中的各种数据。

  • 变量

    • 概念:一块有名字的内存区域,内容可以被修改。

      • 对于变量的访问的两种操作:

        • get 获取

        • set 修改

    • 定义变量

      • 数据类型 变量名 = 初始值;

      • 数据类型: java 支持的任意的类型 byte short int long float double boolean char String。

      • 初始值:只要是一个具有返回值的表达式即可,返回值的数据类型要和 变量的类型兼容。

    • 声明变量

    • 变量的使用

  • 数据类型 ***

  • char 转义字符 String + 连接

    • 一个字符对应一个整数。

    • 不同的字符集中,很多的字符对应的整数不同。ASCII 部分的字符对应的整数是一致的。

    • 所有的乱码的问题都是读写字符数据使用的字符集不同导致的。

  • 运算符

    • 概念

    • 算数的

    • 赋值的

    • 关系

posted @   ITboy搬砖人  阅读(17)  评论(0编辑  收藏  举报
编辑推荐:
· AI与.NET技术实操系列:基于图像分类模型对图像进行分类
· go语言实现终端里的倒计时
· 如何编写易于单元测试的代码
· 10年+ .NET Coder 心语,封装的思维:从隐藏、稳定开始理解其本质意义
· .NET Core 中如何实现缓存的预热?
阅读排行:
· 25岁的心里话
· 闲置电脑爆改个人服务器(超详细) #公网映射 #Vmware虚拟网络编辑器
· 基于 Docker 搭建 FRP 内网穿透开源项目(很简单哒)
· 零经验选手,Compose 一天开发一款小游戏!
· 一起来玩mcp_server_sqlite,让AI帮你做增删改查!!
点击右上角即可分享
微信分享提示