3.JAVASE 变量

3.JAVASE 变量

---

一 、字面值常量&进制

在日常生活中，经常使用数据表示事物的某些特性。比如：年龄，身高，日期等等，这些数据都是具体的数值。那么在Java中像这样的数据如何描述呢？像这样数值确定的数据，Java中用常量来描述。

---

1、字面值常量

字面值常量定义：程序中固定不变化的值。比如：整数1,2,3，小数3.14,布尔值false,true等。

字面值常量分类：

1. 整数常量：所有整数 三类 正整数 零 负整数。
2. 小数常量：所有小数。
3. 布尔(boolean)型常量：较为特有，只有两个数值。true false。
4. 字符常量：将一个数字字母或者符号用单引号( ’ ’ )标识。‘中’ ‘国’。
5. 字符串常量：将一个或者多个字符用双引号(“ ”)标识。“中国”。
6. null常量：只有一个数值就是:null。

JAVA语言的字面值常量 都存放在 常量池里。

---

2、进制

任何数据在计算机中都是以二进制的形式存在的。二进制早起由电信号开关演变而来。用开表示某一个数，用关表示某一个数，然后使用不同的开和关组合起来，就可以表示数据了。一个整数在内存中一样也是二进制的。

• 二进制：每一个二进制数位用0，1 ；满2进1。
• 八进制：每一个八进制数位用0，1，2，3，4，5，6，7 ；满8进1。用0开头表示。
• 十进制：每一个十进制数位用0，1，2，3，4，5，6，7 ，8，9 ；满10进1。 满10进1。
• 十六进制：每一个十六进制数位用0，1，2，3，4，5，6，7 ，8，9，A，B，C，D，E，F ； 满16进1，用0x开头表示。

---

2.1、进制转换

计算机中存储的都是二进制数据，就需要用一些办法转化二进制与其它进制。（计算机帮我们完成这个）

十进制转化为二进制
十进制转化为二进制------->除以2倒取余数

把一个十进制数转成二进制数，使用短除法，不停的除以2，直到商值为0，停止，然后倒着把余数写出来，这个数就是十进制数转后的二进制数。

二进制转十进制数

二进制转成十进制------------>按2的幂数展开并累加

对于一个二进制数，从最右侧开始，使用当前二进制数位上的数据乘以2的n-1次幂(n为当前这个二进制数从右侧开始的第几位。)，并这将这些数据展开后加起来求和即可得到相应的十进制数。

---

2.2、进制规律

---

二进制数据的形式表示所有数据，并且在计算机中把8个二进制数位当做一组，并“字节”来表示。即：8bit = 1Byte,最大值是：0-255之间的任何一个正数都可以在用一个字节表示。

凑数法：上图中的128、64、32、16、8、4、2、1这些数据加起来。当有某一个数时，就说明这个二进制数位上一定存放的是1，若没有这个数，就说明这个二进制数位上一定存放的是0。

2.3、其他进制转换

---

二进制数按照每三个二进制数位为一组划分，发现这三个二进制数位数字能表示大的最大值正好为7，正好符合了八进制的表示形式。于是可以把二进制数用八进制的形式表示。

2.3.1、二进制转八进制

上图是十进制29的二进制表示形式。要把这个数转成八进制，需要从最右侧开始，把每三个二进制数位当成一个整体，转成一个八进制数位。当二进制数位高位不足三位时，用0填补。

2.3.2、二进制转十六进制

---

类似于八进制，但是每四位为一组，高位不足补0。

2.4负数的表示形式

---

说明：取反的意思是将当前二进制数位上的1变0，0变1。

//2转10
    public static void main(String args[]) {
        Scanner input = new Scanner(System.in);
        System.out.print("输入一个二进制数 ");
        int binaryNumber = input.nextInt();//二进制数
        int decimal = 0;// 十进制数字
        int p = 0;// 位数
        while (true) {
            if (binaryNumber == 0) {
                break;
            } else {
                int temp = binaryNumber % 10;
                decimal += temp * Math.pow(2, p);
                binaryNumber = binaryNumber / 10;
                p++;
            }
        }
        System.out.println("十进制数为:"+decimal);
    }

