文章目录
本章资料
本章重点
解释
- 数据类型的转换其实就是字节的转换.
- 4个字节的int转换为8个字节的long, 计算机当然能够转换, 无非是在前面加32个0.
- 8个字节的long转换为4个字节的int, 意味着要去掉前面32位, 精度降低, 以牺牲精度进行的数据转换我们叫它
强制数据类型转换.强制数据类型转换我们需要显示地声明一下, 以告诉计算机我要牺牲精度, 来换取数据类型转换, 我已充分考虑到精度降低带来的后果.
🍄Java变量
🐎变量原理
●为什么需要变量?
一个程序就是一个世界
●变量是程序的基本组成单位
不论是使用哪种高级程序语言编写程序, 变量都是其程序的基本组成单位, 比如:
●变量有三个基本要素(类型+名称+值)
class Test {
int a = 1;//定义了一个变量, 类型int整型, 名称a, 值1
int b = 3;//定义了一个变量, 类型int整型, 名称b, 值3
b = 89;//把89值赋给 b变量
System.out.println(a);//输出a变量的值
System.out.println(b);//输出b变量的值
}
🐎变量概念
●变量(变化的值)的介绍
变量相当于内存中一个数据存储空间的表示, 你可以把变量看做是一个房间的门牌号, 通过门牌号我们可以找到房间., 而通过变量名我们可以访问到变量(值)
●变量使用的基本步骤
1.声明变量
int a;
2.赋值
a = 60; // 应该这么说, 把60赋给a
3.使用 System.out.prinln(a);
public class var01 {
//编写一个main方法
public static void main(String[] args) {
//声明变量
int a;
a = 100;
System.out.println(a);
//还可以这样使用
int b = 800;
System.out.println(b);
}
}
🐎变量快速入门
演示记录人信息的代码
public class var02 {
//编写一个main方法
public static void main(String[] args) {
//记录人的信息
int age = 30;
double score = 88.9;
char gender = '男';
String name = "小明";
//输出信息
System.out.println("人的信息如下:");
System.out.println(name);
System.out.println(age);
System.out.println(score);
System.out.println(gender);
}
}
🐎注意事项和细节
1.变量表示内存中的一个存储区域[不同的变量, 类型不同, 占用的空间大小不同. 比如: int 4个字节, double 就是 8个字节. 先有基本印象]
2.该区域有自己的名称[变量名]和类型[数据类型]
3.变量必须先声明, 后使用, 即有顺序.
4.该区域的数据/值可以在同一类型范围内不断变化
5.变量在同一个作用域内不能重名
6.变量 = 变量名 + 值 + 数据类型, 变量三要素.
public class varDetail {
//编写一个main方法
public static void main(String[] args) {
//变量必须先声明, 后使用, 即有顺序
int a = 50;//int
System.out.println(a);//50
//该区域的数据/值可以在同一类型范围内不断变化
//a = "jack";//错误
a = 88;//正确
System.out.println(a);//88
//变量在同一个作用域内不能重名
// int a = 77;//错误
}
}
class Dog {
public static void main(String[] args) {
int a = 12;//正确
}
}
🐎程序中’+'号的使用
1.当左右两边都是数值型时, 则做加法运算
2.当左右两边有一方为字符串, 则做拼接运算
3.运算的顺序, 是从左到右
下面的代码输出什么
System.out.println(100 + 98);// 198
System.out.println(“100” + 98);// 10098
System.out.println(100 + 3 + “hello”);// 103hello
System.out.println(“hello” + 100 + 3);// hello1003 执行顺序: 从左到右
public class plus {
//编写一个main方法
public static void main(String[] args) {
System.out.println(100 + 98);// 198
System.out.println("100" + 98);// 10098
System.out.println(100 + 3 + "hello");// 103hello
System.out.println("hello" + 100 + 3);// hello1003
}
}
🐍Java数据类型
每一种数据都定义了明确的数据类型, 在内存中分配了不同大小的存储空间(字节).
1.java 数据类型分为两大类 基本数据类型, 引用类型
2.基本数据类型有8种, 数值型[byte, short, int, long, float, double], char, boolean
3.引用类型[类, 接口, 数组]
🐸整数类型
●基本介绍
Java的整数类型就是用于存放整数值的, 比如1, 2, 3;
●整型的类型
| 项目 | Value | Value |
|---|---|---|
| byte[字节] | 1字节 | -128~127 |
| short[短整型] | 2字节 | -215 ~ 215-1 |
| int[整型] | 4字节 | -231 ~ 231 -1 |
| long[长整型] | 8字节 | -263 ~ 263 -1 |
byte n1 = 10;
short n2 = 10;
int n3 = 10;//4个字节
long n4 = 10;//8个字节
🐸整数类型的使用细节
1.Java各整数类型有固定的范围和字段长度, 不受具体OS[操作系统]的影响, 以保证java程序的可移植性.
2.Java的整型常量(具体值)默认是int型, 声明long型常量后需要加 l或 L
3.Java程序中变量常声明为int型, 除非不足以表示大数, 才使用long
4.bit: 计算机中的最小存储单位. byte: 计算机中基本存储单元, 1byte=8bit
public class intDetail {
//编写一个main方法
public static void main(String[] args) {
//Java的整型常量(具体值)默认为 int 型, 声明long型常量后需要加'l'或'L'
int n1 = 1;//4个字节
//不兼容的类型, 从long转换到int可能会有损失
// int n2 = 1L;//long类型是8个字节, int是4个字节
long n3 = 1L;//正确
}
}
🐸浮点类型
●基本介绍
Java的浮点类型可以表示一个小数, 比如1.2, 12.3, 123.4
●浮点型的分类
| 类型 | 占用存储空间 | 范围 |
|---|---|---|
| 单精度 | 4字节 | -3.403E38 ~ 3.403E38 |
| 双精度 | 8字节 | -1.798E308 ~ 1.798E308 |
●说明
1.关于浮点数在机器中存放形式的说明: 浮点数 = 符号位 + 指数位 + 尾数位
2.尾数部分可能丢失, 造成精度损失(小数都是近似值)
🐸浮点类型的使用细节
1.与整数类型类似, Java 浮点类型也有固定的范围和字段长度, 不受具体OS[操作系统]的影响.[float 4个字节; double 8个字节]
2.Java的浮点型常量(具体值)默认为double, 声明float型常量, 需后加f或F
3.浮点型常量有两种表示形式
十进制数形式, 如: 5.12, 5.12F, .512(0.512允许把0省略, 但必须有小数点)
科学计数法形式, 如: 5.12E2[5.12 * 102, 小数点右移两位]-------------- 5.12E-2[5.12 / 102, 小数点左移两位]
4.通常情况下, 应该使用double类型, 因为它比float型更精确.
5.浮点数使用陷阱: 2.7 和 8.1 / 3, 比较
- float或者double类型的小数相加运算时会发现结果有很多位小数,原因在于float/double(二进制)不能精确地表示小数
- 解决方案是将String类型转化为BigDecimal, 将Double的小数转化为BigDecimal要注意用setScale()方法确定小数位数.
- BigDecimal的加减乘除(add(), subtract(), multiply, divide())得到的仍然是BigDecimal,转成字符串用.toString()
public class FloatDetail {
//编写一个main方法
public static void main(String[] args) {
//java 的浮点类型默认为double型, 声明float型常量, 需后加 f 或 F
//double为8个字节, float是4个字节
//不兼容的类型, 从double转换到float可能会有精度损失
// float num1 = 1.1;
float num2 = 1.1F;//正确
double num3 = 1.1;//正确
//4个字节转化为8个字节, 不会出现精度损失
double num4 = 1.1F;//正确
//十进制数形式, 如: 5.12, 5.12F, .512(0.512允许把0省略, 但必须有小数点)
double num5 = .512;//等价于0.512
System.out.println(num5);
//科学计数法
System.out.println(5.12e2);//512.0
System.out.println(5.12e-2);//0.0512
//通常情况下, 应该使用double类型, 因为它比float型更精确.
float num6 = 2.1234567891f;
double num7 = 2.1234567891;
System.out.println(num6);//2.1234567
System.out.println(num7);//2.1234567891
//浮点数使用陷阱 2.7 和 8.7 / 3, 比较
double num8 = 2.7;
double num9 = 8.1 / 3; // 等于多少 ?
System.out.println(num8);//2.7
System.out.println(num9);//接近2.7的一个小数, 而不是2.7 => 2.6999999999999997
//得到一个重要的知识点: 当我们对运算结果是小数的数进行相等判断时, 要小心
//应该是以两个数的差值的绝对值, 在某个精度范围内判断
if(num8 == num9) {
System.out.println("相等");
}
//正确的写法.comment shortcuts: ctrl + /
if(Math.abs(num8 - num9) < 1E-7) {//1E-7 相当于 0.0000001
System.out.println("差值非常小, 到了我规定的精度, 认为相等...");
}
//可以通过java API
System.out.println(Math.abs(num8 - num9));//4.440892098500626E-16(4.440892098500626 / 10^16)
//细节: 如果是直接查询得到的小数或者直接赋的值, 是可以直接判断
double num10 = 2.7;
double num11 = 2.7;
System.out.println(num10);
System.out.println(num11);
if(num10 == num11) {
System.out.println("相等");
}
// if(Math.abs(num10 - num11) < 1E-7) {//1E-7 相当于 0.0000001
// System.out.println("差值非常小, 当了我规定的精度, 认为相等...");
// }
}
}
🐍Java API 文档
1.API (Application Programming Interface, 应用程序编程接口) 是 Java 提供的基本编程接口(包括java提供的类还有相关的方法). 中文在线文档: https://www.matools.com
2.java语言提供了大量的基础类, 因此 Oracle公司也为这些基础类提供了相应的API文档, 用于告诉开发者如何使用这些类, 以及这些类里包含的方法.
3.java类的组织形式
4.举例说明如何使用 Java API 文档. PrintStream有哪些方法. 1.按照 包-类-方法. 2.直接索引.
🐸字符类型(char)
●基本介绍
字符类型可以表示单个字符, 字符类型是char, char是两个字节(两个字节可以存放汉字), 多个字符我们用字符串String
案例
public class Char01 {
//编写一个main方法
public static void main(String[] args) {
char c1 = 'a';
char c2 = '\t';
char c3 = '赵';
char c4 = 97;//说明: 字符类型可以直接存放一个数字
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);//当输出c4的时候, 会输出97表示的值
}
}
🐸字符类型(char)的使用细节
1.字符常量使用单引号(’ ')括起来的单个字符, 例如 char c1 = ‘a’; char c2 = ‘中’; char c3 = ‘b’;
2.Java中还允许使用转义字符 ‘’ 将其后的字符转变为特殊字符型常量, 例如 char c3 = ‘\n’; // \n表示换行符
3.在java中, char的本质是一个整数, 在输出时, 是unicode码[兼容ASCII码]对应的字符
4.可以直接给char赋一个整数, 然后输出时, 会按照对应的unicode字符输出
5.char类型是可以进行运算的, 相当于一个整数, 因为它都对应有Unicode码.
public class CharDetail {
//编写一个main方法
public static void main(String[] args) {
//在java中, char的本质是一个整数, 在默认输出时, 是unicode码对应的字符
//要输出对应的数字, 可以(int)转型
char c1 = 97;
System.out.println(c1);
char c2 = 'a';//输出a 对应的 数字
System.out.println((int)'a');
char c3 = '赵';
System.out.println((int)'赵');//36213
char c4 = 36213;
System.out.println(c4);//输出 赵
//char类型是可以进行运算的, 相当于一个整数, 因为它都对应有Unicode码.
System.out.println('a' + 10);//107
//课堂小测试
char c5 = 'b' + 1;
System.out.println((int)c5);//99
System.out.println(c5);//99对应的字符->ASCII编码表(规定好的)->c
}
}
🐸字符类型(char)的本质讨论
1.字符型存储到计算机中, 需要将字符对应的码值(整数)找出来, 比如 ‘a’ 存储: ‘a’ ⇒ 码值97 ⇒ 二进制(01100001) ⇒ 存储
读取: 二进制(01100001) ⇒ 97 ⇒ ‘a’ ⇒ 显示
2.字符和码值的对应关系是通过字符编码表决定的(规定好的)
●介绍一下字符编码表[sublime测试]
ASCII (1.ASCII 编码表 用一个字节表示. 2.总共128个字符. 3.实际上一个字节可以表示256个字符, 但是ASCII表只用了128个.)
Unicode (Unicode 编码表 固定大小的编码 使用两个字节来表示字符, 字母和汉字统一都是占用两个字节, 这样浪费空间)
utf-8 (编码表, 大小可变的编码 字母使用1个字节, 汉字使用3个字节)
gbk (可以表示汉字, 而且范围广, 字母使用1个字节, 汉字2个字节)
gb2312 (可以表示汉字 gb2312 < gbk)
big5 码 (繁体中文, 台湾, 香港)
下面这个代码, utf-8编码占6个字节; gbk编码占5个编码
abc赵
🐍常用编码
●ASCII码介绍
1.ASCII码: 上个世纪60年代, 美国制定了一套字符编码(使用一个字节), 对英语字符和二进制之间的关系, 做了统一规定. 这被称为ASCII码. ASCII码一共规定了128个字符的编码, 只占用了一个字节的后面7位, 最前面的1位统一规定为0.
特别提示: 一个字节可以表示256个字符, ASCII码只用了128个字符.
2.看一个完整的ASCII码表
3.缺点: 不能表示所有字符
●Unicode编码介绍
1.Unicode的好处: 一种编码, 将世界上所有的符号都纳入其中, 每一个符号都给予一个独一无二的编码, 使用 Unicode 没有乱码的问题.
2.Unicode的缺点: 一个英文字母和一个汉字都占用2个字节, 这对于存储空间来说是浪费.
3.2的16次方是 65536, 所以最多编码是65536个字符
4.编码0-127的字符是与ASCII编码表的编码一样. 比如’a’在ASCII码是0x61, 在unicode编码表是0x0061, 因此 Unicode码兼容ASCII码
●UTF-8编码介绍
1.UTF-8是在互联网上使用最广的一种Unicode的实现方式 (改进)
2.UTF-8是一种变长的编码方式, 它可以使用1-6个字节表示一个符号, 根据不同的符号而变化字节的长度.
3.使用 大小可以的编码 字母占1个字节, 汉字占3个字节
🐸布尔类型
●基本介绍
1.布尔类型也叫boolean类型, boolean类型数据只允许取值true和false, 无null
2.boolean类型占1个字节
3.boolean类型适于逻辑运算, 一般是用于程序流程控制
√ while循环控制语句
√ if条件控制语句
√ do-while循环控制语句
√ for循环控制语句
不可以用 0 或 非0 的整数来代替false和true, 这点和C语言, JavaScript不同
🐸基本数据类型-转换
介绍
当java程序在进行赋值或者运算时, 精度小的类型自动转换为精度大的数据类型, 这个就是自动类型转换.
数据类型按精度(容量)大小排序为(背, 这是规则)
看一个基本案例 AutoConvert.java
int a = ‘c’; //√
double d = 80; //√
public class AutoConvert {
//编写一个main方法
public static void main(String[] args) {
//演示自动转换
int a = 'c';//ok char->int
double d = 87;//ok int->double
System.out.println("a=" + a);//99
System.out.println("d=" + d);//87.0
}
}
🐸数据转换的注意事项和细节
1.有多种类型的数据混合运算时, 系统首先自动将所有数据转换成容量最大的那种数据类型, 然后再进行计算.
2.当我们把精度(容量)大 的数据类型赋值给精度(容量)小 的数据类型时, 就会报错, 反之就会进行自动类型转换.
3.(byte, short) 和 char之间不会相互自动转换
public class AutoConvertDetail {
//编写一个main方法
public static void main(String[] args) {
//细节1: 有多种类型的数据混合运算时, 系统首先自动将所有数据
//转换成容量最大的那种数据类型, 然后再进行计算.
int n1 = 10;
// float f1 = n1 + 1.0;//错误 n1 + 1.0 => 结果类型是 double
// double d1 = n1 + 1.0;//对
float f2 = n1 + 1.0f;//对
//细节2: 当我们把精度(容量)大 的数据类型赋值给精度(容量)小
//的数据类型时, 就会报错, 反之就会进行自动类型转换.
// int n2 = 1.1;//错误 double不能转换为int
//细节3: (byte, short) 和 char之间不会相互自动转换
//当把具体数赋给 byte 时, (1)先判断该数是否在byte范围内, 如果是就可以
byte b1 = 10;//对? 对 原因: 1个字节 00000000~11111111 -128~127
int n3 = 1;//n3是int
// byte b2 = n2;//对? 错 原因: 如果是变量赋值, 判断类型
// char c1 = b1;//对? 错 原因: byte不能自动转成char
}
}
4.byte, short, char 它们三者之间可以计算, 在计算时首先转换为int类型
5.boolean 不参与转换
6.自动提升原则: 表达式结果的类型自动提升为 操作数中最大的类型
AutoConvertDetail.java
public class AutoConvertDetail {
//编写一个main方法
public static void main(String[] args) {
//细节4: byte, short, char 它们三者之间可以计算, 在计算时首先转换为int类型
byte b3 = 1;
byte b4 = 2;
short s1 = 1;
//short s2 = b3 + s1;//错, b3 + s1 => int
int n4 = b3 + s1;//对, b3 + s1 => int
//byte b5 = b3 + b4;//错, b3 + b4 => int
//细节5: boolean 不参与转换
boolean pass = true;
//int num100 = pass;//boolean 不参与类型的自动转换
// 细节6: 自动提升原则: 表达式结果的类型自动提升为 操作数中最大的类型
byte b6 = 1;
short s3 = 100;
int num200 = 1;
float num300 = 1.1f;
//int d2 = b6 + s3 + num200 + num300;//错误: 不兼容的类型: 从float转换到int可能会有损失
double d2 = b6 + s3 + num200 + num300;//对
}
}
🐸基本数据类型-强制转换
●介绍
自动类型转换的逆过程, 将容量大的数据类型转换为容量小的数据类型. 使用时要加上强制转换符 ( ), 但可能造成精度降低或溢出, 要格外注意.
ForceConvert.java
public class ForceConvert {
//编写一个main方法
public static void main(String[] args) {
//演示强制类型转换
int n1 = (int) 1.9;
System.out.println("n1=" + n1);//没有报错, 但是造成精度损失
int n2 = 2000;
byte b1 = (byte) n2;//报错: 数据溢出
System.out.println("b1=" + b1);
}
}
🐸强制类型转换细节
1.当进行数据 从大 ⇒ 小 转换时, 就需要使用到强制转换
2.强转符号只针对于最近的操作数有效, 往往会使用小括号提升优先级
3.char类型可以保存int的常量值, 但不能保存int的变量值, 需要强转
4.byte,short和char类型,在进行运算时, 当作int类型处理
ForceConvertDetail.java
public class ForceConvertDetail {
//编写一个main方法
public static void main(String[] args) {
//演示强制类型转换
//强转符号只针对于最近的操作数有效, 往往会使用小括号提升优先级
// int x = (int) 10 * 3.5 + 6 * 1.5;//编译错误: 不兼容的类型: 从double转换到int可能会有损失
int y = (int) (10 * 3.5 + 6 * 1.5);
System.out.println("y=" + y);//44
char c1 = 100;//对
int n1 = 100;//对
//char c2 = n1;//错 不兼容的类型: 从int转换到char可能会有损失
char c3 = (char) n1;
System.out.println("c3=" + c3);//d
}
}
🐸基本数据转换-练习题
short s = 12;//ok
s = s - 9;//错误 int => short
byte b = 10;//ok
b = b + 11;//错误, int => byte
b = (byte) (b + 11);//ok, 使用强转
char c = 'a';//ok
int i = 16;//ok
float f = .314f;//ok 允许省略0
double d = c + i + f;//ok float => double 实现自动转换
byte b = 16;//ok
short s = 14;//ok
short t = s + b;//错误 int => short
🐸基本数据转换和String类型的转换
●介绍
在程序开发中, 我们经常需要将基本数据类型转成String类型, 或者将String类型转成基本数据类型.
●基本类型转String类型
语法: 将基本类型的值 + " " 即可
案例: BasicToString.java
public class BasicToString {
//编写一个main方法
public static void main(String[] args) {
//演示基本数据类型转String类型
int n1 = 100;
float f1 = 1.1f;
double d1 = 4.5;
boolean b1 = true;
String s1 = n1 + "";
String s2 = f1 + "";
String s3 = d1 + "";
String s4 = b1 + "";
System.out.println(s1 + " " + s2 + " " + s3 + " " + s4);
}
}
●String类型转基本类型
语法: 通过基本类型的包装类调用parseXX方法即可
案例: StringToBasic.java
public class StringToBasic {
//编写一个main方法
public static void main(String[] args) {
//演示String类型转基本数据类型
String s1 = "123";
byte b1 = Byte.parseByte(s1);
String s2 = "123";
short short1 = Short.parseShort(s2);
String s3 = "123";
int n1 = Integer.parseInt(s3);
String s4 = "123";
long l1 = Long.parseLong(s4);
String s5 = "1.1f";
float f1 = Float.parseFloat(s5);
String s6 = "1.2";
double d1 = Double.parseDouble(s6);
String s7 = "true";
boolean boolean1 = Boolean.parseBoolean(s7);
//会在OOP讲解对象和方法的时候学到
//使用 基本数据类型对应的包装类的相应方法, 得到基本数据类型
System.out.println("b1=" + b1);//123
System.out.println("short1=" + short1);//123
System.out.println("n1=" + n1);//123
System.out.println("l1=" + l1);//123
System.out.println("f1=" + f1);//1.1
System.out.println("d1=" + d1);//1.2
System.out.println("boolean1=" + boolean1);//true
//如何从字符串转为char字符 => 含义是指 把字符串的第一个字符取到
//解读: s7.charAt(0) 将s7字符串的第一个字符't'取出
System.out.println(s7.charAt(0));//t
}
}
🐸基本数据转换和String类型的换-注意事项和细节
1.再将String 类型转成 基本数据类型时, 要确保String类型能够转成有效的数据, 比如 我们可以把 “123”, 转成一个整数, 但是不能把 “hello” 转成一个整数
2.如果格式不正确, 就会抛出异常, 程序就会终止, 这个问题在异常处理章节中, 会学习到.
StringToBasicDetail.java
public class StringToBasicDetail {
//编写一个main方法
public static void main(String[] args) {
String str = "hello";
//转成int
int n1 = Integer.parseInt(str);
//编译的时候并不会报错, 执行的时候报错
System.out.println("n1=" + n1);
}
}
🍄第三章 · 课后练习
1.判断下面代码的输出Homework01.java
public class Homework01 {
//编写一个main方法
public static void main(String[] args) {
int n1;
n1 = 13;
int n2;
n2 = 17;
int n3;
n3 = n1 + n2;
System.out.println("n3=" + n3);//n3=30
int n4 = 38;
int n5 = n4 - n3;
System.out.println("n5=" + n5);//n5=8
}
}
2.使用char类型, 分别保存 \n \t \r \ 1 2 3等字符, 并打印输出Homework02.java
public class Homework02 {
//编写一个main方法
public static void main(String[] args) {
// 使用char类型, 分别保存 \n \t \r \\
// 1 2 3等字符, 并打印输出
char c1 = '\n';//换行
char c2 = '\t';
char c3 = '\r';
char c4 = '\\';
char c5 = '1';
char c6 = '2';
char c7 = '3';
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
System.out.println(c5);
System.out.println(c6);
System.out.println(c7);
}
}
3.编程, 保存两本书名, 用+拼接, 看效果.
保存两个性别, 用+拼接, 看效果.
保存两本书价格, 用+拼接, 看效果.Homework03.java
byte,short和char类型,在进行运算时, 当作int类型处理
public class Homework03 {
//编写一个main方法
public static void main(String[] args) {
//编程, 保存两本书名, 用+拼接, 看效果.
//保存两个性别, 用+拼接, 看效果.
//保存两本书价格, 用+拼接, 看效果.
String book1 = "天龙八部";
String book2 = "天书奇谭";
System.out.println(book1 + book2);//天龙八部天书奇谭
//性别应该使用char
char gender1 = '男';
char gender2 = '女';
System.out.println(gender1 + gender2);//得到的是 '男' 字符码值 + '女' 字符码值
//保存两本书价格
float price1 = 12.56f;
float price2 = 25.57f;
System.out.println(price1 + price2);//就是 12.55 + 25.55
}
}
4.编程实现如下效果Homework04.java
代码
public class Homework04 {
//编写一个main方法
public static void main(String[] args) {
/*
姓名 年龄 成绩 性别 爱好
xxx xxx xxx xxx xxx
要求:
1.使用变量将姓名, 年龄, 成绩, 性别, 爱好存储
2.使用+连接
3.添加适当的注释
4.添加转义字符, 使用一条语句输出
*/
String name = "赵志伟";
byte age = 23;
float score = 63.5f;
char gender = '男';
String hobby = "下棋";
//输出了信息, 可以使用换行的方式输出
System.out.println("姓名\t年龄\t成绩\t性别\t爱好\n"
+ name + "\t" + age + '\t' + score + '\t'
+ gender + '\t' + hobby);
}
}
1387
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
