JAVA入门：JDK下载/IDEA安装和快捷键使用/基础语法/方法的使用与类型转换/运算符-优快云博客

本文链接：https://blog.youkuaiyun.com/Powerful_Fy/article/details/149308927

一、JDK下载

1.JDK含义与下载

① JDK(Java Development Kit) 是 Java软件开发工具包(SDK)，包含了JAVA的运行环境（JRE：JVM虚拟机+Java核心类库）和JAVA工具（例如：运行程序工具java、编译程序工具javac）。
②oracle官网，https://www.oracle.com/，选择产品（products），选择java后选择jdk版本及操作系统，推荐选择LTS（长期支持版）

2.环境变量的配置

高版本的jdk已能自动写入环境变量配置无需手动配置，cmd中输入java -version或javac -version显示jdk版本即已无需手动配置；若cmd执行报错则需：

①添加系统变量JAVA_HOME，选择jdk目录路径（不用选择到jdk目录下面的bin）
②系统变量path的值中新增：%JAVA_HOME%\bin

3.编写运行java程序

①创建txt文件，更名为Helloworld.java文件，输入以下内容后保存：

//类名需与文件名一致
public class Helloword{
	public static void main(String[] args){
		System.out.println("Hello,world");
	}
}

②在cmd中选择对应的硬盘并进入目录后使用javac Helloworld.java编译程序，生成编译后的.class文件并使用java Helloworld运行程序

C:\Users\3133>D:     //切换硬盘

D:\>cd code      //打开.java文件所在目录

D:\code>javac HelloWord.java     //编译.java程序

D:\code>dir      //查看编译完成的.class文件已存在     .
2025/07/13  13:38               423 HelloWord.class
2025/07/13  13:37               110 HelloWord.java

D:\code>java HelloWord    //运行程序
Hello,world               //输出结果

二、IDEA安装和快捷键使用

1.下载安装并创建项目

①下载地址：https://www.jetbrains.com/idea/
②安装后运行点击New project
③在项目中创建模块module模块
④在模块中创建package包
⑤在包中创建Java class 文件（.java文件）
⑥新增Helloworld代码后点击shift+F10或点击绿色三角形按钮运行代码（会自动编译，编辑后的.class文件位于项目下的out目录中）

2.快捷键使用

ctrl+D：快速复制鼠标光标所在行的代码到下一行
ctrl+X：删除鼠标光标所在行的代码（剪切）
ctrl+alt+L：自动调整代码缩进
ctrl+/：注释光标所在行代码，若为空行则自动添加//
ctrl+shift+/：注释选中代码，未选中则添加/**/多行注释
alt+shift+↑：向上移动光标所在行的代码
alt+shift+↓：向下移动光标所在行的代码

三、基础语法

1.字面量

字面量的分类：整数、小数、字符（1个字符/单引号）、字符串（双引号）、布尔值（true/false）、空值（null）
特殊字符字面量：\t tab缩进，常用于制表输出（姓名\t性别\t年龄）；\n 换行符；其中\r 回车符 \b 退格符 \f 换页符不常用
注：数值不变时使用字面量，否则使用变量

2.基础数据类型

整型：byte、short、int（默认）、long
浮点型：float、double（默认）
字符型：char
布尔型：boolean
字符串型：String（引用数据类型）
在这里插入图片描述

3.关键字与标识符

关键字（keywords）不可作为类名、变量名或方法名等，例如：public、static、for、int、new、for等等……

标识符为自定义名称（包、方法、类名、变量等），不能以数字开头，只能以大小写字母/下划线/$开头，并符合驼峰命名法：类名首字母大写，变量或方法名首字母小写，后续单词首字母大写

4.方法的定义、注意事项、类型转换（自动/强制）

1）定义格式

修饰符 + 返回值类型 +方法名（形参列表）{
	具体代码
	return 返回值；
}
//示例：
public static + void + testMethod（int a）

2）注意事项

①若方法无返回值，返回值类型使用void
②存在返回值时，需正确填写方法名前面的返回值类型
③方法重载：多个方法名称相同，但形参不同（比如参数的个数不同、参数的数据类型不同、参数数据类型与数量相同但参数所在位置的顺序不同）多个方法涉及同一参数时，定义的变量名需一致，若变量名不一致应新增方法是否不同的方法名。
④方法重载常用于通过不同参数使用相同功能，优点是只需记一个方法名方便调用，示例：

 //定义一个方法，根据姓名查询学生信息
    public static void printStudentInfo(String name) {
        System.out.println("姓名：" + name + "，年龄：18，性别：男");
    }
    //重装方法，根据学号查询学生信息
    public static void printStudentInfo(int id) {
        System.out.println("学号：" + id + "，姓名：张三，年龄：18，性别：男");
    }

