动力节点—关键字，标识符，常量，变量，数据类型

一 关键字：

1，定义：在java语言中，具有特殊含义的英文单词。

class：java中表示类。

2，特点：关键字母都是小写。

3，java语言中，关键字的数量是固定的。不用背单词，要敲代码敲熟就可以了。

4 ，关键字：

用于定义数据类型的关键字    classinlerfacebyteshort

int

longfloatdoublechar

boolean

void    用于定义数据类型值的关键字    truefalsenull  用于定义流程控制的关键字    ifelseswitchcasedefaultwhiledoforbreakcontinuereturn    

注：关键字都是小写的。

二 标识符：

1，定义：标识符就是起名字。

2，作用：标识符负责给代码中的类、接口、变量、方法等成员起名字。

3，标识符可以包含的字母规则：

A：可以有英文大小写字母。

B : 可以有数字。

C：可以有 $和_（下划线）。 

４，标识符使用规则

A：数字不能开头

abc    $abc        正确

1abc                  错误

B：不能使用关键字作为标识符

public               错误

以上的规则都是语法定义的规则（就是我们再编程中必须遵守的）。

5，常见的编程中使用标识符的规则

A：为类、抽象类、接口起名字

如果一个单词：开头第一个字母大写，其他字母都小写。

如果多个单词：每个单词的首字母大写，其他都小写。

B：为变量、方法起名字

如果一个单词：所有字母都小写。

如果多个单词：第一个单词都小写，其后每个单词首字母大写。

eg：

printName

C：为包起名字

包一般用来管理代码的

如果是一个单词：每个单词的所有字母都小写（一般是指包与包之间是平级关系）。

如果是多个单词：每个单词的所有字母都小写，单词和单词之间用  .  号分隔

（一般是指包和包之间是包含关系）。

D：为常量起名字

如果是一个单词：每个单词的所有字母都大写。

如果是多个单词：每个单词的所有字母都大写，单词和单词之间使用_（下划线）分隔。

注意：所有的名称都必须符合（如果不能使用英文，就使用拼音），见名知意。

三 注释：

1，定义：用于解释说明代码的含义。

2，注释的分类：

A：单行注释：      //开头

/*

    ​main方法是java语言执行入口

    ​

*/

B：多行注释：     ​ /*     */

C：文档注释： 是为了依据代码创建使用帮助文档，以便代码的观看和使用。

3，注释常见的编写位置

A：类名之上，说明类的编写目的（就是针对的问题描述）。

B：成员变量之上，说明这个成员变量的用意。

C：在方法定义上，说明这个方法的用意。

D：在特殊的代码之上，说明指定的代码块的使用方法和用意。

4，注释的作用

A：为当前代码的编写人员服务。

B：为其它使用代码服务。

四  常量：

1，定义：在程序运行过程中，其值是不会发生改变的。

eg：    数字10

2，分类

A：字面量常量：一看这个数字就知道它的值是多少。

B：字符串：是使用双引号括起来的字符。

C：字符：是使用单引号括起来的单个字符（必须是单个字符）。

D：整数。

E：小数。

F：布尔：true（真）    false（假）

G：空：  null（空）

自定义常量：在程序中是使用final修饰（在面向对象中学到）。

3，在现有知识体系中常见的常量使用目的

A：为变量赋值。

B：在程序中表示常量

class  Demo{

    ​    ​public  static  void  mian(String[]  args){

    ​    ​    ​    ​System.out.println(10);//输出的是常量，在程序运行过程中其值不会发生变化。

    ​    ​    ​    ​ System.out.println(10);//输出整数常量  10。

    ​    ​    ​    ​ System.out.println("abc")；//输出字符串常量    abc

    ​    ​    ​    ​ System.out.println('a');//输出字符常量   a

    ​    ​    ​    ​ System.out.println(1.23);//输出小数常量   1.23

    ​    ​    ​    ​ System.out.println(true);//输出布尔常量   true

    ​    ​    ​    ​ System.out.println(false);//输出布尔常量   false

    ​    ​}

}

五  变量：

1，变量定义：在程序运行过程中，其值会发生改变的。

2，变量三要素：

A：变量必须要有数据类型。

B：变量必须有名字。

C：变量必须有初始化值。

3，在java语言中常见的变量分类

A：成员变量

