java字符类型定义_java定义的数据类型与转义字符

Java定义的数据类型

一、变量按照数据类型来分：

基本数据类型：

整型：byte \  short \  int  \long

浮点型：float  \  double

字符型：char

布尔型：boolean

引用数据类型：

类：class   (字符串)

接口：interface

数组：array

二、按照变量在类中声明的位置来分：

成员变量 vs 局部变量(此处省略，之后在面向对象会提到)

基本数据类型变量的使用

1.整数类型:byte、short、int、long

整型默认是int类型，声明long型常量后需要加上"l"或"L"

整数类型介绍:

(1)字节型：byte，占用存储空间为1字节=8bit位，有2的8次方一共256种情况，-128~127，一共256个长度(算上0).

代码：

classVariableTest1{

public static voidmain(String[] args){

//1.整型，byte(1字节=8bit)\short(2字节)\int(4字节)\long(8字节)

//(1)byte范围：-128~127

byte b1 = 12;

byte b2 = -128;

System.out.println(b1);

System.out.println(b2);

}

}

编译与运行:

若b2=128，再编译：128超出1字节范围

(2)short,占用存储空间为2字节=16bit位，有2的16次方种情况，-(2的15次方)~2的15次方-1，一共2的16次方个长度(算上0).

(3)int,占用存储空间为4字节=32bit位，有2的32次方种情况，-(2的31次方)~2的31次方-1，一共2的16次方个长度(算上0).

(2)long,占用存储空间为8字节=64bit位，有2的64次方种情况，-(2的63次方)~2的63次方-1，一共2的16次方个长度(算上0).

总代码：

class VariableTest1{

public static void main(String[] args){

//1.整型，byte(1字节=8bit)\short(2字节)\int(4字节)——常用\long(8字节)

//(1)byte范围：-128~127

byte b1 = 12;

byte b2 = -128;

//byte b2 = 128;//编译不通过

System.out.println(b1);

System.out.println(b2);

//(2)声明long型变量需要加上"l"或"L"

//(3)通常使用整型变量时，常用int型

short s1 = 128;

int i1 = 1234;

long l1 = 343L;

System.out.println(l1);

}

}

编译运行：

2.浮点型变量的使用(float \ double)—带小数点的

浮点型常用的两种表示形式：

十进制数形式：如：5.12 512.0f .512(必须有小数点)

科学计数法形式：如：5.12e2  512E2 100E-2(这里，e和E是一样的)

512E2等价于512*10^2

e2相当于小数点向右移动了2位，E-2相当于小数点向左移动了2位。

Java的浮点型常量默认为double型，声明float变量，须后加‘f’或‘F‘。

float：占4个字节，单精度，尾数精度可以达到7位有效数字；double占8个字节，双精度，精度比较高，是float的2倍。

3.字符型变量的使用

char:字节2位，取值范围0~65535，字符编码为Unicode字符集(万国码)

Unicode字符集支持ASCII编码(美国校准信息交换码)

Unicode中每个字符都对应一个十进制整数，从而可以使用多种方式赋值。

字符赋值：(至少得记住3个字符编码) 'A'-65  'a'-97  '0'-48

(1)字符赋值char   c1='A';  计算机只识别0和1  (A对应的是65)

(2)整数赋值char c2=65; c1=c2

大写字母转小写    大写+32=小写

(3)进制赋值：char c3='\u0041';通过十六进制数41在字符集中所对应的的字符赋值。

4.转义字符：

(1)为了在程序中输出单引号，需要用到转义字符。

class CharTest{

public static void main(String[] args){

char c='\''

System.out.println(c);

}

}

编译运行：

(2)转义字符

5.布尔型

boolean:字长没有约定，取值范围只能是true或false，可描述真或假。

内存地址是分配到字节的，不是分配到字节的每一位的。

注意：Java中的Boolean类型不能参与算数运算。

基本数据类型变量间转换

引用数据类型(对象类型)

6.String：字符串(“”)，字符编码为Unicode字符序列。

String类型变量的使用(引用数据类型-String)：

代码：

