java从入门到精通（一）【包含数据类型与变量、运算符、程序逻辑控制】

已于 2025-04-03 20:36:11 修改
阅读量958 收藏 18
点赞数 9
CC 4.0 BY-SA版权
分类专栏： java 文章标签： java 开发语言 javaee
于 2025-04-01 21:05:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/suli20221202/article/details/146778840

一、初始java

1.1  java的main语句

public class HelloWorld{
 public static void main(String[] args){
 System.out.println("Hello,world");
 }
}

java的程序有三个部分组成

1.源文件（扩展名为*.java)：源文件带有类的定义。类用来表示程序的一个组件，小程序或许只会有一个 类。类的内容必须包含在花括号里面。

2.类：类中带有一个或多个方法。方法必须在类的内部声明。

3.方法：在方法的花括号中编写方法应该执行的语句。 总结一下：类存在于源文件里面；方法存在于类中；语句存在于方法中。

注意：在一个源文件中只能有一个public修饰的类，而且源文件名字必须与public修饰的类名字相同。

1.2  java注释有几种？

单行注释：// 注释内容（用的最多）

多行注释：/* 注释内容*/（不推荐）

文档注释： /** 文档注释 */（常见于方法和类之上描述方法和类的作用)，可以被javadoc工具解析，生 成一套以网页文件形式体现的程序说明文档

注意：

1. 多行注释不能嵌套使用

2. 不论是单行还是多行注释，都不参与编译，即编译之后生成的.class文件中不包含注释信息。

1.3  什么是标识符

在程序中由用户给  类名、方法名 或者  变量  所取的名字。

1.3.1 标识符规范

一）强制规范：

标识符中可以包含：字母、数字以及 下划线和 $ 符号等等。

注意：标识符不能以数字开头，也不能是关键字，且严格区分大小写。

二）建议书写规范：

类名：每个单词的首字母大写(大驼峰)

方法名：首字母小写，后面每个单词的首字母大写(小驼峰)

变量名：与方法名规则相同

eg：下面那些标识符是合法的？ A：class B：HelloWorld C：main D：123abc E：ARRAY_SIZE F: $name G: name:jim

正确答案： B、E、F

1.4 java中的关键字有哪些

如下图

二、 数据类型与变量

2.1  什么是字面常量？

在程序运行期间固定不变的量称为常量

public class Demo{
    public static void main(String[] args){
         System.Out.println("hello world!");
         System.Out.println(100);
         System.Out.println(3.14);
         System.Out.println('A');
         System.Out.println(true);
        
   }
}

2.1.1 数据类型

在Java中数据类型主要分为两类：1）基本数据类型 。4类8种。

                                                       2）引用数据类型。

一）基本数据类型

四类：整型、浮点型、字符型以及布尔型

八种：

数据类型关键字内存占用范围
字节型byte1字节-128 ~127
短整型short2字节-32768 ~ 32767
整形int 4字节-2^31 ~2^31-1
长整形long8字节-2^63-2^63-1
单精度浮点数float4字节有范围不关注
双精度浮点数double8字节有范围不关注
布尔型boolean无规定ture和false

注意：不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节 整形和浮点型都是带有符号的 整型默认为int型，浮点型默认为double 字符串属于引用类型。、

补充：字节是计算机中表示空间大小的基本单位. 计算机使用二进制表示数据. 我们认为 8 个二进制位(bit) 为一个字节(Byte). 我们平时的计算机为 8GB 内存, 意思是 8G 个字节. 其中 1KB = 1024 Byte, 1MB = 1024 KB, 1GB = 1024 MB. 所以 8GB 相当于 80 多亿个字节.

2.2   什么是变量？

在程序运行中，会改变的量 称为变量。 数据类型就是用来定义不同变量的。

2.2.1  语法格式：

数据类型 变量名 = 初始值;

int a = 10;   // 定义整形变量a，a是变量名也称为标识符，该变量中放置的值为10
double d = 3.14;
char c = 'A';
boolean b = true;
 
// 注意：在一行可以定义多个相同类型的变量
int a1 = 10, a2 = 20, a3 = 30