⑤使用return提前结束方法执行，示例：

//定义一个除法功能,考虑除数为0的情况
    public static void printDiv(int a, int b) {
        if (b == 0) {
            System.out.println("除数不能为0");
            return; //提前结束方法
        }
        System.out.println(a + "除以" + b + "等于" + a / b);
    }

3）自动类型转换

什么是自动类型转换？将范围类型小的变量（byte）可以直接赋值给范围类型大的变量(int)使用。
从小到大：byte→short→int→long→float→double
使用场景：调用别人写的方法时，方法参数定义的数据类型与自己实际参数的数据类型不一致
示例：

public class test {
    public static void main(String[] args) {
        //测试自动类型转换
        byte a = 10;
        //将byte类型转换成int类型
        print(a);
        //将byte类型转换成double类型
        print2(a);
    }
    public static void print(int a) {
        System.out.println(a);
    }
    //打印结果：10
    public static void print2(double a) {
        System.out.println(a);
    }
    //打印结果：10.0，整数型转浮点型会新增小数点
}

执行原理：byte类型数据在内存中占用1字节（8bit），而int类型数据再内存中占用4字节（32bit），可以装下byte的数据。二进制的有效位不变，前面多出的比特位填充0
在这里插入图片描述

4）强制类型转换

什么是自动类型转换？将范围类型大的变量（int）可以直接赋值给范围类型小的变量(byte)使用。
从小到大：byte→short→int→long→float→double
使用场景：调用别人写的方法时，方法参数定义的数据类型与自己实际参数的数据类型不一致

示例1：将int类型的变量转换为byte类型，当int类型的值在byte类型范围区间（-128~127）中时，数据不会溢出

public class test {
    public static void main(String[] args) {
        //测试强制类型转换
        int a = 20;
        //将int类型转换成byte类型
        byte b = (byte) a;
        getByte(b);
        //输出结果：20，正常未溢出
    }
    //测试用int类型入参byte类型
    public static void getByte(byte c) {
        System.out.println(c);
    }
}

示例2：将int类型的变量转换为byte类型，当int类型的值超出byte类型范围区间（-128~127）中时，数据会溢出

public class test {
    public static void main(String[] args) {
        //测试强制类型转换
        int a = 1500;
        //将int类型转换成byte类型
        byte j = (byte) a;
        getByte(j);
        //输出结果：-36，数据溢出
    }
    //测试用int类型入参byte类型
    public static void getByte(byte j) {
        System.out.println(j);
    }
}

原理：int类型占用内存4字节（32bit），byte类型占用1字节（8bit），int转byte时，直接截取后8位比特位的值，当int对应的值在byte类型范围区间（-128~127）或（8bit位）中时，不会对结果产生影响。但int对应的值超过byte类型范围区间或8bit位时，会对转换结果产生影响。如下图所示，int赋值为1500时，i 转换 j 过程中的有效比特位只保留了8位，导致转换结果为-36，所以强制转换类型可能会导致数据溢出（丢失）。（有效比特位首位为0代表正数，为1代表负数）
在这里插入图片描述
示例3：将浮点型强制转换为整型，会直接丢掉小数部分，返回整数部分

