变量 java_Java变量

2.变量

l  变量的概念：

内存中的一个存储区域

该区域有自己的名称(变量名)和类型(数据类型)和值

Java中每个变量必须先声明，再赋值，然后才能使用

该区域的数据可以在同一类型范围内不断变化

Java 中的变量有四个基本属性：变量名，数据类型，存储单元和变量值

变量名：合法的标识符

变量的数据类型：可以是基本类型和引用类型(必须包含类型)

存储单元：存储单元大小是由数据类型决定的，如：int 为4 个字节32 位

变量值：在存储单元中放的就是变量值(如果是基本类型放的就是具体值，如果是引用类型放的是内存地址，如果null，表示不指向任何对象)

l  定义变量的格式：数据类型    变量名  =  初始化值

l  变量是通过使用变量名来访问这块区域的

//int是一种数据类型，是整型。

int a; //在内存中开辟一块空间，这块空间的类型是整型，给这块空间起名叫a

//赋值

a = 100;

//通过变量名去访问那块内存。

System.out.println(a);

//重复访问

System.out.println(a);

l  使用变量注意：

变量的作用域：一对{ }之间有效。出了大括号就不认识了。

初始化值

变量可以重复赋值，但不能重复声明，在同一个域中，变量名不能重复。

2.1 关于java中的字面值：

1.什么是字面值？

一眼看上去就知道是多少的数据，就是字面值

2.字面值本质：

字面值是有数据类型的：

整型 100

浮点型 3.14

布尔型 true/false

字符型 '中'

字符串型 "ABC"

在内存中占用空间。

字面值就是内存中的一块空间，这块空间有类型，有值。

只有字面值内存无法得到重复利用。

java语言中所有的字符都采用“单引号”括起来

java语言中所有的字符串都采用“双引号”括起来。

public class ConstTest01{

public static void main(String[] args){

System.out.println(10);   //整数型的字面值

System.out.println(3.14);         //浮点型的字面值

System.out.println(true);         //布尔型字面值

System.out.println(false);

System.out.println('a');   //字符字面值

System.out.println("Hello");   //字符串字面值

System.out.println(10); //新内存

//Error

//System.out.println('AB'); //AB本身不是一个字符，而是字符串.

System.out.println("A"); //这是一个字符串类型。

}

}

2.2 java中变量按照数据类型来分类：

>引用类型默认值：null

>8种基本数据类型：注意定义值时不能超过范围

整型：byte(8 bit)  short   int(默认类型)long：变量值的末尾要加“L”或“l”

eg：byte = 1，存储在计算机上为0000 0001。

浮点型：float：末尾要加上“F”或“f”、  double (默认类型)

字符型：char(用‘ ’括起来)只能表示一个字符(英文/中文/标点/转义字符等)，默认值是“\u0000”，要定义多个字符用string。

布尔类型： boolean(只能取值为true或false，不能取null)，默认值是false。

2.3 java中变量按照声明位置的不同来分类：

2.4进制(了解)：

2.4.1二进制：计算机底层都是用二进制来存储、运算。

2.4.2二进制与十进制之间的转换。

二进制转换为十进制：从右向左，2^0 + 2^1 +···+2^n

十进制转换为二进制：

2.4.3二进制在底层存储：正数、负数都是以补码的形式存储的。(原码、反码、补码)

正数：原码、反码、补码三码合一

负数：正数的原码符号位由0变1è负数的原码è负数原码除符号位按位取反è负数的反码è负数反码加1è负数的补码

2.4.4四种进制间的转换

2.5变量的运算：不考虑布尔Boolean类型

①自动类型转换：容量小的数据类型自动转换为容量大的数据类型。

short s = 12;     int i = s + 2;   char c1 = ’a’;//97  char c2 = ‘A’;//65

注意：byte、short、char之间做运算，结果为int型！èlong èfloatèdouble

②强制类型转换：是①的逆过程。使用“()”实现强转。

会导致精度的损失(高位截掉了)。Eg: long a1 = 12345L; int a2 = (int)a1;

----------------------------------------------------------------------------------------------------------------------

//字符串与基本数据类型之间的运算:只能是连接运算：+。得到的结果仍为一个字符串

String str = "abc";

String str1 = str + m1;//abc12345

System.out.println(str1);

----------------------------------------------------------------------------------------------------------------------

//题目：

String st1 = "hello";

int myInt1 = 12;

char ch1 = 'a';//97

System.out.println(str1 + myInt1 + ch1);//输出：hello12a

System.out.println(myInt1 + ch1 + str1);//输出：109hello

System.out.println(ch1 + str1 + myInt1);//输出：ahello12

-------------------------------------------------------------------------------------------------

======================================================================

补充

一、关于变量

1.java中如何定义变量，语法：

数据类型 变量名;

2.如何给变量赋值，语法：

变量名 = 值;

3.变量的本质是什么？

变量就是内存中的一块空间，这块空间有“类型”，“名字”，“值”

