关于java语言当中的标识符
- 1.什么是标识符
- 在java源程序当中凡是程序员有权力自己命名的单词都是标识符。
- 标识符在EditPlus编辑器当中以黑色字体高亮显示
- 标识符可以标识什么元素呢？
- 2.标识符的命名规则【不按照这个规则来，编辑器会报错，这是语法】
- 只能由"数字、字母、下划线_、美元符号$"组成，不能含有其他符号
- 不能由数字开头
- 严格区分大小写
- 关键字不能做标识符
- 理论上无长度限制，但是最好不要太长
- 3.标识符的命名规范【只是一种规范，不属于语法，不遵守规范编辑器不会报错】
- 最好见名知意
- 遵守驼峰命名规范
SystemService
UserService
CustomerService - 类名、接口名：首字母大写，后面每个单词的首字母大写。
- 变量名、方法名：首字母小写，后面每个单词的首字母大写。
- 常量名：全部大写，单词和单词之间用下划线连接
关于java语言当中的关键字
- 什么是关键字？
- SUN在开发java语言的时候，提前制定好的一些具有特定含义的字符序列。
- 在语言当中具有特殊含义的单词，这些单词构成java程序的骨架，这些单词是需要记住的，不能随意编写，区分大小写。
- 关键字在java语言中全部小写
- 关键字在EditPlus工具中颜色是蓝色高亮
- 常见的关键字有哪些？
- public
- class
- static
- void
- if
- for
- while
- do
- default
- byte
- short
- int
- switch
- true
- false
- throw
- throws
- try
- catch
- …
- 提醒：关键字不需要单独拿出来记忆，编写程序的过程中记忆。
关于java语言当中的字面值
- 字面值：
- 10、100
- 3.14
- “abc”
- ‘a’
- true、false
- 字面值就是数据
- 字面值是java源程序的组成部分之一。包括标识符和关键字它们都是java源程序的组成部分。
- 数据在现实世界当中是分门别类的，所以数据在计算机编程语言中也是有类别的：【数据类型】
- 10、100 属于整数型字面值
- 3.14 属于浮点型字面值
- true、false 属于布尔型字面值
- “abc”、"中国人"属于字符串型字面值
- ‘A’、‘人’ 属于字符型字面值
- 注意：
java语言当中所有的字符串型字面值必须使用双引号括起来，双引号是半角
java语言当中所有的字符型字面值必须使用单引号括起来，单引号是半角，且单引号中只能存放单个字符。
关于java语言当中的变量
- 1、什么是变量？
- 变量本质来说是内存中的一块空间，这块空间有"数据类型"、“名字”、“字面值”
- 变量包含三部分：数据类型、名称、字面值【数据】
- 变量是内存中存储数据的最基本的单元
- 2、数据类型的作用？
- 不同的数据有不同的类型，不同的数据类型底层会分配不同大小的空间。
- 数据类型是指导程序在运行阶段应该分配多大的内存空间。
- 3、变量要求：
变量中存储的具体的"数据"必须和变量的"数据类型"一致，当不一致的时候编译报错。 - 4、声明/定义变量的语法格式：数据类型 变量名
- 数据类型：
例如整数型数据，int - 变量名：
只要是合法的标识符就行。规范中要求：首字母小写，后面每个单词首字母大写。
例如：int i; int age; int length; int size
其中int是数据类型，i,age,length,size都是变量名
- 5、变量声明之后怎么赋值？
- 语法格式：变量名 = 字面值
要求：字面值的数据类型必须和变量的数据类型一致。
= 等号是一个运算符，叫做赋值运算符，赋值运算符先运算等号右边的表达式，表达式执行结束之后的结果赋值给左边的变量。
- 6、声明和赋值可以放到一起完成
int i = 10;
- 7、变量赋值之后，可以重新赋值，变量的值可以变化：
int i = 10;
System.out.println(i);//10
int i = 20;
System.out.println(i);//20
int i = 100;
System.out.println(i);//100
- 8、有了变量的概念之后，内存空间得到了重复的使用：
int i = 10;
System.out.println(i);
...
System.out.println(i);
- 9、通常访问一个变量包括两种访问形式：
- 第一种：读取变量中保存的具体数据 get/获取
- 第二种：修改变量中保存的具体数据 set/设置
i = 20; //set
System.out.println(i); //get
int a,b,c
- 11、java中的变量必须先声明，再赋值，才能访问
int i；程序执行到这里，内存空间并没有开辟出来，变量i并没有初始化。所以没有赋值之前是无法访问的
举例：
public class VarTest01
{
public static void main(String[] args){
//声明一个int型的变量，起名为i
int i;
//编译报错，变量i并没有初始化
//System.out.println(i);
//给i变量赋值，i变量在这里完成初始化，内存开辟
i = 100;
System.out.println(i);
//i再次重新赋值
i = 200;
System.out.println(i);
//一行可以同时声明多个变量
//a和b尚未初始化，c赋值给300
int a,b,c = 300;
//编译错误
//System.out.println(a);
//编译错误
//System.out.println(b);
System.out.println(c);
a = 0;
b = 1;
System.out.println(a);
System.out.println(b);
}
}
- 12、在同一个“作用域” 中，变量名不能重名，但是变量可以重新赋值
public class VarTest03{
public static void main(String[] args){
int i = 100;
System.out.println(i);
i = 200;
System.out.println(i);
//会报错，同一个作用域中变量名重复
int i = 500;
System.out.println(i);
}
}
- 13、 变量的作用域
- 什么是作用域？
变量的作用域，其实描述的是变量的有效范围。
在什么范围之内是可以被访问的，只要出了这个范围该变量就无法访问了。 - 变量的作用域只要记住一句话。
出了大括号就不认识了
public class VarTest03
{
//注意，这里的static不要去掉
static int k = 90;
public static void main(String[] args){
//变量i的作用域是main方法
//在整个main方法当中是有效的，可见的，可以访问的
int i = 100;
System.out.println(i); //可以
System.out.println(k); //可以
//a变量的作用域是整个for循环，for循环结束之后，a变量的内存就释放了
for(int a=0;a<10;a++){
}
//这里无法访问变量a
//System.out.println(a);
int j;//作用域是main方法
for(j=0;j<10;j++){
}
System.out.println(j);//访问的是main方法中的j变量
}
public static void dosome(){
//这里无法访问main方法当中的变量;
//已经出了i变量的作用域
//System.out.println(i); //不可以
System.out.println(k); //可以
}
}
- 14、变量的分类
- 根据变量声明的位置来分类：
- 局部变量：在方法体当中声明的变量叫做局部变量
- 成员变量： 在方法体外【类体内】声明的变量叫做成员变量
- 在不同的作用域中，变量名是可以相同的
- 在同一个作用域中，变量名不能重名
public classs VarTest04
{
//主方法：入口
public static void main(String[] args){
//i变量就是局部变量
int i = 3;
System.out.println(i);//java遵循“就近原则”
}
//成员变量
int i = 200; //类体中不分先后顺序
//类体中不能直接编写java语句【除声明变量之外】
//System.out.println(i);
public static void dosome(){
//局部变量
int i = 100;
}
}
关于java语言当中的数据类型
- 1.数据类型的作用时什么？
- 程序当中有很多数据，每一个数据都是有相关类型的，不同数据类型的数据占用空间大小不同。
- 数据类型的作用是指导JVM在运行程序的时候给该数据分配多大的内存空间。
- 2、java中的数据类型包括两种：
- 3、关于基本数据类型：
- 基本数据类型包括四大类八小种：
- 第一类：整数型
byte 、short、int、long - 第二类：浮点型
float、double - 第三类：布尔型
boolean - 第四类：字符型
char
- 4、字符串"abc"不属于基本数据类型，但属于引用数据类型，字符属于基本数据类型
- 5、八种基本数据类型各自占用空间大小是多少？
| 基本数据类型 | 占用空间大小【单位：字节】 |
|---|
| byte | 1 |
| short | 2 |
| int | 4 |
| long | 8 |
| float | 4 |
| double | 8 |
| boolean | 1 |
| char | 2 |
- 6、计算机在任何情况下都只能识别二进制，例如：只认识1010101010…
【现代的计算机底层采用交流电的方式，接通和断开就两种状态，计算机只识别1或0，其他不认识】 - 7、什么是二进制？
- 数据的一种表示形式。十进制是满十进一原则，二进制表示满二进一原则。
例如 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
18 19 20
例如 0 1 10 11 100 101 110 111 1000…
- 8、字节：
1 Byte = 8 bit【1个字节 = 8个比特位】1个比特位表示1个二进制位：1/0
1 KB = 1024 Byte
1 MB = 1024 KB
1 GB = 1024 MB
1 TB = 1024 GB - 9、整数型当中的Byte类型，占用1个字节，所以byte类型的数据占用8个比特位。那么byte类型的取值范围是什么？
- 关于java中的数字类型，数字都是有正负之分的，所以在数字的二进制当中有一个二进制位被称为“符号位”。并且这个“符号位”在所有二进制位的最左边，0代表正数，1代表负数。
- byte类型最大值：01111111
- byte类型最大值：2的7次方 - 1，结果是127
- byte类型最小值：-128【和原码、反码、补码有关系，非11111111】
- 10、二进制和十进制转换规则：略
- 11、计算机只认识二进制，那么计算机是如何认识现实生活中的文字呢？
- 八种基本数据类型当中，byte,short,int,long,float,double,boolean这7种数据类型计算机在表示的时候比较容易，因为底层都是数字，十进制的数字和二进制之间存在一种固定的转换规则。
- 但是八种基本数据类型当中char类型表示的是现实世界中的文字，文字和计算机二进制之间“默认”情况下是不存在任何转换关系的。
- 为了让计算机可以表示现实世界当中的文字，我们需要进行人为的干涉，需要人负责提前制定好“文字”和”二进制“之间的对照关系。这种对照转换关系被称为：字符编码。
- 计算机最初只支持英文，最先出现的字符编码是：ASCII码【一个字节编码】
‘a’–>97【01100001】 ‘b’–>98 …
‘A’–>65 ‘B’–>66 …
‘0’–>48 ‘1’–>49 …
- 后来出现了一种编码方式统一了全球所有的文字，容量较大，这种编码方式叫做：unicode编码，unicode编码方式有多种具体的实现：
- java语言源代码采用的是unicode编码方式，所以“标识符”可以用中文，比如类名可以为中文。
- 现在实际开发中，一般使用UTF-8编码方式
- 12、 八种基本数据类型的取值范围：
| 数据类型 | 取值范围 |
|---|
| byte | [-128 ~ 127] |
| short | [-32768 ~ 32767] |
| int | |
| long | |
| float | |
| double | |
| boolean | [true,false] |
| char | [0 ~ 65535] |
注意：short和char所表示的种类总数是一样的，不过char没有负数。
public class DataTypeTest02
{
//变量还是遵守这个语法：先声明，再赋值，才能访问
//成员变量没有手动赋值系统会默认赋值【局部变量不会】
static int f;//成员变量
public static void main(String[] args){
System.out.println(f);//0
}
}
| 数据类型 | 默认值 |
|---|
| byte,short,int,long | 0 |
| float,double | 0.0 |
| boolean | false【在c语言中，true是1，false是0】 |
| char | u0000 |
八种基本数据类型的默认值是一切向0看齐。
详细阐述各类数据类型
public class DataTypeTest01
{
public static void main(String[] args){
//定义一个char类型的变量，起名c，同时赋值字符'a'
char c = 'a';
System.out.println(c);
//一个中文占用2个字符，char类型正好是2个字节
//所以java中的char类型变量可以存储一个中文字符
char x = '国';
System.out.println(x);
//编译错误
//ab是字符串不能使用单引号括起来
//char y = 'ab';
//"a"是字符串类型
//k变量是char类型
//类型不兼容，编译错误
char k = "a";
//先声明
char e;
//赋值
e = 'e';
//再赋值
e = 'f';
}
}
- 转义字符
转义字符会出现特殊字符之前，会将特殊字符转换成普通字符
- n 换行符
- t 制表符
- ’ 普通的单引号
- \ 普通的反斜杠
- " 普通的双引号
public class DataTypeTest03
{
public static void main(Sting[] args){
//普通的n字符
char c1 = 'n';
System.out.println(c1);
//这是一个换行符，属于char类型的数据
//反斜杠在java语言当中具有转义功能
char c2 = 'n';
//System。out.println()和System.out.print()区别：
//println输出后换行,print表示输出，但是不换行
//普通的t字符
char x = 't';
System.out.println(x);
//制表符tab
//强调制表符和空格不同，他们的ASCII不一样，体现在键盘是上两个不同的“按键”
char y = 't';
System.out.print("A");
System.out.println(y);
System.out.println("B");//A B
//要求在控制台上输出“反斜杠字符”
//反斜杠将后面的单引号转义成不具备特殊含义的普通单引号字符
//左边的单引号缺少了结束的单引号字符，编译报错
char k = '\';
System.out.println(k);
//在控制台上输出一个普通的单引号字符
//第一个单引号和最后单引号配对儿
char a = ',';
System.out.println(a);
char f = '"';
System.out.println(f);//输出"
System.out.println("HelloWorld!");
System.out.println("“HelloWorld!”");//内部是全角双引号
//编译错误
//System.out.println(""HelloWorld!"");//内部是半全角字符
System.out.println(""HelloWorld!"");
char m = '中';
System.out.println(m);
//JDK中自带的native2ascii.exe命令，可以将文字转换成unicode编码形式
//在命令行输入native2ascii，回车，然后输入文字之后回车即可得到unicode编码
char n = 'u4e2d';//‘中’对应的unicode编码是 4e2d
System.out.println(n);
//编译错误
//char g = '4e2d';
//编译错误
//char g = 'u4e2d';
//通过：反斜杠u联合起来后面的一串数字是某个文字的unicode编码
char g = 'u4e2d';
//char类型的默认值
char c10 = 'u0000';
System.out.println(c10);//空字符
System.out.println(c10+1);//1
}
}
| 数据类型 | 占用空间大小 | 默认值 | 取值范围 |
|---|
| byte | 1 | 0 | 【-128~127】 |
| short | 2 | 0 | 【-32768~32767】 |
| int | 4 | 0 | 【-2147483648~2147483647】 |
| long | 8 | 0L | |
- java语言当中的“整数型字面值”被默认当做int类型来做处理。要让这个“整数型字面值”被当做long类型来处理的话，需要在“整数型字面值”后面添加l/L；建议使用大写L。
- java语言当中的整数型字面值有三种表示方式：
- 第一种方式：十进制【是一种缺省默认的方式】
- 第二种方式：八进制【在编写八进制整数型字面值的时候需要以0开始】
- 第三种方式：十六进制【在编写十六进制整数型字面值的时候需要以0x开始】
public class DataTypeTest04
{
public static void main(Sring[] args){
int a = 10;
int b = 010;
int c = 0x10;
System.out.println(a);//10
System.out.println(b);//8
System.out.println(c);//16
System.out.println(a + b + c);//34
//123这个整数型字面值是int类型
//i变量声明的时候也是int类型
//int类型的123赋值给int类型的变量i，不存在类型转换。
int i = 123;
//456整数型字面值被当做int类型，占用4个字节
//x变量在声明的时候是long类型，占用8个字节
//int类型的字面值456赋值给long类型的变量x，存在类型转换
//int类型转换成long类型
//int类型是小容量
//long类型是大容量
//小容量可以自动转换成大容量
long x = 456;
System.out.println(x);
//2147483647字面值是int类型，占用4个字节
//y是long类型，占用8个字节，自动类型转换
long y = 2147483647;
System.out.println(y);
//编译错误：过大的整数：2147483648
//2147483648被当做int类型的4个字节来处理，但是这个字面值超出int类型范围
//long z = 2147483648;
//解决错误
//2147483648字面值一上来就被当做long类型来处理，在字面值后面添加L
//2147483648L是8个字节的long类型
//z是long类型变量，以下程序不存在类型转换
long z = 2147483648L;
System.out.println(z);
}
}
public class DataTypeTest05
{
public static void main(String[] args){
//100L是long类型字面值
//x是long类型变量
//不存在类型转换，直接赋值
long x = 100L;
//x变量是long类型，8个字节
//y变量是int类型，4个字节
//以下程序编译报错：大容量不能直接赋值给小容量
//int y = x;
//大容量转换成小容量，需要进行强制类型转换
//强制类型转换需要加“强制类型转换符”
//加上强制类型转换符之后编译通过了，但是运行阶段可能损失精度。
//所以强制类型转换谨慎使用，因为损失精度之后可能损失很严重。
//强转原理：
//原始数据：00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100
//强转之后的数据：00000000 00000000 00000000 01100100
//将左边的4个字节的二进制砍掉【所有的数据强转的时候都是这样完成的】
int y = (int)x;
System.out.println(y);
//原始数据：00000000 00000000 00000000 00000000 10000000 00000000 00000000 00000000
//强转之后的数据：10000000 00000000 00000000 00000000
//10000000 00000000 00000000 00000000目前存储在计算机内部，计算机存储数据都是采用补码的形式存储
//所以10000000 00000000 00000000 00000000现在是一个补码形式
//将以上的补码转换到原码就是最终的结果
long k = 2147483648L;
int a = (int)k;
System.out.println(a);//损失精度严重，结果是负数 【-2147483648】
//分析以下程序是否可以编译通过？
//依据目前所学内容，以下程序是无法编译通过的
//理由：50是int类型的字面值，b是byte类型的字面值，显然是大容量int转换成小容量byte
//大容量转换成小容量是需要添加强制类型转换符的，以下程序没有添加强转符号，所以编译报错
//但是，在实际编译的时候，以下代码编译通过了，这说明：在java语言当中，当一个整数型字面值
//没有超出byte类型取值范围的话，该字面值可以直接赋值给byte类型的变量。
byte b = 50;//编译通过
byte b = 127;//编译通过
//编译报错，128这个int类型字面值已经超出了byte类型的取值范围，不能直接赋值给byte类型的变量
//byte b = 128;
//纠正错误，需要使用强制类型转换符
//但是一定会损失精度
//原始数据：00000000 00000000 00000000 10000000
//强转之后：10000000【这是存储在计算机内部的，是一个补码形式，则它的原码是什么？】
byte b = (byte)128;//-128
System.out.println(b);
//short s = 32767;//通过
//short s = 32768;//编译报错
//65535是int类型，4个字节
//cc是char类型，2个字节
//按照以前所学知识点来说，以下程序是编译报错的。
//char cc = 65535;//通过
//char cc = 65536;//编译报错
}
}
- 3、浮点型
- float 单精度【4个字节】
double 双精度【8个字节，精度较高】 - double的精度太低【相对来说】，不适合做财务软件。财务涉及到钱的问题，要求精度更高，所以SUN在基础SE类库当中为程序员准备了精确度更高的类型，只不过这种类型是一种引用数据类型，不属于基本数据类型，它是java.math.BigDecimal
- 其实java程序中SUN提供了一套庞大的类库，java程序员是基本这套基础的类库进行开发的。所以要知道java的SE类库的字节码在哪，要知道java的SE类库的源码在哪。
- SE类库字节码：D:JAVAjava8packjrelibrt.jar
- SE类库源码：
D:JAVAjava8packsrc.zip
- 例如：String.java和String.class
我们的（String[ ] args）中的String使用的是String.class字节码文件 - 在java语言当中，所有的浮点型字面值【3.0】，默认被当做double类型来处理
要想该字面值当做float类型来处理，需要在字面值后面添加F/f。 - 注意：
double和float在计算机内部二进制存储的时候都是近似值。
在现实世界中有一种数字是无限循环的，例如：3.3333333333333333…
计算机的资源是有限的，用有限的资源存储无限的数据只能存储近似值。
public class DataTypeTest06
{
public static void main(String[] args){
//3.0是double类型的字面值
//d是double类型的变量
//不存在类型转换
double d = 3.0;
System.out.println(d);
//5.1是double类型的字面值
//f是float类型的变量
//大容量转换成小容量需要加强制类型转换符，所以以下程序编写错误
//float f = 5.1;
//解决方案：
//第一种解方案：强制类型转换
float f = (float)5.1;
//第二种解决方案：没有类型转换
float f = 5.1F;
}
}
- 4、布尔型
- boolean
- 在java语言当中boolean只有两个值，true、false，没有其他值
- 不像c语言当中，0和1可以表示假和真。
- 在底层存储时boolean类型只占用1个字节，因为实际存储的时候false底层是0，true底层是1
- 布尔类型在实际开发当中非常重要，经常使用在逻辑运算和条件控制语句当中。
public class DataTypeTest07
{
public static void main(String[] args){
//编译错误：不兼容的类型
//boolean flag = 1;
boolean loginSucsess = true;
if(loginSucsess )
{
System.out.println("恭喜你，登录成功"); }
else{
System.out.println("对不起，同户名不存在或者密码错误!");
}
}
}
- 5、数据类型转换
- 八种基本数据类型当中除了布尔类型之外剩下的7种数据类型之间都可以互相转换。
- 小容量向大容量转换，称为自动类型转换，容量从小到大排序：
byte < short < int < long < float < double
< char <
注：
任何浮点类型不管占用多少个字节，都比整数型容量大
char和short可表示的种类数量相同，但是char可以取更大的正整数。
- 大容量转换成小容量，叫做强制类型转换，需要加强制类型转换符，程序才能编译通过，但是在运行阶段可能会损失精度，所以谨慎使用。
- 当整数字面值没有超出byte,short,char的取值范围，可以直接赋值给byte,short,char类型的变量
- byte,short,char混合运算的时候，各自先转换成int类型再做运算.
- 多种数据类型混合运算，先转换成容量最大的那种类型再做运算
- 注意：分析编译阶段和运行阶段，不要在编译阶段掺杂运行运算
byte b = 3;//可以编译通过，3没有超出byte类型取值范围
int i = 10;
byte b = i / 3;//编译报错，编译器只检查语法，不会“运算”i/3，错误是int/int类型，结果为int类型，转成byte时，没有加强制类型转换符
//10和3默认是int类型，所以运算后的最大类型也是int，为3
//所以是正确的
int f = 10 / 3;// 3
//先计算10/3，为3，再根据自动类型转换，将3转换成3.0
double dd = 10 / 3;// 3.0
//先将3转换成3.0，然后计算10.0/3.0，然后转换成double类型
dd = 10.0 / 3;//3.33333333333333
long g = 10;
//错误：g是long类型，计算g/3时，3会由int类型转换成long类型，于是g/3得到long类型，而将long类型转换成int类型，没有加强制转换符
int h = g/3;
int h = (int)g/3;//正确
long h = g/3;//正确
//错误：g先由long类型强制转换成int类型，再由int强制转成byte类型，而byte/int,则根据最大容量原则，最后为int类型，byte h = int，没有加强制类型转换符
byte h = (byte)(int)g/3;
//注意：编译器javac只检查语法，不进行计算
byte h = 3;//正确
byte h = (byte)(int)(g/3);//正确，计算优先级原则，先计算右边括号中
byte h = (byte)g/3;//不能转换，因为优先级问题，byte/int类型为int类型
byte h = (byte)(g/3);//可以转换，因为运算结果没有超出byte取值范围
//编译错误，short和byte运算，首先会转换成int类型再运算
//所以运算结果为int,但由于编译器不会计算，只能判断语法，所以它判断将大容量int转换成小容量short，没有加强制类型转换，会报错
short i = 10;
byte j = 5;
short k = i + j;
short k = 15;//编译通过，15没有超出short取值范围
short k = (short)(i + j);//编译通过
char l = 'a';
System.out.println(l);//a
//将char类型强制类型转换成byte类型，但由于没有超出byte取值范围，不存在精度损失，仍为97
System.out.println((byte)l);//97
//先将char类型l转换成int类型，为97,再与100相加
int m = l + 100;
System.out.println(m);//197
