Java入门第一章——编程语言基础：数据类型与变量

标识符

1.标识符是java源程序中程序员自己命名的单词

​ 标识符可以标识：类名、方法名、变量名、常量名、接口名…

2.标识符命名规则

*只能由“数字、字母、下划线_、美元符号$"组成，不能含其他符号

*不能数字开头

*严格区分大小写

*关键字不能作标识符

3.命名规范

*最好见名知意

​ public class UserService{}

*遵守驼峰命名方式

SystemService 、UserService 、CustomerService

*类名、接口名：首字母大写，后面每个单词首字母大写。

*变量名、方法名：首字母小写，后面每个单词首字母大写。

*常量名：全部大写。

关键字

Java关键字：

class、extends、implements、interface、import、package、break、case、continue、default、do、if、else、for、return、switch、while、false、true、null、boolean、byte、char、short、int、long、float、double、try、catch、throw、throws、finally、abstract、final、native、private、protected、public、static、synchronized、transient、volatile、instanceof、new、super、void、assert、enum、goto、const

数据类型

1.每一个数据都是有相关类型的， 不同数据类型的数据占用空间大小不同。

*数据类型的作用是指导 JVM在运行程序的时候给该数据分配多大的内存空间。

2.Java中的数据类型：

*基本数据类型：byte,short,int,long,float,double,boolean,char

*引用数据类型

—类

—接口

—数组

。。。。。。

3.基本数据类型

*基本数据类型包括四大类八小种：

第一类：整数型

​ byte,short,int,long

第二类：浮点型

​ float,double

第三类：布尔型

​ boolean

第四类：字符型

​ char

4.字符串“ abc "不属于基本数据类型，属于”引用数据类型“，字符属于基本数据类型：

*字符串使用双引号“ abc "

*字符使用单引号 ‘a’

5.八种数据类型：

基本数据类型	占用空间大小【单位字节】	取值范围	默认值
byte	1 B	-128~127	0
short	2 B	-32768~32767	0
int	4 B	-2147483648~2147483647	0
long	8 B		0L
float	4 B
double	8 B
boolean	1 bit	true/false
char	2 B	0~65535

注：char和short的种类总数是一样的，不过char可以表示更大的正整数，因为char没有负数。

*1 byte =1 B=8 bit 【1字节=8个比特位】

*1个比特位表示一个二进制位：1/0

*1 KB = 1024 Byte; 1 MB = 1024 KB; 1 GB= 1024 MB; 1 TB = 1024 GB;

*1 TB = 1024 * 1024 * 1024 * 1024 * 8 bit

拓展：int能做的BigInteger也能做，以及float能做的BigDecimal呀能做。不过后者（BigInteger与BigDecimal)必须使用方法调用，不能使用运算符。使用这二者必须使用方法调用，不能使用运算符。并且运算速度会慢一些，但精度会高很多。

变量

1.变量本质上来说是内存中的一块空间，这块空间有“数据类型”、“有名字”、“有值”。

*变量包含三部分：数据类型、名称、数据【值】。

*变量是内存中存储数据的最基本的单元。

2.数据类型的作用：

*不同的数据有不同的类型，不同的数据类型底层会分配不同大小的空间。

*数据类型是指导程序在运行阶段应该分配多大的内存空间。

3.变量要求：变量中存储的具体”数据“必须和变量的”数据类型“一致，当不一致时候编译报错。

4.声明/定义变量的语法格式：

​ 数据类型 变量名；

   int  i;
   char  userName; //变量名规范：首字母小写，后面每个单词的首字母大写  

5.变量赋值语法格式：

​ 变量名 = 值(或者运算式子)；

“ = ”作为一个运算符，叫做赋值运算符，赋值运算符先运算等号右边的表达式，表达式执行结束后的结果赋值给左边的变量。

  i = 10;
  char a = "hello world"; //值的数据类型必须与变量的数据类型一致。 

6.声明和赋值可以放到一起。

数据类型 变量名 = 值;

int i = 10;