public class VarTest01{

public static void main(String[] args){

//int是一种数据类型，是整型。

int a; //在内存中开辟一块空间，这块空间的类型是整型，给这块空间起名叫a

//赋值

a = 100;

//通过变量名去访问那块内存。

System.out.println(a);

//重复访问

System.out.println(a);

System.out.println(a);

}

}

二、变量的声明

public class VarTest02{

public static void main(String[] args){

//申请一块int类型的空间，起名i，并赋值10

int i = 10;

System.out.println(i);

//重新赋值

i = 100;

System.out.println(i);

//变量可以重新赋值，但不能重复声明

//在同一个域中，变量名不能重复。

//int i = 200; //Error

//java语言中的变量必须先声明，再赋值，才能使用。

int a;

a = 10;

System.out.println(a);

//声明三个变量i1,i2,i3，类型都是int类型，i1,i2两个变量没有赋值，只有i3变量赋值。

int i1,i2,i3 = 456;

//Error

//System.out.println(i1); //i1没有赋值不能访问。

System.out.println(i3);

}

public static void m1(){

int i = 10; //不在同一个区域中可以声明。

}}

三、关于变量的作用域：有效范围。作用范围。

出了大括号就不认识了。

public class VarTest03{

//类体

//声明变量

int m = 100;

public void m1(){

int m = 200;

System.out.println(m); //200 (就近原则.)

}

public static void m(){

int k = 10;

}

public static void main(String[] args){

int i = 10;

System.out.println(i);

//Error

//无法访问m方法中的k变量.

//System.out.println(k);

//for循环

/*

for(int j=0;j<10;j++){

System.out.println(j);

}

//Error,j变量是属于for循环的。

System.out.println(j);

*/

//j的作用域在整个main方法中。

int j;

for(j=0;j<10;j++){

System.out.println(j);

}

System.out.println(j);}}

四、变量根据出现的位置可以分为两种：

1.局部变量,在方法体中声明的变量叫做局部变量。包括形式参数列表。

2.成员变量,在类体中，方法之外声明的变量统称成员变量。

public class VarTest04{

//成员变量

int i = 10;

//成员变量

int m;

public void m1(int m){ //m也是局部变量.

int k = 10; //局部变量

}

public void m2(){

System.out.println(m); //0

}

public static void main(String[] args){

VarTest04 vt = new VarTest04();

vt.m2();

}

}

五、关于整型类型：一个整数默认是int类型

byte        1byte(8bit)  -128~127

short              2byte

int          4byte

long        8byte

整数型有三种表示方式：

十进制

八进制  以0开始

十六进制  以0x开始

public class DataTypeTest01{

public static void main(String[] args){

//十进制

int i1 = 10; //常用.

//八进制

int i2 = 010;

//十六进制

int i3 = 0x10;

System.out.println(i1); //10

System.out.println(i2); //8

System.out.println(i3); //16

//将一个int类型100字面值赋值给i4变量。

int i4 = 100;

//将一个int类型的123字面值赋值给long类型的l1

//int类型容量小于long类型.

//以下程序存在类型转换.只不过叫“自动类型转换”

long l1 = 123;

//由于123后面有一个L，所以上来就会把123看做long类型。

//所以以下程序不存在类型转换，只是一个普通的赋值运算。

long l2 = 123L;

//可以(int类型-->long类型，自动类型转换)

long l3 = 2147483647;

//程序将2147483648看做int类型，但是这个数据本身已经超出了int的取值范围。

//long l4 = 2147483648;

long l4 = 2147483648L;

}

}

六、整型类型间转换

public class DataTypeTest02{

public static void main(String[] args){

long l1 = 1000L;

//将long类型转换成int类型，不能自动类型转换.

//int i1 = l1;

//需要强制类型转换

//需要加强制类型转换符

//以下的程序虽然编译通过了，但是程序在运行阶段可能损失精度，所以一定要谨慎使用。

int i1 = (int)l1; //大容量向小容量转换，需要强制类型转换.

//记忆一个规则：如果这个整数没有超出byte的取值范围，可以直接将这个整数赋值给byte类型.

byte b1 = 10;

byte b2 = 127;

//Error

//128本身已经超出了byte的取值范围。

//byte b3 = 128;

//如果整数本身没有超出short的取值范围，可以将这个整数直接赋值给short

short s1 = 32767;

//short s2 = 32768;

//最后结论：如果整数没有超出byte,short,char的取值范围，可以直接将这个整数赋值给byte,short,char

char c1 = 97;

char c2 = 65535;

//char c3 = 65536;

}

}

七、关于浮点类型：一个小数默认是double类型

float  4个字节

double 8个字节

public class DataTypeTest03{

public static void main(String[] args){

double d1 = 1.2;

//强制类型转换

//float f1 = 3.2;

float f1 = (float)3.2;

//自动赋值运算

float f2 = 3.2F;

}

}

八、关于char类型

char是字符类型，java中采用UNICODE编码。

底层占用两个字节。

char类型涉及到字符编码方式：

1.字符编码方式是现实世界中的文字和计算机的表示方式的转换规则。

ASCII

'a'   97

'A'    65

'0'    48

ISO-8859-1

GB2312

unicode UTF-8  UTF-16 UTF-32

