XIN-XIANG荣

Java基础篇(简单语法的一些细节介绍）

活动地址：CSDN21天学习挑战赛
✨博客主页: XIN-XIANG荣
✨系列专栏:【Java SE】
✨一句短话: 难在坚持,贵在坚持,成在坚持!
✨博客说明: 尽己所能，把每一篇博客写好，帮助自己熟悉所学知识，也希望自己的这些内容可以帮助到一些在学习路上的伙伴，文章中如果发现错误及不足之处，还望在评论区留言，我们一起交流进步！

文章目录

前言
1. 注释
2. 标识符
3. 关键字
4. 常量
5. 数据类型
6. 变量
7. 类型转换
8. 字符串类型
9. 运算符
- 9.1 / %
- 9.2 += -= *= %=
- 9.3 逻辑非（！）、条件运算符
- 9.4 短路求值
- 9.5 移位运算
10. 逻辑控制
11. 输入输出
- 11.1 输出到控制台
- 11.2 从键盘输入
12. 获取一个随机数
结语

前言

这篇博客介绍Java中的一些基本语法，但由于这部分语法很简单，所以不做太多的赘述，只是在C语言的基础上介绍一些细节的区分。

1. 注释

Java中的注释主要分为以下三种：

单行注释：// 注释内容（用的最多）
多行注释：/* 注释内容*/（不推荐）
文档注释： /** 文档注释 */

这里主要是介绍文档注释，常见于方法和类之上描述方法和类的作用，可以被javadoc工具解析，生成一套以网页文件形式体现的程序说明文档。

javadoc 工具可以识别以下标签：

标签	描述
@author	标识一个类的作者
@deprecated	指名一个过期的类或成员
{@docRoot}	指明当前文档根目录的路径
{@inheritDoc}	从直接父类继承的注释
{@link}	插入一个到另一个主题的链接
{@linkplain}	插入一个到另一个主题的链接，但是该链接显示纯文本字体
@param	说明一个方法的参数
@return	说明返回值类型
@see	指定一个到另一个主题的链接
@serial	说明一个序列化属性
@serialData	说明通过writeObject( ) 和 writeExternal( )方法写的数据
@serialField	说明一个ObjectStreamField组件
@since	标记当引入一个特定的变化时
@throws	标志一个类抛出的异常
{@value}	示常量的值，该常量必须是static属性
@version	指定类的版本
@exception	和 @throws标签一样.

2. 标识符

程序中由用户给类名、方法名或者变量所取的名字。
【硬性规则】

标识符中可以包含：字母、数字以及下划线和 $ 符号等等。
不能使用关键字定义标识符
注意：标识符不能以数字开头，也不能是关键字，且严格区分大小写。

【软性建议】

类名：每个单词的首字母大写(大驼峰)
方法名：首字母小写，后面每个单词的首字母大写(小驼峰)
变量名：与方法名规则相同

3. 关键字

关键字是由Java语言提前定义好的，有特殊含义的标识符，或者保留字。

abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
switch	synchronized	this	throw	throws
transient	try	void	volatile	while

4. 常量

字面常量的分类：

字符串常量：由""括起来的，比如“12345”、“hello”、“你好”。
整形常量：程序中直接写的数字(注意没有小数点)，比如：100、1000
浮点数常量：程序中直接写的小数，比如：3.14、0.49
字符常量：由单引号括起来的当个字符，比如：‘A’、‘1’
布尔常量：只有两种true和false
空常量：null

5. 数据类型

在Java中数据类型主要分为两类：基本数据类型和引用数据类型。
基本数据类型有四类八种：

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

数据类型	关键字	内存占用	范围	包装类型
字节型	byte	1 字节	-128~127	Byte
短整型	short	2 字节	-32768~32767	Short
整形	int	4字节	-2^31~232-1	Integer
长整形	long	8字节	-2^63-263-1	Long
单精度浮点数	float	4字节	有范围，一般不关注	Float
双精度浮点数	double	8字节	有范围，一般不关注	Double
字符型	char	2字节	0~65535	Character
布尔型	boolean	没有明确规定	true和flase	Boolean

注意：

不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节
Java当中没有无符号数这个概念，整形和浮点型都是带有符号的
给出的字面常量中，整型默认为int型，浮点型默认为double

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

// long型变量所能表示的范围：这个数据范围远超过 int 的表示范围. 
//足够绝大部分的工程场景使用.
System.Out.println(Long.MIN_VALUE);
System.Out.println(Long.MAX_VALUE);

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

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

6. 变量

对于变量的概念这里不做介绍，

Java中变量的使用需要注意如下几点：

Java中变量在使用之前必须要赋值，否则会编译报错，所以变量在定义时尽量附上初始值，如果没有合适的初始值，可以设置为0.
在给变量进行赋值时，值不能超过变量类型的范围，否则会导致溢出，编译时也会报错
长整型（long）变量的初始值后加L或者l，推荐加L
计算机中的字符本质上是一个整数.,在 C 语言中使用 ASCII码表示字符, 而 Java 中使用 Unicode码表示字符. 因此一个字符占用两个字节, 表示的字符种类更多, 包括中文。
Java 的 boolean 类型和任何类型都不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法.

boolean value = true;
System.out.println(value + 1);

// 代码编译会出现如下错误
Test.java:4: 错误: 二元运算符 '+' 的操作数类型错误
System.out.println(value + 1);
^
第一个类型: boolean
第二个类型: int
1 个错误

7. 类型转换

Java 作为一个强类型编程语言, 当不同类型之间的变量相互赋值的时候, 会有教严格的校验.

Java中也存在隐式类型转换（隐式），强制类型转换（显式），整形提升等。
注意事项：

不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型
如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 否则会编译失败，强转有可能精度丢失
将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查
强制类型转换不一定能成功，不相干的类型不能互相转换
对于 short, byte 这种比 4 个字节小的类型, 计算机会先提升成 4 个字节的 int , 再运算.

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; 
// double没有int表示的数据范围大，需要强转，小数点之后全部丢弃

byte b1 = 100; 
// 100默认为int，没有超过byte范围，隐式转换
byte b2 = (byte)257; 
// 257默认为int，超过byte范围，需要显示转换，否则报错

boolean flag = true;
a = flag; 
// 编译失败：类型不兼容
flag = a; 
// 编译失败：类型不兼容

int a = 10;
long b = 20;
int c = a + b; 
// 编译出错: a + b-->int + long--> long + long 赋值给int时会丢失数据
long d = a + b; 
// 编译成功：a + b==>int + long-->long + long 赋值给long

byte a = 10;
byte b = 20;
byte c = (byte)(a + b);

8. 字符串类型

在Java中使用String类定义字符串类型，比如：

public static void main(String[] args) {
    String s1 = "hello";
    String s2 = " world";
    System.out.println(s1);
    System.out.println(s2);
    System.out.println(s1+s2); // s1+s2表示：将s1和s2进行拼接
}

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

int 转成 String

int num = 10;
// 方法1,当字符串和整数在一起使用+号时，
//+号起到拼接的作用
String str1 = num + "";
// 方法2
String str2 = String.valueOf(num);

.String 转成 int

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

9. 运算符

关于操作符，在C语言部分的博客有过详细的介绍，在java中也是大同小异的，这里只针对java部分做出一些补充和区分。

9.1 / %

做除法和取模时，右操作数不能为0
% 不仅可以对整形取模，也可以对double类型取模，但是没有意义，一般都是对整形取模的

9.2 += -= *= %=

该种类型运算符操作完成后，会将操纵的结果赋值给左操作数；使用这些运算符，当大范围的类型赋值给小范围类型时不需要进行强制类型转换，类型转换会默认进行

int a = 1;
long b = 2;
//不需要进行强制类型转换
a += b;
//需要进行强制类型转换
a = (int)(a + b);

9.3 逻辑非（！）、条件运算符

Java中的！只能运用于布尔表达式，

条件运算符只有一个:
表达式1 ? 表达式2 : 表达式3 ，而表达式1只能是布尔表达式

java中的真与假只能是true和flase；要与C语言中的0为假，非0为真区分，java中不存在这种说法。

9.4 短路求值

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

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

java中的 & 和 | 如果两侧的表达式结果为 boolean 时, 也表示逻辑运算.；

但与 && || 相比, 它们不支持短路求值.

9.5 移位运算

关于位运算，java当中比C语言言多出一个运算符 >>> (无符号右移)。

移位规则：右侧位舍弃, 左侧位补 0

注意：

java当中没有无符号数这个概念，只是这个操作符的名字叫无符号右移。
左移 1 位, 相当于原数字 2. 左移 N 位, 相当于原数字 2 的N次方.
右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.
由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.
移动负数位或者移位位数过大都没有意义.\

10. 逻辑控制

逻辑控制有顺序、选择、循环三种结构。

这里强调在java中如if else， while, for, do while这些语句中，其中的表示真假的结果必须是布尔表达式，不存在0为假，非0为真。

switch的括号内只能是以下类型的表达式：

基本类型：byte、char、short、int，注意不能是long类型
引用类型：String常量串、枚举类型

11. 输入输出

11.1 输出到控制台

基本语法：

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

println 输出的内容自带 \n, print 不带 \n
printf 的格式化输出方式和 C 语言的 printf 是基本一致的.

代码示例:

System.out.println("hello world");

int x = 10;
System.out.printf("x = %d\n", x)

格式化字符表：

转换符	类型	举例	结果
d	十进制整数	(“%d”, 100)	100
x	十六进制整数	(“%x”, 100)	64
o	八进制整数	(“%o”, 100)	144
f	定点浮点数	(“%f”, 100f)	100.000000
e	指数浮点数	(“%e”, 100f)	1.000000e+02
g	通用浮点数	(“%g”, 100f)	100.000
a	十六进制浮点数	(“%a”, 100)	0x1.9p6
s	字符串	(“%s”, 100)	100
c	字符	(“%c”, ‘1)	1
b	布尔值	(“%b”, 100)	true
n	散列码	(“%h”, 100)	64
%	百分号	(“%.2f%%”, 2/7f)	0.29%

11.2 从键盘输入

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

注意：

当输入的数据有很多不同的类型的时候，优先去处理字符串的输入，因为在输入数据的数据时，只有敲入回车才会进行读取，而敲入的这个回车会留在缓冲区，如果是后读入字符串，nextLine()就会读走这个回车，造成nextLine()失效。
nextLine()读取整行的数据包括单词间的空格，到回车结束（也就是从开始读一整行包括回车）；next()读取键盘输入的字符串，遇到空格便会停止读取。

import java.util.Scanner;// 需要导入 util 包

public class Blog {
    public static void main(String[] args) {
        
        //Scanner 工具    System.in：键盘
        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(); // 注意, 要记得调用关闭方法
    }
}

执行结果如下：

使用 Scanner 循环读取 N 个数字，并求取其平均值:

import java.util.Scanner;

public class Blog {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int sum = 0;
        int num = 0;
        while (scan.hasNextInt()) {
            //scan.hasNextInt()判断是否还有下一个整数
            int tmp = scan.nextInt();
            sum += tmp;
            num++;
        }
        System.out.println("sum = " + sum);
        System.out.println("avg = " + sum / num);
        scan.close();
    }
}

注意：当循环输入多个数据的时候, 使用 ctrl + d 来结束输入 .