2.3  整形变量

1）在定义时给出初始值

int a = 10;
System.Out.println(a);

2）在定义时没有给初始值，但使用前必须设置初值，无初值程序会报错

int b;
b = 10;
System.Out.println(b);

3)  int 型变量所能表示的范围 可用如下代码查看：

 注意：在定义int性变量时，所赋值不能超过int的范围

System.Out.println(Integer.MIN_VALUE);
System.Out.println(Integer.MAX_VALUE);

1. int不论在任何种系统下都是4个字节

2. 推荐使用方式一定义，如果没有合适的初始值，可以设置为0

3. 在给变量设置初始值时，值不能超过int的表示范围，否则会导致溢出

4. 变量在使用之前必须要赋初值，否则编译报错

5. int的包装类型为 Intege

2.4   短整形变量

1.byte在任何系统下都占1个字节

2. byte的范围是：-128 ~ 127

3. 字节的包装类型为Byte

其余同上整形变量

2.5  长整形变量 

1. 长整型变量的初始值后加L或者l，推荐加L2. 长整型不论在那个系统下都占8个字节

3. 长整型的表示范围为：-2^63 ~2^63-1

4. long的包装类型为Long

其余同上整形变量

2.6   字节变量

byte b = 10;
System.Out.println(b)


// byte型变量所能表示的范围：
System.Out.println(Byte.MIN_VALUE);
System.Out.println(Byte.MAX_VALUE);

1. byte在任何系统下都占1个字节

2. byte的范围是：-128 ~ 127

3. 字节的包装类型为Byte

2.7  浮点型变量

2.7.1 单精度浮点型

float num = 1.0f;    // 写作 1.0F 也可以
System.out.println(num);

1. float 类型在 Java 中占四个字节,

2. 同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数 都优先考虑 double, 不太推荐使用 float.

3. float的包装类型为Float

2.7.2  双精度浮点数

double d = 3.14;
System.Out.println(d);

1. double在任何系统下都占8个字节

2. 浮点数与整数在内存中的存储方式不同，不能单纯使用 的形式来计算

3. double的包装类型为Double

2.8  字符型变量

char c1 = 'A';    // 大写字母
char c2 = '1';    // 数字字符
 
System.out.println(c1);
System.out.println(c2);
 
// 注意：java中的字符可以存放整形
char c3 = '帅';
System.out.println(c3);

1. Java 中使用 单引号 + 单个字母 的形式表示字符字面值.

2. 计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此 一个字符占用两个字节, 表示的字符种类更多, 包括中文.

3. char的包装类型为Character

2.9  布尔型变量

boolean b = true;
System.out.println(b);
 
b = false;
System.out.println(b);

1. boolean 类型的变量只有两种取值, true 表示真, false 表示假.

2. Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法.

3. Java虚拟机规范中，并没有明确规定boolean占几个字节，也没有专门用来处理boolean的字节码指令，在 Oracle公司的虚拟机实现中，boolean占1个字节。

4. boolean的包装类型为Boolean。

三、类型转换

类型转换分为强制类型转换（显性）和自动类型转换（隐性）

3.1  自动类型转换（隐性）

代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。特点：数据范围小的转为数 据范围大的时会自动进行。

System.Out.println(1024);   // 整型默认情况下是int
System.Out.println(3.14);   // 浮点型默认情况下是double
int a = 100;
long b = 10L;
b = a;   // a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值
a = b;   // 编译报错，long的范围比int范围大，会有数据丢失，不安全
 
float f = 3.14F;
double d = 5.12;
 
d = f; // 编译器会将f转换为double，然后进行赋值
f = d; // double表示数据范围大，直接将float交给double会有数据丢失，不安全
 
 
byte b1 = 100;  // 编译通过，100没有超过byte的范围，编译器隐式将100转换为byte
byte b2 = 257;  // 编译失败，257超过了byte的数据范围，有数据丢失

3.2  强制类型转换 （显性）

强制类型转换：当进行操作时，代码需要经过一定的格式处理，不能自动完成。特点：数据范围大的到数据范围小的。