//10转2
public static void main(String[] args) {
	Scanner input = new Scanner(System.in);
    System.out.print("输入一个十进制数 ");
    int n = input.nextInt();
    String str = "";
    while (n != 0) {
    	str = n % 2 + str;
        n = n / 2;
    }
    System.out.println(str);
}

二、Java的变量

---

1、java变量的概念

---

变量表示内存中的一个存储区域，该区域用来不断的存放同一类型的常量数据，并可以重复使用这个区域。并且这个区域有自己的名称（变量名）和类型（数据类型）。可以理解：变量就如同数学中的未知数。

运行中可能会被改变的值。

2、定义变量格式

---

数据类型 变量名 = 初始化值； = 是赋值符号。

注：格式是固定的，记住格式，以不变应万变。

int res = (12*24);
// 开辟一片名叫 res区域，存放int类型的数据。将12*24的值赋值给res区域，作为初始值。
int res3;
// 开辟一片名叫 res3区域，存放int类型的数据。
//如果一个变量 没有赋值，是无法直接使用的。

3.变量命名

---

变量表示内存中的一个存储区域，这时必须给这个区域起个名字 ，才能使用。当在给变量起名时，同样需要见名知义。同标识符。

例如：String name ；使用name表示这个空间名字，即说明这个空间存放的姓名。

4.变量注意事项

---

变量在使用时，必须先给变量空间存放数据，即初始化。同时变量也有自己的生命周期（作用域问题）。

常量池的值有就直接用，没有就创建，注意常量池基础数据很多，开发时不考虑它的大小和多少，以及内存优化问题。

三、Java数据类型

---

在生活中，使用的数据有大有小，有整数，也有小数，同时也会使用字母，或者汉字表示特定含义。在Java中根据数据的不同特点，数据也分为不同的类型。

Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间。

整数默认：int 小数默认：double

1.布尔类型boolean

---

boolean类型通常用于逻辑运算和程序流程控制。

boolean 类型数据只允许取值true或 false(不可以使用0 或非0的整数来代替true和false,区分于C语言)。

boolean flag;
flag = true;
System.out.println("flag"+ flag);

2.char类型

---

char用来存储通常意义上的字符，char占两个字节；范围是==[0,65535],前256 (2^16)==个表示 特殊字符 ，通常用单引号包裹''。

例如：char c = ‘A’; char c2 = ‘传’; char c3=97;

java字符采用Unicode编码，可用十六进制编码形式表示。 char c1 = ‘\u0061’;//a

3.转义字符

---

有些符号在Java语言中有独特意义，当需要使用原本意义的时候需要，转义表示。例如：键盘上的制表符tab键。可以使用 ‘\t’表示。如双引号，在Java中使用双引号表示字符串，若想使用双引号本身含义，即可使用’\”’表示。

4.字符编码表

字符编码表（ASCII）：一张存放所有字符与整数的对应关系的表。整数可以通过这样的形式存储了。（计算机只识别二进制）。

例如：‘A’-----> 65

‘B’----->66

‘a’------>97

‘b’------>98

…

所以当把一个整形赋值给char的时候，计算机会查询整数对应的字符，将这个字符存在char空间里。例如：char ch = 65；其实是将A存放在ch中。

5.String类型

---

String不属于基本数据类型;但和字符有一定的联系。String是一个类（java语言里的最小单元），表示字符串；就是一串字符，字符串用""包裹起来，连接字符用+。

String str1 = "这是一个字符串";
String str2 = "这是一个字符串";
String str3 = new String("这是一个字符串");
String str4 = new String("这是一个字符串");

String的equals方法源码分析

