标签：ons 有一个 默认 字符串类 利用 强制 正数 string 字符串
l 变量的概念：
变量名：合法的标识符
变量的数据类型：可以是基本类型和引用类型（必须包含类型）
存储单元：存储单元大小是由数据类型决定的，如：int 为4 个字节32 位
变量值：在存储单元中放的就是变量值（如果是基本类型放的就是具体值，如果是引用类型放的是内存地址，如果null，表示不指向任何对象）
l 定义变量的格式：数据类型 变量名 = 初始化值
l 变量是通过使用变量名来访问这块区域的
//int是一种数据类型，是整型。
int a; //在内存中开辟一块空间，这块空间的类型是整型，给这块空间起名叫a
//赋值
a = 100;
//通过变量名去访问那块内存。
System.out.println(a);
//重复访问
System.out.println(a);
l 使用变量注意：
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"); //这是一个字符串类型。
}
}
>引用类型默认值：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.4.1二进制：计算机底层都是用二进制来存储、运算。
2.4.2二进制与十进制之间的转换。
二进制转换为十进制：从右向左，2^0 + 2^1 +···+2^n
十进制转换为二进制：
2.4.3二进制在底层存储：正数、负数都是以补码的形式存储的。（原码、反码、补码）
正数：原码、反码、补码三码合一
负数：正数的原码符号位由0变1è负数的原码è负数原码除符号位按位取反è负数的反码è负数反码加1è负数的补码
2.4.4四种进制间的转换
①自动类型转换：容量小的数据类型自动转换为容量大的数据类型。
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<GBK<GB18030
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<short<int<long<float<double
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);
}
}
标签：ons 有一个 默认 字符串类 利用 强制 正数 string 字符串
原文地址：https://www.cnblogs.com/superjishere/p/11776207.html