int a = 10;
long b = 100L;
b = a;        // int-->long，数据范围由小到大，隐式转换
a = (int)b;   // long-->int, 数据范围由大到小，需要强转，否则编译失败
 
float f = 3.14F;
double d = 5.12;
d = f;        // float-->double，数据范围由小到大，隐式转换
f = (float)d; // double-->float, 数据范围由大到小，需要强转，否则编译失败
 
a = d;   // 报错，类型不兼容
a = (int)d;   // int没有double表示的数据范围大，需要强转，小数点之后全部丢弃
 
byte b1 = 100;        // 100默认为int，没有超过byte范围，隐式转换
byte b2 = (byte)257;  // 257默认为int，超过byte范围，需要显示转换，否则报错
 
boolean flag = true;
a = flag;   // 编译失败：类型不兼容
flag = a;   // 编译失败：类型不兼容

1. 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型

2. 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失

3. 将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查

4. 强制类型转换不一定能成功，不相干的类型不能互相转换

3.3  字符串类型

在有些情况下，需要将字符串和整形数字之间进行转换：

1. int 转成 String

int num = 10;
// 方法1
String str1 = num + "";  
// 方法2
String str2 = String.valueOf(num);

2. String 转成 int

String str = "100";
int num = Integer.parseInt(str);

四、类型提升

1. 不同类型的数据混合运算, 范围小的会提升成范围大的.

2. 对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算.

五、运算符

5.1 算数运算符

1） 基本四则运算符：加减乘除模(+ - * / %)

int a = 20;
int b = 10;
 
System.out.println(a + b);     // 30
System.out.println(a - b);     // 10
System.out.println(a * b);     // 200
System.out.println(a / b);     // 2
System.out.println(a % b);     // 0 --->模运算相当于数学中除法的余数

注意： 都是二元运算符，使用时必须要有左右两个操作数 int / int 结果还是int类型，而且会向下取整

2） 增量运算符 += -= *= %=

int a = 1;
a += 2;                  // 相当于 a = a + 2
System.out.println(a);   // 输出3
 
a -= 1;                  // 相当于 a = a - 1
System.out.println(a);   // 输出2
 
a *= 3;                  // 相当于 a = a * 3
System.out.println(a);   // 输出6
 
a /= 3;                  // 相当于 a = a / 3

3） 自增/自减运算符 ++ --

int a = 1;
a++;    // 后置++   表示给a的值加1，此时a的值为2
System.out.println(a++);   // 注意：后置++是先使用变量原来值，表示式结束时给变量+1，因此输出2
System.out.println(a);     // 输出3
 
 
++a;    // 前置++   表示给a的值加1
System.out.println(++a);   // 注意：前置++是先给变量+1，然后使用变量中的值，因此输出5
System.out.println(a);     // 输出5
 
// --操作符给操作-1，与++含义类似

注意：

1.单独使用，【前置++】和【后置++】没有任何区别

2.混合使用，【前置++】先+1，然后使用变量+1之后的值，【后置++】先使用变量原来的值，表达式 结束时给变量+1

3.只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改

5,2  关系运算符

关系运算符主要有六个: == != < > = ，其计算结果是 true 或者 false 。

int a = 10;
int b = 20;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
//     在Java中 == 表示相等
System.out.println(a == b);       // false
System.out.println(a != b);       // true
System.out.println(a < b);        // true
System.out.println(a > b);        // false
System.out.println(a <= b);       // true
System.out.println(a >= b);       // false

5.3   逻辑运算符（重点）

逻辑运算符主要有三个: && || ! ，运算结果都是 boolean类型。

1） 逻辑与 &&

语法规则：表达式1 && 表达式2，左右表达式必须是boolean类型的结果。 相当于现实生活中的且。全真为真，其余为假。

比如：如果是学生，并且 带有学生证 才可以享受半票。 两个表达式都为真，结果才是真，只要有一个是假，结果就是假。

表达式1表达式2结果
真真

真

真假假
假真假
假假假
int a = 1;
int b = 2;
 