B：局部变量：

    ​在方法内部定义变量就叫做局部变量

eg：

class  Demo1{

    ​    ​public  static  void  main(String[]  args){

    ​    ​    ​    ​//1，定义一个变量表示人的年龄。

    ​    ​    ​    ​//2，数据类型是整数  int  类型。

    ​    ​    ​    ​//3，在程序中使用变量，肯定使用某个标识符来代表在内存中变量占用的那块空间。

    ​    ​    ​    ​//1,2,3其实就是变量三要素中第一步，变量类型。

    ​    ​    ​    

    ​    ​    ​    ​​//4，使用  age  来表示人的年龄。

    ​    ​    ​    ​//  4就是变量三要素中第二步，变量名字。

    ​    ​    ​    ​//5，人的年龄通常根据实际年龄1岁开始。

    ​    ​    ​    ​//5就是变量三要素中第三步，变量初始化值。

    ​    ​    ​    ​int  age=1；

    ​    ​    ​    ​//因为变量age定义在main方法中，所以age还是局部变量。

    ​    ​}

}

4，理解变量

A：每个变量在内存中都会占用空间。

B：在程序运行中，这个内存空间值也叫变量的值是可以改变的。

C：每个变量根据实际需求定义自己合适的数据类型。

D：在程序中为变量起一个名字来代替变量在内存中占用的空间。

E：程序中，使用变量之前，要先被初始化。

5，变量的特点

A：变量的作用域：

    ​变量起作用的代码空间。

    ​变量所在最近的大括号内部就是它的作用域。

B：变量在内存中的创建过程：

    ​为变量开辟空间。

    ​为变量初始化值

C：在同一个变量作用域中，不能出现同名称的变量

D：在定义一个变量时：

    ​通常“=”号右边叫做定义变量。

    ​通常“=”号左边叫变量赋值（变量第一次，则通常叫变量初始化）。

E：在变量第一次使用之前，必须具备变量三要素。

F：定义多个变量的方式

eg：

class  Demo2{

    ​    ​public  static  void  main(String[]  args){

    ​    ​    ​    ​int  age=1;//定义age变量并赋值为 1，及初始化。

    ​    ​    ​    ​    ​age=2；//再次为变量age赋值为 2。

    ​    ​    ​    ​System.out.println(age);//输出变量age的值。

    ​    ​    ​    ​

    ​    ​    ​    ​//在变量使用之前看看变量三要素有没有具备。

    ​    ​    ​    ​//int  age；//定义age变量。    ​    ​

    ​    ​    ​    ​//age=10;//为变量age赋值及初始化。

    ​    ​    ​    ​//System.out.println(age);//输出变量age 的值。

    ​    ​    ​    ​//在同一个作用内，不能出现通名称变量。

    ​    ​    ​    ​//boolean  age=true；// 变量重名错误。    ​    ​

    ​    ​}

}

六 数据类型

1，数据类型是变量三要素之一。

2，分类

java语言中常见的数据类型分类：

    ​基本数据类型：

    ​    ​    ​数字型：整数型

    ​    ​    ​    ​    ​    ​   byte（字节）    ​    ​

    ​    ​    ​    ​    ​    ​   short（短整型）

    ​    ​    ​    ​    ​    ​    int（整型）

    ​    ​    ​    ​    ​    ​    ​long（长整型）

    ​    ​    ​小数型：

    ​    ​    ​    ​    ​    ​    ​float（单精度）

    ​    ​    ​    ​    ​    ​    ​double（双精度）

    ​    ​    ​字符型:     ​char

    ​    ​    布尔型：  boolean

    ​    ​    ​引用数据类型:  类（具体类、抽象类）、接口、数组、集合。

七 基本数据类型——布尔型

1，布尔型只有两个值可以使用：true和false。

2，布尔类型变量只能使用true或者false去赋值。

3，布尔类型常见的使用方式

布尔类型常见和语句一起使用，其值true或者false通常用于语句的判断。

即：

如果true，则执行。

如果false，则不执行。

eg：

class  Dmeo3{

