目录
一、标识符
1.1标识符的概念
Java中给类、接口、变量、方法等资源起名使用的字符序列,称为标识符（命名）。
(1)组成内容：
允许所有的大小写英文字母
允许0-9的数字组成
允许英文的 _ 和 $ 符号, 其他所有符号和空格不能作为名字出现, 出现就直接报错
允许其他国家语言的字符 : 但是实际开发项目中, 所有命名都是英文, 没有中文
注意事项
标识符不能是关键字
数字不开头
最好见名知意
实例代码：
public class Day0201 {
//主函数方法
public static void main(String[] args){
//定义
//语法： 变量类型 变量名称 = 变量的值;
String name = "尼古拉斯·赵四"; //允许
String name1 = "尼古拉斯·赵四"; //字母+数字 可以
String n123ame = "尼古拉斯·赵四"; //允许但不建议
//String 551name = "尼古拉斯·赵四"; //出错：数字不允许开头
String name_1 = "尼古拉斯·赵四";
String name1_ = "尼古拉斯·赵四";
String _name1 = "尼古拉斯·赵四";
//String %name1 = "尼古拉斯·赵四";
//String name1% = "尼古拉斯·赵四"; //都错误，不允许出现%
String $name1 = "尼古拉斯·赵四";
String name1$ = "尼古拉斯·赵四";
//String 007 = "尼古拉斯·赵四"; //错误，数字开头
String 赵四 = "尼古拉斯·赵四"; //可以 但是千万不要这么命名
String mingzi = "张三"; //尽量不要这样使用
//英文命名一般由一个单词和多个单词组成
String fullname = "尼古拉斯·赵四"; //fullName
String full_name = "尼古拉斯·赵四";
//第一个不符合规范是因为两个单词拼接。如果定义的是变量，那么第一个单词首字母小写
//第二个单词首字母要大写，如果使用_连接符，那么单词都小写。
//引用变量
System.out.println(赵四);
}
}1.2.Java行业内部命名规范
1. 类的名字和接口的名字 ( 文件名称 ) : 大驼峰 , 每一个英文单词的首字母大写举例 : HelloWorld GoldSale2. 变量命名 : 小驼峰 , 第一个英文单词全小写 , 从第二个英文单词开始 , 首字母大写举例 : 产品数量 productNumber sale3. 方法的命名 : 小驼峰 , 与变量命名一致举例 : 功能 求和 getSum 输出打印 : print4. 常量的命名 : 面向对象环节才能学习到所有字母全大写 , 单词之间使用 _ 进行分隔PI SCHOOL_NAME
类、接口 ：大驼峰 首字母大写 之后拼接单词首字母都 大写
常量特殊 ：全部大写 多个单词_拼接
方法、变量 ：小驼峰 首字母小写 之后拼接单词首字母都 大写
二、常量
2.1常量的概念
在Java代码运行的过程中, 其值不会发生变化的量(数据), 称为常量
举例 : 圆周率 π 、身份证号
电脑的任何运行的程序，都会占用运行内存。
2.2.常量的分类
在Java1.6中，常量是存在方法区中的。
(1)在写法上常量分为 字面量常量和符号常量(面向对象中内容，暂时了解)
什么是字面值常量？ 简称 字面量
定义：在编程语言中，如果定义一个基本数据类型的值且直接使用，那么是不需要程序单独为其
处理的，因为基本数据类型是程序内置的数据类型，所以可以直接使用。
例如：System.out.print(100)
符号常量
public static final String IDCARD ="150233198804231123";
public class Day0202{
//符号常量 一般定义在类中并且在方法外，以static 和 final 关键词修饰
//final 最终的 static 静态的
public static final String ID_CARD = "12345678901230987654";
public static void main(String[] args) {
//变量
int i = 100; //这种算定义 不算直接使用
System.out.println(i);
System.out.println(300); //自面量常量
System.out.println(200); //常量
//总结：这个案例中，100是使用i定义出来的，之后可以改变 变量
//200 和 200 没名字并且只能使用这一次 这种我们叫常量
System.out.println(ID_CARD);
}
}
(2)常量按照数据类型分类 :
基本数据类型
和
引用数据类型
(面向对象中内容，暂时了解)
无论是Java还是c 都是强类型语言， 以后会学习JavaScript 这种语言我们叫弱类型语言
强类型语言：不同的数据类型要分别定义接收。
弱类型语言：指可以通过一个特定的符号接收任意类型的数据 javascript var
基本数据类型分为 4 大类 :a : 整数类型 34 , 0 , -9b : 浮点类型 ( 小数类型 ) 3.14 , 9.98c : 字符类型 , 使用一对英文的单引号包裹单个字符序列 '3' 'a' 'Y' '?' ' 家 ' 注意： '-1' 不是一个d : 布尔类型 : 表示真假值 , 是与非 , 使用在判断场景下 , 只有两个值 true ( 真 , 是 ) false ( 假 , 否 )引用数据类型：我们先学习最简单的字符串类型常量 : 使用一对英文的双引号 , 包裹起来一些列字符序列 , 称为字符串注意 : 字符串类型可以和任意基本数据类型做加法。但是不运算结果只做拼接，得到的结果依然是一个拼接的字符串
public class Day0203 {
//字面量常量
public static void main(String[] args) {
//================== public static final
// 基本数据类型 byte short int long char float double boolean
//===================
//整数(int)
System.out.println(10);
System.out.println(-10);
System.out.println(100000000000000L); //大数值
//浮点(小数 double)
System.out.println(10.33);
//字符(单引号只能表述一个字符)
System.out.println('哈');
System.out.println('%');
//布尔 只有两个值 表示 真假
System.out.println(true);
System.out.println(false);
//================== 引用数据类型 ===================
//目前只学习字符串
System.out.println("我是一个字符串，我是引用类型");
}
}
三、 常量练习
3.1.基本数据类型常量练习
public static void main(String[] args) {
// 1. 整数常量
System.out.println(34);
System.out.println(-9);
// 2. 浮点类型常量
System.out.println(-9.0);
System.out.println(3.14);
// 3. 字符类型
System.out.println('a');
System.out.println('A');
System.out.println('1');
System.out.println(';');
System.out.println('你');
// -1不是一个字符
// System.out.println('-1');
// 4. 布尔类型
System.out.println(true);
System.out.println(false);
}3.2.引用数据类型常量练习
public class Day0205 {
//引用类型的符号常量,对于字符串，程序不会做额外的校验 直接原样输出
public static final String CODE = "public hahha";
public static void main(String[] args) {
//字面量常量
//System.out.println("Hello World！");
//字符串很特殊
//1. 任何一个类型都可以和字符串相加，得到一个新的字符串
System.out.println("Hello"+" World!"+" 哈哈");
//问题：常量是不可以改变的， 那么这种算改变么？
//2. 关于数值
System.out.println(7+8); //15 结果是int
System.out.println("7"+8); //78 字符串
System.out.println("s"+(7+8)); //s78
System.out.println(7+8+"s"); //15s
//字符串和任何类型得到一个新的字符串
System.out.println("m"+8.5555+"9"); //报错
//System.out.println("7"*8); //报错
}
}四、快捷键
ctrl+s 保存2 ctrl+c 复制3 ctrl+v 粘贴4 ctrl+x 剪切 5 ctrl+a 全选6 ctrl+z 撤销7 ctrl+y 前进8 ctrl+f 搜索910 常量11 写法上分12 字面量常量（直接打印使用，没名字）13 符号常量 ( 位置方法外类内 public static final 修饰 ...) 要求名字全大写14 数据类型分15 基本数据类型16 整数、小数 / 浮点 、字符、 布尔17 引用数据类型18 String 【案例】（不止有String，还有其他）
五、变量
5.1.变量概念
变量: 在程序运行过程中,其值可以发生改变的量，人为和程序都可以控制改变
举例 : 年龄, 手机号码, 家庭住址, 产品单价...
5.2.变量的定义和使用
变量的定义步骤
变量的定义分为两步:
(1) 变量的声明: 确定了变量名 和 变量的数据类型
(2) 变量的赋值: 为变量进行初始化赋值
变量的定义语法
(1) 方式1: 先声明 再赋值
语法:
数据类型 变量名; --> 变量的声明
变量名 = 变量值; --> 变量的赋值
案例:
int a;
a = 10;
(2) 方式2: 声明的同时并赋值
语法:
数据类型 变量名 = 变量值;
案例:
int a = 20;
变量的使用
(1)变量的访问 : 直接通过变量名访问变量值
(2)变量的赋值 : 变量名 = 新的变量值;
public class S0205 {
public static void main(String[] args) {
//基本的定义1
int i; //表示声明一个变量并给一个标识符(起名字)
i = 10; //给当前的变量赋值
//基本的定义2 --- 使用的最多
int x = 10; //直接定义
//复杂的定义1 --- 一般不建议使用
int a,b,c; //连续声明3个数据类型相同的变量
a = 10;
b = 20;
c = 1;
//复杂的定义2 --- 更不建议使用
int q,w,e = 20; //这种方式虽然能直接定义三个变量，但是只有最后一个初始化
//System.out.println(a);
//字符串拼接 - 把abc三个变量通过字符串的形式拼接
//System.out.println(a + "-" + b + "今天电脑死机了真开心" + c);
System.out.println(e);
}
}
变量定义和赋值过程的图解
public class S0206 {
//定义在方法外的变量，我们叫【全局变量】
static int w = 20;
//主函数方法是static静态的
public static void main(String[] args) {
//定义在方法中的变量我叫【局部变量、成员变量】
int i = 10;
i = 100;
//如果在静态方法中打印变量方法外的变量，那么变量也必须是静态的。
System.out.println(w);
}
//输出语句必须写在方法中main和普通方法都可以，但是不可以写在方法外
//System.out.println(w);
}
关于
全局变量
和
局部变量 (面试题)
# 使用范围全局变量的使用范围是整个类都可以使用，局部变量只能在定义的方法中使用简述 : 全局变量相当于银行的钱，每个人只要有银行卡就可以提取消费， 局部变量就是每个人 ( 方法 ) 兜里所以说如果定义一个变量想公共使用，那么定义成全局的， 如果只是方法自己使用，定义成方法内部的局部变量。# 定义的区别定义的是全局变量，如果在静态方法中使用， 那么要求变量也必须是静态的，如果是非静态方法使用， 变量则要求是非静态的成员变量的定义在静态方法中不可以再使用静态的声明，因为静态方法在内存中存储的地址是不一样的。总结一下就是 目前我们只学习了静态的 main 方法， 如果定义全局变量那么就定义成 static 静态的， 定义局部变量则是定义在方法中的变量不允许定义静态方法。
局部变量是存在栈中，全局变量存在堆中，程序运行中有两个存储空间可用，一个是栈，是归属 于进程本身的，另外一个是堆，所有进程共用的。
public class Day0207 {
//全局静态变量：定义在方法外
static int i = 100;
//主函数，执行的入口,默认只会执行这一个方法
public static void main(String[] args) {
//局部变量定义方法内
int k = 50;
System.out.println(i);
System.out.println(k);
}
public static void show(){
System.out.println(i);
//System.out.println(k); k无法使用
}
}
图示：
案例1 定义一个局部变量，并且改变其对应的值
class S02Demo02 {
public static void main(String[] args){
//成员变量需要定义到方法中
int i = 10;
//改变值
i = 100;
System.out.println(i);
}
}案例2 定义一个全局变量，并且改变其对应的值
案例3
public static void main(String[] args) {
// 变量定义 : 数据类型 变量名 = 变量值;
// 数据类型 变量名; 变量声明
// 变量名 = 数据值; 变量的赋值
// 定义出一个整数类型变量
// int是一种数据类型, 表示整数
int i = 10;
// 拆分的变量定义
int j;
j = 99;
System.out.println(i + j);// 109
// 给i变量进行赋值
i = 88;
System.out.println(i + j);// 187
}
3.变量定义和使用的注意事项
(a).变量的作用域:
从变量定义的位置开始,包含当前变量本身, 且离变量最近的一对大括号就是变量
的使用范围
,即作用域只能在变量的作用域范围内访问该变量
(b).
在方法中可以定义同名的两个局部变量,但是要求两个同名的局部变量不能有重合的作用域
举例 : 同一班级(重叠作用域)中有两个同名学生(两个同名变量), 于是老师通过名字区分学员, 无
法区分, 矛盾情况, Java中, 所有矛盾情况, 不会出现, 属于语法错误
public class Day0209 {
static int i = 10; //全局
//主函数
public static void main(String[] args) {
int i = 100; //局部
System.out.println("主函数"+i); //100 就近原则
}
}
(c).局部变量在使用之前必须先赋值
int i; //变量的声明，如果不使用不会报错，一旦使用必须初始化
i = 100;
System.out.println(i);(d).相同数据类型的变量可以连续定义, 但不建议使用
int i,k,y,o; //不建议
int w,t = 100; //这种方式可以使用
注意 : 局部变量, 表示定义在方法中的变量, 因为方法中变量使用范围相对比较小, 称为局部
public class Day0209 {
static int i = 10; //全局
//主函数
public static void main(String[] args) {
int i = 100; //局部
System.out.println("主函数"+i); //100 就近原则
//代码块
{
int k = 20;
}
{
int k = 2000;
}
}
}六、计算机存储单元
6.1.概述:
计算机底层是采用二进制的方式存储数据的,计算机中存储的最小信息单位叫比特位(bit),通
常用 b 表示,
8个比特位构成计算机中最基本的存储单位叫字节(Byte),通常用 B 表示.
8位=1字节
6.2.存储单位之间的换算关系
8
bit
= 1B 0000 0000 ---- 1111 1111
1024B = 1KB
1024KB = 1MB
1024MB = 1GB
1024GB = 1TB
1024TB = 1PB...EB、ZB、YB、BB、NB 、DB（计算机中最大的单位）
EB 相当于全世界所有人类讲过的话
ZB 相当于地球沙子数量总和
YB 相当于永定河水分子总和
BB 相当于亚马逊河水分子总和
NB 相当于太平洋水分子总和
DB 相当于地球所有分子总和
拓展：
中国数字单位有：由小到大依次为个、十、百、千、万、亿、兆、京、垓
[gāi]
、秭[zǐ]、穰
[ráng]、沟、涧、正、载、极、恒河沙、阿僧祇qí、那由他、不可思议、无量大数。万以下是十进
制，万以后则为万进制，即万万为亿，万亿为兆、万京为垓。
3.扩展 : 内存概念
笔记本: 运行内存 32G, 当程序或者代码需要运行的时候, 进入到内存中占有指定空间运行, 当程序
或者代码运行完毕, 出内存, 释放掉占有的空间位置.
硬盘500GB : 固定存储
七、JAVA数据类型
7.1.数据类型分类
Java语言是一门强类型语言, 定义一个变量时, 必须要指定这个变量的数据类型; 因为不同的数据类型在内存中占有的空间大小不同, 表示的数据也不同, 因此需要知道当定义一个变量时, 在内存是开辟多大空间存储
7.2.基本数据类型
(a)整数类型
（十转二除2取余）
注意事项:
1. 整数类型中字面值常量的默认类型是int类型
2. long类型的变量在定义的时候,当字面值超过int范围需要在字面值后加 L / l,建议 L
public static void main(String[] args) {
// 1. 整数类型变量定义
// -128 127
byte b = 15;
System.out.println(b);
// byte类型占有内存大小, 不足以表示155数据, 因此报错
// byte b1 = 155;
// System.out.println(b1);
short s = 10000;
System.out.println(s);
// 最常用的整数类型: int类型
int i = 999999999;
System.out.println(i);
long lon = 1234567;
System.out.println(lon);
/*
整数类型注意事项2 :
定义一个long类型时, 如果数值范围超出了int,那么需要在数值之后
使用一个L或者l表示这个数据是长整型数据, 否则报错
*/
long lon2 = 1456785643125L;
System.out.println(lon2);
// 整数注意事项1 : 整数类型中字面值常量的默认类型是int类型
System.out.println(5);
}(b)小数(浮点)类型
注意事项:
1.小数类型的
字面值常量
默认类型是 double类型
2.float 类型(单精度)变量在定义的时候,需要在字面量后加 F / f,建议F
3.double 类型（双精度）的变量在定义的时候,可以在字面量后加 D / d,也可以不加.
4.浮点型存储的数据是不精确的数据,所以在运算过程中,其结果也有可能不精确.
5.对编程人员来说，double 和 float 的区别是 double 精度高，有效数字 16 位，float 精度 7
位。但 double 消耗内存是 float 的两倍，double 的运算速度比 float 慢得多，能用单精度时不
要用双精度（以省内存，加快运算速度）。
double a = 0.1;
double bbb = 0.2;
System.out.println(a + bbb);// 0.30000000000000004(c)字符类型
1.字符类型变量的赋值方式:
(1) 通过 ' ' 形式赋值
案例:
char c = 'A';
(2) 通过ASCII(阿斯克)码表赋值, 但是如果直接使用整数给char类型赋值, 那么整数范围必须在0-
65535之间, 因为人类的语言文字, 放在一起, 一共有65535个字符可以表示, 超出范围,无法对应编
码表, 代码报错
案例:
char c = 65;
2.编码表存在的解释说明:
人类语言文字,需要被计算机识别, 而计算机底层全部都是二进制, 也就是数字; 因此需要将人类的
语言文字与数字形成对应关系, 目的就是为了让计算机以数字的形式将字符存储下来, 于是最早期,
美国人形成了一张表, 简称ASCII编码表;
ASCII编码表中存储了所有的字母大小写, 英文符号以及数字与整数的对应关系
注意 : 比较常见编码需要记住:
常用的ASCII码表值
'A' -- 65 'a' -- 97 '0' -- 48
3 ASCII编码表: 0 —— 65535
4.中国有自己的编码表, 兼容了ASCII, 同时咱们编码表中, 包含所有中文文字
GBK : 中国标准信息交换码表 支持中文简体和繁体
GB2312：支持中文简体
BIG5：台湾大五码
UTF-8 : 国际标准码表, 包含了各个国家语言文字
案例代码
public static void main(String[] args) {
// 3. 字符类型
char ch = 'A';
System.out.println(ch);
char ch1 = 66;
System.out.println(ch1);
//char ch2 = 77889; 报错, 数据超出了0-65535
//System.out.println(ch2);
char ch3 = '家';
System.out.println(ch3);
}(d)布尔类型
public static void main(String[] args) {
// 4. 布尔类型
boolean boo = true;
boolean boo2 = false;
System.out.println(boo);
System.out.println(boo2);
}综合案例
public class S0209 {
public static void main(String[] args) {
//整数型 byte short int long
System.out.println(2); //默认的字面量类型int
byte b = 25;
short s = 26;
int i = 27;
long l = 28;
// 如果使用字面量能否指定类型？ L、F、D
// 字面量直接指定类型的时候，Java默认只支持后缀添加FLD
System.out.println(128);
//浮点 float double(字面量默认是double类型)
//在指定的值的时候，Java会将浮点的值默认也认为是double类型
//要求大家定义float类型的时候必须添加f
float f = 2.666666666666666F;
//double定义的时候值的类型默认就是double d可加可不加。
double d = 3.5555555555555555;
char c1 = '哈';
char c2 = 65535; //char类型可以使用数字直接表述，''表示的最终也会转化为数字
char c3 = 'A';
System.out.println(c1);
//布尔 boolean true/false
boolean b1 = true;
boolean b2 = false;
}
}
综合案例
public class Day0210{
public static void main(String[] args) {
//整数类型(默认int)
//byte(字节) short(短整型) int(整型) long(长整型)
byte b1 = -128;
byte b2 = 127;
short s1 = -32768;
short s2 = 32767;
int i = 2147483647;
long l = 888888888888888888L; //取决于int是否装得下
//无论定义任何任何整数类型，默认都是先当成int去处理，在根据定义的类型
//程序在默认将int类型转化为对应的类型
//浮点(double) float double
float f = 6.6F; //因为默认double所以程序担心有损失，需要加F
double d = 9.0000000000009999999; //默认double 直接定义
//字符(char)
char c = 65535; //数值取值范围0 - 65535
char c1 = '魑';
System.out.println(c1);
//布尔boolean
boolean b = true;
System.out.println(false);
}
}
(e)基本数据类型排序
（面试题）
# Java的基本数据类型有哪些？请从小到大书写出来！！
# 第一种忽略分类表示，按占用字节表示(少)
byte(字节1) < short(短整型2) = char(字符型2) < int(整型4) = float(单精度4)
< double(双精度8) = long(长整型8) 特殊: boolean(布尔类型 未知字节)
# 按类型分(多)----
byte(字节1) < short(短整型2) < int(整型4) < long(长整型8),char(字符型2),
folat(单精度4) < double(双精度8), 特殊: boolean(布尔类型 未知字节)
7.3.引用数据类型
String 类是字符串,在定义String类型的变量的时候,使用 "" 括起来表示字符串常量内容
举例 : String str = “写任意字符序列”;
public class D0408 {
public static void main(String[] args) {
String s1 = "张三";
String s2 = "程序员";
String s3 = s1 + s2;
System.out.println(s3);
}
} 
经典面试题
//问：内存中定义了几个值？几个引用？
//问：在常量池中一共定义几个值？ 一共有一个引用？
String s1 = "哈哈";
String s2 = "嘿嘿";
String s3 = "呵呵";
String s4 = s1 + s2;
String s5 = s4 + s3;
值：5ge 哈哈、嘿嘿、呵呵、哈哈嘿嘿、哈哈嘿嘿呵呵
引：5个 s1~s5
String s1 = "张三";
s1 = "李四";
String s2 = s1 + "王五";
值 张三、李四、李四王五
引用： s1 s2
(a)字符串和其他类型相加
public class D0408 {
public static void main(String[] args) {
String str = "S";
//基本数据类型
byte b = 1;
short s = 2;
int i = 3;
long l = 4L;
float f = 3.14F;
double d = 3.3;
char c = 11;
boolean boo = true;
System.out.println(str + b);
System.out.println(str + s);
System.out.println(str + i);
System.out.println(str + l);
System.out.println(str + f);
System.out.println(str + d);
System.out.println(str + c);
System.out.println(str + boo);
//任何类型的数据和字符串相加都会转化成字符串类型
int k = 10;
//int m = k + ""; //错
String n = k + ""; //对
}
}7.4.基本数据类型转换
(1)转换原因: Java是强类型语言,数据类型之间不能随意转换,但运算时数据类型不匹配,所以需要转
换.
(2)数据类型转换分类:
a :
自动向上转型 (小类型转化为大类型 -- 可以自动转换)
b :
强制向下转型 (大类型转化为小类型 -- 强制手动转换)
a自动向上转型：
(1)范围小的数据类型可以直接转换为范围大的数据类型
举例 : 50ml水杯, ---> 小数据类型
举例 : 50ml水杯,
小数据类型
500ml水瓶---> 大数据类型
将水杯中水倒入到水瓶中, 可以, 容量完全符合
(2)数据类型范围大小排序:
(3)boolean类型不参与大小排序
(4)注意事项:
int类型以下运算提升为int,int以上计算提升为较大类型
案例1
public class D0409 {
public static void main(String[] args) {
//1字节
byte b = 10;
//2字节
short s = b;
//char c = b; // byte -128 ~ 127 char = 0 ~ 65535 //报错
//4字节
float f = b;
int i = b;
//同级别
//float f1 = 100F;
//int f2 = f1; 报错：任何浮点数转化int不关心字节数都会默认报错，丢失精度
int m1 = 100;
float m2 = m1; //正常：同字节下 整数转小数是可以直接添加小数位，不会报错。
//8字节
double d = b;
long l = b;
System.out.println(f);
}
}案例2
class S02Demo08 {
/**
* 主函数方法
* @parma String[]
* @return void
*/
public static void main(String[] args) {
//byte short char int float long double
//boolean类型不参与类型转化
//char类型虽然能转化，但是一般我们不会使用char转化
byte b = 2;
//所谓自动提升类型就是用一个大类型接收一个小类型的值
short c = b;
long d = b;
float f = b;
System.out.println(f);
}
}b强制向下转型：
(1)大范围数据类型的变量/常量 赋值 给一个小范围数据类型的变量,需要进行强制转换.
举例 : 50ml水杯, ---> 小数据类型
500ml水瓶---> 大数据类型
将水瓶中水倒入到水杯中, 可以, 但是水有可能会溢出
(2)格式:
目标数据类型 变量名 = (目标数据类型)原数据类型变量名或原常量值;
(3)注意事项:
1. 强制类型转换可能会损失精度,得到错误的数据.
2. 小数类型强制转换为整数类型时,直接舍去小数部分,只保留整数部分.
(4) 常量优化机制: 在编译时,整数常量的计算会直接算出结果,并且会自动判断该结果是否在该数据
类型取值范围内
public class Day0302 {
public static void main(String[] args) {
//强制向下转型 水池水 --- 水桶里装
//整数
long l = 10000000000000L;
int i = (int)l; //1316134912 -- 损失数据 慎重
byte b = (byte)l; //0
//浮点
double d = 9.9;
float f = (float)d;
//浮点转整数 -- 直接舍弃小数位
int x = (int)d;
//一旦出现数据不稳定不确定的情况，使用的时候宁愿麻烦也要转为大类型计算
System.out.println(x);
}
}public class D0410 {
public static void main(String[] args)
{
//8字节
long l = 888888888888L;
double d = 88.88;
//4字节(强制转化)
int i = (int)l;
float f = (float)d;
//不同类型大转小
int k = (int)d;
float f1 = l;
char c = (char)l;
System.out.println(c);
System.out.println(f1);
}
}(c)小结
关于强制向下转型：如果不是必须要转化，那么在实际开发生尽量避免大类型转化为下类型，如 果无法避免，那么切记要保证数据完整。（接收的小类型一定比值的范围大）
关于自动向上转型：如果你想，随便。
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
