02_java关键字、表识符、注释、进制转换、补码反码、数据类型转换

1:关键字(掌握)
2:标识符(掌握)-类、接口、方法、变量命名规则
 3:注释(掌握)
4:常量(掌握)
5:进制转换(了解)
6:变量(掌握)
7:数据类型(掌握)
8:数据类型转换(掌握)
思考题
 面试题(一)(二)
看程序写结果(一)(二)
运算符的优先级（从高到低）
常用字符与ASCII代码对照表

1:关键字(掌握)
(1)被Java语言赋予特定含义的单词
(2)特点：全部小写。
(3)注意事项：
A:goto和const作为保留字存在。
B:类似于Notepad++这样的高级记事本会对关键字有特殊颜色标记

 1 /*
 2     关键字：被java语言赋予特定含义的单词。
 3     
 4     特点：组成关键字单词的字母全部小写。
 5     
 6     注意：
 7         A:goto和const是保留字
 8         B:类似于Notepad++这样的高级记事本，针对关键字都有特殊的颜色标记。
 9 */
10 class KeyWordDemo {
11     public static void main(String[] args) {
12         System.out.println("HelloWorld");
13     }
14 }

2:标识符(掌握)-类、接口、方法、变量命名规则
(1)就是给类，接口，方法，变量等起名字的字符序列
(2)组成规则：
  A:英文大小写字母
  B:数字
  C:$和_
(3)注意事项：
  A:不能以数字开头
  B:不能是java中的关键字
  C:区分大小写
(4)常见的命名规则(见名知意)
  A:包全部小写
   单级包：小写
    举例：liuyi,com
   多级包：小写，并用.隔开
    举例：cn.itcast,com.baidu
  B:类或者接口
   一个单词：首字母大写
    举例：Student,Demo
   多个单词：每个单词首字母大写
    举例：HelloWorld,StudentName
  C:方法或者变量
   一个单词：首字母小写
    举例：name,main
   多个单词：从第二个单词开始，每个单词首字母大写
    举例：studentAge,showAllNames()
  D:常量
   全部大写
   一个单词：大写
    举例：PI
   多个单词：大写，并用_隔开
    举例：STUDENT_MAX_AGE

 1 /*
 2     标识符：就是给类，接口，方法，变量等起名字。
 3     
 4     组成规则：
 5         A:英文字母大小写
 6         B:数字字符
 7         C:$和_
 8         
 9     注意事项：
10         A:不能以数字开头
11         B:不能是Java中的关键字
12         C:Java语言严格区分大小写
13         
14     常见的命名规则：见名知意
15         举例：我要定义一个学生类
16             class Student {}
17             class S{}
18             
19         包：其实就是文件夹，用于把相同的类名进行区分
20             全部小写
21         
22             单级：liuyi
23             多级：cn.itcast
24                 cn
25                     itcast
26                     
27         类或者接口：
28             一个单词：单词的首字母必须大写
29                 举例：Student,Dog
30             多个单词：每个单词的首字母必须大写
31                 举例：HelloWorld,StudentName
32             
33         方法或者变量：
34             一个单词：单词的首字母小写
35                 举例：main,age
36             多个单词：从第二个单词开始，每个单词的首字母大写
37                 举例：studentAge,showAllNames()
38                 
39         常量：
40             一个单词：全部大写
41                 举例：PI
42             多个单词：每个字母都大写，用_隔开
43                 举例：STUDENT_MAX_AGE
44         
45 */
46 class MakeNameDemo {
47     public static void main(String[] args) {
48         //正确做法
49         int x = 100;
50         
51         //不能以数字开头
52         //int 1y = 100;
53         int y1 = 100;
54         
55         //不能是Java中的关键字
56         //int public = 100;
57         int Public = 100;
58     }
59 }

3:注释(掌握)
(1)就是对程序进行解释说明的文字
(2)分类：
  A:单行注释 //
  B:多行注释 /**/
  C:文档注释(后面讲) /** */