/*

String类型变量的使用

1.String属于引用数据类型

2.声明String类型变量时，使用一对""，单引号会报错

3.String可以和8种基本数据类型做运算(包括布尔型的类型)

*/

class StringTest{

public static void main(String[] args){

String s1 = "Hello World";

System.out.println(s1);

String s2 = "a";

String s3 = "";

//char c = '';//编译不通过，字符里不能为空

//*****************************************

int number = 1001;

String numberStr = "学号:";

String info = numberStr + number;

boolean b1 = true;

String info1 = info + b1;//+ 连接

System.out.println(info1);

//是加法还是连接？

//练习1

char c = 'a';// c=97

int num = 10;

String str= "hello";

System.out.println(c+num+str);//107hello

System.out.println(c+str+num);//ahello10

System.out.println(c+(str+num));//ahello10

System.out.println((c+num)+str);//107hello

System.out.println(str+num+c);//hello10a

//练习2

System.out.println("* *");

System.out.println('*' +'\t'+ '*');//error int + int

System.out.println('*' +"\t"+ '*');//String +做连接

System.out.println('*' +'\t'+ "*");//error int +做连接

System.out.println('*' +('\t'+ "*"));

//*******************************************

//String str1 = 123;

String str1 = 123 + "";

System.out.println(str1);

//int num1 = str1;

//int num1 = (int)str1;//error

int num1 = Integer.parseInt(str1);

System.out.println(num1);

}

}

编译运行：

变量类型转换：

变量类型转换分为自动类型提升和强制变量转换。

1.自动类型提升：

代码：

/*

基本数据类型之间的运算规则：

前提：不包含boolean类型

1.自动类型提升

当容量小的数据类型与容量小的数据类型的变量做运算时，结果自动提升为容量大的数据类型。

byte-->short-->int-->long-->float-->double

特别的：当byte、char、short做运算，结果数据类型均为int类型。

byte、char、short-->int-->long-->float-->double

说明：此时的容量大小只的是数据范围的大小，不是占内存的大小

2.强制类型转换

*/

class AutoConvertTest{

public static void main(String[] args){

byte b1 = 2;//1个字节

int i1 = 129;//4个字节

int i2 = b1 + i1;//小的加大的用值范围大的接收

long l1 = b1 + i1;//右边是int，4字节(左边8字节)

float f = b1 + i1;//float 4个字节

//byte b2 = b1 + i1;//4个字节接收 int

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

System.out.println(l1);//131

System.out.println(f);//131.0

//**************************

//char:字节2位，取值范围0~65535

char c1 = 'a';

int i3 = 10;

int i4 = c1 + i3;

System.out.print(i4);//char与int-->int

short s2 = 10;

//short c2 = c1 + s2;//不兼容，编译不通过

byte b2 = 10;

//byte c3 = c1 + b2;//不兼容，编译不通过

//char c3 = c1 + b2;//不兼容，编译不通过

}

}

编译运行：

2.强制变量转换

一般情况代码：

classForceConvertTest{

public static voidmain(String[] args){

double d1 = 12.9;

int i1 = (int)d1;//强制转换 截断操作

System.out.println(i1);

//没有精度损失

long l1 = 123;

short s2 = (short)l1;

System.out.println(s2);

int i2=128;

byte b= (byte)i2; 127

System.out.println(b);//-128 原因：二进制转换 10000000,最高位为1，1代表负。之后在进制转换会提到。

}

}

编译运行：

两个特殊情况代码：

class ForceConvertTest{

public static void main(String[] args){

//1.编码情况

long l=123213;//没写l,int型

System.out.println(l);//没写l,没有报错(小范围->大范围-自动提升)

//long l1=213324232352423413;//超出int范围，运行提示过大的整数

//编译失败

//错误：不兼容的类型：从double转换到float可能会有损失

//float f1 = 12.3;

//System.out.println(f1);

//2.编码情况

//整型常量，默认为int型

//浮点型常量，默认为double型

byte b = 12;

//byte b1 = b + 1;//从int转换成byte可能会有损失

float f1 = b + 12.3;//不兼容(从double到float)

}

}