一、关键字与保留字

  • 被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
  • 关键字中所有字母都为小写

二、标识符

  1. 标识符：凡是自己可以起名字的地方都叫标识符。

    • 比如：类名、变量名、方法名、接口名、包名

  2. 标识符命名规则

    • 由26个英文字母大小写，0-9，_或$ 组成

    • 数字不可以开头

    • 不可以使用关键字和保留字，但能包含关键字和保留字

    • Java中严格区分大小写，长度无限制

    • 标识符不能包含空格

  3. Java中的名称命名规范：

    • 包名：多单词组成时所有字母都小写：xxxyyyzzz

    • 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz

    • 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个
      单词首字母大写：xxxYyyZzz

    • 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

  4. 注意：

    • 注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”
    • 注意2：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用

三、变量【重点】

3.1变量的概念

概念：计算机内存中的一块存储空间

3.1 变量的使用

  1. Java定义变量的格式：数据类型 变量名 = 变量值；

  2. 说明：

    • Java中每个变量必须先声明，后使用
    • 变量都定义在其作用域内。在作用域内，它是有效的。换句话说，出了作用域就失效了
    • 同一个作用域内，不能定义重名的变量

3.2 java定义的数据类型

  1. 变量按数据类型来分：

    • 基本数据类型：

      • 整型：byte \ short \ int \ long
      • 浮点型：float \ double
      • 字符型：char（1个字符，两个字节）
      • 布尔型：boolean

    • 引用数据类型

      • 类（class）
      • 接口（interface）
      • 数组（array）
  2. 变量在类中声明的位置
    成员变量 VS 局部变量

3.3 整型

  • 整数类型：byte、short、int、long
  • java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’
  • java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long
  1. public class VariTest {
  2.     public static void main (String[] args){
  3.         //1.整型：byte(1字节=8bit)\short(2字节)\int(4字节)\long(8字节)
  4.         //byte范围：
  5.         byte b1 = 12;
  6.         byte b2 = -128;
  7.         System.out.println(b1);
  8.         System.out.println(b2);
  9.         //声明long变量，必须以”l“或”L“结尾
  10.         //通常，定义整型变量时，使用int型
  11.         short s1 = 128;
  12.         int i1 = 1234;
  13.         long l1 = 12345678;//从int型自动转为long型
  14.         long l1 = 12345678L;
  15.         System.out.println(l1);
  16.     }
  17. }