(3)把HelloWorld案例写了一个带注释的版本。
  后面我们要写一个程序的过程。
  需求：
  分析：
  实现：
  代码体现：
(4)注释的作用
  A:解释说明程序，提高了代码的阅读性。
  B:可以帮助我们调试程序。
   后面我们会讲解一个更高端的一个调试工具

 1 /*
 2     注释：用于解释说明程序的文字
 3     
 4     Java中注释的分类及格式
 5         单行注释：//
 6         多行注释：/星 星/
 7             注意：多行不可以嵌套使用，而单行是可以的
 8         文档注释：被javadoc工具解析生成一个说明书，面向对象部分讲解。
 9 */
10 
11 //这是我的注释案例
12 class ZhuShiDemo {
13     //main方法是主方法
14     //是程序的入口
15     //被jvm调用
16     public static void main(String[] args) {
17         System.out.println("好好学习,天天向上");
18     }
19 }

 1 /*
 2     注释的作用：
 3         A:解释说明程序，提高程序的阅读性
 4         B:可以帮助我们调试程序。
 5             后面我们会讲解更高级的调试。
 6 */
 7 class ZhuShiDemo2 {
 8     public static void main(String[] args) {
 9         System.out.println("林青霞");
10         System.out.println("王祖贤");
11         System.out.println("刘亦菲");
12         System.out.println("范冰冰");
13     }
14 }

 1 /*
 2     需求：我准备写一个java程序，把"HelloWorld"这句话输出在控制台
 3     
 4     分析：
 5         A:要写一个Java程序，必须定义类
 6         B:把数据能够输出，说明我们的程序是可以独立运行的，而程序要独立运行，必须定义main方法
 7         C:把数据输出在控制台，必须使用输出语句
 8         
 9     实现：
10         A:java语言提供了一个关键字：class用来定义类，后面跟的是类名
11         B:main方法的格式是固定的：
12             public static void main(String[] args) {
13             
14             }
15         C:输出语句的格式是固定的：
16             System.out.println("HelloWorld");
17             "HelloWorld"这个内容是可以改变的
18 */
19 
20 //这是我的HelloWorld案例
21 class HelloWorld {
22     /*
23         为了程序能够独立运行，定义main方法
24         main方法是程序的入口
25         被jvm自动调用
26     */
27     public static void main(String[] args) {
28         //为了把数据显示在控制台，我们就使用了输出语句
29         System.out.println("HelloWorld");
30     }
31 }

4:常量(掌握)-字面常量，自定义常量
(1)在程序执行的过程中，其值不发生改变的量
(2)分类：
  A:字面值常量
  B:自定义常量(后面讲)
(3)字面值常量
  A:字符串常量 "hello"
  B:整数常量 12,23
  C:小数常量 12.345
  D:字符常量 'a','A','0'
  E:布尔常量 true,false
  F:空常量 null(后面讲)
(4)在Java中针对整数常量提供了四种表现形式
  A:二进制由0，1组成。以0b开头。
  B:八进制由0，1，...7组成。以0开头。
  C:十进制由0，1，...9组成。整数默认是十进制。
  D:十六进制由0，1，...9,a,b,c,d,e,f(大小写均可)组成。以0x开头。

 1 /*
 2     常量：
 3         在程序执行过程中，其值不发生改变的量。
 4         
 5     分类：
 6         A:字面值常量
 7         B:自定义常量(后面讲)
 8         
 9     字面值常量
10         A:字符串常量    用双引号括起来的内容。
11             举例："hello","world","HelloWorld"
12         B:整数常量    所有的整数
13             举例：100,200
14         C:小数常量    所有的小数
15             举例：10.23,110.11
16         D:字符常量    用单引号括起来的内容
17             举例：'a','A','0'
18             错误的：'ab'
19         E:布尔常量    比较特殊
20             举例：true,false
21         F:空常量    后面讲
22             举例：null
23 */
24 class ConstantDemo {
25     public static void main(String[] args) {
26         //字符串常量的输出
27         System.out.println("hello");
28         
29         //整数常量的输出
30         System.out.println(100);
31         
32         //小数常量的输出
33         System.out.println(100.10);
34         
35         //字符常量的输出
36         System.out.println('a');
37         System.out.println('A');
38         System.out.println('0');
39         //这个是有问题的
40         //System.out.println('ab');
41         
42         //布尔常量的输出
43         System.out.println(true);
44         System.out.println(false);
45     }
46 }