    ​    ​public  static  void  main(String[]  args){

    ​    ​    ​    //​boolean  x=true;//定义一个布尔型变量 x ，返回一个值是true。

    ​    ​    ​    //​boolean  y=1；//不兼容的类型，boolean只能用true或者false。

    ​    ​    ​    ​

    ​    ​    ​    ​//对boolean类型定义一个小需求。

    ​    ​    ​    ​//如果温度小于0度，则需要添加衣服。

    ​    ​    ​    ​//定义温度是个变量，这时就要想到变量三要素。

    ​    ​    ​     double  wenDu=-10.0；//定义一个double类型变量wenDu并赋值为-10.0，及初始化。

    ​    ​    ​    ​//根据需求，使温度值进行判断。

    ​    ​    ​    ​if（wenDu<0）{

    ​    ​    ​    ​    ​    ​//如果温度小于0，则需要添加衣服。

    ​    ​    ​    ​    ​    ​System.out.println("需要添加衣服");//输出if判断语句的值。

    ​    ​    ​    ​}

    ​    ​}

}

八 基本数据类型——字符型

1，字符是使用单引号括起来的单个字符。

2，针对特殊字符的处理（需要使用转义字符）

使用转义字符   \   可以让程序对具有语法含义的字符，按照普通字符处理。

3，设计系统本身的编码表问题

编码表：

一个对应表，通常把实际中常用的字符和计算机中某个数字做对应。

在计算机中，所有的数据都是使用二进制数字（就是0和1组成的数字）来表示。

在美国，就发现生活中常用的字符有限的；那么他们就在计算机中把这些字符使

用固定的二进制进行了对应那么这个编码表被定义为ASCII码表。

在程序运行时，如果碰到字符参与运算，那么就会从ASCII表中查找这个字符对应的

二进制数字，并使用其（二进制转十进制）十进制数来进行计算。

ASCII表中常用的三个数字：

97     对应  a

65    ​对应    A

48    对应    0

每个国家都有一个编码表，中国的国标码：

GB2313      ​    ​GBK          GB18030

如果每个国家都有一份，不给管理。某个字符对应到计算机中的数字会出现

重复，这样的后果会造成编码表不通用和混乱。

为了解决以上问题，国籍组织对每个国家的字符统一编码进行管理，这个编码

表叫Unicode。     ​    ​java就是用Unicode

Unicode编码表中，每个字符都是使用两个字节的空间储存的，但是英文字符

每个字符都使用一个字节空间即可，这样就不会浪费储存空间。

为了解决以上问题，就又出现UTF—8编码表，这个编码表的特点是英文字符通

常使用一个字节储存，中文使用两个字节储存。如果不够，最多每个字符使用三

个字节来储存。

eg：

class  Demo4{

    ​    ​public  static  void  main(String[] args){

    ​    ​    ​    ​char  xx='a';//演示字符型变量并初始化。

    ​    ​    ​    ​System.out.println(xx);//输出字符型变量xx的值。

    ​    ​    ​    

    ​    ​    ​    ​​//使用转义字符处理特殊符号

    ​    ​    ​    ​//需求：

    ​    ​    ​    ​//想要输出字符 ‘ 单引号，先定义一个变量及初始   '单引号    。

    ​    ​    ​    ​char  yy=‘  \‘  ’；//字符型变量的定义并初始化。

    ​    ​    ​    System.out.println(yy);//输出字符型变量yy 的值。

    ​    ​    ​    

    ​    ​    ​    ​//编码表：

    ​    ​    ​    ​System.out.println('a'+1);//输出字符型变量值是   98

    ​    ​    ​    ​//以上是字符‘a’参与运算，会到ASCII表中查找字符a对应的数字97，则97+1=98.​

    ​    ​}

}

九  基本数据类型——整型

1，整型包括的类型范围

byte     ​short    ​    ​int    ​    ​long

2，记住byte字节类型的取值范围

-128    到    ​127

通常会考byte的赋值是否在可取值的范围之内。

3整型的默认类型是    ​int。

4，每种整型类型的占用内存空间

byte（1个字节）

shaort（2个字节）

int(4个字节)

long（8个字节）

eg：

class  Demo5{

    ​    ​public  static  void  main(String[]  args){

    ​    ​    ​   // ​byte  x=128;//可能损失精度，128超过了byte的取值范围。

    ​    ​    ​   //System.out.println(x);//输出变量x 的值。

    ​    ​    ​   

    ​    ​    ​   //整型在代码中所有的直接使用的值都是默认是int类型的。

    ​    ​    ​    ​int  y=10；//在程序中默认的分配空间是整型。

    ​    ​    ​    ​byte  i=10；//虽然变量  i 定义的数据是byte型，但是为它赋值的10默认是int型。

    ​    ​}

}