3.4 浮点型

  • 与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作
    1.     系统的影响。

  • 浮点型常量有两种表示形式：

    • 十进制数形式：如：5.12 512.0f .512 (必须有小数点）
      科学计数法形式:如：5.12e2 512E2 100E-2

  • float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。

  • double:双精度，精度是float的两倍。通常采用此类型。

  • Java的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’

  1. 浮点型，表示带小数点的数值

  2. float表示的数值范围比long还大

  3. 定义float类型变量时，要以”f“或”F“结尾（因为默认是double）

  4. 通常，定义浮点型变量时，使用double型（范围更大，精度更高）

    1. /*定义float类型变量时，要以”f“或”F“结尾*/
    2. float f1 = 12.3F;

3.5字符型

字符型：char（1字符=2字节）
  • 定义char型变量，通常使用一对‘ ’（单引号） ```java //字符型：char（1字符=2字节） //定义char型变量，通常使用一对’’，内部只能写一个字符 char c1 = ‘a’; c1 = ‘A’; System.out.println(c1);

char c2 = ‘1’; char c3 = ‘中’; System.out.println(c2); System.out.println(c3);

  3. - 
  4. Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。
  5. <br />例如：char c3 = ‘\n’; // '\n'表示换行符
  7. - 
  8. 可以使用ASCII
  10. - 
  11. 可以用unicode字符集
  14. <a name="ee08ce60"></a>
  15. #### 3.6布尔类型
  17. 1. 
  18. boolean只能取两值之一：true、false
  20. 2. 
  21. 通常在条件判断、循环结构中使用

boolean isMarried = true; if(isMarried){i System.out.println(“你就不能参加单身party了！很遗憾”); System.out.println(“你就不能参加\”单身\”party了！\n很遗憾”); }else{ System.out.println(“你可以多谈谈女朋友”); }

  4. <a name="8424d49c"></a>
  5. ## 四、类型转换
  7. <a name="466841f2"></a>
  8. #### 4.1基本数据类型之间的运算规则
  10. 前提：这里讨论的只是七种基本数据类型变量间的运算。不包含boolean类型的。
  12. 1. 
  13. 自动类型提升:
  14. <br />当容量小的数据类型的变量与容量大的数据类的变量做运算时，结果自动提升为容量大的数据类型
  15. <br />**byte、char、short** --> int --> long --> float --> double
  16. <br />特别的：当byte、char、short三种类型的变量做运算时，结果为int类型
  17. <br />                **同种类型运算结果也是int类型**
  18. ```java
  19.         byte b1 = 2;
  20.         int i1 = 129;
  21.         byte b2 = b1 +i1;//编译不通过
  23.         int b2 = b1+i1;//转换成int型
  24.         long l1 = b1+i1;//转换成long型
  25.         System.out.println(b2);
  27.         float f = b1+i1;//转换成float型
  28.         System.out.println(f);
  30.         short s1 = 123;
  31.         double d1 = s1;//转换成double型
  32.         System.out.println(d1);    
  34.         char c1 = 'a';//97
  35.         int i3 = 10;
  36.         int i4 = c1+i3;
  37.         System.out.println(i4);
  39.         short s2 = 10;
  40.         //short s3 = c1 + s2;编译不通过
  42.         byte b2 = 10;
  43.         //char c3 = c1 + b2;编译不通过
  45.         //short s3 = b2 + s2;编译不通过
  47.         //short s4 = b1+b2;编译不通过

  1. 强制类型转换:

    • 需要使用强转符：（）

    • 注意点：强制类型转换，可能导致精度损失
      说明：此时的容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量

  1. class VariTest2{
  2.     public static void main(String[] args){
  4.         double d1 = 12.3;
  5.         //精度损失举例
  6.         int i1 = (int)d1;//截断操作
  7.         System.out.println(i1);
  9.         //没有精度损失
  10.         long l1 = 123;
  11.         short s2 = (short)l1;
  13.         //精度损失举例2
  14.         int i2 = 128;
  15.         byte b = (byte)i2;
  16.         System.out.println(b);//-128
  17.     }
  18. }
  1. 变量运算两种特殊情况
  1. class VariTest4{
  2.     public static void main(String[] args){
  3.         //编码情况1；
  4.         long l = 123123;//定义long型没加L，实际上将123123作为int型，然后进行自动类型转换
  5.         System.out.println(l);
  6.         //过大的整数，编译失败，结尾没加L
  7.         //long l1 = 123123123123123;
  9.         long l1 = 123123123123123l;//编译通过
  11.         //****************
  12.         //默认为double型，往float转，编译失败
  13.         //float f1 = 12.3;
  14.         float f1 = 12.3f;
  16.         //编码情况2;
  17.         //整型常量，默认类型为int型
  18.         //浮点型常量，默认类型为double型
  19.         byte b = 12;
  20.         //byte b1= b +1;//编译失败
  22.         //float f1 = b + 12.3;//编译失败
  23.     }
  24. }

五、String类型

String类型变量的使用

  1. String属于引用数据类型，字符串

  2. 声明String类型变量时，使用一对“ ”

  3. String可以和8种基本数据类型变量做运算，且运算只能是连接运算;+

  4. 运算结果仍然是String类型

  1. class StringTest{
  2.     public static void main(String[] args){
  3.         String s1 = "hello,world";
  4.         System.out.println(s1);
  6.         String s2 = "a";
  7.         String s3 = "";
  9.         //char c = '';//不放字符，编译不通过（必须放一个字符）
  11.         //**************** 
  12.         int number = 1001;
  13.         String numberStr = "xuehao";
  14.         String info = numberStr + number;//+:连接运算
  15.         System.out.println(info);
  17.         boolean b1 = true;
  18.         String info1 = info + b1;//+:连接运算
  19.         System.out.println(info1);
  21.         //****************
  22.         //练习1
  23.         char c = 'a';//97  A:65
  24.         int num = 10 ;
  25.         String str = "hello";
  26.         System.out.println(c + num + str);//107hello
  27.         System.out.println(c + str + num);//ahello10
  28.         System.out.println(c + (num + str));//a10hello
  29.         System.out.println((c + num) + str);//107hello
  30.         System.out.println(str + num + c);//hello10a
  32.         //练习2
  33.         //* *
  34.         System.out.println("*    *");
  35.         System.out.println('*' + '\t' + '*');//表示加法
  36.         System.out.println('*' + "\t" + '*');//表示连接
  37.         System.out.println('*' + '\t' + "*");//后面是连接
  38.         System.out.println('*' + ('\t' + "*"));
  40.         //****************
  41.         //String str1 = 123;//编译不通过
  42.         String str1 = 123 + "";
  43.         System.out.println(str1);//"123"
  45.         //int num1 = str1;//编译失败
  46.         //int num1 = (int)str1;//不通过
  48.         int num1 = Integer.parseInt(str1);
  49.         System.out.println(num1);//123  
  50.     }
  51. }