public class test {
    public static void main(String[] args) {
        //测试强制类型转换
        double a = 3.14;
        int b = (int)a;
        System.out.println(b);
        //输出结果：3，截取小数点前的数字
    }

5）表达式的自动类型转换

表达式中小范围的变量在计算时，会自动转换为表达式中较大范围的数据类型参与计算

注意事项：
①从小到大：byte、short、char→int→long→float→double，其中byte、short、char会直接被转换成int进行计算
②表达式的最终结果类型由表达式中最高类型决定

示例1：参数类型包含byte、int、double时，方法test1的返回值类型若不使用double则报错，印证表达式的最终结果类型由表达式中最高类型决定，调用方法时a参数输入整型会默认为int类型，需加(byte)强制转换

public class test {
    public static void main(String[] args) {
        //测试表达式的自动类型提升转换
        System.out.println(test1((byte) 1, 200, 3.8));
        //输出结果：204.8
    }
    //定义不同数据类型作为参数的表达式运算
    public static double test1(byte a, int b, double c) {
        return a + b + c;
    }
}

示例2：byte、short、char会直接被转换成int进行计算，方法test2的返回值类型不使用int则报错

public class test {
    public static void main(String[] args) {
        System.out.println(test2((byte) 100, (byte) 120));
    }
    public static int test2(byte a, byte b) {
        return a + b;
    }
}

示例3：不使用自动类型转换，方法test2的返回值类型继续使用byte，return强制使用byte返回，但结果为-36而非220，数据溢出，需注意表达式的结果是否会超过byte类型数据范围（-128~127）

public class test {
    public static void main(String[] args) {
        System.out.println(test2((byte) 100, (byte) 120));
        //输出结果为-36
    }
    public static byte test2(byte a, byte b) {
        return (byte) (a + b);
    }
}

5.数据输入

①使用内置功能scanner获取键盘输入数据，需先导入scanner所在包
②创建对象使用scanner功能
③获取输出内容
④注意：lang包不需要导入，为默认包，例如System、String即在Java.lang包中
示例：

//导入Scanner所在包
import java.util.Scanner;
public class ScannerDemo {
    public static void main(String[] args) {
        getInfo();
    }
    //定义功能，获取用户输入的姓名与年龄
    public static void getInfo() {
        //创建一个Scanner对象用于使用scanner功能
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入姓名：");
        //获取用户输入的姓名，按键盘回车结束并将输入内容保存在name变量中
        String name = sc.next();
        System.out.println("请输入年龄：");
        //获取用户输入的年龄，按键盘回车结束并将输入的整数内容保存在age变量中
        int age = sc.nextInt();
        System.out.println("姓名是：" + name + "，年龄是：" + age);
    }
}

IDEA自动导入相关Java包设置：最上方工具栏选择file→settings→搜索auto→选择auto import，勾选以下两项即可。
在这里插入图片描述

四、Java运算符

1.基本运算符

在这里插入图片描述
示例1：需注意当除数与被除数都是int类型时，若不能整除，结果也不会保留小数。若需结果保留小数，可将被除数或除数转变为浮点型，不能整除时，运算结果即可保留小数（表达式的最终结果类型由表达式中最高类型决定）

public class OperatorDemo {
    public static void main(String[] args) {
        test1(10, 3);
    }
    //输出各种基本运算符的运算方式与结果
    public static void test1(int a, int b) {
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b); //输出结果：3
        //将被除数强制转换为浮点型方法1
        System.out.println((double) a / b); //输出结果：3.3333333333333335
        //将被除数强制转换为浮点型方法2
        System.out.println(1.0 * a / b); //输出结果：3.3333333333333335
        System.out.println(a % b);
    }

}

示例2：+ 号的特殊用途——连接符（原则：能计算就计算，不能计算就用作连接），优先级从左到右，先与字符串连接时，转换为字符串后面再遇到数字时不再进行计算，只进行字符串连接。

public static void test1() {
        int a = 10;
        System.out.println("abc"+ a); //输出结果：abc10
        System.out.println(a + 3); //输出结果：13
        //优先级从左到右，先与字符串连接时，转换为字符串后面再遇到数字时不再进行计算 ，只进行字符串连接
        System.out.println("abc" + a + 3); //输出结果：abc103,当变量a与字符串连接时，变量a会自动转换成字符串类型
        //先进行计算 ，再进行字符串连接
        System.out.println(a + 'a' + "abc"); //输出结果：107abc,char类型的字符a会自动转换成对应的ASCII码值97，再和变量a相加，得到107
    }

2.自增自减运算符

在这里插入图片描述
注意：只能对变量（i++）生效，无法用于字面量（例如：2++）

示例1：变量单独使用时，自增和自减在变量前或后无区别

//定义方法，体现自增与自减在变量单独使用时的前后位置不同结果无区别
    public static void printVar() {
        int a = 10;
        a++;
        System.out.println(a); //输出结果：11
        ++a;
        System.out.println(a); //输出结果：12
        a--;
        System.out.println(a); //输出结果：11
        --a;
        System.out.println(a); //输出结果：10
    }

示例2：非单独使用变量的情况下，自增自减在变量前后位置的区别

//定义方法，体现自增自减在变量非单独使用情况下前后位置不同的区别
public static void printVar2() {
        int a = 10;
        System.out.println(a++); //输出结果：10,a的值变为11，a++表示a的值先输出，再自增(自增在变量之后，先用后加)
        System.out.println(++a); //输出结果：12,a的值变为12，++a表示先自增，再输出a的值(自增在变量之前，先加后用)
        System.out.println(a--); //输出结果：12,a的值变为11，a--表示a的值先输出，再自减(自减在变量之后，先用后减)
        System.out.println(--a); //输出结果：10,a的值变为10，--a表示先自减，再输出a的值(自减在变量之前，先减后用)
    }

示例3：同示例2体现非单独使用变量的情况下，自增自减在变量前后位置的区别