5:进制转换(了解)
(1)其他进制到十进制
  系数：就是每一个位上的数值
  基数：x进制的基数就是x
  权：对每一个位上的数据，从右，并且从0开始编号，对应的编号就是该数据的权。

  结果：系数*基数^权次幂之和。
(2)十进制到其他进制
  除基取余，直到商为0，余数反转。
(3)进制转换的快速转换法
  A:十进制和二进制间的转换
   8421码。
  B:二进制到八进制，十六进制的转换

 1 /*
 2     不同进制的数据表现：
 3         二进制：由0，1组成。以0b开头。
 4         八进制：由0,1,...7组成。以0开头。
 5         十进制：由0,1,...9组成。默认整数是十进制。
 6         十六进制：由0,1,...9,a,b,c,d,e,f(大小写均可)组成。以0x开头。
 7 */
 8 class JinZhiDemo {
 9     public static void main(String[] args) {
10         System.out.println(100); //十进制
11         
12         System.out.println(0b100); //二进制
13         System.out.println(0100); //八进制
14         System.out.println(0x100); //十六进制
15     }
16 }

进制概述以及二进制，八进制图解：

十进制到其他进制的转换：

快速的进制转换法：

原码反码补码的讲解：

1：得到下面数据的十进制值：

0b10101 =1*2^4 + 1*2^2 + 1*2^0 =16 + 4 + 1 =21

0123 =1*8^2 + 2*8^1 + 3*8^0 =64 + 16 + 3 =83 0x3c =3*16^1 + c*16^0 =48 + 12 =60

2：得到下面数据的二进制，十进制，十六进制 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 / 8 = 6 　4

6 / 8 = 0 6

064 得到十六进制：

52 / 16 = 3 4

3 / 16 = 0 3

0x34

3:有符号数据表示法的练习

A:已知某数X的原码为10110100B，试求X的补码和反码。

　　符号位数值位

原码 : 1 0110100

反码：1 1001011

补码：1 1001100

B:已知某数X的补码11101110B，试求其原码。

符号位数值位

补码： 1 1101110

反码： 1 1101101

原码： 1 0010010

6:变量(掌握)
(1)在程序的执行过程中，其值在某个范围内可以发生改变的量
(2)变量的定义格式：
  A:数据类型变量名 = 初始化值;
  B:数据类型变量名;
    变量名 = 初始化值;

变量的概述及格式：

7:数据类型(掌握)
(1)Java是一种强类型语言，针对每种数据都提供了对应的数据类型。
(2)分类：
  A:基本数据类型：4类8种
  B:引用数据类型：类，接口，数组。
(3)基本数据类型
  A:整数   占用字节数
   byte        1
   short       2
   int           4
   long         8
  B:浮点数
   float      4
   double     8
  C:字符
   char        2
  D:布尔
   boolean   1

  注意：
   整数默认是int类型，浮点数默认是double。

   长整数要加L或者l。
   单精度的浮点数要加F或者f。