2.字符如果采用的编码和解码不一致的话，会出现乱码。

public class CharTest01{

public static void main(String[] args){

char c1 = 'a';

//Error

//char c2 = 'ab';

//汉子占用2个字节，所以java中的char可以存储一个汉字。

char c3 = '中';

System.out.println(c1);

System.out.println(c3);

}

}

九、关于转义字符

public class CharTest02{

public static void main(String[] args){

/*

char c1 = 't';

System.out.print(c1);

System.out.println("abc");

*/

// 斜线在java语言中有转义功能，可以将普通t字符，转换成“制表符”

char c1 = '\t';

System.out.print(c1);

System.out.println("abc");

//这是一个普通的“单引号”字符

char c2 = '\'';

System.out.println(c2);

//这是一个普通的“斜线”字符

char c3 = '\\';

System.out.println(c3);

//这是一个普通的“双引号”字符

char c4 = '\"';

System.out.println(c4);

//这是一个普通的换行符。

char c5 = '\n';

System.out.print("abc");

System.out.print(c5);

System.out.print("def");

char c6 = '中';

char c7 = '\u4e2d'; //'中'对的unicode码是 4e2d

System.out.println(c6);

System.out.println(c7);

}

}

十、关于布尔类型

1.boolean类型的数据只有两个值：true/false,没有1和0。

2.boolean类型的数据主要用在逻辑运算和条件控制语句中。

public class DataTypeTest04{

public static void main(String[] args){

//Error:boolean只能是true/false

//boolean b1 = 1;

boolean sex = false;

if(sex){

System.out.println("男");

}else{

System.out.println("女");

}

}

}

十一、混合类型间运算

//byte,short,char做混合运算的时候先各自转换成int在做运算。

public class DataTypeTest05{

public static void main(String[] args){

byte b1 = 10;

short s1 = 20;

int i1 = b1 + s1;

System.out.println(i1); //30(int)

//java程序分编译期和运行期

//编译阶段只是知道b1+s1的结果是int类型。

//int类型无法直接赋值给byte类型.

//byte b2 = b1 + s1;

//可以.

byte b3 = 100;

}

}

十二、关于基本数据类型转换规则

1. 8种基本数据类型除boolean类型之外都可以相互转换.

2. 小容量向大容量转换叫做自动类型转换：

byte

char<

3. byte,short,char做混合运算的时候，各自都先转换成int在做运算

4.大容量向小容量转换是强制类型转换，需要加强制转换符，

编译虽然通过，运行期可能损失精度。谨慎使用。

5.如果整数没有超出byte,short,char的取值范围，可以直接将这个整数赋值给byte,short,char

6.多种数据类型做混合运算，先转换成容量最大的那种再做运算。

public class DataTypeTest06 {

public static void main(String[] args) {

//出现错误，1000超出了byte的范围

//byte a = 1000;

//正确，因为20没有超出byte范围

//所以赋值

byte a = 20;

//变量不能重名

//short a =  1000;

//正确，因为数值1000没有超出short类型的范围

//所以赋值正确

short b =  1000;

//正确，因为默认就是int，并且没有超出int范围

int c = 1000;

//正确，可以自动转换

long d = c;

//错误，出现精度丢失问题，大类型-->>小类型会出现问题

//int e = d;

//将long强制转换成int类型

//因为值1000，没有超出int范围，所以转换是正确的

int e = (int)d;

//因为java中的运算会会转成最大类型

//而10和3默认为int,所以运算后的最大类型也是int

//所以是正确的

int f = 10/3;

//声明10为long类型

long g = 10;

//出现错误，多个数值在运算过程中，会转换成容量最大的类型

//以下示例最大的类型为double，而h为int，所以就会出现大类型(long)到小类型(int)的转换，将会出现精度丢失问题

//int h = g/3;

//可以强制转换,因为运算结果没有超出int范围

//int h = (int)g/3;

//可以采用long类型来接收运算结果

//long h = g/3;

//出现精度损失问题，以下问题主要是优先级的问题

//将g转换成int，然后又将int类型的g转换成byte,最后byte类型的g和3运算，那么它的运算结果类型就是int，所以int赋值给byte就出现了精度损失问题

//byte h = (byte)(int)g/3;

//正确

//byte h = (byte)(int)(g/3);

//不能转换,还有因为优先级的问题

//byte h = (byte)g/3;

//可以转换，因为运算结果没有超出byte范围

//byte h = (byte)(g/3);

//可以转换，因为运算结果没有超出short范围

short h = (short)(g/3);

short i = 10;

byte j = 5;

//错误，short和byte运算，首先会转换成int再运算

//所以运算结果为int，int赋值给short就会出现精度丢失问题

//short k = i + j;

//可以将运算结果强制转换成short

//short k = (short)(i + j);

//因为运算结果为int，所以可以采用int类型接收

int k  = i + j;

char l = 'a';

System.out.println(l);

//输出结果为97，也就是a的ascii值

System.out.println((byte)l);

int m = l + 100;

//输出结构为197,取得a的ascii码值，让后与100进行相加运算

System.out.println(m);

}

}