5，整型数据的表示法：

A：进制

数值换算中的进位制度

二进制：逢二进一    ​    ​    ​取值范围就是：0和1.

八进制：逢八进一    ​    ​    ​取值范围就是：0 1 2 3 4 5 6 7

十进制：逢十进一    ​    ​    ​取值范围就是：0 1 2 3 4 5 6 7 8 9

十六进制：逢十六进一    ​  取值范围就是：0 1 2 3 4 5 6 7 8 9 A B C D E F

B：计算机中基础的数据存储规则

在计算机中，所有的数据都是使用0或1组合进行表示的。

每个0或者1都叫一个二进制位。

每8个二进制位又叫一个字节byte。

1024byte=1k字节

1024k=1M

1024M=1G

1024G=1T

B​_1：如何把一个二进制数变成十进制数？

    ​计算规则：

    ​    ​    ​0 0 0 0  0 1 1 1=0*2^7+0*2^6+……0*2^3+1*2^2+1*2^1+1*2^0=4+2+1=7

下标    ​ 7 6 5 4  3 2 1 0

    ​ 系数*以2为底，以下标为指数，

    ​再把每一个二进制按照如上规则计算出十进制求和。

    ​以上的计算规则可以应用于任何进制转十进制。

    ​任意进制转十进制的计算公式：

    ​每一个数为按照      ​系数*以进制数为底    ​以下标为指数    ​计算数值，

再把每一个数位计算出的数据求和。

B_2：十进制转其它进制

eg：把十进制7转成二进制？

把7作为被除数，依次除以2，每次记录余数。

把余数倒序就是结果。

问：byte的最大值127怎么来的？

每个二进制位的最左边的二进制位是符号位

0表示整数      1表示负数——符号位

依照这个规则，byte的最大值就是0111 1111换算成十进制就是127.

C：整型数据在程序中有四种进制表示法

二进制表示法    ​    ​以0b开头    ​    ​    ​注：jDK7.0以上支持

八进制表示法    ​    ​以0开头

十进制表示法    ​    ​默认（数值本身）

十六进制表示法    ​以0X开头

6，整型的long型

A:为long型变量赋值需要在数值后面加大写L。

B：如果没有超出int型范围，则为long型变量赋值不会出现错误，但是建议

只要为long型变量后面加大写L。

eg：

class  Demo6{

    ​    ​public  static  void  main(String[]  args){

    ​    ​    ​    ​//int  x=10000000000;//已经超过了int型的最大值。

    ​    ​    ​    ​//long  y=10000000000；//过大的整数，因为程序默认的是整型int型。

    ​    ​    ​    ​long  x=100000000000L；//定义long型变量并赋值，及初始化。值后加大写L。

    ​    ​    ​    ​long  y=12L；//定义long型变量并赋值及初始化，值后加大写L。因为这样别人更容易

    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​//明白你的意思。知道你是为long型赋值。

    ​    ​    ​    ​System.out.println(x);//输出long型变量  x  的值。

    ​    ​}

}

十  基本数据类型——小数型

float（单精度）

double（双精度）

1，精度

可以表示小数精确程度，即其只是在一定的精度范围内表示小数。

double比float表示小数的精度更高。

2，小数默认是double型

3，如何为float类型变量赋值

eg：

class  Demo8{

    ​    ​public  static  void  main(String[]  args){

    ​    ​    ​    ​//float  x=1.23;//错误，可能出现损失精度。

    ​    ​    ​    ​float  y=1.23F；//定义float型变量 y 赋值为1.23F，及初始化。

    ​    ​    ​    ​//如果为float型变量赋值，必须要在后面加大写F。

    ​    ​}

}

十一  默认类型转换（自动类型提升）

1，默认类型转换的使用时机

A：整型中把一个小类型数值为一个大类型的变量赋值。

B：在数值运算中会符合自动类型提升规则。

B_1:

 byte   short   char在运算过程中会被自动提升为int。

byte   short是把数值占用空间直接提升为4个字节，变int型在计算。

char是使用ASCII表，找到对应的int型数字，再进行计算。

