1.数据类型
1.整数型
1.byte
2.short
3.int
4.long2.浮点型
1.float
2.double3.字符型
char4.布尔型
boolean：true、false5.示例：
public class VariableDemo3{
//入口
public static void main(String[] args){
//整数型
//byte
byte a=13;
System.out.println(a);
//short
short b=134;
System.out.println(b);
//int
int c=1314;
System.out.println(c);
//long
//若要定义long类型变量加一个L后缀
long d=99999999999L;
System.out.println(d);
//浮点型
//float
//若要定义float类型的变量，加一个F后缀
float e=1333333.1232F;
System.out.println(e);
//double
double f=12321313.123;
System.out.println(f);
//字符型
//char
char g='中';
System.out.println(g);
//布尔型
//boolean
boolean h=true;
boolean o=false;
System.out.println(h);
System.out.println(o);
}
}
结果：
C:\Users\秦风\Desktop\java_study\代码>java VariableDemo3
13
134
1314
99999999999
1333333.1
1.2321313123E7
中
true
false
注意点：double中，超过8位小数，会使用科学计数法--1.2321313123E7
其中的E7表示乘以10的7次方
如果想要让其以十进制输出可以使用：
System.out.printf("%.3f%n",f); //%n换行符
char g='中';
System.out.println(g);
输出：
12321313.1230
中
为何不用System.out.println方法是因为：
C:\Users\秦风\Desktop\java_study\代码>javac VariableDemo3.java
VariableDemo3.java:25: 错误: 对于println(String,double), 找不到合适的方法
System.out.println("%.3f",f);
^
方法 PrintStream.println()不适用
(实际参数列表和形式参数列表长度不同)
方法 PrintStream.println(boolean)不适用
(实际参数列表和形式参数列表长度不同)
方法 PrintStream.println(char)不适用
(实际参数列表和形式参数列表长度不同)
方法 PrintStream.println(int)不适用
(实际参数列表和形式参数列表长度不同)
方法 PrintStream.println(long)不适用
(实际参数列表和形式参数列表长度不同)
方法 PrintStream.println(float)不适用
(实际参数列表和形式参数列表长度不同)
方法 PrintStream.println(double)不适用
(实际参数列表和形式参数列表长度不同)
方法 PrintStream.println(char[])不适用
(实际参数列表和形式参数列表长度不同)
方法 PrintStream.println(String)不适用
(实际参数列表和形式参数列表长度不同)
方法 PrintStream.println(Object)不适用
(实际参数列表和形式参数列表长度不同)
1 个错误
because：
println() 没有支持 (String, double) 参数的重载方法，因此编译器找不到匹配的方法。
6.注意点：
1.println和printf的关键区别（%.3f表示保留3位小数，%d表示整数，%s表示字符串，%n表示换行）
| 方法 | 功能 | 参数规则 | 是否自动换行 |
|
| 输出单个值并换行 | 仅接受 1 个参数 | 是（自动添加换行） |
|
| 格式化输出多个值 | 格式字符串 + 多个参数（可变） | 否（需手动加 ） |
2.类型注意点
1. long 类型需要后缀 L
原因：
Java 规定，整数字面量（如 123）默认是 int 类型。
当字面量超出 int 范围（-2³¹ ~ 2³¹-1）时，必须用 L 标记为 long 类型，否则会编译报错。
示例：long d=99999999999;
输出：
C:\Users\秦风\Desktop\java_study\代码>javac VariableDemo3.java
VariableDemo3.java:15: 错误: 过大的整数: 99999999999
long d=99999999999;
^
1 个错误
2. float 类型需要后缀 F
原因：
Java 规定，小数字面量（如 3.14）默认是 double 类型。
将 double 字面量直接赋值给 float 变量会导致--精度丢失风险，
因此必须显式标记为 float（加 F）或强制类型转换。
示例：
float a = 3.14F; // 合法（明确标记为 float）
float b = (float)3.14; // 合法（强制类型转换）
float c = 3.14; // 编译错误！3.14 是 double，无法隐式转为 float
3. 不加后缀的后果
类型 不加后缀的赋值行为
long - 若值在 int 范围内：自动转为 long（合法）
- 若值超出 int 范围：编译错误
float - 无论值是否在 float 范围内：直接赋值 double 字面量会导致编译错误
（需要显式标记或转换）
4. 底层原理
类型安全性：Java 是强类型语言，禁止隐式的高精度（double）到低精度（float）转换，
避免意外精度损失。
字面量默认规则：
123 → int
123L → long
3.14 → double
3.14F → float
5. 扩展：其他类型的后缀
类型 后缀 示例
long L 10000000000L
float F 3.14F
double D（可省略） 3.14 或 3.14D
6.总结
long 需要 L：避免整数字面量超出 int 范围时的编译错误。
float 需要 F：防止 double 到 float 的隐式转换导致精度丢失风险。
Java 的设计哲学：通过显式标记强制开发者明确类型，减少隐式错误。7.图片整合如下：
8.Practice
1.讲师介绍
public class VariableTest2{
//入口
public static void main(String[] args){
String name="谢广坤";
int age=18;
char sex='男';
double height=180.1;
boolean alone=false;
System.out.printf("讲师介绍：%n姓名：%s%n年龄：%d%n性别：%s%n身高：%.2f%n是否单身：%s%n",name,age,sex,height,alone);
}
}
输出：
C:\Users\秦风\Desktop\java_study\代码>java VariableTest2
讲师介绍：
姓名：谢广坤
年龄：18
性别：男
身高：180.10
是否单身：false
2.电影介绍
public class VariableTest2{
//入口
public static void main(String[] args){
String Movie_title="送初恋回家";
String Starring_role="刘鑫 张雨提 高媛...";
int year=2020;
double rating=9.0;
System.out.printf("电影名：%s%n主演：%s%n年份：%d%n评分：%.1f",Movie_title,Starring_role,year,rating);
}
}
输出：
电影名：送初恋回家
主演：刘鑫 张雨提 高媛...
年份：2020
评分：9.0
3.手机介绍
public class VariableTest2{
//入口
public static void main(String[] args){
String brand="HUAWEI MATE 30E Pro";
double price=5299.00;
System.out.printf("手机：%s%n价格：%.2f",brand,price);
}
}
输出：
手机：HUAWEI MATE 30E Pro
价格：5299.00-----------------------------------------------------------------------------------------------------------
2.标识符
1.标识符定义：给类、方法、变量等取的名字 （是一个统称）
2.遵守规则：
1.硬性要求：由数字、字母、下划线（_）和美元符号（$）组成
2.不能以数字开头
3.不能是关键字
4.区分大小写（写Class可以）
5.见名知意
3.标识符规范：
1.小驼峰命名法：方法、变量
1.是一个单词全小写 name
2.多个单词，第一个单词首字母小写，其他单词首字母大写 movieName
2.大驼峰命名法：类名
1.是一个单词，首字母大写 Demo1
2.多个单词，每个单词字母均大写 HelloWorld-----------------------------------------------------------------------------------------------------------
3.键盘录入
1.介绍：并不需要去手动录入键盘配置键盘等等，因为java已经写好了一个类--Scanner，这个类
就可以直接接受键盘输入的数字
2.步骤：
1.导包 -- Scanner这个类在哪
import java.util.Scanner; // 导包必须在类定义的上面
2.创建对象 -- 开始使用Scanner类
Scanner sc = new Scanner(System.in); // 此处sc可自己设置，其他均不可改变
3.接收数据 -- 开始实现
int i = sc.nextInt(); // i为变量名可变，其他均不变
3.实现：
//1.导包，找到Scanner这个类在哪
import java.util.Scanner;
public class ScannerDemo1{
public static void main(String[] args){
//2.创建对象，表示准备开始使用Scanner类
Scanner sc = new Scanner(System.in);
//3.接收数据
System.out.printf("你现在几岁："); //注意：printf：默认不换行，println默认换行
int i = sc.nextInt(); //i记录了键盘数据
//4.输出键盘值i
System.out.printf("原来你已经%d岁了",i);
}
}
输出：
你现在几岁:12
原来你已经12岁了
4.practice：
1.需求：键盘录入两个整数，求他们的和并打印出来
2.实现：
import java.util.Scanner;
public class ScannerTest{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.printf("请输入第一个整数：");
int i = sc.nextInt();
System.out.printf("请输入第二个整数：");
int f = sc.nextInt();
int c=i+f;
System.out.printf("%d+%d=%d",i,f,c);
}
}
3.结果：
请输入第一个整数：12
请输入第二个整数：32
12+32=44
-----------------------------------------------------------------------------------------------------------
4.IDEA
1.官网下载配置即可
2.优点:其会自动编译，不用手动javac编译，有各种ai工具能够帮助我们快速编写代码以及提示代码
3.IDEA的项目结构：
project(项目)
module(模块)
package(包)
class(类)
4.so,打开IDEA后 创建项目--创建一个模块--创建一个包（一般为公司域名反写）--创建一个java类
5.注：
1.可以使用psvm快捷写入主入口
2.sout直接写输入语句
3.实现自动导包--在设置中点击编辑器--常规--自动导入，勾选动态添加明确的import以及动态优化import即可
4.取消掉小写自动报错---也是在常规中--代码补全--取消掉区分大小写
5.设置背景图片--设置--外观--背景图像
6.idea的常规操作：
1.新建类在某个包中、删除类
2.给类改名--不能在类中代码去改，因为要保证类名与文件名的一致，所以直接重命名即可（可以按快捷键shift+Fn+F6）
3.关闭项目--点击左上角文件--点击关闭项目-----------------------------------------------------------------------------------------------------------
5.运算符
基础概念：
运算符：对字面量或者变量进行操作的符号（+ - * / % // **）
表达式：把字面量和变量连接起来，符合java语法的式子（a+b...）1.算术运算符
1.符号： + - * / %
加 减 乘 除 取模、取余
2.代码示例：
package com;
public class bilibiliDemo1 {
public static void main(String[] args) {
// + - * / %
System.out.println(3+2);
System.out.println(34-13);
System.out.println(34*2);
System.out.println(12/3);
System.out.println(3%2);//1，也是除法只是取的余数
//计算是有小数参与
//在代码中默认是整数相加，所以需要显示的声明为小数
//整数参与计算只能得到整数
//如果小数参与计算了，结果可能是不精确的（javaSE中会了解到）
System.out.println(1.02+2.2); //3.22
System.out.println(1.02+123.02); //124.03999999999999
System.out.println(1.1-1.01);
//取模应用场景：
//1.可以用取模来判断，A是否可以被B整除
//2.判断A是否为偶数
//如果结果为A/2=0则，A为偶数，否则A为奇数
//3.斗地主发牌，给每一张牌编号，如果是然后牌号%3，
//如果为1则发给第一位玩家
//如果是2则发给第二位玩家
//如果为0则发给第三位玩家
}
}
运行结果为：
5
21
68
4
1
3.22
124.03999999999999
0.09000000000000008
3.练习，通过键盘录入一个三位数，并输出其百位十位个位，如下：
package com;
import java.util.Scanner;
public class bilibiliTest1 {
public static void main(String[] args) {
//达成的效果：键盘录入一个三位数，将其拆分为个位十位百位，并打印出来
//先声明Scanner类
Scanner sc = new Scanner(System.in);
System.out.print("请输入一个三位数整数：");
int i = sc.nextInt();
int g = i%10;
System.out.printf("个位数是：%d%n",g);
int s = i/10%10;
System.out.printf("十位数是：%d%n",s);
int b = i/100;
System.out.printf("百位数是：%d",b);
//公式总结：
//个位数：i%10
//十位数：i/10%10
//百位数：i/100%10
//千位数：i/1000%10
//万位数：i/10000%10
}
}
运行结果：
请输入一个三位数整数：345
个位数是：5
十位数是：4
百位数是：3
4.数字相加：
int a=12;
double b=20.12;
请问：c=a+b c是什么数据类型 答案是：double
再请问，int a=10;int b=20.0
c=a+b c是什么数据类型 答案是：double
记住一句话：数字进行运算时，数据类型不一样不能够进行运算，需要转换成一样的才能进行运算
5.显隐转换：（byte < short < int < long < float < double）
1.隐式转换：
int a =10;
double b=a; //隐式转换（范围小的变成大的，没啥问题）
but,注意：byte、short、char三种类型的数据在运算时，都会直接提升为int，然后再进行运算
所以：
public class demo1{
public static void main(String[] args){
byte a=10;
byte b=20;
//数据类型？ c=a+b; 实际上是先转换为int然后两个int类型来进行运算
int c=a+b;
byte b=10;
byte s=20;
long n=100L;
//数据类型 result=b+s+n？ 首先b+s -->就是统一先转换为int类型再来进行转换，所以
//b+s 的结果为int类型，然后再int和long类型进行转换，类型不一样不能进行计算，所以先
//转换成long类型，然后再进行计算，所以最后result是long类型！！！
}
}
2.强制（显式）转换：
1.场景：你想要将一个取值范围大的数值，赋值给取值范围小的变量，是不允许的，so
如果你一定要转换，就用强制转换
2.格式：目标数据类型 变量 = (目标数据类型) 被强制转换的数据;
3.示例：
double a=100.1;
int b =(int) a; //会丢失精度（小数点后面的数据没了）
4.代码实现：
//强制转换：
//1.
byte e=10;
byte f=20;
int g=e+f; // 一点问题没有 ，结果为：30不会错误
System.out.println(g);
//2.
byte h=10;
byte i=20;
byte j=(byte)(h+i); //没啥问题，如果你要这样写是有错的：byte k=(byte)h+(byte)i;
System.out.println(j);
//3.
byte k=100;
byte l=100;
byte m=(byte)(k+l);
System.out.println(m); //运行看看，因为byte类型只有8位，而int类型有32位，所以会丢失
6.+号--字符串、数字相加：
例1：
System.out.println("今天是："+2025+"年"+05+16); //只要有字符串参与时做的都是拼接操作
例2：
System.out.println("abc"+true); //abctrue
例3：
System.out.println(1+2+"abc"+1+2); //3abc12
注：
当出现多个+号时会从左到右去执行，所以 例1的结果为："今天是：2025年516"
7.+号--字符相加：
char类型进行相加--ASCII码进行相加
例1：
//char类型进行相加
char c1='a';
int result=c1+0;
System.out.println(result); //97
例2：
System.out.println(1+"a"); //98
System.out.println(1+"abc"); //1abc
2.自增自减运算符
1.自增（++）：变量值+1
2.自减（--）：变量值-1
例1：
//自增自减:
int x=10;
x++;
System.out.println(x); //11
++x;
System.out.println(x); //12
--x;
System.out.println(x); //11
x--;
System.out.println(x); //10
例2：
//++x与x++区别
1.++x为：先+后用
2.x++为：先用后+
例：
int a1=10;
int b1=++a1;
System.out.println(b1); //11
System.out.println(a1); //11
int a2=10;
int b2=a2++;
System.out.println(b2); //10
System.out.println(a2); //11
//Practice:
int a3=10;
int b3=a3++;
int c3=++a3;
System.out.println(a3); //12
System.out.println(b3); //10
System.out.println(c3); //123.赋值运算符
1.= ：赋值，将=号右边的值赋值给=左边的变量
2.+=、-=、*=、/=、%=
例：
//+=、-=、*=、/=、%=
int a4=10;
a4+=5; //a4=a4+5
System.out.println(a4); //15
a4-=5;
System.out.println(a4); //10
a4*=5;
System.out.println(a4); //50
a4/=5;
System.out.println(a4); //10
a4%=5;
System.out.println(a4); //0
注意：
+=、-=、*=、/=、%= 隐藏了一个强制转换
比如byte s=1;
s+=2; //是-->s=s+2？
//错的 因为s=s+2;就将一个int类型的s转换成了byte，隐式转换会报错
//so，-->s=(byte)(s+2);
4.关系运算符（比较运算符）
1.==
== 是判断两边是否相等，相等返回true，否则返还false
2.!=
!= 判断两边是否不相等，不相等返回true，相等返回false
3.> >= < <=
与上类似，符合要求返回true，不符合则返回false
4.例：
//关系运算符==、!=、>、<、>=、<=
int a5=10;
int b5=20;
System.out.println(a5==b5); //false
System.out.println(a5!=b5); //true
System.out.println(a5>b5); //false
System.out.println(a5<b5); //true
System.out.println(a5>=b5); //false
System.out.println(a5<=b5); //true
//practice
//约会中，键盘录入两个整数（0~10），一个代表你的时髦，另外一个代表你的 partner 的时髦
// 如果你的时髦大于partner 的时髦，那么就打印：true，否则打印：false
Scanner scanner=new Scanner(System.in);
System.out.println("请输入你的时髦程度：(0~10之间)");
int myfashion_score=scanner.nextInt();
System.out.println("请输入相亲对象的时髦程度：(0~10之间)");
int girlfashion_score=scanner.nextInt();
boolean result1=myfashion_score>girlfashion_score;
System.out.println(result1);
结果1：
请输入你的时髦程度：(0~10之间)
1
请输入相亲对象的时髦程度：(0~10之间)
5
false
结果2：
请输入你的时髦程度：(0~10之间)
10
请输入相亲对象的时髦程度：(0~10之间)
9
true
注意：
1.关系运算符的结果都是boolean类型的，即--要么是true，--要么是false
2.区分==与= --- 一个是判断两边是否相等 ---一个是赋值5.逻辑运算符
1.引言：
在数学中，x大于10小于80可以这样写 -- 10<x<80
但是在java中需要将 10<x<80 进行拆解：
拆解为：x>10 x<80
合并为：x>10 & x<80 //其中&即为逻辑运算符
2.逻辑运算符种类：
1.&（逻辑与/且）
两边都为真才为真
2.|（逻辑或）
两边有一边为真即为真
3.^（逻辑异或）
相同为false、不同为true
4.!（逻辑非）
取反
3.练习：
//逻辑运算符&、|、^、!
//逻辑与/且&
System.out.println(true&true);//true
System.out.println(false&false);//false
System.out.println(true&false);//false
System.out.println(false&true);//false
System.out.println("---------------------------------------------------------");
//逻辑或|
System.out.println(true|true);//true
System.out.println(false|false);//false
System.out.println(true|false);//true
System.out.println(false|true);//true
System.out.println("---------------------------------------------------------");
//逻辑异或^
System.out.println(true^true);//false
System.out.println(false^false);//false
System.out.println(true^false);//true
System.out.println(false^true);//true
System.out.println("---------------------------------------------------------");
//取反
//注意：！要么写一个要么就一个都不写
System.out.println(!false);//true
System.out.println(!true);//false
4.短路逻辑运算符：以后用的比较多（ && || ！）
1.讲解：能够提升代码效率，because如果第一个不满足，后续就不会继续执行
1.&&：
有车&&有房 -->结婚 if你没车不用看了，直接判定不结婚
如果是正常逻辑与&，就算知道了没车，也会继续判定有没有房...
2.||：
与上同
有车||有房 -->结婚 if你有车不用看了，直接判定结婚
如果是正常逻辑或|，就算知道了有车，也会继续判定有没有房...
2.例：
1.&& || 输出的也是true、false与& |相同
//短路运算符：
// &&
System.out.println(true&&true);//true
System.out.println(false&&false);//false
System.out.println(true&&false);//false
System.out.println(false&&true);//false
System.out.println("---------------------------------------------------------");
// ||
System.out.println(true||true);//true
System.out.println(false||false);//false
System.out.println(true||false);//true
System.out.println(false||true);//true
System.out.println("---------------------------------------------------------");
2.对比&& &
//例1：&&
int a6=10;
int b6=15;
boolean result2 = a6++<5 && b6++<20;
System.out.println(a6); //11
System.out.println(b6); //15
//例2：&
int a7=10;
int b7=15;
boolean result3 = a7++<5 & b7++<20;
System.out.println(result3);
System.out.println(a7); //11
System.out.println(b7); //16
3.practice
//practice,键盘录入两个数，if一个为6--最终结果输出true if他们的和为6的倍数--输出true
//其他情况为false
Scanner scanner=new Scanner(System.in);
System.out.println("请输入第一个整数：");
int a =scanner.nextInt();
System.out.println("请输入第二个整数：");
int b =scanner.nextInt();
boolean result = a==6 || b==6 ||(a+b)%6==0;
System.out.println(result);6.三元运算符
1.（三元运算符/三元表达式）作用：可以进行判断，根据判断得出不同的内容
2.格式：布尔表达式？表达式1：表达式2;
3.注意：
1.三元表达式--如果关系表达式为true--结果为：表达式1的结果 ---false--结果：表达式2的结果
2.三元表达式--需要取赋值给一个变量或者在if、for...使用，单独写是错误的
4.示例：
//需求：使用三元运算符来取得两个数的较大值
//三元运算符求较大值
System.out.println("请输入第一个正整数：");
int c=scanner.nextInt();
System.out.println("请输入第二个正整数：");
int d=scanner.nextInt();
int max=c>d?c:d;
System.out.println(max);
//或者直接写在输出中：
System.out.println(c>d?c:d);
5.practice:
1.//需求：动物园有两只老虎，体重通过键盘录入获得，请用程序实现判断
//两只老虎的体重是否相等
//老虎体重判断
System.out.println("请输出第一只老虎的体重：");
double tiger1_weight=scanner.nextDouble();
System.out.println("请输出第二只老虎的体重：");
double tiger2_weight=scanner.nextDouble();
String weight=tiger1_weight==tiger2_weight?"两只老虎体重相同":"两只老虎体重不同";
System.out.println("结果为："+weight);
2.//已知一座庙里住着三个和尚，已知他们的身高分别为150cm，210cm，165cm
//请用程序实现获取这个三个和尚的最高身高
//庙里求最高和尚
int h1=150;
int h2=210;
int h3=165;
int max1=h1>h2?h1:h2;
int max2=max1>h3?max1:h3;
//ctrl+alt+l 自动格式化代码（让代码自动对齐）--
//有可能会和其他软件的快捷键冲突（qq、网易于...关闭软件即可）
System.out.println("身高最高的和尚，他的身高是："+max2+"cm");
7.运算符优先级
记住：小括号优先于所有
其他的运算符
1.图例：
2.&的运算（逻辑与运算，全1才为1，其他情况均为0）
3.| 的运算（逻辑或运算--全0才为0，其他情况均为1）
4.左移（<<）：左移一次*2，两次*4 -- 算出来的规则
5.右移（>>）：右移一次/2，两次/4 -- 算出来的规则
6.无符号右移（>>>）:不管你是正数还是负数都补0，其他与右移相同
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
