Java基础_变量
第三章 变量
3.1 认识变量
变量本质上就是代表一个”可操作的存储空间”,空间位置是确定的,但是里面放置什么值不确定。我们可通过变量名来访问“对应的存储空间”,从而操纵这个“存储空间”存储的值。 变量作为程序中最基本的存储单元,其要素包括变量名,变量类型和作用域。变量在使用前必须对其声明, 只有在变量声明以后,才能为其分配相应长度的存储空间。
3.1.1 什么是变量
-
变量是程序的基本组成单位
-
变量是由 数据类型+变量名+值 组成的
-
变量的基本原理:
在计算机中的内存 数据类型会声明出 一个空间,然后赋值进去,最后通过变量名(即在内存中的一个地址),查询或者更改。
/*
* 变量是程序的基本组成单位
* 不论是使用哪种高级程序语言编写,变量都是其程序的基本组成单位
*
* 变量有三个基本要素:
* 类型 名称 值
*/
public class Variable{
//编写一个main方法
public static void main(String[] args){
//定义了一个变量,类型是 int (整型)。名称为:a,值为:1
int a = 1 ;
//定义了一个变量,类型是 int (整型)。名称为:b,值为:3
int b = 3 ;
//在控制台输出 a 和 b 变量的值
System.out.println(a);
System.out.println(b);
//给 变量b 重新赋值
b = 5 ;
//在控制台输出 b 变量的值
System.out.println(b);
}
}
3.1.3 变量的类型
变量用于操作系统中,实体之间的传递,把变量看作一个在内存空间中声明的存储位置,在调用变量的时候,系统会自动的调用内存中的存储位置。
在Java中,变量又称为字段,故字段在Java中又有分类。
基本数据类型:
-
整型:
byte(-128~127) \ short(2字节) \ int(4字节)\long(8字节)
int - 存储整数(整数),不带小数,例如 123 或 -123
long - 类型数据必须以l或者L结尾(整型数据默认是int类型)
-
浮点型:
float(4字节)\double(8字节)
double - 存储带小数的浮点数,例如 19.99 或 -19.99
float - 类型数据要加F或者f结尾(默认浮点数类型是double)
-
字符型:
char[2]- 存储单个字符,例如 ‘a’ 或 ‘B’。Char 值用单引号括起来
-
布尔型:
boolean[1] - 存储具有两种状态的值:真或假
引用数据类型:
-
类(class)- 字符串类型属于类类型的数据。
String- 存储文本,例如“hello”。字符串值用双引号括起来
-
接口(interface)
-
数组(array)
3.2 变量的介绍
3.2.1 变量的概念
变量相当于内存中一个数据存储空间的表示,可以通过变量名可以访问到变量(值)。在现实生活中,变量相当于一个房间,房间可以通过房间号来找到。
3.2.2 变量使用的基本步骤
- 声明变量
//初始化声明一个变量
int var01;
- 赋值
//把 100 赋值给 var01
var01 = 100;
- 打印变量
//在控制台打印 var01
System.out.println(var01);
-
往往可以一步 声明变量的同时完成初始化赋值
//声明变量 var02 并把 100 赋给它
int var02 = 100;
//在控制台打印 var02
System.out.println(var02);
3.3 变量快速入门
变量使用入门案
/*
* 变量使用入门案例
* 1、在控制台打印个人信息
* 2、个人信息包括-名称 性别 年龄 成绩
*/
public class Variable01{
//编写一个main方法
public static void main(String[] args){
//个人名称
String name = "小原同学";
//性别
char gender = '男';
//年龄
int age = 21;
//成绩
double score = 99.99;
//在控制台打印个人信息
System.out.println("个人基本信息如下:");
System.out.println("名称为:"+ name);
System.out.println("性别为:"+ gender);
System.out.println("年龄为:"+ age);
System.out.println("成绩为:"+ score);
}
}
3.4 变量使用注意事项
- 变量表示内存中的一个存储区域
- 不同的变量,不同的类型,占用的空间大小不同。
-
变量必须先声明,后使用。程序是有序执行。
-
变量 = 数据类型 + 数据名 + 值
-
变量在同一个作用域内,名称不能相同
-
该区域的 数据 可以在 同一类型 范围内 任意变化
// 变量使用注意事项
public class VarDetail{
//编写一个main方法
public static void main(String[] args){
//1、变量 = 数据类型 + 数据名 + 值
//2、变量必须先声明,后使用。
int firstInt = 99;
//在控制台打印 int类型的firstInt
System.out.println(firstInt);
//3、该区域的数据可以在 同一类型 范围内任意变化
// firstInt = '变'; × 不能类型变化会出错
firstInt = 999;
//在控制台打印 int类型的firstInt
System.out.println(firstInt);
//4、变量在同一个作用域内,名称不能相同
// int firstInt = 88; (×)
}
}
class CommonVar{
public static void main(String[] args){
int firstInt = 88;
//在控制台打印 int类型的firstInt
System.out.println(firstInt);
}
}
3.5 程序中 +号的使用
-
当左右两边都是数值类型时,则做加法运算
-
当左右两边有一方为字符串类型时,则做拼接运算
-
程序的运算顺序,是从左到右,从上到下的
// 程序中 +号的使用
// 1、当左右两边都是数值类型时,则做加法运算
// 2、当左右两边有一方为字符串类型时,则做拼接运算
// 3、程序的运算顺序,是从左到右,从上到下的
public class SystemPlus{
//编写一个main方法
public static void main(String[] args){
//在控制台打印
System.out.println(900+99); //999
System.out.println(900+99+"9"); //9999
System.out.println("9"+900+99); //990099
}
}
3.6 数据类型详细
- java 数据类型分为两大类 基本数据类型, 引用类型
- 基本数据类型有 8 中 数值型 [byte , short , int , long , float ,double] char , boolean
- 引用类型 [类,接口, 数组]
![](file:///C:/Users/Yuan/AppData/Roaming/marktext/images/2022-07-31-16-54-59-image.png?msec=1661307037124)
3.6.1 整数类型
类型 | 占用存储空间 | 表数范围 |
---|---|---|
byte [字节] | 1字节 | -27 ~ 27-1(-128~127) |
short [短整型] | 2字节 | -215 ~ 215-1 (-32768~32767) |
int [整型] | 4字节 | -231 ~ 231-1 (-2147483648~2147483647) 约21亿 |
long [长整型] | 8字节 | -263 ~ 263-1 |
整型的使用细节:
- Java各整数类型有固定的范围和字段长度,不受具体 OS[操作系统] 的影响,以
保证java程序的可移植性。 - Java的整型常量(具体值)默认为int型,声明long型常量须后加T'或L'
- java程序中变量常声明为int型, 除非不足以表示大数,才使用long
- bit: 计算机中的最小存储单位。byte:计算机中基本存储单元,1byte = 8 bit。
通过二进制存储入系统:
![](file://C:\Users\Yuan\AppData\Roaming\marktext\images\2022-07-31-18-40-22-image.png?msec=1661307037083)
代码实现:
//整型的使用细节
public class IntDetail{
//编写一个main方法
public static void main(String[] args){
//Java 的整型常量(具体值)默认为 int 型,声明 long 型常量须后加‘l’或‘L’
// long 类型不能转换 int 类型
// int num2 = 1L;
int num1 = 1;//4 个字节
// int 类型可以转换 long 类型
long num3 = 1L;//8 个字节
long num4 = 2;
//在控制台打印
System.out.println(num1);
// System.out.println(num2);
System.out.println(num3);
System.out.println(num4);
}
}
3.6.2 浮点类型
Java 的浮点类型可以表示一个小数,比如 123.4,7.8 ,0.12 等等。
浮点型的分类:
类型 | 占用存储空间 | 范围 |
---|---|---|
float 单精度 | 4字节 | -3.403E38 ~ 3.403E38 |
double 双精度 | 8字节 | -1.798E308 ~ 1.798E308 |
面试细节:
- 关于浮点数在机器中存放形式的简单说明,浮点数=符号位+指数位+尾数位
- 尾数部分可能丢失,造成精度损失(小数都是近似值)。
浮点类型的使用细节:
-
与整数类型类似,Java浮点类型也有固定的范围和字段长度,不受具体OS的
影响。[float 4个字节 double是8个字节] -
Java 的浮点型常量默认为double型,声明float型常量, 须后加 'f' 或 'F'
-
浮点型常量有两种表示形式:
十进制数形式: 5.12
512.0f
.512 (必须有小数点)
科学计数法形式: 5.12e2
[5.12*10的2次方]
5.12E-2
[5.12/10的2次方]
- 通常情况下,应该使用double型,因为它比float型更精确。 [举例说明]
double d1 = 3.1415926535 ; (更精确)
float f1 = 3.1415926535F ;(丢失部分精度)
- 浮点数使用出现的问题:2.7 和 8.1/3 比较
double num01 = 2.7;
double num02 = 8.1 / 3 ;
if(Math.abc(num01 - num02) < 0.00001 ){
System.out.println("这俩值基本相同了!");
}
代码实现:
//浮点数细节及使用细节
public class FloatDetail{
//编写一个main方法
public static void main(String[] args){
//浮点型常量 默认为 double 类型,声明为float类型常量,需要在后面加 'f' 或 'F'
double db01 = 3.1415926; //8 个字节
float ft01 = 2.713156F; //4 个字节
// double 类型不能转换 float 类型
// float db02 = 3.14;
// float 类型可以转换 double 类型
double db02 = 3.1415926F; //8 个字节
double db03 = 2.713156; //8 个字节
System.out.println("第一次数据为");
System.out.println(db01);
System.out.println(ft01);
System.out.println(db02);
System.out.println(db03);
//十进制数形式:如:5.12 512.0f .512 (必须有小数点)
double db04 = .512;
double db05 = 0.512;
double db06 = 512.0f;
System.out.println("第二次数据为");
System.out.println(db04);
System.out.println(db05);
System.out.println(db06);
System.out.println(db04 == db05); //判断 db04 和 db05 是否相同
//科学计数法形式:如:9.99e2 =》[9.99 * 10^2] 999E-2 =》[999 / 10^2]
double db07 = 9.99e2;
double db08 = 9.99E2;
double db09 = 999E-2;
double db10 = 999e-2;
System.out.println("第三次数据为");
System.out.println(db07);
System.out.println(db08);
System.out.println(db09);
System.out.println(db10);
System.out.println(db07 == db08); //判断 db07 和 db08 是否相同
System.out.println(db09 == db10); //判断 db09 和 db10 是否相同
//通用情况,应该使用 double 型,因为它比 float 型更精确
//位数多的话会出现精度丢失
double db11 = 0.12345678901;
float ft02 = 0.12345678901F;
System.out.println(db11);
System.out.println(ft02);
//浮点数使用出现的问题:2.7 和 8.1/3 比较
double db12 = 2.7 ;
double db13 = 8.1/3 ;
double db14 = 2.7 ;
System.out.println("----------------------------------");
System.out.println(db12); // 2.7
System.out.println(db13); //接近 2.7的一个小数。
//对比两个小数时 要对数据进行处理 然后再进行比较判断
//例题则需要 以两个数的差值的绝对值,在某个精度范围内判断
if(db12 == db14){
//细节:如果是直接查询得的的小数或者直接赋值,是可以判断相等
System.out.println( "db12 == db14 相等");
}
if(Math.abs(db12-db13) < 0.00001 ){
System.out.println("差值非常小,约等于他们相同!");
}
System.out.println(Math.abs(db12 - db13));
}
}
3.6.3 字符类型(char)
基本介绍:
字符类型可以表示单个字符,字符类型是 char,char 是两个字节(可以存放汉字),多个字符我们用字符串String(我们后面详细讲解 String)
案例演示: Char01.java
//字符类型的基本使用
public class Char01{
//编写一个main方法
public static void main(String[] args){
char cr1 = '原';
char cr2 = 'y';
char cr3 = '\t';
//字符类型可以直接存放一个数字,因为在底层编码对应的是数字
//每个数字都会对应一个字母 比如 97 =》'a'
char cr4 = 97;
System.out.println(cr1);
System.out.println(cr2);
System.out.println(cr3);
System.out.println(cr4);
}
}
字符类型使用细节:
- 因为char是16位的,采取的Unicode的编码方式,所以char就有以下的初始化方式:
//字符,可以是汉字,因为是Unicode编码
char c = 'c';
//可以用整数赋值
//可以用整数赋值【整数范围:0~65535】。输出字符编码表中对应的字符。
char c = 十进制数,八进制数,十六进制数等等;
//用字符的编码值来初始化,如:char='\0',表示结束符,
//它的ascll码是0,这句话的意思和 char c=0 是一个意思。
char c = '\u数字';
- 字符常量是用单引号
''
括起来的字符。
例如:char c01 = 'a';
char c02 = '我';
char c03 = '9';
- char 类型的变量 允许使用转义字符
'\'
来将其后的字符转变为特殊字符型常量。
例如:char c04 = '\n';
--> '\n'表示换行符 '\t'表示对齐符
- 在 java 中,char 的本质是一个整数,在输出时,默认是 unicode 码对应的字符
在线Unicode编码转换-Unicode和ASCII在线互转-中文转Unicode工具
- 可一直接给 char 赋一个整数,然后输出时,会按照对应的unicode字符的输出。
ASSIC -------> Unicode --------> 对应的字符 97 -------> 'a'
-
char类型是可以进行运算的,相当于一个整数,因为它都有对应的 Unicode码。
-
ASCII 字符编码表
Ascii码对照表-在线Ascii码对照表-在线ASCII转换
- char类型是可以运算的因为char在ASCII等字符编码表中有对应的数值。
在Java中,对char类型字符运行时,直接当做ASCII表对应的整数来对待。
- char + char,char + int——类型均提升为int,
附值char变量后,输出字符编码表中对应的字符。
代码实现:
//字符类型的使用细节
public class CharDetail{
//编写一个main方法
public static void main(String[] args){
// 在 java 中,char 的本质是一个整数,在输出时,默认是 unicode 码对应的字符
// 因为char是16位的,采取的Unicode的编码方式,所以char就有以下的初始化方式:
// ASCII 是包含在 Unicode 的
char cr0 = 21407; // 通过 Unicode 转换为对应的字符 -----> '原'
//控制台输出:原
System.out.println(cr0);
//要输出对应的数字,可以(int)字符 强制转换
char cr1 = '原'; //不做处理的话 会直接输出 ---> 原
//控制台输出:'原' 对应的 字符编码
System.out.println((int)cr1);
char cr2 = 23567; //通过 Unicode 转换为对应的字符 -----> '小'
//控制台输出:'小' 对应的 字符编码
System.out.println((int)cr2);
//char 类型是可以进行运算的,相当于一个整数,因为它都对应有 Unicode 码.
// '原' 对应的Unicode码 21407 + int 类型 8593 =30000
//char类型相加,提升为int类型
System.out.println('原'+ 8593 );
//想法:char类型的 加减会出现什么情况?
//char + char,char + int——类型均提升为int,附值char变量后,输出字符编码表中对应的字符。
char cr3 = 'a' + 1; //97 + 1 ==> 98
char cr4 = 'b' + 1; //98 + 1 ==> 99
int i1 = 10;
//常量无需转换,cr3 + 1 是一个 int类型 的变量
//故 cr9 = cr3 + 1;会报错 需要强制转换
char cr9 = (char)(cr3+1);
char cr10 = (char)(cr3+i1);
char cr11 = (char)(cr3+cr4);
System.out.println((int)cr3); //98
System.out.println(cr3); // b
System.out.println((int)cr4); //99
System.out.println(cr4); // c
System.out.println(cr9); // b
System.out.println((int)cr9); //99
System.out.println(cr10); // L
System.out.println((int)cr10); //108
System.out.println(cr11); // ?
System.out.println((int)cr11); //197
// 99 -> 通过 编码表 ASCII 找到对应的字符 -> c
char cr5 = 43; //目前 ASCII 默认支持十进制
System.out.println(cr5);
}
}
3.6.4 字符类型本质
常见的字符编码表
-
ASCII码 —ASCII编码表由一个字节表示,128个字符,实际上一个字节可以表示256个字符,但是老外的英文只有那么24个字母,用不了那么多的字符。但是随着计算机的普及,全球都在使用计算机,原本的编码不能够满足全球各国语言,所以出现了Unicode
-
Unicode — Unicode编码表是固定大小的编码,使用两个字节来表示字符,字母和汉字统一都是占用两个字节,容易造成空间浪费。
-
utf-8 — 大小可变的编码,字母使用一个字节,汉字使用3个字节。
-
gbk — gbk编码可以表示汉字,而且范围广,字母使用一个字节,汉字2个字节。
-
gb2312 — 可以表示汉字,gb2312<gbk
-
big5 码 — 繁体中文,台湾,香港
字符集
字符(Character)是各种文字和符号的总称,包括各国家文字、标点符号、图形符号、数字等。字符集(Character set)是多个字符的集合,字符集种类较多,每个字符集包含的字符个数不同,常见字符集名称:ASCII 字符集、GB2312 字符集、BIG5 字符集、 GB18030 字符集、Unicode 字符集等。计算机要准确的处理各种字符集文字,就需要进行字符编码,以便计算机能够识别和存储各种文字。
字符编码
字符编码(英语:Character encoding)也称字集码,是把字符集中的字符编码为指定集合中某一对象(例如:比特模式、自然数序列、8 位组或者电脉冲),以便文本在计算机中存储和通过通信网络的传递。
为了理解字符集和字符编码的关系,这里举个简单的例子,我们可以把字符集当成接口,把字符编码当成接口的实现。Unicode
是接口(字符集), UTF-8
/ UTF-16
/ UTF-32
则是不同的实现(字符编码)。
ANSI
ANSI 全称(American National Standard Institite)美国国家标准学会(美国的一个非营利组织),首先 ANSI 不是指的一种特定的编码,而是不同地区扩展编码方式的统称,各个国家和地区所独立制定的兼容 ASCII 但互相不兼容的字符编码,微软统称为 ANSI 编码。
ASCII码介绍:
-
一个字节表示具体的字符,只用了后七位(2 ^ 7 = 128)最前面的一位统一为0,能够表示128个字符,其中包括了英文字符、阿拉伯数字、西文字符以及32个控制字符。
-
用来表示更多的欧洲文字,不同国家有不同的字符编码,即使都是256个字符编码,但后128个字符的编码方式不一样,代表的字母也不一样
-
ASCII 字符编码表
Unicode 字符集:
-
包含了世界上所有的字符,并且每一个符号都是独一无二的;
-
中文需要两个字节进行存储,而用两个存储字节英文字符时,前面一个字节都为0,造成存储的浪费;出现了 Unicode 的多种的存储方式;
UTF-8 :
-
UTF-8是互联网上使用最广的一种Unicode的实现方式,是一种可变长的编码方式。
-
对于单字节的符号,字节的第一位设为0,后面7位为这个符号的Unicode码。因此对于英文的字母,UTF-8编码和ASCII码是相同的;
-
对于n(n>1)字节的符号,第一个字节的前n位都设为1,第n+1位设为0,后面字节的前两位一律设为10,剩下没有提及的二进制位,全部为这个符号的Unicode;
3.6.5 布尔类型(boolean)
基本介绍:
-
布尔类型(Boolean 类型),Boolean类型数据只允许取值
true
false
,为空则为Null
。 -
boolean 类型 占一个字节
-
boolean 类型适用于 逻辑运算,一般用于流程控制
-
if 条件控制语句
-
for 循环控制语句
-
while 循环控制语句
-
do-while 循环控制语句
boolean 案例了解:
// if循环语句判断案例
public class Boolean01{
//编写一个main方法
public static void main(String[] args){
//条件 判断成绩是否通过 案例
//定义一个布尔变量 通过状态
boolean isPass = true;
//判断 isPass 是否 等于 true
if(isPass == true){
//如果 isPass 为 true 则打印成绩合格
System.out.println("恭喜你,成绩为合格");
} else {
//如果 isPass 为 flase 则打印成绩不合格
System.out.println("对不起,成绩不合格");
}
}
}
3.7 数据类型转换
3.7.0 基本数据类型转换
介绍:
当 Java 程序在进行赋值或者运算时,精度小的类型自动转换为精度大的数据类型,这个就是自动类型转换。
数据类型按精度大小排序:
char ---> int ---> long ---> float ---> double
byte ---> short ---> int ---> long ---> float ---> double
自动转换 演示案例:
//自动类型转换 基本案例
public class AutoConvert{
//编写一个main方法
public static void main(String[] args){
//java程序在进行赋值的时候,精度小的可以自动转换为精度大的数据类型
// char 类型 自动转换为 int
int it1 = 'd';
//输出打印 it1 显示 char类型’d‘对应的编码
System.out.println(it1);
// int 类型 自动转换为 double
double db1 = 99;
//输出打印 db1 显示 double 类型的 100
System.out.println(db1);
}
}
3.7.1 自动类型转换注意和细节
-
有多种类型的数据混合运算时,系统首先 自动 将所有数据转换成运算里精度高的那种数据类型,然后再进行运算。
-
当我们把精度低的数据类型赋给精度高的数据类型时,会进行自动类型转换,
当我们把精度大的数据类型赋给精度小的数据类型时,就会报错。 高精度->低精度
-
(byte,short)和 char 之间不会相互自动转换。
-
byte,short,char 他们之间可以进行计算,但是要首先要转换为 int 类型。
-
Boolean 不参与 类型转换。
-
自动提升原则:表达式结果的类型自动提升为 操作数中最大的类型
代码实现:
//自动类型转换 注意事项及使用细节
public class AutoConvertDetail{
//编写一个main方法
public static void main(String[] args){
//1、有多种类型的数据混合运算时,系统首先自动 将所有数据转换成运算里精度高的那种数据类型,然后再进行运算。
// 定义一个 int 类型的常量 99
int it1 = 99;
// 定义一个 float 类型的变量 it1 + 0.99F =》结果为 double类型 XXXXX
// float ft1 = it1 + 0.99;
// 定义一个 float 类型的变量 it1 + 0.99F =》结果为 99.99 float类型
float ft1 = it1 + 0.99F;
// 定义一个 double 类型的变量 it1 + 0.99999 =》结果为 99.99999 double类型
double db1 = it1 + 0.99999;
// 定义一个 double 类型的变量 it1 + 0.999F =》结果为 99.999xxxxx double类型
double db2 = it1 + 0.999F;
System.out.println(ft1); // 99.99
System.out.println(db1); // 99.99999
System.out.println(db2); // 99.999xxxxx
//2、当我们把精度大的数据类型赋给精度小的数据类型时,就会报错。高精度->低精度
// 定义一个 float 类型的变量 --> 将 常量100 赋给float类型
float ft2 = 100; //100.0
// 定义一个 int 类型的变量 --> 将 100.00 赋给int类型
// int it2 = 100.00; //报错 double类型 -> int类型
System.out.println(ft2); // 100.0
//3、(byte,short)和 char 之间不会相互自动转换。
byte be1 = 'a';
System.out.println(be1); // 97
short st1 = 'b';
System.out.println(st1); // 98
//当把具体数赋给 byte 或者 short 时,(1)先判断该数是否在 byte short 范围内
byte be2 = 99 ;
short st2 = 100;
char cr1 = 'a';
/* 错误原因:byte 不能自动转成 char类型 、short 不能自动转成 char类型
char cr2 = be2;
char cr3 = st2;
*/
//当把变量赋值时候,会先判断类型
// byte be3 = cr2; cr2是char类型的
// short st3 = cr3; cr3是char类型的
/* 错误:类型转换错误
System.out.println(cr2); // c
System.out.println(cr3); // d
System.out.println(be3);
System.out.println(st3);
*/
//4、byte,short,char 他们之间可以进行计算,但是要首先要转换为 int 类型。
byte be4 = 9;
short st4 = 10;
int st5 = be4 + st4; //这三者进行运算 会将精度提到int类型 be4 + st4 => int类型
System.out.println(st5); //int类型 ==》 19
//只要这三者进行运算,哪怕是同类型也会提升至 int类型
byte be5 = 100;
int be6 = be4 + be5;
short st6 = 100;
int st7 = st4 + st6;
System.out.println(be6); //int类型 ==》109
System.out.println(st7); //int类型 ==》110
char cr4 = 97;
int it6 = be4 + cr4;
System.out.println(it6); //int类型 ==》106
//5、Boolean 不参与 类型转换。
boolean bn1 = true;
// int it7 = true; //报错:不兼容的类型,直接无法转换
//6、自动提升原则:表达式结果的类型自动提升为 操作数中最大的类型
//练习代码需求:判断 类型混合运算的结果是什么类型的;
byte num1 = 10;
short num2 = 100;
int num3 = 1000;
double num4 = 888.88;
double num10 = num1 + num2 + num3 + num4; //自动提升为精度最高的类型 double num4;
System.out.println(num10); //double类型 ==》1998.88
}
}
3.7.2 强制类型转换
介绍:
自动类型转换的逆过程,将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符( ),但可能造成精度降低或溢出,格外要注意。
强制类型转换 演示案例:
//强制类型转换 基本案例
public class ForceConvert{
//编写一个main方法
public static void main(String[] args){
//精度高的强制转换为 精度低的类型 会造成精度丢失
double num1 = 99.99;
int num2 = (int)num1;
System.out.println("int类型的数值为:" + num2);
//精度高的强制转换为 精度低的类型 超过了精度低的容量 会造成精度溢出
int num3 = 999;
byte num4 = (byte)num3;
System.out.println("byte类型的数值为:" + num4);
}
}
强制类型转换 细节说明:
- 当进行数据转换时, 从 精度大 ====》 精度小,就需要使用到强制转换.
double ==> int
int ==> byte
- 强转符号只针对于最近的操作数有效,往往会使用小括号提升优先级.
int = (int) 2.7;
int = (int) (10 * 2.7)
------>先运算括号里面的。
- char类型可以保存int的常量值 但不能保存 int的变量值,需要强转.
char char1 = 10;
char char2 = (char) int2 ;
- byte、short、char类型再进行运算时,当作int类型处理。
只要出现三者运算,自动提升为int类型
//强制类型转换 使用细节
public class ForceConvertDetail{
//编写一个main方法
public static void main(String[] args){
//1、当进行数据转换时, 从 精度大 ====》 精度小,就需要使用到强制转换.
double db1 = (double) 100;
byte be1 = (byte) 100;
System.out.println(db1);//输入结果:double ==> 100.0
System.out.println(be1);//输入结果:byte ==> 100
//2、强转符号只针对于最近的操作数有效,往往会使用小括号提升优先级.
int ride = (int) (99.9*33.33 + 22.22 * 10);
System.out.println(ride); //输入结果:int ==> 3551
// 错误示范 int ride = (int) 99.9*33.33 + 22.22 * 10; 只会强转临近 常量
int ride1 = (int) 90.9*10 + 10 * 10;
System.out.println(ride1); //输入结果:int ==> 1000
//3、char类型可以保存int的常量值 但不能保存 int的变量值,需要强转.
char char1 = 10;
System.out.println(char1); //输入结果:char ==> 10
int it1 = 100;
char char2 = (char)it1; // 是一个100的字符 '100'--> d
System.out.println(char2); //输入结果:char ==> '100' --> d
//4、byte、short、char类型再进行运算时,当作int类型处理。
byte be2 = 10;
short st1 = 10;
char c1 = 'd';
int it2 = be2 + st1 + c1;
System.out.println(it2); //输入结果:int ==> 120
}
}
3.8 基本数据类型和 String 类型的转换
3.8.1 介绍和使用
在程序开发中,我们经常需要将基本数据类型转换成String类型,
或者将String类型转成基本数据类型。
基本类型转String类型
-
实现:
定义基本数据类型后,
String = 基本数据类型 + "";
// 基本数据类型 --> String 类型的转换 public class StringToBasic{ //编写一个main方法 public static void main(String[] args){ //基本数据类型 byte byte1 = 11; short short1 = 22; int int1 = 33; long long1 = 44L; float float1 = 55.55F; double double1 = 66.66; char char1 = 100; boolean boolean1 = true; //转换为 String 类型 String byte2 = byte1 + ""; String short2 = short1 + ""; String int2 = int1 + ""; String long2 = long1 + ""; String float2 = float1 + ""; String double2 = double1 + ""; String boolean2 = boolean1 + ""; String char2 = char1 + ""; System.out.println(byte2); //String --> "11" ; System.out.println(short2); //String --> "22" ; System.out.println(int2); //String --> "33" ; System.out.println(long2); //String --> "44" ; System.out.println(float2); //String --> "55.55" ; System.out.println(double2); //String --> "66.66" ; System.out.println(boolean2); //String --> "true" ; System.out.println(char2); //String --> "d" ; } }
String类型转基本数据类型
-
实现:
通过使用基本类型的包装类,调用
parseXxxx
方法实现Integer.parseInt("int");
orBoolean.parseBoolean("true")
// String 类型 --> 基本数据类型的转换 public class BasicToString{ //编写一个main方法 public static void main(String[] args){ //声明一个 String类型的变量 String str1 = "119"; String str2 = "true"; //使用 基本数据类型对应的包装类,的相应方法,得到基本数据类型 byte b1 = Byte.parseByte(str1); short s1 = Short.parseShort(str1); int i1 = Integer.parseInt(str1); long l1 = Long.parseLong(str1); float f1 = Float.parseFloat(str1); double d1 = Double.parseDouble(str1); boolean bn1 = Boolean.parseBoolean(str2); System.out.println(b1); //byte --> 119 System.out.println(s1); //short --> 119 System.out.println(i1); //int --> 119 System.out.println(l1); //long --> 119 System.out.println(f1); //float --> 119.0 System.out.println(d1); //double --> 119.0 System.out.println(bn1); //boolean -->true //怎么把字符串转成字符 char -> 含义是指 把字符串的第一个字符得到 //s5.charAt(0) 得到 s5 字符串的第一个字符 '1' char cr1 = str1.charAt(0); char cr2 = str1.charAt(1); char cr3 = str1.charAt(2); System.out.println(cr1); System.out.println(cr2); System.out.print(cr3); } }
3.8.2 注意事项
-
在将 String 类型转成 基本数据类型时,要确保 String 类型能够转成有效的数据,比如我们可以把"123" , 转成一个整数,但是不能把 "hello" 转成一个整数
-
如果格式不正确,就会抛出异常,程序就会终止。
代码实现:
//演示字符串转基本数据类型的细节
public class StringToBasicDetail{
//编写一个main方法
public static void main(String[] args){
//定义 String 类型的变量
String str1 = "110";
String str2 = "hello";
//转换为 int 类型
int it1 = Integer.parseInt(str1);
int it2 = Integer.parseInt(str2);//编译报错 因为系统无法识别类型
System.out.println(it1);
System.out.println(it2);
}
}
3.9 本章练习
1、判断程序会输出什么结果
[Homework01.java]
// 1、判断程序会输出什么结果
public class Homework01{
//编写一个main方法
public static void main(String[] args){
int num1;
int num2;
int num3;
num1 = 99;
num2 = 357;
num3 = num1 + num2; // int类型 -----> 456
System.out.println("num3的值为:" + num3);
int num4 = 159;
int num5;
num5 = num3 - num4; // int类型 -----> 297
System.out.println("num5的值为:" + num5);
}
}
2、使用char类型 打印 特殊字符
[Homework02.java]
使用 char 类型,分别保存 \n \t \r \ 123 等字符,并打印输出
代码实现:
//2、使用 char 类型,分别保存 \n \t \r \\ 123 等字符,并打印输出
public class Homework02{
//编写一个main方法
public static void main(String[] args){
char num1 = '\n';
char num2 = '\t';
char num3 = '\r';
char num4 = '\\';
char num5 = '1';
char num6 = '2';
char num7 = '3';
System.out.println(num1); // 换行
System.out.println(num2); // 制表位
System.out.println(num3); // 回车
System.out.println(num4); // 输出 \
System.out.println(num5); // 1
System.out.println(num6); // 2
System.out.println(num7); // 3
}
}
3、编程,保存 两本书名 书的价格 两个性别
[Homework03.java]
编程,保存两本书名,用 + 拼接,看效果。保存两个性别,用加号拼接,看效果。
保存两本书的价格,用加号拼接,看效果
代码实现:
//3、编程,保存两本书名,用 + 拼接,看效果。保存两个性别,用加号拼接,看效果。保存两本书的价格,用加号拼接,看效果
public class Homework03{
//编写一个main方法
public static void main(String[] args){
//声明 两本书 String类型 并且保存书名
String book1 = "《末世英雄传》";
String book2 = "《天域苍穹》";
//打印输出 用+拼接的结果 《末世英雄传》《天域苍穹》
System.out.println(book1+book2); // 只是将两个字符串类型拼接到了一起
//声明 两个性别 使用char类型保存
char sex1 = '男';
char sex2 = '女';
//打印的会是 字符对应的字符编码值 加法运算
System.out.println(sex1+sex2); // 常量 ===> 52906;
//声明 两本书的价格 使用 double 类型保存
double price1 = 33.33;
double price2 = 66.66;
//打印输出 两个 double 类型 加法运算
System.out.println(price1+price2); // double ===> 99.99
}
}
4、编程实现以下需求
[Homework04.java]
姓名 | 性别 | 年龄 | 成绩 | 爱好 |
---|---|---|---|---|
小原 | 男 | 21 | 99.99 | 乒乓球 |
-
声明
姓名、性别、年龄、成绩、爱好
这些变量 -
使用 + 拼接,添加转义字符,使用一条语句输出
-
添加适当的注释
代码实现:
//4、在控制台输出个人信息 -- 姓名、性别、年龄、成绩、爱好
public class Homework04{
//编写一个main方法
public static void main(String[] args){
//声明一个 String 类型的变量 name;
String name = "小原";
//声明一个 char 类型的变量 sex;
char sex = '男';
//声明一个 int 类型的变量 age;
int age = 21;
//声明一个 double 类型的变量 garden;
double garden = 99.99;
//声明一个 String 类型的变量 habbit;
String habbit = "篮球、乒乓球";
//输出打印
System.out.println("姓名\t性别\t年龄\t成绩\t爱好\n"+ name +"\t"+ sex +"\t"+ age +"\t"+ garden +"\t"+ habbit);
}
}