public boolean equals(Object anObject) {
	if (this == anObject) {// 地址
    	return true;// 地址一样本身就是一个东西
    }
    if (anObject instanceof String) {// 类型是否一致
		String anotherString = (String)anObject;// 强制转化
        int n = value.length;// 当前对象子串的长度
        if (n == anotherString.value.length) {// 目标子串的长度
        	char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {// 循环比较字符串的每一位
            	if (v1[i] != v2[i])
                	return false;// 不一样就返回false
            	i++;
            }
                return true;// 每一位都一样 返回true
        }
	}
	return false;// 类型不同也是错的
}

6.整数类型

整型数据根据数据范围不同，需要使用不同的关键字来表示。

byte、short、int、long这四个关键字都可以在内存中开辟出存放整型数据的空间。

byte开辟1个字节的空间，short开辟2个字节空间，int开辟4个字节空间，long开辟8个字节空间。

整数类型	最小值	最大值
Byte	-2^7=-128	2^7-1=127
Short	-2^15=-32768	2^15-1=32767
Integer	-2^31=-2147483648 (Integer.MIN_VALUE)	2^31=2147483647(Integer.MAX_VALUE)
Long	-2^63=-9223372036854775808	2^63-1=9223372036854775807

byte b = 2; // 会自动把2（int）转为byte类型存放在b空间。
short s = 3;
int i = 4;
long l = 5L; //当把一个值赋给long型空间时，需要在数值后面加L或l标注其为long类型。

JAVA语言整形的四种表现形式

二进制整数，0b或0B开头，如：int a = 0B110;（不要超过范围）

十进制整数，如：int a = 17;

八进制整数，要求以0开头，如 int a = 012;

十六进制整数，要求0X或0x开头，如int a = 0x12;

Java语言的整型常量默认是int型，声明long型变量后加上‘l’或‘L’

浮点类型(float、double)

double和float关键字在内存中开辟的空间可以存放小数。double开辟8个字节的空间，float开辟4个字节的空间;

Java浮点类型常量有两种表示方式：

• 十进制形式： 例如：3.14 ，168.0， .618
• 科学计数法形式： 例如：3.14e2， 3.14E2， 1000E-2

Java浮点型常量默认是double，则要声明一个常量为float型，则需在常量后加上f 或 F,

如：double pi = 3.14;//正确

float pi = 3.14F;//必须加上f，或转型 float pi3 = (float)3.14;

注意：Java里只有浮点型的变量才可以接受科学计算式结果：

int num = 314E2; //错误；num为int类型，不可以使用科学计数法。

java数据存储区域简述

1. 寄存器：最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制.
2. 栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中(对象可能在常量池里)（字符串常量对象存放在常量池中。）
3. 堆：存放所有new出来的对象。
4. 静态域：存放静态成员（static定义的）
5. 常量池：存放字符串常量和基本类型常量（public static final）
6. 非RAM存储：硬盘等永久存储空间

栈，堆和常量池，对于栈和常量池中的对象可以共享，对于堆中的对象不可以共享。栈中的数据大小和生命周期是可以确定的，当没有引用指向数据时，这个数据就会消失。堆中的对象的由垃圾回收器负责回收，因此大小和生命周期不需要确定，具有很大的灵活性。

对于字符串：其对象的引用都是存储在栈中的，如果是编译期已经创建好(直接用双引号定义的)的就存储在常量池中，如果是运行期（new出来的）才能确定的就存储在堆中。对于equals相等的字符串，在常量池中永远只有一份，在堆中有多份。

垃圾回收站（GC）：会检查托管堆中是否有应用程序不再使用的任何对象。如果有，他们的内存就可以回收。

1.垃圾回收器开始执行时，垃圾回收器沿着线程栈上行以检查所有根（然后遍历所有类型对象上的所有根），如果发现一个根引用了一个对象，就在对象的“同步块索引字段”上开启一个位（对象就是这样标记的），如果对象里又引用有其他对象，则会遍历所有对象以标识。检查好所有根之后，堆中将包含一组已标记和未标记的对象。

2.垃圾回收器线性遍历堆，以寻找未标记对象的连续内存。如果发现的内存块比较小，垃圾回收器会忽略它们。但是，如果发现大的、可用的连续内存块，“垃圾回收器会把非垃圾的对象移动到这里以压缩堆”。 最后记得重新分配地址存根