System.out.println(a == 1 && b == 2);   // 左为真 且 右为真 则结果为真
System.out.println(a == 1 && b > 100);  // 左为真 但 右为假 则结果为假
System.out.println(a > 100 && b == 2);  // 左为假 但 右为真 则结果为假
System.out.println(a > 100 && b > 100); // 左为假 且 右为假 则结果为假

2）逻辑或  ||

语法规则：表达式1 || 表达式2，左右表达式必须是boolean类型的结果。全假为假，其余为真。

相当于现实生活中的或，比如：买房子交钱时，全款 或者 按期 都可以，如果全款或者按期，房子都是你的， 否则就不是你的。

表达式1表达式2结果
真真真
真假真
假真真
假假假
int a = 1;
int b = 2;
 
System.out.println(a == 1 || b == 2);   // 左为真 且 右为真 则结果为真
System.out.println(a == 1 || b > 100);  // 左为真 但 右为假 则结果也为真
System.out.println(a > 100 || b == 2);  // 左为假 但 右为真 则结果也为真
System.out.println(a > 100 || b > 100); // 左为假 且 右为假 则结果为假

3） 逻辑非 !

语法规则：! 表达式    真变假，假变真。

表达式结果
真假
假真
int a = 1;


System.out.println(!(a == 1));   // a == 1 为true，取个非就是false
System.out.println(!(a != 1));  // a != 1 为false，取个非就是true

4）短路求值（重点）

&& 和 || 遵守短路求值的规则.

例如   &&   当  逻辑与 左侧  表达式为假时，就不会执行 逻辑与  右侧的表达式

           ||     当  逻辑或  左侧 表达式为真时，就不会执行  逻辑或  右侧的表达式

对于 && , 如果左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式.

对于 ||, 如果左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式.

& 和 | 如果表达式结果为 boolean 时, 也表示逻辑运算. 但与 && || 相比, 它们不支持短路求值.

5.4 位运算符

位运算符主要有四个: & | ~ ^ ，除 ~ 是一元运算符外，其余都是二元运算符。

位操作表示 按二进制位运算. 计算机中都是使用二进制来表示数据的(01构成的序列), 按位运算就是在按照二进制位 的每一位依次进行计算.

1）  按位与 &: 如果两个二进制位都是 1, 则结果为 1, 否则结果为 0

eg：10 与 20

100000101010的二进制
200001010020的二进制
按位与后000000000的二进制

2） 按位或 |: 如果两个二进制位都是 0, 则结果为 0, 否则结果为 1.

eg：10 或 20

100000101010的二进制
200001010020的二进制
按位或后0001111030的二进制

注意: 当 & 和 | 的操作数为整数(int, short, long, byte) 的时候, 表示按位运算, 当操作数为 boolean 的时候, 表 示逻辑运算

3）  按位取反 ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0

100000101010的二进制
按位或后11110101246的二进制

注意： 0x 前缀的数字为 十六进制 数字. 十六进制可以看成是二进制的简化表示方式. 一个十六进制数字对应 4 个二进制位. 0xf 表示 10 进制的 15, 也就是二进制的 1111 printf 能够格式化输出内容, %x 表示按照十六进制输出. \n 表示换行符

4） 按位异或 ^: 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.

100000101010的二进制
200001010020的二进制
按位异或后0001111030的二进制

注意：如果两个数相同，则异或的结果为0

5.5 移位运算符（了解）

移位运算符有三个: > >>> ，都是二元运算符，且都是按照二进制来运算的。

1）  左移 最左侧位不要了, 最右侧补 0.

int a = 0x10;
System.out.printf("%x\n", a << 1);
 
// 运行结果(注意, 是按十六进制打印的)
20

注意：向左移位时，丢弃的是符号位，因此正数左移可能会编程负数。

2）  右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)

int a = 0x10;
System.out.printf("%x\n", a >> 1);
 
// 运行结果(注意, 是按十六进制打印的)
8
    
int b = 0xffff0000;
System.out.printf("%x\n", b >> 1);
 
// 运行结果(注意, 是按十六进制打印的)
ffff8000

3）  无符号右移 >>>: 最右侧位不要了, 最左侧补 0.