7.变量赋值之后，可以重新赋值，变量的值可以变化；

 int i = 10;
 System.out.println(i); // i=10
 i = 20;
 System.out.println(i); //  i=20
 i = 100;
 System.out.println(i); // i=100

8.变量定义后，内存空间得到重复的使用。

*访问一个变量包括两种形式：

get（获取）：读取变量中保存的具体数据

set（设置）：修改变量中保存的具体数据

 int i = 20; //set
 System.out.println(i); //get

9.变量在一行上可以声明多个

int a,b,c;
int a,b,c=100; //c赋值了100，a与b未赋值。
int a=100,b=10,c= 20; //a赋值了100,b赋值了10，c赋值了20

10. java中变量必须先声明，再赋值，才能访问。

int  i; //程序执行到这里，内存空间未开辟出来，变量i并没有初始化。所以没有赋值之前无法访问。

11.在同一个“作用域”当中，变量名不能重名，但是变量可以重新赋值。

12.变量的作用域：变量的作用域描述的就是变量的有效范围，即在某个范围内变量可以被访问。

​ 简单说就是出了大括号就不认识。

​ 但是可以使用static。

public class VarTest03{
    static int k =90;
    public static void main(String[] args){
        int i = 100;
        System,out.println(k); //可以输出k
    }
    public static void doSome(){
        System.out,println(i); //i在mian方法里，无法访问。即在doSome没有定义。
    }
}

for方法中的例子

for(int i=0;i<10;i++){
     System.out.println(i); //在for里边，i可以访问，
                            //i的作用域是for循环
}
System.out.println(i); //在for外边i没有定义,无法访问

int j; //先定义了j
for(j=0;j<10;j++){}
System.out,println(j);//先定义了j，for里边循环后可以继续访问j变量
                      //j的作用域是这个整个方法内部

13.关于变量的分类：

根据变量声明的位置来分类：

​ *局部变量—在方法体当中声明的变量叫做局部变量。

​ *成员变量—在方法体外【类体之内】声明的变量叫做成员变量。

public class VarTest04{
    //成员变量
    int k = 200;
    
    public static void main(String[] args){
        //i为局部变量
        int i = 10;
        System.out.println(i);//i=10，就近原则，先访问局部变量。
    }
    //成员变量
    int i =100; //在不同作用域中，变量名可以相同。
                //在同个作用域中，变量名不可用相同。
    
    //System.out.println(i); 不能执行 
    //因为类体中不能直接编写Java语句【除声明变量以外】
    
    public static void doSome(){
        //局部变量
        int i =90;
    }
}

数据类型详解

变量需要先声明，再赋值，才能访问。

static int f ; // 成员变量没有手动赋值系统会默认赋值。【局部变量不会】

八种数据类型默认值

数据类型	默认值
整数型：byte,short,int,long	0
浮点型：float,double	0.0
布尔型：boolean	false【在C语言中true是1，false是0】
字符型：char	\u0000

注：八种基本类型的默认值一切向0看齐。

1.char类型举例

public class DataTypeTest01{
    public static void main(String[] args){
        //定义一个char类型的变量，起名为c，同时赋值字符’a'
        char c = 'a';//编译成功
        
        //一个中文占用2个字节，char类型正好是2个字节
        //java中的char类型变量可以存储一个中文字符
        char x = '国';  //编译成功
        
        //ab为字符串，不能用单引号括起来
        char y= 'ab'; //编译错误
        // “a” 双引号括起来的也为字符串
        char k = "a";  //编译错误，应该用String
        
        //声明
        char e;
        //赋值
        e = 'e';
        
    }
}

2.char类型：转义字符 " \ "