/*
    数据类型：Java是一种强类型的语言，针对每一种数据都定义了明确的数据类型。
    
    数据类型分类：
        A:基本数据类型
        B:引用数据类型(类,接口,数值)
        
    基本数据类型:4类8种
        A:整数            占用字节数
            byte            1
            short            2
            int            4
            long            8
            
        B:浮点数
            float             4
            double         8
            
        C:字符
            char            2
        D:布尔
            boolean        1
        
        注意：
            整数默认是int类型
            浮点数默认是double类型。
            
            长整型后缀用L或者l标记。建议使用L。
            单精度浮点数用F或者f标记。建议使用F。
*/
class DataTypeDemo {
    public static void main(String[] args) {
        //定义变量的格式：
        //数据类型 变量名 = 初始化值;
        
        //定义一个字节变量
        byte b = 10;
        System.out.println(10);
        System.out.println(b);
        
        //定义一个短整型变量
        short s = 100;
        System.out.println(s);
        
        //定义一个整型变量
        int i = 1000;
        System.out.println(i);
        
        //超过了int的范围
        //int j = 1000000000000;
        long j = 1000000000000L;
        //long j = 100L;
        System.out.println(j);
        
        //定义浮点数据变量
        float f = 12.345F;
        System.out.println(f);
        
        double d = 12.345;
        System.out.println(d);
        
        //定义字符变量
        char ch = 'a';
        System.out.println(ch);
        
        //定义布尔变量
        boolean flag = true;
        System.out.println(flag);
    }
}

 1 /*
 2     使用变量的时候要注意的问题：
 3         A:作用域
 4             变量定义在哪个大括号内，它就在这个大括号内有效。
 5             并且，在同一个大括号内不能同时定义同名的变量。
 6             
 7         B:初始化值
 8             没有初始化值的变量不能直接使用。
 9             你只要在使用前给值就行，不一定非要在定义的时候立即给值。
10             推荐在定义的时候给值。
11             
12             定义变量的格式：
13                 a:数据类型 变量名 = 初始化值;
14                 b:数据类型 变量名;
15                   变量名 = 初始化值;
16         
17         C:在一行上建议只定义一个变量
18             可以定义多个，但是不建议
19 */
20 class DataTypeDemo2 {
21     public static void main(String[] args) {
22         //定义变量
23         int x = 100;
24         
25         //错误，不能有同名的
26         //int x = 200;
27         
28         //定义变量必须给值
29         //int y;
30         //System.out.println(y);
31         
32         int z;
33         z = 100;
34         System.out.println(z);
35         
36         //在一行上定义多个变量
37         //int a = 10; int b = 20; int c  = 30;
38         //上面的写法可以，但是不建议。
39         int a = 10; 
40         int b = 20; 
41         int c  = 30;
42         
43         //int d, e;
44         //d = 40;
45         //e = 50;
46         
47         //int f,int g; //错误
48         //int h; int i; //正确
49     }
50 }

8:数据类型转换(掌握)
(1)boolean类型不参与转换
(2)默认转换
  A:从小到大
  B:byte,short,char -- int -- long -- float -- double
  C:byte,short,char之间不相互转换，直接转成int类型参与运算。
(3)强制转换
  A:从大到小
  B:可能会有精度的损失，一般不建议这样使用。
  C:格式：
   目标数据类型变量名 = (目标数据类型) (被转换的数据);
(4)思考题和面试题：
  A:下面两种方式有区别吗?
   float f1 = 12.345f;
   float f2 = (float)12.345;
  B:下面的程序有问题吗，如果有，在哪里呢?
   byte b1 = 3;
   byte b2 = 4;
   byte b3 = b1 + b2;
   byte b4 = 3 + 4;
  C:下面的操作结果是什么呢?
   byte b = (byte)130;
  D:字符参与运算
   是查找ASCII里面的值
   'a'  97
   'A'  65
   '0'  48

   System.out.println('a');
   System.out.println('a' + 1);
  E:字符串参与运算
   这里其实是字符串的连接

   System.out.println("hello"+'a'+1);

 1 /*
 2     +是一个运算符(我们等会讲解)。做加法运算的。
 3     
 4     一般来说，我们在运算的时候，要求参与运算的数据类型必须一致。
 5     
 6     注意：
 7         boolean类型不能转换为其他的数据类型
 8 
 9     默认转换(从小到大的转换)
10         A:byte,short,char—int—long—float—double
11         B:byte,short,char相互之间不转换，他们参与运算首先转换为int类型
12 */
13 class DataTypeDemo3 {
14     public static void main(String[] args) {
15         //直接输出的方式做加法
16         //System.out.println(3 + 4);
17     
18         //两个int类型做加法
19         int x = 3;
20         int y = 4;
21         int z = x + y;
22         System.out.println(z);
23         
24         //定义一个byte类型，一个int类型，做加法
25         byte a = 3;
26         int b = 4;
27         System.out.println(a + b);
28         
29         //可能损失精度
30         //byte c =  a + b;
31         int c = a + b;
32         System.out.println(c);
33     }
34 }