int a = 0xffffffff; System.out.printf("%x\n", a >>> 1); // 运行结果(注意, 是按十六进制打印的) 7fffffff

注意:

1. 左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.

2. 右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.

3. 由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.

4. 移动负数位或者移位位数过大都没有意义.

5.6  条件运算符

条件运算符只有一个:

表达式1 ? 表达式2 : 表达式3

当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值;

当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值.

也是 Java 中唯一的一个 三目运算符, 是条件判断语句的简化写法.

// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;

注意：

1. 表达式2和表达式3的结果要是同类型的，除非能发生类型隐式类型转换

2. 表达式不能单独存在，其产生的结果必须要被使用。

5.7  运算符的优先级

在一条表达式中，各个运算符可以混合起来进行运算，但是运算符的优先级不同，比如：* 和 / 的优先级要高于 + 和 - ，有些情况下稍不注意，可能就会造成很大的麻烦。

// 求a和b的平均值
int a = 10;
int b = 20;
int c = a + (b - a) >> 1;
System.out.println(c);


10

上述表达式中，由于 + 的优先级要高于 >> , 因此a先和b-a的结果做加法，整体为20，最后再进行右移，因此结果 为10。

注意：运算符之间是有优先级的. 具体的规则我们不必记忆. 在可能存在歧义的代码中加上括号即可.

六、逻辑控制语句

6.1   顺序结构

按照代码书写的顺序一行一行执行。

System.out.println("aaa");
System.out.println("bbb");
System.out.println("ccc");、


// 代码书写顺序改变 结果也会改变 
// 运行结果
aaa
bbb
ccc

6.2   选择结构

6.2.1  if 语句

1）语法格式1

如果布尔表达式结果为true，执行if中的语句，否则不执行。

if(布尔表达式){
    // 语句
}

eg 进行判断 如果位true则执行语句

int score = 92;
if(score >= 90){
    System.out.println("学无止境");
}

2） 语法格式2

如果布尔表达式结果为true，则执行if中语句，否则执行else中语句。

if(布尔表达式){
    // 语句1
}else{
    // 语句2
}

eg 判断 90 分以上进行奖励 90分一下进行惩罚

int score = 92;
if(score >= 90){
    System.out.println("奖励!!!");
}else{
    System.out.println("惩罚!!!");
}

3）语法格式3

表达式1成立，执行语句1，否则表达式2成立，执行语句2，否则执行语句3

if(布尔表达式1){
    // 语句1
}else if(布尔表达式2){
    // 语句2
}else{
    // 语句3
}

eg：分数在 [90, 100] 之间的，为优秀   

分数在 [80, 90) 之前的，为良好

分数在 [70, 80) 之间的，为中等

分数在 [60, 70) 之间的，为及格

分数在 [ 0, 60) 之间的，为不及格

其余为错误数据

if(score >= 90){
    System.out.println("优秀");
}else if(score >= 80 && score < 90){
    System.out.println("良好");
}else if(score >= 70 && score < 80){
    System.out.println("中等");
}else if(score >= 60 && score < 70){
    System.out.println("及格");
}else if(score >= 0 && score < 60){
    System.out.println("不及格");
}else{
    System.out.println("错误数据");
}

6.2.2   switc语句

1）语法

1. 先计算表达式的值

2. 和case依次比较，一旦有响应的匹配就执行该项下的语句，直到遇到break时结束 、

3. 当表达式的值没有与所列项匹配时，执行default

switch(表达式){
 case 常量值1:{
语句1;[break;]
 }
 case 常量值2:{
 语句2;
 [break;]
 }
default:{
 内容都不满足时执行语句;
 [break;]
 } 
}

注意：

1.多个case后的常量值不可以重复 switch的括号内只能是以下类型的表达式： 基本类型：byte、char、short、int

2.不能是long类型 引用类型：String常量串、枚举类型

3.break 不要遗漏, 否则会失去 "多分支选择" 的效果

4.switch 不能表达复杂的条件

5.switch 虽然支持嵌套, 但是不美观，一般不推荐

6.3  循环结构

6.3.1  while循环

格式

循环条件为 true, 则执行循环语句; 否则结束循环