public class DataTypeTest03{
    public static void main(String[] args){
        //普通的字符
        char c1 = 'n';
        System.out.print(c1);
        System.out.print("A");
        //以上两句打印输出结果为：
        //nA
        
        //这里的 \n  是一个换行符
        //反斜杠 在Java中具有转义功能。这里加了反斜杠，\n表示一个换行字符。相当于在window中按回车。
        char c2 = '\n';
        System.out.print("A");
        System.out.print(c2);
        System.out.print("B");
        //以上三句打印输出结果为:
        //A   
        //B
        
        //与“ \n ”符号相同的作用为System.out.println()
        //System.out.println()和System.out.print()的区别：println输出之后换行，print只输出不换行。
        
        // “ \t" 为制表符， 与键盘上“Tab”键一样
        //制表符和“空格”不同，他们的ASCII不一样，体现在键盘上两个不同按键。
        //简单来说ASCII是每个字符对应的代码。
        char c3 = '\t';
        System.out.print("A");
        System.out.print(c3);
        System.out.print("B");
        //以上三句打印输出结果为： 
        // A	B 
    }
}

​ 那么“ \ ”字符是转义字符,单独这么写一个“ \ ”，系统会判定这里只是一个转义，没有加入需要转义的字符，导致报错。

        char c4 = '\';  //报错
        
        //如果需要输出“ \ ”这个字符需要输入两个反斜杠
        //解释：第一个“ \ ”具有转义功能，将第二个“ \ ”转义为一个普通的字符。 
        char c5 = '\\'; 
        System.out.print(c5);//这里输出的结果就是： \