强制转换：

 1 /*
 2     强制转换：
 3         从大的数据类型到小的数据类型。
 4         
 5         格式：
 6             目标数据类型 变量 = (目标数据类型) (被转换的数据);
 7             
 8         注意：
 9             不要随意的去使用强制转换，因为它隐含了精度损失问题。
10 */
11 class DataTypeDemo4 {
12     public static void main(String[] args) {
13         byte a = 3;
14         int b = 4;
15         
16         //这个肯定没有问题
17         //int c = a + b;
18         
19         //byte c = 7;
20         //这个是有问题的
21         //byte c = a + b; 
22         //用强制类型转换改进
23         byte c = (byte) (a + b);
24         System.out.println(c);
25     }
26 }

思考题：

 1 /*
 2     思考题1：请问下面这个有没有问题
 3         double d = 12.345;
 4         float f = d;
 5         
 6     思考题2：看看下面两个定义有没有区别呢?
 7         float f1 = (float)12.345;
 8         float f2 = 12.345f;
 9         
10         f1其实是通过一个double类型转换过来的。
11         而f2本身就是一个float类型。
12 */
13 class DataTypeDemo5 {
14     public static void main(String[] args) {
15         //把double赋值给float，加了强制类型转换
16         double d = 12.345;
17         float f = (float)d;
18         
19         //看看下面两个定义有没有区别呢?
20         float f1 = (float)12.345;
21         float f2 = 12.345F;
22     }
23 }

面试题一：

 1 /*
 2     面试题：
 3         byte b1=3,b2=4,b;
 4         b=b1+b2;
 5         b=3+4;
 6         哪句是编译失败的呢？为什么呢？
 7         b = b1 + b2;是有问题的。
 8         因为变量相加，会首先看类型问题，最终把结果赋值的也会考虑类型问题。
 9         常量相加，首先做加法，然后看结果是否在赋值的数据类型范围内，如果不是，才报错。
10 */
11 class DataTypeDemo6 {
12     public static void main(String[] args) {
13         //定义了三个byte类型的变量，b1，b2，b3
14         //b1的值是3，b2的值是4，b没有值
15         byte b1 = 3,b2 = 4,b;
16         
17         //b = b1 + b2; //这个是类型提升，所有有问题
18         
19         b = 3 + 4; //常量，先把结果计算出来，然后看是否在byte的范围内，如果在就不报错。
20     }
21 }

面试题二：

/*
    byte b = 130;有没有问题?如果我想让赋值正确，可以怎么做?结果是多少呢?
    
    练习：byte b = (byte)300;
*/
class DataTypeDemo7 {
    public static void main(String[] args) {
        //因为byte的范围是：-128到127。
        //而130不在此范围内，所以报错。
        //byte b = 130; 
        
        //我们可以使用强制类型转换
        byte b = (byte) 130;
        
        //结果是多少呢?
        System.out.println(b);
    }
}
/*
    分析过程：
        我们要想知道结果是什么，就应该知道是如何进行计算的。
        而我们又知道计算机中数据的运算都是补码进行的。
        而要得到补码，首先要计算出数据的二进制。
        
        A:获取130这个数据的二进制。
            00000000 00000000 00000000 10000010
            这是130的原码，也是反码，还是补码。
        B:做截取操作，截成byte类型的了。
            10000010 
            这个结果是补码。
        C:已知补码求原码。
                    符号位        数值位
            补码：    1            0000010
            
            反码：    1            0000001
            
            原码：    1            1111110
*/