while(循环条件){
 循环语句;
}

eg： 打印1到100之间的数字

int num = 1;
while (num <= 10) {
    System.out.println(num);
    num++;
}

注意：

1. 和 if 类似, while 下面的语句可以不写 { } , 但是不写的时候只能支持一条语句. 建议还是加上 { }

2. 和 if 类似, while 后面的 { 建议和 while 写在同一行.

3. 和 if 类似, while 后面不要多写 分号, 否则可能导致循环不能正确执行.

6.3.2  break

break 的功能是让循环提前结束

eg：找到 100 - 200 中第一个 3 的倍数

int num = 100;
while (num <= 200) {
    if (num % 3 == 0) {
        System.out.println("找到了 3 的倍数, 为:" + num);
        break;
   }
    num++;
}
 
// 执行结果
找到了 3 的倍数, 为:102

6.3.3  continue

continue 的功能是让循环跳出本次循环 执行下一次循环

eg：找到 100 - 200 中所有 3 的倍数

int num = 100;
while (num <= 200) {
    if (num % 3 != 0) {
        num++;  // 这里的 ++ 不要忘记! 否则会死循环. 
        continue;
   }
    System.out.println("找到了 3 的倍数, 为:" + num);
    num++;
}

6.3.4  for循环

格式

表达式1: 用于初始化循环变量初始值设置，在循环最开始时执行，且只执行一次

表达式2: 循环条件，满则循环继续，否则循环结束

表达式3: 循环变量更新方式

for(表达式①;布尔表达式②;表达式③){
 表达式④;
}

eg：打印 1 - 10 的数字

for (int i = 1; i <= 10; i++) {
    System.out.println(i);
}

注意：

1. 和 if 类似, for 下面的语句可以不写 { } , 但是不写的时候只能支持一条语句. 建议还是加上 { }

2. 和 if 类似, for 后面的 { 建议和 while 写在同一行.

3. 和 if 类似, for 后面不要多写 分号, 否则可能导致循环不能正确执行.

 4. 和while循环一样，结束单趟循环用continue，结束整个循环用break

6.3.5 do  while 循环

格式：

先执行循环语句, 再判定循环条件，循环条件成立则继续执行，否则循环结束。

do{
 循环语句;
}while(循环条件);

eg：打印 1 - 10

int num = 1;
do {
    System.out.println(num);
    num++;
} while (num <= 10);

七、输入输出语句

7.1 输入语句

使用 Scanner 读取    字符串/整数/浮点数

格式：

 注意事项: 当循环输入多个数据的时候, 使用 ctrl + z 来结束输入 (Windows 上使用 ctrl + z, Linux / Mac 上使用 ctrl
+ d).
在后续oj题当中，遇到IO类型的算法题，有各种循环输入的要求，后序给大家介绍。
import java.util.Scanner;  // 需要导入 util 包
 
Scanner sc = new Scanner(System.in);

sc.close(); // 注意, 要记得调用关闭方法

eg：

 
使用 Scanner 循环读取 N 个数字，并求取其平均值
。
import java.util.Scanner;  // 需要导入 util 包
 
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的姓名：");
String name = sc.nextLine();
System.out.println("请输入你的年龄：");
int age = sc.nextInt();
System.out.println("请输入你的工资：");
float salary = sc.nextFloat();
System.out.println("你的信息如下：");
System.out.println("姓名: "+name+"\n"+"年龄："+age+"\n"+"工资："+salary);
sc.close(); // 注意, 要记得调用关闭方法

7.2   输出语句

格式：

println 输出的内容自带 \n,

print 不带 \n

printf 的格式化输出方式和 C 语言的 printf 是基本一致的.

System.out.println(msg);            // 输出一个字符串, 带换行
System.out.print(msg);              // 输出一个字符串, 不带换行
System.out.printf(format, msg); // 格式化输出

格式化字符串：

转换符类型
d十进制
x十六进制
o八进制
f定点浮点数
e指数浮点数
g通用浮点数
a十六进制浮点数
s字符串
c字符
b布尔值
h散列码
%百分号

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值