整数的数值运算都会默认结果是int型。

B_2：

如果在运算过程中有long型参加，则结果肯定是long型。

如果在运算过程中有float型参加，则结果肯定是float型。

如果在运算过程中有double型参加，则结果肯定是double型。

class  Demo9{

    ​    ​public  static  void  main(String[]  args){

    ​    ​    ​    ​//左边xx是long型，右边12是默认int型。

    ​    ​    ​    ​long   xx=12；//赋值成功是把12默认类型转换（自动类型提升）

    ​    ​    ​    ​//定义long型变量赋值为12，及初始化。

    ​    ​    ​

    ​    ​    ​    ​float  yy=1.23F；//定义float型变量并赋值为1.23F；及初始化。

    ​    ​    ​    ​double  m=2.34；//定义double型变量并赋值为2.34；及初始化。

    ​    ​    ​    ​System.out.println(xx+yy-m);//输出变量xx+yy-m的值。其结果还是double型。

    ​    ​}

}

十二： 强制类型转换

在代码运行过程中，强制性把某一个数据类型转换成另一种数据类型。

class  DemoTest{

    ​    ​public  static  void main(String[]  args){

    ​    ​    ​    ​byte  x1=4;//定义byte型变量x1并赋值为4，及初始化。

    ​    ​    ​    ​byte  x2=5；//定义byte型变量x2并赋值为5，及初始化。

    ​    ​    ​    ​//语法：

    ​    ​    ​    ​//目的类型    ​ 变量名称=（目的类型）（待转换类型）

    ​    ​    ​    ​byte  x3=（byte）（x1+x2）//强制转换类型为byte型。

    ​    ​    ​    ​System.out.println(x3);//输出变量x3的值 为9。

    ​    ​    ​    ​

    ​    ​    ​    ​//byte    ​x=4；//定义byte型变量x并赋值为4，及初始化。

    ​    ​    ​    ​//byte   y=5；//定义byte型变量y并赋值为5，及初始化。

    ​    ​    ​    ​//byte   b=x+y；//可能损失精度，因为在编译期间，并不清楚x和y的值，只是知道在

    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​ //运算中，byte会被自动提升为int型，运算结果是int型，把一个int型

    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​ //装入byte型就可能出现损失精度。

    ​    ​}

}

十三： 字符串参与运算

1“+”号在java程序中有如下作用

A：代表是一个正数

B：代表加法运算

C：代表字符串连接符

2，字符串参加运算符合如下规则：

A：“+”号两运算因子中有一个是字符串，那么这个“+”号就起到字符串连接符的作用。

B：字符串参与运算，其结果必须是字符串。

C：字符串连接就是直接把一个字符串拼接在另一个字符串之后。

eg：

class  DemoTest1{

    ​    ​public  static  void main(String[]  args){

    ​    ​    ​    ​//因为以下的主运算符都是加法。

    ​    ​    ​    ​//所以从左到右依次运算。

    ​    ​    ​    ​//第一个“+”号开始运算。

    ​    ​    ​    ​//“5+5=”+5；“+”的左边运算因子都是字符串，所以这个“+”是字

    ​    ​    ​    ​//符串连接符；“5+5=”+5，结果是“5+5=5”；

    ​    ​    ​    ​//第二个“+”号开始运算。

    ​    ​    ​    ​//“5+5=5”+5；“+”的左边运算因子是字符串，所以这个“+”是字

    ​    ​    ​    ​//符串连接符。所以最终结果是“5+5=55”；

    ​    ​    ​    ​System.out.println("5+5="5+5);//输出一个字符串，结果是“5+5=55”；

    ​    ​    ​    ​//第一个“+”开始运算。

    ​    ​    ​    ​//5+5；“+”的左右两边都是数字，那么这个“+”就是做加法。

    ​    ​    ​    ​//结果是10；

    ​    ​    ​    ​//第二个“+”开始运算。

    ​    ​    ​    ​//10+“=5+5”；“+”的右边运算因子是字符串，所以这个“+”是字

    ​    ​    ​    ​// ​符串连接符。

    ​    ​ ​    ​    ​//其最终结果是“10+5+5”；

    ​    ​    ​    ​System.out.println(5+5"=+5+5");//输出一个字符串，其结果是“10+5+5”；

    ​    ​}

}