Java基础语法（运算符+方法+类型转换+输入输出）
Java零基础入门：基础语法核心知识点全解析（运算符+方法+类型转换+输入输出）
本文整理了JavaSE入门阶段最核心的基础语法知识点，涵盖数据类型转换、各类运算符、Scanner键盘输入、方法详解四大核心模块，所有代码均基于JDK8+环境测试运行。
一、数据类型转换
Java中不同数据类型之间的赋值和运算，需要遵循固定的类型转换规则，主要分为自动类型转换、强制类型转换，以及表达式中的自动类型提升三大类。
1.1 自动类型转换
核心规则：类型范围小的变量，可以直接赋值给类型范围大的变量，无需手动处理，由JVM自动完成转换。
数据类型范围从小到大排序：byte → short → int → long → float → double
其中char类型可直接提升为int类型参与运算。
public class Type1 {
public static void main(String[] args) {
// 自动类型转换：byte → int
byte a = 12;
print(a);
// 自动类型转换：byte → double
print2(a);
}
// 定义方法接收 int 类型
public static void print(int num) {
System.out.println("转换为int：" + num);
}
// 定义方法接收 double 类型
public static void print2(double num) {
System.out.println("转换为double：" + num);
}
}运行结果：
转换为int：12
转换为double：12.0
1.2 强制类型转换
核心规则：类型范围大的变量，无法直接赋值给范围小的变量，会直接编译报错，必须手动完成强制类型转换。
语法格式：
目标数据类型 变量名 = (目标数据类型) 待转换的变量/值;⚠️ 注意事项：
- 强制类型转换可能出现数据溢出，导致结果不符合预期；
- 浮点型强转为整型时，会直接截断小数部分，仅保留整数部分返回。
public class Type2 {
public static void main(String[] args) {
// 强制类型转换：int → byte
int i = 20;
byte j = (byte) i;
print3(j);
// 强制类型转换导致数据溢出
int m = 1500;
byte n = (byte) m;
System.out.println(m); // 1500
System.out.println(n); // -36 数据溢出
// 浮点型强转整型，直接舍弃小数部分
double k = 3.14;
int l = (int) k;
System.out.println(l); // 3
}
public static void print3(byte j) {
System.out.println(j);
}
}1.3 表达式的自动类型提升
核心规则：在表达式运算中，小范围类型的变量会自动提升为表达式中范围最大的类型，再参与运算。
重点：
- 表达式最终结果的类型，由表达式中的最高类型决定；
byte、short、char类型在运算时，会直接提升为int类型再参与运算。
public class Type3 {
public static void main(String[] args) {
// byte运算时自动提升为int，结果为int类型
int result = calc2((byte) 110, (byte) 120);
System.out.println(result);
// 手动强制转换为byte类型
int result2 = calc3((byte) 110, (byte) 120);
System.out.println(result2);
}
// byte + byte 自动提升为int运算，返回int
public static int calc2(byte a, byte b) {
return a + b;
}
// 手动强制转换，将结果转回byte
public static byte calc3(byte a, byte b) {
byte c = (byte) (a + b);
return c;
}
// 表达式最终结果由最高类型double决定
public static double calc(int a, int b, double c, char r) {
return a + b + c + r;
}
}二、Java核心运算符
2.1 算术运算符与+号的特殊用法
基础算术运算符包括：+（加）、-（减）、*（乘）、/（除）、%（取余/取模）。
⚠️ 核心避坑点：两个整数相除，结果只会保留整数部分，直接舍弃小数。若想要得到小数结果，必须先将其中一个操作数转为浮点型。
+号的两种核心用法：
- 常规算术加法运算；
- 字符串连接符：当
+号遇到字符串时，会作为连接符使用，运算结果仍为字符串。
执行规则：能算则算，不能算就连接，从左到右依次执行。
public class Operator1 {
public static void main(String[] args) {
// 基础算术运算符演示
print(10, 3);
System.out.println("---------------------------------");
// +号连接符用法演示
print2();
}
public static void print(int a, int b) {
System.out.println(a + b); // 13
System.out.println(a - b); // 7
System.out.println(a * b); // 30
System.out.println(a / b); // 3 整数相除舍弃小数
System.out.println((double) a / b); // 3.3333333333333335 强转浮点型
System.out.println(1.0 * a / b); // 3.3333333333333335 转为浮点型运算
System.out.println(a % b); // 1 取余
}
// 研究+符号做连接符还是运算符
public static void print2() {
int a = 5;
System.out.println("abc" + a); // abc5 字符串连接
System.out.println(a + 5); // 10 算术运算
System.out.println("itheima" + a + 'a'); // itheima5a 从左到右连接
System.out.println(a + 'a' + "itheima"); // 102itheima 先算算术，再连接
}
}2.2 自增自减运算符
++（自增）：对变量自身的值+1--（自减）：对变量自身的值-1
核心规则：
- 只能操作变量，不能操作字面量；
- 单独使用时，放在变量前后无任何区别；
非单独使用时（在表达式/赋值语句中）：
- 放在变量前：先自增/自减，再参与运算（先加后用）
- 放在变量后：先参与运算，再自增/自减（先用后加）
public class Operator2 {
public static void main(String[] args) {
// 自增自减单独使用
print(10);
System.out.println("=========================");
// 自增自减前后置区别
print2(10);
}
public static void print(int a) {
a++;
++a;
System.out.println(a); // 12
a--;
--a;
System.out.println(a); // 10
}
public static void print2(int a) {
int b = a++; // 先用后加
System.out.println(a); // 11
System.out.println(b); // 10
int c = ++a; // 先加后用
System.out.println(a); // 12
System.out.println(c); // 12
}
}2.3 赋值运算符
分为基本赋值运算符和扩展赋值运算符两类：
- 基本赋值运算符：
=，执行逻辑为从右往左赋值； - 扩展赋值运算符：
+=、-=、*=、/=、%=。
核心特点：扩展赋值运算符自带强制类型转换，底层会自动处理类型转换，不会出现编译报错。
底层等价逻辑：a += b 等价于 a = (a的数据类型)(a + b);
public class Operator3 {
public static void main(String[] args) {
receive(5);
print();
}
// 收红包案例，演示+=的用法
public static void receive(int b) {
int a = 100;
a += b; // 等价于 a = (int)(a + b);
System.out.println("收红包后，我的钱包金额：" + a); // 105
// 扩展赋值运算符自带强制类型转换
byte a1 = 10;
byte a2 = 20;
a1 += a2; // 等价于 a1 = (byte) (a1 + a2);
System.out.println(a1); // 30
}
// 其他扩展赋值运算符演示
public static void print() {
int a = 10;
a -= 5;
System.out.println(a); // 5
int b = 10;
b *= 5;
System.out.println(b); // 50
int c = 10;
c /= 5;
System.out.println(c); // 2
int d = 10;
d %= 5;
System.out.println(d); // 0
}
}2.4 关系运算符
用于判断两个数据的大小/相等关系，运算结果固定为布尔类型true/false。
常用关系运算符：>、>=、<、<=、==（等于）、!=（不等于）。
⚠️ 致命避坑点：判断两个值是否相等必须使用==，而不是使用赋值运算符=！
public class Operator4 {
public static void main(String[] args) {
print(10, 2);
print2(10, 10);
}
public static void print(int a, int b) {
System.out.println(a > b); // true
System.out.println(a < b); // false
System.out.println(a >= b); // true
System.out.println(a <= b); // false
System.out.println(a == b); // false
System.out.println(a != b); // true
}
public static void print2(int a, int b) {
System.out.println(a > b); // false
System.out.println(a < b); // false
System.out.println(a >= b); // true
System.out.println(a <= b); // true
System.out.println(a == b); // true
System.out.println(a != b); // false
}
}2.5 三元运算符
语法格式：
条件表达式 ? 值1 : 值2;执行流程：先计算条件表达式的结果，结果为true返回值1，结果为false返回值2。
适用场景：简单的二选一逻辑，也可嵌套使用实现多条件判断。
public class Operator5 {
public static void main(String[] args) {
// 求两个数的最大值
print(10, 40);
// 判断成绩是否通过
print(59);
// 求三个数的最大值
System.out.println("较大值：" + getMax(10, 20, 30));
System.out.println("较大值：" + getMax2(10, 20, 30));
}
// 求两个整数的较大值
public static void print(int a, int b) {
int max = a > b ? a : b;
System.out.println("较大值：" + max);
}
// 判断成绩是否通过
public static void print(int score) {
String result = score >= 60 ? "通过" : "挂科";
System.out.println(result); // 挂科
}
// 分步求三个整数的较大值
public static int getMax(int a, int b, int c) {
int max = a > b ? a : b;
max = max > c ? max : c;
return max;
}
// 三元运算符嵌套求三个整数的较大值
public static int getMax2(int a, int b, int c) {
int max = a > b ? (a > c ? a : c) : (b > c ? b : c);
return max;
}
}2.6 逻辑运算符
用于将多个条件组合起来运算，最终结果为布尔类型，开发中最常用的是&&、||、!。
分为两大类：
- 普通逻辑运算符：
&（逻辑与）、|（逻辑或）、!（逻辑非）、^（逻辑异或） - 短路逻辑运算符：
&&（短路与）、||（短路或）
区别：
&、|：无论左边条件结果如何，右边代码一定会执行；&&：左边为false时，右边直接不执行（短路），执行效率更高；||：左边为true时，右边直接不执行（短路），执行效率更高。
public class Operator6 {
public static void main(String[] args) {
// 逻辑与&：所有条件都为true，结果才为true
System.out.println(isMatch(180, 70, '女')); // true
System.out.println(isMatch(180, 70, '男')); // false
// 逻辑或|：只要有一个条件为true，结果就为true
System.out.println(isMatch2(180, 10000)); // true
System.out.println(isMatch2(160, 1000000)); // true
System.out.println(isMatch2(160, 100)); // false
// 逻辑非!：取反
isMatch3(true); // false
System.out.println("-----------------------------");
// 逻辑异或^：条件结果相同为false，不同为true
isMatch4();
System.out.println("-------------------------------");
// 短路与&&、短路或|| 和 普通运算符的区别
print();
}
// 逻辑与&演示：择偶条件判断
public static boolean isMatch(int height, int weight, char sex) {
boolean result = height > 170 & weight >= 60 & weight <= 80 & sex == '女';
return result;
}
// 逻辑或|演示：择偶条件判断
public static boolean isMatch2(int height, int income) {
boolean result = height >= 180 | income > 300000;
return result;
}
// 逻辑非!演示
public static void isMatch3(boolean flag) {
System.out.println(!flag);
}
// 逻辑异或^演示
public static void isMatch4() {
System.out.println(false ^ false); // false
System.out.println(true ^ true); // false
System.out.println(true ^ false); // true
System.out.println(false ^ true); // true
}
// 短路与非短路的区别演示
public static void print() {
int a = 111;
int b = 2;
System.out.println(a > 1000 & ++b > 1); // false 左边为false，右边仍执行
System.out.println(b); // 3
int i = 10;
int j = 20;
System.out.println(i > 6 | ++j > 1); // true 左边为true，右边仍执行
System.out.println(j); // 21
}
}三、Scanner键盘输入
Java中通过java.util.Scanner类可以接收用户键盘输入的数据，实现程序与用户的交互。
使用固定三步骤：
- 导包：
import java.util.Scanner;（java.lang包下的类无需导包，如String、System） - 创建Scanner对象：
Scanner sc = new Scanner(System.in); - 接收用户输入：根据数据类型调用对应方法，如
next()接收字符串、nextInt()接收整数、nextDouble()接收小数。
package com.itheima.scanner;
// 1. 导包：告诉程序去JDK的哪个包中找Scanner类
import java.util.Scanner;
public class ScannerDemo1 {
public static void main(String[] args) {
printUserInfo();
}
// 接收用户输入的用户名和年龄，并打印输出
public static void printUserInfo() {
// 2. 创建Scanner扫描器对象
Scanner sc = new Scanner(System.in);
// 3. 接收用户输入的字符串
System.out.println("请输入用户名：");
String username = sc.next();
System.out.println("您叫：" + username);
// 接收用户输入的整数
System.out.println("请输入年龄：");
int age = sc.nextInt();
System.out.println("您多少岁：" + age);
}
}四、Java方法详解
方法是Java程序中功能的最小单元，是用于执行特定任务的代码块，可接收数据进行处理，并返回处理结果。将重复逻辑封装为方法，可大幅提高代码的复用性和可维护性。
4.1 方法的定义格式
完整语法格式：
修饰符 返回值类型 方法名(形参列表) {
方法体代码（执行功能的核心代码）
return 返回值;
}定义方法的两个核心判断：
- 方法是否需要接收数据？需要则定义对应的形参列表；
- 方法是否需要返回数据？需要则定义对应返回值类型，不需要则写
void。
4.2 方法的四种常见形式
根据有无参数、有无返回值，方法可分为四种常见形式，覆盖绝大多数开发场景：
public class MethodDemo1 {
public static void main(String[] args) {
// 有参有返回值：求两个整数的和
int sum = getSum(10, 20);
System.out.println("和是：" + sum);
int sum2 = getSum(100, 200);
System.out.println("和是：" + sum2);
System.out.println("----------------------------");
// 无参无返回值：打印3行HelloWorld
printHelloWorld();
System.out.println("----------------------------");
// 有参有返回值：获取指定位数的验证码
System.out.println(getCode(4));
System.out.println(getCode(5));
}
// 有参有返回值：求任意两个整数的和并返回
public static int getSum(int a, int b) {
return a + b;
}
// 无参无返回值：打印3行HelloWorld
public static void printHelloWorld() {
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
}
// 有参有返回值：获取指定位数的数字验证码
public static String getCode(int len) {
String code = "";
for (int i = 0; i < len; i++) {
int num = (int) (Math.random() * 10);
code += num;
}
return code;
}
}4.3 方法重载
定义：一个类中，多个方法名称相同，但形参列表不同，就构成了方法重载。
形参列表不同的判定标准：形参的类型不同、个数不同、顺序不同，满足其一即可。
⚠️ 注意：方法重载与返回值类型、修饰符无关，仅看方法名和形参列表。
package com.itheima.method;
public class MethodDemo2 {
public static void main(String[] args) {
// 重载方法的调用，会根据传入的参数自动匹配对应的方法
print(10);
print("黑马程序员");
print(10.5, 2);
}
// 定义一个方法，打印一个整数
public static void print(int a) {
System.out.println(a);
}
// 重载方法：参数类型不同
public static void print(String str) {
System.out.println(str);
}
// 重载方法：参数个数不同
public static void print(double d, int a) {
System.out.println(d);
}
// 重载方法：参数顺序不同
public static void print(int a, double d) {
System.out.println(d);
}
}4.4 return的特殊用法
在返回值类型为void的方法中，可使用单独的return;，作用是提前结束当前方法的执行，常用在卫语句中，提前处理异常/非法情况。
package com.itheima.method;
public class MethodDemo3 {
public static void main(String[] args) {
div(10, 0);
div(10, 2);
}
// 除法功能，处理除数为0的异常情况
public static void div(int a, int b) {
if (b == 0) {
System.out.println("除数不能为0");
return; // 提前结束方法，后续代码不再执行
}
System.out.println(a / b);
}
}五、案例
程序接收用户输入的身高、体重、性别、年龄，自动计算并输出用户的BMI指数和BMR基础代谢率。
计算公式
- BMI指数：
BMI = 体重(kg) / (身高(m) * 身高(m)) BMR基础代谢率（Harris-Benedict公式）：
- 男性：
BMR = 88.362 + (13.397 × 体重) + (4.799 × 身高) - (5.677 × 年龄) - 女性：
BMR = 447.593 + (9.247 × 体重) + (3.098 × 身高) - (4.330 × 年龄)
- 男性：
代码实现
import java.util.Scanner;
public class AllTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 1. 接收用户输入的个人信息
System.out.println("请您输入您的身高（单位：cm）：");
double height = sc.nextDouble();
System.out.println("请您输入您的体重（单位：kg）：");
double weight = sc.nextDouble();
System.out.println("请您输入您的性别（男/女）：");
String sex = sc.next();
System.out.println("请您输入您的年龄：");
int age = sc.nextInt();
// 2. 调用方法计算BMI和BMR
double bmi = calcBMI(height / 100, weight);
System.out.println("您的BMI值是：" + String.format("%.2f", bmi));
double bmr = calcBMR(height, weight, sex, age);
System.out.println("您的BMR基础代谢率是：" + String.format("%.2f", bmr) + " 卡路里/天");
}
// 封装方法：计算BMI指数
public static double calcBMI(double height, double weight) {
return weight / (height * height);
}
// 封装方法：计算BMR基础代谢率
public static double calcBMR(double height, double weight, String sex, int age) {
double bmr = 0;
if ("男".equals(sex)) {
bmr = 88.362 + (13.397 * weight + 4.799 * height - 5.677 * age) ;
} else {
bmr = 447.593 + (9.247 * weight + 3.098 * height - 4.330 * age);
}
return bmr;
}
}以上就是Java入门阶段基础语法的核心知识点，这些内容是后续学习面向对象、流程控制、集合框架等内容的核心基础。建议大家把每个代码示例都手动敲一遍，加深对知识点的理解。