String s1 = "china";
String s2 = "china";
String s3 = "china";
String ss1 = new String("china");
String ss2 = new String("china");
String ss3 = new String("china");

黄色这3个箭头，对于通过new产生一个字符串（假设为”china”）时，会先去常量池中查找是否已经有了”china”对象，如果没有则在常量池中创建一个此字符串对象，然后堆中再创建一个常量池中此”china”对象的拷贝对象。这也就是有道面试题：String s = new String(“xyz”);产生几个对象？一个或两个，如果常量池中原来没有”xyz”,就是两个。*

同时，对于基础的变量和常量：变量和引用存储在栈中，常量存储在常量池中。

int i1 = 9;
int i2 = 9;
int i3 = 9;	
public static final int INT1 = 9;
public static final int INT2 = 9;
public static final int INT3 = 9;

四、数据类型转换

---

1、隐式类型转换

---

当在存储整数数据时，Java中所有的 整数默认 都是int类型的。所以在将**-128~127之间的数据存储在byte**类型空间中时，JVM会把这个int类型的数据自动转换成byte类型，然后存放在byte空间中。short同理。

// 类型转化
byte b = 2;// 隐式转化 int类型的2转化为byte类型 放在b中
short s = 34;// 同上
char ch1 = 65;// 隐式转化 int类型的65转化为char类型 放在ch1中
char ch2 = 'A';//
// 当数据超过需要隐式转化的类型时，会发生错误。
// char ch = 65536;X
// byte b2 = 128;X
// short s2 = 65536;X
// 基本数据类型转化的范围：byte,short,char--int--long--float--double
int i = 123;
long l = 6777;
l = i;
float f = 4.14F;
double d = f;
byte b = 2; //会自动把int类型2转为byte类型存放在b空间
short s = 234; //也会把int类型234转为short类型存放在s空间
// 当把一个int类型的数据存放在char类型空间中时，也会发生隐式类型转换.
char ch = 65; //这里会用int类型65，到编码表中查找对应的字符，然后将字符存放在ch空间中
char ch2 = 'A';//直接将A字符存放在ch2空间中

注意：当把超过byte和short范围的数据给他们开辟空间存放会发生编译时错误。同样把无法在编码表中查到对应字符的数据存放到char空间也会报错。

整型，字符型，浮点型的数据在混合运算中相互转换，转换时遵循以下原则：
容量小的类型可自动转换为容量大的数据类型（类型自动提升）；byte,short,char → int → long → float → double

byte，short，char之间不会相互转换，他们在计算时首先会转换为int类型。

int i = 123;
long l = i;	
float f = 3.14F;
double d = f;

2、强制类型转换

---

容量大的数据类型转换为容量小的数据类型时，要加上强制转换符，但可能造成精度的降低或溢出，使用时要格外注意。
强制转换格式：(数据类型)(被转数据);

long l = 123L;
int i = (int) l;
double d = 3.14;
float f = (float) d;

class Demo 
{
	public static void main(String[] args) 
	{
		//隐式转换
		byte b = 3;
		int x = 4;
		x = x + b;// b会自动提升为int类型进行运算。
		//强制转换
		byte b = 3;
		b = b + 4;//报错
		b = (byte)(b+4);//强制类型转换，强制将b+4的结果转换为byte类型，再赋值给b。
	}
}

思考下面代码的错误：

class Demo 
{
	public static void main(String[] args) 
	{
		byte b1 = 3,b2 = 4,b;
		b = b1 + b2;// 因为java虚拟机在运算时会自动将b1和b2转换成int类型相加，所得的值是一个int类型的值，所以需要强转
		b = 3 + 4;// byte类型的取值范围是-128到127，两个值相加编译器能够知道结果是多少，直接赋值没有问题，如果换成b=b1+4，就会报错，因为编译器不知道b1的值，他只知道b1是一个byte类型的变量，一个byte变量和一个int类型相加，会自动转换成int类型，常量优先原理，会自动根据结果转换。
	}
}