​ 既然“ \ "不能单独打印，同时单引号也是一样不能直接打印的。

   //想要在控制台中输出一个 “ ’ ”这样的一个单引号字符。
    char a = ''; //这个语句会报错，语法报错。
    char b = '''; //这个语句也会报错，第一个单引号和第二个单引号配对，最后的单引号找不到另一半
    // java编译的时候，符号是一个“栈”的数据结构来编译的。"栈"是一个数据结构，这里不过多描述。
    // 所以第二个编译的时候会导致单引号没有另一个匹配导致报错。
        
    //那么如果要打印一个普通的单引号，只需要在前边加上“\”，将其转义。
    char c = '\'';
    System.out.println(c);//这样输出的结果就是： '

    //而其他像双引号这种就可以直接字符输出打印
    char d = '"';
    System.out.println(d);//这样的输出结果就是： "

   //但是在需要输出两个双引号时
   System.out.println(""Hello World"");//这样会报错的，前面两个双引号会配对，后面两个双引号配对。
   //只需要将中间两个需要的双引号前面加上转义字符"\"即可
   //两个都要上转义字符，如果有一个双引号没有加上转义字符。
   //若有三个双引号，导致有一个双引号没有配对，编译错误。
   System.out.println("\"Hello world\"");//输出结果就是："Hello world"

所以转义字符出现在特殊字符之前，会将特殊字符转义为普通字符。（语法上所写的字符都为特殊字符）

而反斜杠和u结合起来后面一串数字是某个文字的unicode编码。

注：Unicode是一种用于字符编码的国际标准，它定义了世界上所有字符的唯一编号，并提供了一种将这些字符在计算机中表示和处理的方式。其中也包括中文字。

 char g = '\u4e2d';
 System.out.print(g);//输出的结果是：中
 char j = '\u0000'; //这里的\u0000表示一个空的字符。属于控制字符，也叫不可显字符。代表一个空格

所以反斜杠“\”作为转义字符来使用。

符号	表示意思
\n	换行符（和按回车一样）
\t	制表符（与键盘上Tab一样)
\’	普通的单引号
\\	普通的反斜杠
\"	普通的双引号
\u	表示后面一串字符是一个unicode编码

3. java中整数型字面值的三种表示方式：

​ *第一种：十进制【一种缺省默认方式】(缺省简单理解：前面没有带0或0x这种标识为八进制和十进制的符号)

​ *第二种：八进制【在编写八进制整数型时候需要以0开始】

​ *第三种：十六进制 【在编写十六进制整数型时候需要以0x开始】

int a = 10; //十进制，直接填正常数字
int b = 010; //八进制，前面要带“0”。反过来，前面带“0”开始的整数型就是“八进制”。
int c = 0x10; //十六进制，前面要带“0x”反过来，前面带“0x”开始的整数型就是“十六进制”。。
 
System.out.println(a);//打印结果为：10
System.out.println(b);//打印结果为：8
System.out.println(c);//打印结果为：16

System.out.println(a + b + c);//打印结果为：34。可见打印出来还是以10进制打印。

​ java中“整数型字面值”被默认当做int类型来处理。若要让这个值被当做long类型来处理的话，需要在值后面加上l或者L。建议使用大写L，因为小写的不容易分辨。

​ 一般的，小容量的类型往大容量的类型转换可以自动转换。

//123这个整数型的值是int类型。
//i变量声明的时候也是int类型，这个时候123赋值给int类型的i，不存在类型转换。
int i = 123;
System.out.println(i);//打印结果为123

//456这个整数型的值是int类型，占用4个字节。
//x变量在声明的时候是long类型，占用8个字节。
//int类型的整数型值456赋值给long类型的x变量，存在类型转换。
//小容量可以转换成大容量，称为自动转换机制。计算机中数字都是以二进制存储的。
//int在赋值给long时候仅需要把int的4个字节（32bit)放到long（8字节64位）的后4个字节。
long x = 456;
System.out.println(x);//打印结果为456

//2147483647是int类型，所以依旧可以转换。
long y = 2147483647;
System.out.println(y);//打印结果为2147486347

//2147483648已经溢出了int类型，没有处理的情况下，直接使用会报错。
long z = 2147483648;//报错
System.out.println(z);

//溢出int类型要在数字后面加上L（大小写都可以，小写不好辨认，一般写大写）转成long类型来处理。
long z2 = 2147486348L;//可以编译，2147486348L是8字节的long类型，赋值时没有进行相应的类型转换。
Systen.out.println(z2);//打印结果为2147486348

4.整数型从大类型转换为小类型。（如long转换为int）

​ 整数型大类型直接赋值给小类型编译时会报错，如果大容量要转化为小容量，需要进行强制类型转换，这时候就用到了强制类型转换符。但是根据计算机以二进制存储的特性，大容量转化为小容量是以小容量的类型作为转换的内存，取大容量的后面位数作为小容量的字面值，所以运行时可能会损失精度。

​ 注：计算机中，以二进制补码来对数据进行存储。

long x = 100L; //计算机中存储的数据（二进制）为： 
               //00000000 00000000 00000000 00000000 00000000 00000000 0000000 01100100
int y = x; //这句会报错
int y2 = (int) x; //加了强制转化，转化后计算机中存储数据（二进制）为：
                  // 00000000 00000000 00000000 01100100
                  //将左边的二进制砍掉
System.out.println(y2); //可以正常输出结果为：100

//若以一个超出int的long类型值
long k = 2147483648L;
int e = (int)k; //这是由于计算机存储是以二进制的补码来存储的，导致砍掉前面4个字节后，
                //其数据（二进制）为：11111111 11111111 11111111 11111111
                //所以导致是一个负数.损失精度严重。
                //若这里想细究，需要懂得原码、反码、补码等知识。
System.out.println(e);//打印结果：-2147483648

//如果比int类型容量小，例如byte,short。可以直接赋值在范围内的数值。
byte a = 50;//可以编译
byte b = 128; //显然128超出byte的范围，会报错。
short c = 32767;//可以编译
short d = 32768;//显然32768超出short范围，会报错。

//倘若一意孤行，可以用强制类型转换。
byte b1 = (byte) 128; //可以编译，但是会损失精度，就像上面的e变量一样。

5.浮点型数据类型（小数）：

—float单精度【4个字节】

—double 双精度【8个字节】

​ java语言当中，所有浮点型字面值，默认被当做double类型来处理。若想要字面值当做float类型来处理，需要在字面值后面添加f/F。

​ 注：double和float在计算机内部二进制存储的时候存储的都是近似值。在现实世界当中，是有些数字是无限循环的，例如1/3。在计算机资源是有限的，用有限的资源存储无线数据只能存储近似值。

public class DataTypeTest{
    public static void main(String[] args){
        //3.0是double类型的字面值，所以赋值给double的d不存在类型转换 
        double d = 3.0;
        System.out.println(d);
        
        //若是为float类型，就要考虑默认字面值以double来处理。
        float f = 5.1;//编译报错：这里的5.1是double类型，不能直接float。
        //想要修改有两种解决办法
        float f1 = (float) 5.1;//强制类型转换。
        float f2 = 5.1f;//将数据后面添加f/F把数据当做float来处理。不存在强制类型转换
        
    }
}

​ 相对来说double的精度比较低，所以不适合做财务软件，也就是涉及到钱的问题，要求精度较高。所以SUN在基础JAVASE类库中为程序员提供了更高的类型，不过这种类型是一种引用的数据类型，不属于基本数据类型。它是：java.math.BigDecimal

​

---

​ 注解：也就是说，Java程序中SUN提供了一套庞大的类库，JAVA程序员是基于这套基础类库进行开发的。所以JAVA的SE类库字节码和JAVA类库的源码在哪都要清楚。

​ *SE类库字节码：C:\Program Files\Java\jdk1.8.0_261\jre\lib\rt.jar

​ *SE类库源码：C:\Program Files\Java\jdk1.8.0_261\src.zip

​ 注：“C:\Program Files\Java\ ” 这一串是jdk安装的地址

​ 例如：String.java和String.class

​ 我们main方法汇总（String[] args)中的String使用的就是 String.class字节码文件

6.boolean类型（布尔类型）：true/false

​ *实际计算机存储时，false底层是0，true底层是1。

​ *一般使用在逻辑运算和条件控制语句当中。

public class DataTypeTest{
    public static void main(String[] args){
        boolean flag = 1; //编译错误：boolean在JAVA中只能是true或者是false。不是0或者1
        
        boolean loginSuccess = flase;
        //boolean loginSuccess = true;
        
        if(longinSuccess){   //if(true)则进入到if控制语句中
            System.out.println("登录成功"); //loginSuccess=true打印这条
            
        }else{   //else：如果没有进入到if中，则进入到else控制语句中
            
            System.out.println("登录失败");//loginSuccess=false打印这条
        }     
    }
}

7.关于基本类型之间互相转换—转换规则：

​ （1）八种基本数据类型当中除了布尔类型外剩下七种类型之间可以互相转换

​ （2）小容量向大容量转换为自动类型转换。容量从小到大排序：

​ byte < short (char) < int < long < float < double

​ 注：任何浮点类型不管占用多少字节，都比整数型容量大。

​ 且char和short可表示的种类数量相同，但是char可以取更大的正整数。

char a = 65;
char b = 97;
//char字符中有对应的ASCII编码表。65代表的是A，97代表的是a。
//具体数字代表哪个符号可自行查询。
System.out.println(a);  //打印结果为:A
System.out.println(b);  //打印结果为:a

​ （3）大容量转化为小容量需要强制类型转换，需要加强制类型转换。但会损失精度，谨慎使用。

​ （4）当整数型字面值没有超出byte,short,char的取值范围，可以直接赋值给byte,short,char类型的变量。

​ （5）byte,short,char混合运算的时候，各自先转换成int类型再做计算。

​ （6）多种数据类型混合运算，先转换为最大容量的数据类型再做计算。

int i = 10;
byte j = i/3; //编译报错，i是int类型，不能赋值给byte

byte j2 = (byte) i / 3; //编译报错，这个(byte)i表示将i转化为byte， 
                         //       后除以3会把i重新转化为int类型计算。运算结果依旧是int类型。
int j2_ = (byte) i /3;  //编译成功，作为j2的解释

byte j3 = (byte) (i/3);//编译成功，(i/3)表示先运算，在进行(byte)的强制类型转换

 short i = 10;
 byte j = 5;
 short k = i+j; //编译报错，short类型和byte类型会先转换成int类型再做计算，得出结果为int类型
 int k2 = i+j; //编译成功
 short k3 = (short) (i + j); //编译成功

char a = 'a';
System.out.println((byte)a); //输出结果为： 97

int m = a +100;
System.out.println(m); //输出结果为： 19

——本章节为个人学习笔记。学习视频为动力节点Java零基础教程视频：动力节点—JAVA零基础教程视频