public static void varTest(){
        int c = 10;
        int d = 5;
        int rs3 = c++ + ++c - --d - ++d + 1 + c--;
        System.out.println(rs3); //输出结果：26
        System.out.println(c); //输出结果：11
        System.out.println(d); //输出结果：5
    }

3.赋值运算符

在这里插入图片描述
案例：体现各种扩展赋值运算符的运行结果和实际的代码逻辑（强制类型转换）

public static void test() {
        int a = 10;
        a += 5;
        System.out.println(a); //输出结果：15,等同于a = (a的类型)(a + 5);
        int b =10;
        b -= 5;
        System.out.println(b); //输出结果：5,等同于b = (b的类型)(b - 5);
        int c = 10;
        c *= 5;
        System.out.println(c); //输出结果：50,等同于c = (c的类型)(c * 5);
        int d = 10;
        d /= 5;
        System.out.println(d); //输出结果：2,等同于d = (d的类型)(d / 5);
        int e = 10;
        e %= 5;
        System.out.println(e); //输出结果：0,等同于e = (e的类型)(e % 5);
    }

4.关系运算符

在这里插入图片描述
案例：理解各种关系运算符的运算结果

public static void main(String[] args) {
        test1(10, 20);
    }
    // 各种关系运算符的运算结果
    public static void test1(int a ,int b) {
        System.out.println(a > b); // false
        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); // true
    }

5.三元运算符

格式：条件表达式 ? 值1：值2，条件表达式的结果为真，返回值1；结果为假，返回值2
案例：理解三元运算符的使用：对比两个整数输出较大值/对比三个整数输出较大值/对输入内容返回对应区间的预设值

public static void main(String[] args) {
        //理解三元运算符
        test1();
        test2(60);
        test3(100, 90, 80);
    }
    //对比两个整数输出较大值
    public static void test1() {
        int a = 10;
        int b = 20;
        int c = a > b ? a : b; //a大于b则为true,输出a的值;a小于b则为false,输出b的值;
        System.out.println(c); //输出结果：20
    }
    //根据成绩输出是否及格
    public static void test2(int  score) {
        String result = score >= 60 ? "及格" : "不及格";
        System.out.println(result); //
    }
    //对比三个整数的较大值
    public static void test3(int a, int b, int c) {
        int max = a > b ? a : b; //a>b为true,max=a;a<=b为false,max=b;
        max = max > c ? max : c; //max>c为true,max=max;max<=c为false,max=c;
        System.out.println(max); //输出结果：100
    }

6.逻辑运算符

在这里插入图片描述
案例：常用&&、||、!，需注意注释中内容：&与&&、|与||的区别

public static void main(String[] args) {
        //理解逻辑运算符
        test();
        test2();
    }
    public static void test() {
        int a = 10;
        int b = 20;
        //体现逻辑运算符&、|、!、^的使用
        System.out.println(a > b & b > a); //false，发现左边为false，右边还会继续计算
        System.out.println(a < b | b > a); // true，发现左边为true，右边依然继续计算
        System.out.println(!(a > b)); // true
        System.out.println(a > b ^ b > a); // true
    }
    //体现逻辑运算符&&、||、!的使用
    public static void test2() {
        int a = 10;
        int b = 20;
        System.out.println(a > b && ++b > a); //与&的区别：发现左边结果为false，则右边不再计算，直接结束返回false
        System.out.println(b);  //结果为：20,a>b为false,直接结束计算，b不再增加
        System.out.println(a < b || b > ++a); //与|的区别：发现左边结果为true，则右边不再计算，直接结束返回true
        System.out.println(a); //结果为：10,a<b为true,直接结束计算，a不再增加
    }

五、案例：健康计算器

需求：根据输入的身高、体重、年龄、性别计算BMI（身体质量指数）和BMR（基础代谢率）

import java.util.Scanner;

public class OperatorDemo4 {
    public static void main(String[] args) {
        //目标功能：健康指数计算器，用于计算BMI和BMR
        //1. 创建Scanner对象
        Scanner sc = new Scanner(System.in);
        //2. 获取用户输入
        System.out.println("请输入用户身高（单位：米）：");
        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();
        System.out.println("BMI计算结果：" + getBMI(height,weight));
        System.out.println("BMR计算结果：" + getBMR(height,weight,age,sex));
    }
        //3. 定义方法，计算BMI
    public static double getBMI(double height,double weight){
        return weight/(height*height);
    }
        //4. 定义方法，计算BMR（Harris-Benedict公式）
    public static double getBMR(double height,double weight,int age,String sex){
        if ("男".equals(sex)){
            return 13.7 * weight + 5 * height - 6.8 * age + 66;
        }else{
            return 9.6 * weight + 1.8 * height - 4.7 * age + 655;
        }
    }
}