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

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

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搬砖人  阅读(32)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 阿里最新开源QwQ-32B,效果媲美deepseek-r1满血版,部署成本又又又降低了!
· AI编程工具终极对决:字节Trae VS Cursor,谁才是开发者新宠?
· 开源Multi-agent AI智能体框架aevatar.ai,欢迎大家贡献代码
· Manus重磅发布:全球首款通用AI代理技术深度解析与实战指南
· 被坑几百块钱后,我竟然真的恢复了删除的微信聊天记录!
点击右上角即可分享
微信分享提示