看程序写结果（一）：

 1 /*
 2     看程序写结果
 3     
 4     通过字符和一个整数相加，我们给出一张表：ASCII码表。
 5         通过看完这张表以后，我们要记住三个值：
 6             'a'        97
 7             'A'        65
 8             '0'        48
 9 */
10 class DataTypeDemo8 {
11     public static void main(String[] args) {
12         //直接输出一个字符
13         System.out.println('a'); //a
14         //输出一个字符和一个整数做加法
15         System.out.println('a'+1); //98
16     }
17 }

看程序写结果（二）：

 1 /*
 2     看程序写结果
 3         字符串数据和其他数据做+，结果是字符串类型。
 4         这里的+不是加法运算，而是字符串连接符。
 5 */
 6 class DataTypeDemo9 {
 7     public static void main(String[] args) {
 8         System.out.println("hello"+'a'+1); //helloa1
 9         System.out.println('a'+1+"hello"); //98hello
10         
11         System.out.println("5+5="+5+5); //5+5=55
12         System.out.println(5+5+"=5+5"); //10=5+5
13     }
14 }

不同数据类型变量参与运算图解：

运算符的优先级（从高到低）

优先级	描述	运算符
1	括号	()、[]
2	正负号	+、-
3	自增自减，非	++、--、!
4	乘除，取余	*、/、%
5	加减	+、-
6	移位运算	<<、>>、>>>
7	大小关系	>、>=、<、<=
8	相等关系	==、!=
9	按位与	&
10	按位异或	^
11	按位或	\|
12	逻辑与	&&
13	逻辑或	\|\|
14	条件运算	?:
15	赋值运算	=、+=、-=、*=、/=、%=
16	位赋值运算	&=、\|=、<<=、>>=、>>>=

如果在程序中，要改变运算顺序，可以使用()。

常用字符与ASCII代码对照表

为了便于查询，以下列出ASCII码表：第128～255号为扩展字符（不常用）
ASCII码	键盘	ASCII 码	键盘	ASCII 码	键盘	ASCII 码	键盘
27	ESC	32	SPACE	33	!	34	"
35	#	36	$	37	%	38	&
39	'	40	(	41	)	42	*
43	+	44	'	45	-	46	.
47	/	48	0	49	1	50	2
51	3	52	4	53	5	54	6
55	7	56	8	57	9	58	:
59	;	60	<	61	=	62	>
63	?	64	@	65	A	66	B
67	C	68	D	69	E	70	F
71	G	72	H	73	I	74	J
75	K	76	L	77	M	78	N
79	O	80	P	81	Q	82	R
83	S	84	T	85	U	86	V
87	W	88	X	89	Y	90	Z
91	[	92		93	]	94	^
95	_	96	`	97	a	98	b
99	c	100	d	101	e	102	f
103	g	104	h	105	i	106	j
107	k	108	l	109	m	110	n
111	o	112	p	113	q	114	r
115	s	116	t	117	u	118	v
119	w	120	x	121	y	122	z
123	{	124	\|	125	}	126	~

相关阅读:
移动端布局方案汇总&&原理解析
 Javascript运行机制
 git 使用
 async await详解
 vue使用axios调用豆瓣API跨域问题
 hash和history的区别
 http状态码
 XSS 和 CSRF简述及预防措施
 【pytorch】pytorch基础学习
 [源码解读] ResNet源码解读（pytorch）
原文地址：https://www.cnblogs.com/super90/p/4658860.html