文章目录 1. Java概述1.1 Java语言发展史1.2 Java语言跨平台原理1.3 JRE和JDK1.4 JDK的下载和安装1.4.1 下载1.4.2 安装1.4.3 JDK的安装目录介绍 2. 第一个演示程序2.
语言:人与人交流沟通的表达方式
计算机语言:人与计算机之间进行信息交流沟通的一种特殊语言
Java语言是美国Sun公司(Stanford University Network)在1995年推出的计算机语言
Java之父:詹姆斯·高斯林(James Gosling)
2009年，Sun公司被甲骨文公司收购，所以我们现在访问oracle官网即可:https://www.oracle.com
当前，我们课程使用的jdk版本:11.0
Java程序并非是直接运行的，Java编译器将Java源程序编译成与平台无关的字节码文件(class文件)，然后由Java虚拟机(JVM)对字节码文件解释执行。所以在不同的操作系统下，只需安装不同的Java虚拟机即可实现java程序的跨平台。
JVM(Java Virtual Machine)，Java虚拟机
JRE(Java Runtime Environment)，Java运行环境，包含了JVM和Java的核心类库(Java api) JDK(Java Development Kit)称为Java开发工具，包含了JRE和开发工具
总结:我们只需安装JDK即可，它包含了java的运行环境和虚拟机。
通过官方网站获取JDK
http://www.oracle.com/
注意:针对不同的操作系统，需要下载对应版本的JDK。
傻瓜式安装，下一步即可。但默认的安装路径是在C:\Program Files下，为方便统一管理建议修改安装路径，将与开发相关的软件都安装到一个目录下，例如:E:\develop。
注意:安装路径不要包含中文或者空格等特殊字符(使用纯英文目录)。
| 目录名称 | 说明 |
|---|---|
| bin | 该路径下存放了JDK的各种工具命令。javac和java就放在这个目录。 |
| conf | 该路径下存放了JDK的相关配置文件。 |
| include | 该路径下存放了一些平台特定的头文件。 |
| jmods | 该路径下存放了JDK的各种模块。 |
| legal | 该路径下存放了JDK各模块的授权文档。 |
| lib | 该路径下存放了JDK工具的一些补充jar包。 |
在接触集成开发环境之前，我们需要使用命令行窗口对java程序进行编译和运行，所以需要知道一些常用DOS命令。
1、打开命令行窗口的方式:win + r打开运行窗口，输入cmd，回车。
2、常用命令及其作用
| 操作 | 说明 |
|---|---|
| 盘符名称: | 盘符切换。E:回车，表示切换到E盘。 |
| dir | 查看当前路径下的内容。 |
| cd 目录 | 进入单级目录。cd itterence |
| cd .. | 回退到上一级目录。 |
| cd 目录1\目录2… | 进入多级目录。cd itterence\JavaSE |
| cd \ | 回退到盘符目录。 |
| cls | 清屏。 |
| exit | 退出命令提示符窗口。 |
开发Java程序，需要使用JDK提供的开发工具(比如javac.exe、java.exe等命令)，而这些工具在JDK的安装目录的 bin目录下，如果不配置环境变量，那么这些命令只可以在该目录下执行。我们不可能把所有的java文件都放到JDK的bin目录下，所以配置环境变量的作用就是可以使bin目录下的java相关命令可以在任意目录下使用。
如果命令提示符窗口是配合环境变量前打开的,需要关闭该窗口,重新打开一个窗口测试
HelloWorld案例是指在计算机屏幕上输出“HelloWorld”这行文字。各种计算机语言都习惯使用该案例作为第一个演示案例。
开发Java程序，需要三个步骤:编写程序，编译程序，运行程序。
新建文本文档文件，修改名称为HelloWorld.java。
2、用记事本打开HelloWorld.java文件，输写程序内容。
public class HelloWorld { public static void main(String[] args) { System.out.println("HelloWorld"); }}存文件，打开命令行窗口，将目录切换至java文件所在目录，编译java文件生成class文件，运行class文件。
编译:javac 文件名.java
范例:javac HelloWorld.java
执行:java 类名
范例:java HelloWorld
在电脑系统或程序中，隐藏着的一些未被发现的缺陷或问题统称为bug(漏洞)。
具备识别BUG的能力:多看
2、具备分析BUG的能力:多思考，多查资料
3、具备解决BUG的能力:多尝试，多总结
非法字符问题。Java中的符号都是英文格式的。
2、大小写问题。Java语言对大小写敏感(区分大小写)。
3、在系统中显示文件的扩展名，避免出现HelloWorld.java.txt文件。
4、编译命令后的java文件名需要带文件后缀.java
5、运行命令后的class文件名(类名)不带文件后缀.class …
Notepad++功能比windows中的自带记事本功能强大，除了可以用来制作一般的纯文字说明文件，也十分适合编写计算机程序代码。Notepad++有行号，能够快速定位问题位置，还有语法高亮度显示、代码折叠等功能。而且它是免费的。
安装:傻瓜式安装，一直下一步即可。建议也安装到统一的开发软件目录下，比如E:\develop。
安装完毕之后，为了使用方便，做一个简单的配置:修改默认语言和编码。
注释是对代码的解释和说明文字，可以提高程序的可读性，因此在程序中添加必要的注释文字十分重要。Java中的 注释分为三种:
单行注释。单行注释的格式是使用//，从//开始至本行结尾的文字将作为注释文字。
// 这是单行注释文字多行注释。多行注释的格式是使用将一段较长的注释括起来。
注意:多行注释不能嵌套使用。
文档注释。文档注释以 结束。(以后讲)
关键字是指被java语言赋予了特殊含义的单词。
关键字的特点:关键字的字母全部小写。
常用的代码编辑器对关键字都有高亮显示，比如现在我们能看到的public、class、static等。
常量:在程序运行过程中，其值不可以发生改变的量。
Java中的常量分类:
字符串常量 用双引号括起来的多个字符(可以包含0个、一个或多个)，例如"a"、“abc”、"中国"等
整数常量 整数，例如:-10、0、88等
小数常量 小数，例如:-5.5、1.0、88.88等
字符常量 用单引号括起来的一个字符，例如:‘a’、‘5’、‘B’、'中’等
布尔常量 布尔值，表示真假，只有两个值true和false
空常量 一个特殊的值，空值，值为null
除空常量外，其他常量均可使用输出语句直接输出。
public class Demo { public static void main(String[] args) { System.out.println(10); // 输出一个整数 System.out.println(5.5); // 输出一个小数 System.out.println('a'); // 输出一个字符 System.out.println(true); // 输出boolean值true System.out.println("欢迎来到黑马程序员"); // 输出字符串 }}我们知道计算机是可以用来存储数据的，但是无论是内存还是硬盘，计算机存储设备的最小信息单元叫“位 (bit)”，我们又称之为“比特位”，通常用小写的字母”b”表示。而计算机中最基本的存储单元叫“字节(byte)”，
通常用大写字母”B”表示，字节是由连续的8个位组成。
除了字节外还有一些常用的存储单位，其换算单位如下:
1B(字节) = 8bit
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
Java是一个强类型语言，Java中的数据必须明确数据类型。在Java中的数据类型包括基本数据类型和引用数据类型两种。
Java中的基本数据类型:
| 数据类型 | 关键字 | 内存占用 | 取值范围 |
|---|---|---|---|
| 整数类型 | byte | 1 | -128~127 |
| short | 2 | -32768~32767 | |
| int(默认) | 4 | -2的31次方到2的31次方-1 | |
| long | 8 | -2的63次方到2的63次方-1 | |
| 浮点类型 | float | 4 | 负数:-3.402823E+38到-1.401298E-45 正数: 1.401298E-45到 3.402823E+38 |
| double(默认) | 8 | 负数:-1.797693E+308到-4.9000000E-324 正数:4.9000000E-324 到1.797693E+308 | |
| 字符类型 | char | 2 | 0-65535 |
| 布尔 类型 | boolean | 1 | true，false |
| 说明: e+38表示是乘以10的38次方，同样，e-45表示乘以10的负45次方。在java中整数默认是int类型，浮点数默认是double类型。 |
变量:在程序运行过程中，其值可以发生改变的量。
从本质上讲，变量是内存中的一小块区域，其值可以在一定范围内变化。
变量的定义格式:
数据类型 变量名 = 初始化值; // 声明变量并赋值
int age = 18;
System.out.println(age);
或者
// 先声明，后赋值(使用前赋值即可) 数据类型 变量名;
变量名 = 初始化值;
double money;
money = 55.5;
System.out.println(money);
还可以在同一行定义多个同一种数据类型的变量，中间使用逗号隔开。但不建议使用这种方式，降低程序的可读性。
int a = 10, b = 20; // 定义int类型的变量a和b，中间使用逗号隔开System.out.println(a);System.out.println(b);int c,d; // 声明int类型的变量c和d，中间使用逗号隔开c = 30;d = 40;System.out.println(c);System.out.println(d);变量的使用:通过变量名访问即可。
标识符是用户编程时使用的名字，用于给类、方法、变量、常量等命名。
Java中标识符的组成规则:
由字母、数字、下划线“_”、美元符号“$”组成，第一个字符不能是数字。
不能使用java中的关键字作为标识符。
标识符对大小写敏感(区分大小写)。
Java中标识符的命名约定:
小驼峰式命名:变量名、方法名
首字母小写，从第二个单词开始每个单词的首字母大写。
大驼峰式命名:类名
每个单词的首字母都大写。
另外，标识符的命名最好可以做到见名知意
例如:username、studentNumber等。
在Java中，一些数据类型之间是可以相互转换的。分为两种情况:自动类型转换和强制类型转换。 自动类型转换:
把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。这种转换方式是自动的，直接书写即可。例如:
double num = 10; // 将int类型的10直接赋值给double类型 System.out.println(num); // 输出10.0强制类型转换:
把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。
强制类型转换格式:目标数据类型 变量名 = (目标数据类型)值或者变量;
例如:
double num1 = 5.5;int num2 = (int) num1; // 将double类型的num1强制转换为int类型System.out.println(num2); // 输出5(小数位直接舍弃)
说明:
int a = 'a'; System.out.println(a); // 将输出97byte b1 = 10;byte b2 = 20;byte b3 = b1 + b2;// 第三行代码会报错，b1和b2会自动转换为int类型，计算结果为int，int赋值给byte需要强制类型转换。// 修改为:int num = b1 + b2;// 或者:byte b3 = (byte) (b1 + b2);运算符:对常量或者变量进行操作的符号
表达式:用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。
不同运算符连接的表达式体现的是不同类型的表达式。
举例说明:
int a = 10;int b = 20;int c = a + b;+:是运算符，并且是算术运算符。
a + b:是表达式，由于+是算术运算符，所以这个表达式叫算术表达式。
| 符号 | 作用 | 说明 |
|---|---|---|
| + | 加 | 参看小学一年级 |
| - | 减 | 参看小学一年级 |
| * | 乘 | 参看小学二年级，与“×”相同 |
| / | 除 | 参看小学二年级，与“÷”相同 |
| % | 取余 | 获取的是两个数据做除法的余数 |
注意: /和%的区别:两个数据做除法，/取结果的商，%取结果的余数。
整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。
int a = 10;int b = 3;System.out.println(a / b); // 输出结果3System.out.println(a % b); // 输出结果1char类型参与算术运算，使用的是计算机底层对应的十进制数值。需要我们记住三个字符对应的数值:
‘a’ – 97 a-z是连续的，所以’b’对应的数值是98，'c’是99，依次递加
‘A’ – 65 A-Z是连续的，所以’B’对应的数值是66，'C’是67，依次递加
‘0’ – 48 0-9是连续的，所以’1’对应的数值是49，'2’是50，依次递加
// 可以通过使用字符与整数做算术运算，得出字符对应的数值是多少char ch1 = 'a';System.out.println(ch1 + 1); // 输出98，97 + 1 = 98char ch2 = 'A';System.out.println(ch2 + 1); // 输出66，65 + 1 = 66char ch3 = '0';System.out.println(ch3 + 1); // 输出49，48 + 1 = 49算术表达式中包含不同的基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。
提升规则:
byte类型，short类型和char类型将被提升到int类型，不管是否有其他类型参与运算。
整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型
等级顺序:byte,short,char --> int --> long --> float --> double
例如:
byte b1 = 10;byte b2 = 20;// byte b3 = b1 + b2; // 该行报错，因为byte类型参与算术运算会自动提示为int，int赋值给byte可能损失精度int i3 = b1 + b2; // 应该使用int接收byte b3 = (byte) (b1 + b2); // 或者将结果强制转换为byte类型// -------------------------------int num1 = 10;double num2 = 20.0;double num3 = num1 + num2; // 使用double接收，因为num1会自动提升为double类型tips:正是由于上述原因，所以在程序开发中我们很少使用byte或者short类型定义整数。也很少会使用char类型定义字符，而使用字符串类型，更不会使用char类型做算术运算。
当“+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算。
System.out.println("itheima"+ 666); // 输出:itheima666在”+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行“+”操作时，从左到右逐个执行。
System.out.println(1 + 99 + "年黑马"); // 输出:100年黑马System.out.println(1 + 2 + "itheima" + 3 + 4); // 输出:3itheima34// 可以使用小括号改变运算的优先级System.out.println(1 + 2 + "itheima" + (3 + 4)); // 输出:3itheima7 赋值运算符的作用是将一个表达式的值赋给左边，左边必须是可修改的，不能是常量。
| 符号 | 作用 | 说明 |
|---|---|---|
| = | 赋值 | a=10，将10赋值给变量a |
| += | 加后赋值 | a+=b，将a+b的值给a |
| -= | 减后赋值 | a-=b，将a-b的值给a |
| *= | 乘后赋值 | a*=b，将a×b的值给a |
| /= | 除后赋值 | a/=b，将a÷b的商给a |
| %= | 取余后赋值 | a%=b，将a÷b的余数给a |
| 注意: | ||
| 扩展的赋值运算符隐含了强制类型转换。 |
short s = 10;s = s + 10; // 此行代码报出，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度s += 10; // 此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s + 10);| 符号 | 作用 | 说明 |
|---|---|---|
| ++ | 自增 | 变量的值加1 |
| – | 自减 | 变量的值减1 |
注意事项:
++和-- 既可以放在变量的后边，也可以放在变量的前边。
单独使用的时候， ++和-- 无论是放在变量的前边还是后边，结果是一样的。
参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者–。
参与操作的时候，如果放在变量的前边，先拿变量做++或者–，后拿变量参与操作。
最常见的用法:单独使用。
int i = 10;i++; // 单独使用 System.out.println("i:" + i); // i:11int j = 10;++j; // 单独使用 System.out.println("j:" + j); // j:11int x = 10;int y = x++; // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1System.out.println("x:" + x + ", y:" + y); // x:11，y:10int m = 10;int n = ++m; // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1System.out.println("m:" + m + ", m:" + m); // m:11，m:11练习:
int x = 10;int y = x++ + x++ + x++;System.out.println(y); // y的值是多少?注意:通过此练习深刻理解自增和自减的规律，但实际开发中强烈建议不要写这样的代码!小心挨打!
关系运算符有6种关系，分别为小于、小于等于、大于、等于、大于等于、不等于。
| 符号 | 说明 |
|---|---|
| == | a==b，判断a和b的值是否相等，成立为true，不成立为false |
| != | a!=b，判断a和b的值是否不相等，成立为true，不成立为false |
| > | a>b，判断a是否大于b，成立为true，不成立为false |
| >= | a>=b，判断a是否大于等于b，成立为true，不成立为false |
| < | a |
| <= | a<=b，判断a是否小于等于b，成立为true，不成立为false |
| 注意事项: | |
| 关系运算符的结果都是boolean类型，要么是true，要么是false。 | |
| 千万不要把"==“误写成”=“，”=="是判断是否相等的关系，=是赋值。 |
int a = 10;int b = 20;System.out.println(a == b); // falseSystem.out.println(a != b); // trueSystem.out.println(a > b); // falseSystem.out.println(a >= b); // falseSystem.out.println(a < b); // trueSystem.out.println(a <= b); // true// 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量 boolean flag = a > b;System.out.println(flag); // 输出false逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。
| 符号 | 作用 | 说明 |
|---|---|---|
| & | 逻辑与 | a&b，a和b都是true，结果为true，否则为false |
| | | 逻辑或 | a|b，a和b都是false，结果为false，否则为true |
| ^ | 逻辑异或 | a^b，a和b结果不同为true，相同为false |
| ! | 逻辑非 | !a，结果和a的结果正好相反 |
//定义变量int i = 10; int j = 20; int k = 30;//& “与”，并且的关系，只要表达式中有一个值为false，结果即为falseSystem.out.println((i > j) & (i> k)); //false & false,输出false System.out.println((i < j) & (i> k)); //true & false,输出false false System.out.println((i > j) & (i< k)); //false & true,输出System.out.println((i < j) & (i< k)); //true & true,输出trueSystem.out.println("--------");//| “或”，或者的关系，只要表达式中有一个值为true，结果即为trueSystem.out.println((i > j) | (i> k)); //false | false,输出false System.out.println((i < j) | (i> k)); //true | false,输出trueSystem.out.println((i > j) | (i< k)); //false | true,输出trueSystem.out.println((i < j) | (i< k)); //true | true,输出trueSystem.out.println("--------");//^ “异或”，相同为false，不同为trueSystem.out.println((i > j) ^ (i > k)); //false ^ false,输出falseSystem.out.println((i < j) ^ (i > k)); //true ^ false,输出trueSystem.out.println((i > j) ^ (i < k)); //false ^ true,输出trueSystem.out.println((i < j) ^ (i < k)); //true ^ true,输出falseSystem.out.println("--------");//! “非”，取反System.out.println((i > j)); //falseSystem.out.println(!(i > j)); //!false,输出true 短路逻辑运算符
| 符号 | 作用 | 说明 |
|---|---|---|
| && | 短路与 | 作用和&相同，但是有短路效果 |
| || | 短路或 | 作用和 |
| 在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都 计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式 将不再参与运算。 |
int x = 3;int y = 4;System.out.println((x++ > 4) & (y++ > 5)); // 两个表达都会运算System.out.println(x); // 4System.out.println(y); // 5System.out.println((x++ > 4) && (y++ > 5)); // 左边已经可以确定结果为false，右边不参与运算 System.out.println(x); // 4System.out.println(y); // 4三元运算符语法格式:
关系表达式 ? 表达式1 : 表达式2;
解释:问号前面的位置是判断的条件，判断结果为boolean型，为true时调用表达式1，为false时调用表达式2。其逻辑为:如果条件表达式成立或者满足则执行表达式1，否则执行第二个。
举例:
int a = 10;int b = 20;int c = a > b ? a : b; // 判断 a>b 是否为真，如果为真取a的值，如果为假，取b的值三元运算符案例:
1、需求:动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现判断两只老虎的体重是否相同。
public class OperatorTest01 {public static void main(String[] args) {//1：定义两个变量用于保存老虎的体重，单位为kg，这里仅仅体现数值即可。int weight1 = 180;int weight2 = 200;//2：用三元运算符实现老虎体重的判断，体重相同，返回true，否则，返回false。boolean b = weight1 == weight2 ? true : false;//3：输出结果System.out.println("b:" + b);}}需求:一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，请用程序实现获取这三个和尚的最高身高。
public class OperatorTest02 {public static void main(String[] args) {//1：定义三个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。int height1 = 150;int height2 = 210;int height3 = 165;//2：用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。int tempHeight = height1 > height2 ? height1 : height2;//3：用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。int maxHeight = tempHeight > height3 ? tempHeight : height3;//4：输出结果System.out.println("maxHeight:" + maxHeight);}}我们可以通过 Scanner 类来获取用户的输入。使用步骤如下:
1、导包。Scanner 类在java.util包下，所以需要将该类导入。导包的语句需要定义在类的上面。
import java.util.Scanner;
创建Scanner对象。
Scanner sc = new Scanner(System.in);// 创建Scanner对象，sc表示变量名，其他均不可变
接收数据
int i = sc.nextInt(); // 表示将键盘录入的值作为int数返回。
示例:
import java.util.Scanner;public class ScannerDemo {public static void main(String[] args) { //创建对象Scanner sc = new Scanner(System.in); //接收数据int x = sc.nextInt();//输出数据 System.out.println("x:" + x); }}改写三个和尚案例，数据使用键盘录入。
import java.util.Scanner;public class ScannerTest {public static void main(String[] args) {//身高未知，采用键盘录入实现。首先导包，然后创建对象。Scanner sc = new Scanner(System.in);//键盘录入三个身高分别赋值给三个变量。System.out.println("请输入第一个和尚的身高：");int height1 = sc.nextInt();System.out.println("请输入第二个和尚的身高：");int height2 = sc.nextInt();System.out.println("请输入第三个和尚的身高：");int height3 = sc.nextInt();//用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。int tempHeight = height1 > height2 ? height1 : height2;//用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。int maxHeight = tempHeight > height3 ? tempHeight : height3;//输出结果。System.out.println("这三个和尚中身高最高的是：" + maxHeight +"cm");}}在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能。
顺序结构
分支结构(if, switch)
循环结构(for, while, do…while)
顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
顺序结构执行流程图:
格式:
if (关系表达式) {
语句体;
}
执行流程:
1首先计算关系表达式的值
2如果关系表达式的值为true就执行语句体
3如果关系表达式的值为false就不执行语句体
4继续执行后面的语句内容
示例:
public class IfDemo {public static void main(String[] args) {System.out.println("开始");//定义两个变量int a = 10;int b = 20;//需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于bif(a == b) {System.out.println("a等于b");}//需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于cint c = 10;if(a == c) {System.out.println("a等于c");}System.out.println("结束");}}格式:
if (关系表达式) {
语句体1;
} else {
语句体2;
}
执行流程:
public class IfDemo02 {public static void main(String[] args) {System.out.println("开始");//定义两个变量int a = 10;int b = 20;b = 5;//需求：判断a是否大于b，如果是，在控制台输出：a的值大于b，//如果不是，在控制台输出：a的值不大于bif(a > b) {System.out.println("a的值大于b");} else {System.out.println("a的值不大于b");}System.out.println("结束");}} if语句案例:奇偶数
需求:任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数。
分析:
import java.util.Scanner;public class IfTest01 {public static void main(String[] args) {//为了体现任意给出一个整数，采用键盘录入一个数据。(导包，创建对象，接收数据)Scanner sc = new Scanner(System.in);System.out.println("请输入一个整数：");int number = sc.nextInt();//判断整数是偶数还是奇数要分两种情况进行判断，使用if..else结构//判断是否偶数需要使用取余运算符实现该功能 number % 2 == 0//根据判定情况，在控制台输出对应的内容if(number%2 == 0) {System.out.println(number + "是偶数");} else {System.out.println(number + "是奇数");}}}格式:
if (关系表达式1) {
语句体1;
} else if (关系表达式2) {
语句体2;
}
…
else {
语句体n+1;
}
执行流程:
示例:
键盘录入一个星期数(1,2,…7)，输出对应的星期一，星期二，…星期日
import java.util.Scanner;public class IfDemo03 {public static void main(String[] args) {System.out.println("开始");//需求：键盘录入一个星期数(1,2,...7)，输出对应的星期一，星期二，...星期日Scanner sc = new Scanner(System.in);System.out.println("请输入一个星期数(1-7)：");int week = sc.nextInt();if(week == 1) {System.out.println("星期一");} else if(week == 2) {System.out.println("星期二");} else if(week == 3) {System.out.println("星期三");} else if(week == 4) {System.out.println("星期四");} else if(week == 5) {System.out.println("星期五");} else if(week == 6) {System.out.println("星期六");} else {System.out.println("星期日");}System.out.println("结束");}}if语句格式3案例:
需求:小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
分析:
import java.util.Scanner;public class IfTest02 {public static void main(String[] args) {//小明的考试成绩未知，可以使用键盘录入的方式获取值Scanner sc = new Scanner(System.in);System.out.println("请输入一个分数：");int score = sc.nextInt();//由于奖励种类较多，属于多种判断，采用if...else...if格式实现//为每种判断设置对应的条件//为每种判断设置对应的奖励//数据测试：正确数据，边界数据，错误数据if(score>100 || score<0) {System.out.println("你输入的分数有误");} else if(score>=95 && score<=100) {System.out.println("山地自行车一辆");} else if(score>=90 && score<=94) {System.out.println("游乐场玩一次");} else if(score>=80 && score<=89) {System.out.println("变形金刚玩具一个");} else {System.out.println("胖揍一顿");}}}格式
switch (表达式) {case 1:语句体1;break;case 2:语句体2;break;...default:语句体n+1;break;}格式说明：
执行流程：
春：3、4、5夏：6、7、8秋：9、10、11冬：1、2、12import java.util.Scanner;public class SwitchTest {public static void main(String[] args) {//键盘录入月份数据，使用变量接收Scanner sc = new Scanner(System.in);System.out.println("请输入一个月份：");int month = sc.nextInt();//多情况判断，这里采用switch语句实现//在每种情况中，完成输出对应的季节//case穿透switch(month) {case 1:case 2:case 12:System.out.println("冬季");break;case 3:case 4:case 5:System.out.println("春季");break;case 6:case 7:case 8:System.out.println("夏季");break;case 9:case 10:case 11:System.out.println("秋季");break;default:System.out.println("你输入的月份有误");}}}循环：
循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形 成死循环。
for循环格式：
for (初始化语句;条件判断语句;条件控制语句) {循环体语句;}格式解释：
执行流程：
①执行初始化语句
②执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
③执行循环体语句
④执行条件控制语句
⑤回到②继续
public class ForDemo {public static void main(String[] args) {//需求：在控制台输出5次"HelloWorld"System.out.println("HelloWorld");System.out.println("HelloWorld");System.out.println("HelloWorld");System.out.println("HelloWorld");System.out.println("HelloWorld");System.out.println("--------");//用循环改进for(int i=1; i<=5; i++) {System.out.println("HelloWorld");}}}public class ForTest01 {public static void main(String[] args) {//需求：输出数据1-5for(int i=1; i<=5; i++) {System.out.println(i);}System.out.println("--------");//需求：输出数据5-1for(int i=5; i>=1; i--) {System.out.println(i);}}}public class ForTest02 {public static void main(String[] args) {//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0int sum = 0;//从1开始到5结束的数据，使用循环结构完成for(int i=1; i<=5; i++) {//将反复进行的事情写入循环结构内部，此处反复进行的事情是将数据 i 加到用于保存最终求和的变量 sum 中sum += i;}//当循环执行完毕时，将最终数据打印出来System.out.println("1-5之间的数据和是：" + sum);}}public class ForTest03 {public static void main(String[] args) {//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0int sum = 0;//对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅是结束条件不同for(int i=1; i<=100; i++) {//对1-100的偶数求和，需要对求和操作添加限制条件，判断是否是偶数if(i%2 == 0) {sum += i;}}//当循环执行完毕时，将最终数据打印出来System.out.println("1-100之间的偶数和是：" + sum);}}153 3*3*3 + 5*5*5 + 1*1*1 = 153public class ForTest04 {public static void main(String[] args) {//输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束for(int i=100; i<1000; i++) {//在计算之前获取三位数中每个位上的值int ge = i%10;int shi = i/10%10;int bai = i/10/10%10;//判定条件是将三位数中的每个数值取出来，计算立方和后与原始数字比较是否相等if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {//输出满足条件的数字就是水仙花数System.out.println(i);}}}}public class ForTest05 {public static void main(String[] args) {//定义变量count，用于保存“水仙花数”的数量，初始值为0int count = 0;//输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束for(int i=100; i<1000; i++) {//在计算之前获取三位数中每个位上的值int ge = i%10;int shi = i/10%10;int bai = i/10/10%10;//在判定水仙花数的过程中，满足条件不再输出，更改为修改count的值，使count+1if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {count++;}}//打印输出最终结果System.out.println("水仙花共有：" + count + "个");}}while循环完整格式：
初始化语句;while (条件判断语句) {循环体语句; 条件控制语句;}while循环执行流程：
①执行初始化语句
②执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
③执行循环体语句
④执行条件控制语句
⑤回到②继续
示例代码：
public class WhileDemo {public static void main(String[] args) {//需求：在控制台输出5次"HelloWorld"//for循环实现for(int i=1; i<=5; i++) {System.out.println("HelloWorld");}System.out.println("--------");//while循环实现int j = 1;while(j<=5) {System.out.println("HelloWorld");j++;}}}public class WhileTest {public static void main(String[] args) {//定义一个计数器，初始值为0int count = 0;//定义纸张厚度double paper = 0.1;//定义珠穆朗玛峰的高度int zf = 8844430;//因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环//折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度while(paper <= zf) {//循环的执行过程中每次纸张折叠，纸张的厚度要加倍paper *= 2;//在循环中执行累加，对应折叠了多少次count++;}//打印计数器的值System.out.println("需要折叠：" + count + "次");}}完整格式：
初始化语句;do {循环体语句;条件控制语句;}while(条件判断语句);执行流程：
① 执行初始化语句
② 执行循环体语句
③ 执行条件控制语句
④ 执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
⑤ 回到②继续
示例代码：
public class DoWhileDemo {public static void main(String[] args) {//需求：在控制台输出5次"HelloWorld"//for循环实现for(int i=1; i<=5; i++) {System.out.println("HelloWorld");}System.out.println("--------");//do...while循环实现int j = 1;do {System.out.println("HelloWorld");j++;}while(j<=5);}}循环嵌套概述：在循环中，继续定义循环
示例代码：
public class ForForDemo {public static void main(String[] args) {for(int hour=0; hour<24; hour++) {for(int minute=0; minute<60; minute++) {System.out.println(hour + "时" + minute + "分");}System.out.println("--------");}}}理解：
结论：
概述：
使用步骤：
导入包
import java.util.Random;
创建对象
Random r = new Random();
产生随机数
int num = r.nextInt(10);
解释： 10代表的是一个范围，如果括号写10，产生的随机数就是0-9，括号写20，参数的随机数则是0-19
示例代码：
import java.util.Random;public class RandomDemo {public static void main(String[] args) {//创建对象Random r = new Random();//用循环获取10个随机数for(int i=0; i<10; i++) {//获取随机数int number = r.nextInt(10);System.out.println("number:" + number);}//需求：获取一个1-100之间的随机数int x = r.nextInt(100) + 1;System.out.println(x);}}需求：
程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？
当猜错的时候根据不同情况给出相应的提示
A. 如果猜的数字比真实数字大，提示你猜的数据大了
B. 如果猜的数字比真实数字小，提示你猜的数据小了
C. 如果猜的数字与真实数字相等，提示恭喜你猜中了
示例代码：
import java.util.Random;import java.util.Scanner;public class RandomTest {public static void main(String[] args) {//要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100Random r = new Random();int number = r.nextInt(100) + 1;while(true) {//使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现Scanner sc = new Scanner(System.in);System.out.println("请输入你要猜的数字：");int guessNumber = sc.nextInt();//比较输入的数字和系统产生的数据，需要使用分支语句。这里使用if..else..if..格式，根据不同情况进行猜测结果显示if(guessNumber > number) {System.out.println("你猜的数字" + guessNumber + "大了");} else if(guessNumber < number) {System.out.println("你猜的数字" + guessNumber + "小了");} else {System.out.println("恭喜你猜中了");break;}}}}参见：IDEA工具安装详解.pdf
IDEA工具安装详解.pdf
数组(array)是一种用于存储多个相同类型数据的存储模型
数据类型[] 数组名
示例：
int[] arr; double[] arr; char[] arr;定义了一个int类型的数组,数组名是arr
数据类型 数组名[]
示例：
int arr[];double arr[];char arr[];定义了一个int类型的变量,变量名是arr数组
数组动态初始化就是只给定数组的长度，由系统给出默认初始化值
数据类型[] 数组名 = new 数据类型[数组长度];int[] arr = new int[3];等号左边：
int:数组的数据类型
[]:代表这是一个数组
arr:代表数组的名称
等号右边：
new:为数组开辟内存空间
int:数组的数据类型
[]:代表这是一个数组
代表数组的长度
每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。
这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。
数组名[索引];public class ArrayDemo { public static void main(String[] args) { int[] arr = new int[3]; //输出数组名 System.out.println(arr); //[I@880ec60 //输出数组中的元素 System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); }} 内存是计算机中的重要原件，临时存储区域，作用是运行程序。
我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的。
必须放进内存中才能运行，运行完毕后会清空内存。
Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。
| 区域名称 | 作用 |
|---|---|
| 寄存器 | 给CPU使用，和我们开发无关。 |
| 本地方法栈 | JVM在使用操作系统功能的时候使用，和我们开发无关。 |
| 方法区 | 存储可以运行的class文件。 |
| 堆内存 | 存储对象或者数组，new来创建的，都存储在堆内存。 |
| 方法栈 | 方法运行时使用的内存，比如main方法运行，进入方法栈中执行。 |
在创建数组时，直接将元素确定
完整版格式
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};简化版格式
数据类型[] 数组名 = {元素1,元素2,...};public class ArrayDemo { public static void main(String[] args) { //定义数组 int[] arr = {1, 2, 3}; //输出数组名 System.out.println(arr); //输出数组中的元素 System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); }}public class ArrayDemo { public static void main(String[] args) { int[] arr = new int[3];System.out.println(arr[3]); }}数组长度为3，索引范围是0~2，但是我们却访问了一个3的索引。
程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
解决方案
将错误的索引修改为正确的索引范围即可！
public class ArrayDemo { public static void main(String[] args) { int[] arr = new int[3];//把null赋值给数组 arr = null; System.out.println(arr[0]); }}arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
解决方案
给数组一个真正的堆内存空间引用即可！
数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
public class ArrayTest01 {public static void main(String[] args) {int[] arr = { 1, 2, 3, 4, 5 };System.out.println(arr[0]);System.out.println(arr[1]);System.out.println(arr[2]);System.out.println(arr[3]);System.out.println(arr[4]);}}以上代码是可以将数组中每个元素全部遍历出来，但是如果数组元素非常多，这种写法肯定不行，因此我们需要改造成循环的写法。数组的索引是 0 到 lenght-1 ，可以作为循环的条件出现。
public class ArrayTest01 { public static void main(String[] args) { //定义数组 int[] arr = {11, 22, 33, 44, 55}; //使用通用的遍历格式 for(int x=0; x<arr.length; x++) { System.out.println(arr[x]); } }}最大值获取：从数组的所有元素中找出最大值。
实现思路：
代码实现：
public class ArrayTest02 { public static void main(String[] args) { //定义数组 int[] arr = {12, 45, 98, 73, 60}; //定义一个变量，用于保存最大值 //取数组中第一个数据作为变量的初始值 int max = arr[0]; //与数组中剩余的数据逐个比对，每次比对将最大值保存到变量中 for(int x=1; x<arr.length; x++) { if(arr[x] > max) { max = arr[x]; } } //循环结束后打印变量的值 System.out.println("max:" + max); }} 方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集
定义格式：
public static void 方法名 ( ) {// 方法体;}范例：
public static void method ( ) {// 方法体;}调用格式：
方法名();范例：
method();注意：
方法必须先定义，后调用，否则程序将报错
public class MethodTest { public static void main(String[] args) { //在main()方法中调用定义好的方法 getMax(); } //定义一个方法，用于打印两个数字中的较大数，例如getMax() public static void getMax() { //方法中定义两个变量，用于保存两个数字 int a = 10; int b = 20; //使用分支语句分两种情况对两个数字的大小关系进行处理 if(a > b) { System.out.println(a); } else { System.out.println(b); } }}定义格式：
参数：由数据类型和变量名组成 - 数据类型 变量名
参数范例：int a
public static void 方法名 (参数1) {方法体;}public static void 方法名 (参数1, 参数2, 参数3...) {方法体;}范例：
public static void isEvenNumber(int number){ ...}public static void getMax(int num1, int num2){ ...}注意：
方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错方法定义时，多个参数之间使用逗号( ，)分隔调用格式：
方法名(参数)；方法名(参数1,参数2);范例：
isEvenNumber(10);getMax(10,20); 等同于变量定义格式，例如：int number
等同于使用变量或常量，例如： 10 number
public class MethodTest { public static void main(String[] args) { //在main()方法中调用定义好的方法（使用常量） getMax(10,20); //调用方法的时候，人家要几个，你就给几个，人家要什么类型的，你就给什么类型的 //getMax(30); //getMax(10.0,20.0); //在main()方法中调用定义好的方法（使用变量） int a = 10; int b = 20; getMax(a, b); } //定义一个方法，用于打印两个数字中的较大数，例如getMax() //为方法定义两个参数，用于接收两个数字 public static void getMax(int a, int b) { //使用分支语句分两种情况对两个数字的大小关系进行处理 if(a > b) { System.out.println(a); } else { System.out.println(b); } }}定义格式
public static 数据类型 方法名 ( 参数 ) { return 数据 ;}范例
public static boolean isEvenNumber( int number ) { return true ;}public static int getMax( int a, int b ) {return 100 ;}调用格式
方法名 ( 参数 ) ;数据类型 变量名 = 方法名 ( 参数 ) ;范例
isEvenNumber ( 5 ) ;boolean flag = isEvenNumber ( 5 ); 需求：设计一个方法可以获取两个数的较大值，数据来自于参数
思路：
代码：
public class MethodTest { public static void main(String[] args) { //在main()方法中调用定义好的方法并使用变量保存 int result = getMax(10,20); System.out.println(result); //在main()方法中调用定义好的方法并直接打印结果 System.out.println(getMax(10,20)); } //定义一个方法，用于获取两个数字中的较大数 public static int getMax(int a, int b) { //使用分支语句分两种情况对两个数字的大小关系进行处理 //根据题设分别设置两种情况下对应的返回结果 if(a > b) { return a; } else { return b; } }}方法不能嵌套定义
示例代码：
public class MethodDemo { public static void main(String[] args) { } public static void methodOne() {public static void methodTwo() { // 这里会引发编译错误!!! } }}void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据
示例代码：
public class MethodDemo { public static void main(String[] args) { } public static void methodTwo() { //return 100; 编译错误，因为没有具体返回值类型 return; //System.out.println(100); return语句后面不能跟数据或代码 }}格式：
public static 返回值类型 方法名(参数) { 方法体; return 数据 ;}解释：
public static 修饰符，目前先记住这个格式
返回值类型 方法操作完毕之后返回的数据的数据类型
如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return
方法名 调用方法时候使用的标识
参数 由数据类型和变量名组成，多个参数之间用逗号隔开
方法体 完成功能的代码块
return 如果方法操作完毕，有数据返回，用于把数据返回给调用者
定义方法时，要做到两个明确
调用方法时的注意：
方法重载概念
方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
注意：
正确范例：
public class MethodDemo {public static void fn(int a) { //方法体 } public static int fn(double a) { //方法体 }}public class MethodDemo {public static float fn(int a) { //方法体 } public static int fn(int a , int b) { //方法体 }}错误范例：
public class MethodDemo {public static void fn(int a) { //方法体 } public static int fn(int a) { //方法体 }}public class MethodDemo01 { public static void fn(int a) { //方法体 }} public class MethodDemo02 { public static int fn(double a) { //方法体 }}需求：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型（byte,short,int,long）
思路：
代码：
public class MethodTest { public static void main(String[] args) { //调用方法 System.out.println(compare(10, 20)); System.out.println(compare((byte) 10, (byte) 20)); System.out.println(compare((short) 10, (short) 20)); System.out.println(compare(10L, 20L)); } //int public static boolean compare(int a, int b) { System.out.println("int"); return a == b; } //byte public static boolean compare(byte a, byte b) { System.out.println("byte"); return a == b; } //short public static boolean compare(short a, short b) { System.out.println("short"); return a == b; } //long public static boolean compare(long a, long b) { System.out.println("long"); return a == b; }}测试代码：
public class ArgsDemo01 { public static void main(String[] args) { int number = 100; System.out.println("调用change方法前：" + number); change(number); System.out.println("调用change方法后：" + number); } public static void change(int number) { number = 200; }}结论：
结论依据：
测试代码：
public class ArgsDemo02 { public static void main(String[] args) { int[] arr = {10, 20, 30}; System.out.println("调用change方法前：" + arr[1]); change(arr); System.out.println("调用change方法后：" + arr[1]); } public static void change(int[] arr) { arr[1] = 200; }}结论：
结论依据：
需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]
思路：
①因为要求结果在一行上输出，所以这里需要在学习一个新的输出语句System.out.print(“内容”);
System.out.println(“内容”); 输出内容并换行
System.out.print(“内容”); 输出内容不换行
System.out.println(); 起到换行的作用
②定义一个数组，用静态初始化完成数组元素初始化
③定义一个方法，用数组遍历通用格式对数组进行遍历
④用新的输出语句修改遍历操作
⑤调用遍历方法
代码：
public class MethodTest01 { public static void main(String[] args) { //定义一个数组，用静态初始化完成数组元素初始化 int[] arr = {11, 22, 33, 44, 55}; //调用方法 printArray(arr); } //定义一个方法，用数组遍历通用格式对数组进行遍历 public static void printArray(int[] arr) { System.out.print("["); for(int x=0; x<arr.length; x++) { if(x == arr.length-1) { System.out.print(arr[x]); } else { System.out.print(arr[x]+", "); } } System.out.println("]"); }}需求：设计一个方法用于获取数组中元素的最大值
思路：
代码：
public class MethodTest02 { public static void main(String[] args) { //定义一个数组，用静态初始化完成数组元素初始化 int[] arr = {12, 45, 98, 73, 60}; //调用获取最大值方法，用变量接收返回结果 int number = getMax(arr); //把结果输出在控制台 System.out.println("number:" + number); } //定义一个方法，用来获取数组中的最大值 public static int getMax(int[] arr) { int max = arr[0]; for(int x=1; x<arr.length; x++) { if(arr[x] > max) { max = arr[x]; } } return max; }}是供程序员使用的程序调试工具，它可以用于查看程序的执行流程，也可以用于追踪程序执行过程来调试程序。
如何加断点
如何运行加了断点的程序
看哪里
点哪里
如何删除断点
输入星期数，显示今天的减肥活动
周一：跑步
周二：游泳
周三：慢走
周四：动感单车
周五：拳击
周六：爬山
周日：好好吃一顿
public class Test01 { public static void main(String[] args) { //键盘录入一个星期数，用一个变量接收 Scanner sc = new Scanner(System.in); System.out.println("请输入一个星期数："); int week = sc.nextInt(); //对星期数进行判断，这里用 if 语句实现 if (week < 1 || week > 7) { System.out.println("你输入的星期数有误"); } else if (week == 1) { System.out.println("跑步"); } else if (week == 2) { System.out.println("游泳"); } else if (week == 3) { System.out.println("慢走"); } else if (week == 4) { System.out.println("动感单车"); } else if (week == 5) { System.out.println("拳击"); } else if (week == 6) { System.out.println("爬山"); } else { System.out.println("好好吃一顿"); } }} 输入星期数，显示今天的减肥活动
周一：跑步
周二：游泳
周三：慢走
周四：动感单车
周五：拳击
周六：爬山
周日：好好吃一顿
public class Test02 { public static void main(String[] args) { //键盘录入一个星期数，用一个变量接收 Scanner sc = new Scanner(System.in); System.out.println("请输入一个星期数："); int week = sc.nextInt(); //对星期数进行判断，这里用 switch 语句实现 switch (week) { case 1: System.out.println("跑步"); break; case 2: System.out.println("游泳"); break; case 3: System.out.println("慢走"); break; case 4: System.out.println("动感单车"); break; case 5: System.out.println("拳击"); break; case 6: System.out.println("爬山"); break; case 7: System.out.println("好好吃一顿"); break; default: System.out.println("你输入的星期数有误"); } }} 朋友聚会的时候可能会玩一个游戏：逢七过。
规则是：从任意一个数字开始报数，当你要报的数字包含7或者是7的倍数时都要说：过。
为了帮助大家更好的玩这个游戏，这里我们直接在控制台打印出1-100之间的满足逢七必过规则的数据。
这样，大家将来在玩游戏的时候，就知道哪些数据要说：过。
public class Test03 { public static void main(String[] args) { //数据在1-100之间，用for循环实现数据的获取 for(int x=1; x<=100; x++) { //根据规则，用if语句实现数据的判断：要么个位是7，要么十位是7，要么能够被7整除 if(x%10==7 || x/10%10==7 || x%7==0) { //在控制台输出满足规则的数据 System.out.println(x); } } }} 有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，
假如兔子都不死，问第二十个月的兔子对数为多少？
public class Test04 { public static void main(String[] args) { //为了存储多个月的兔子对数，定义一个数组，用动态初始化完成数组元素的初始化，长度为20 int[] arr = new int[20]; //因为第1个月，第2个月兔子的对数是已知的，都是1，所以数组的第1个元素，第2个元素值也都是1 arr[0] = 1; arr[1] = 1; //用循环实现计算每个月的兔子对数 for(int x=2; x<arr.length; x++) { arr[x] = arr[x-2] + arr[x-1]; } //输出数组中最后一个元素的值，就是第20个月的兔子对数 System.out.println("第二十个月兔子的对数是：" + arr[19]); }} 我国古代数学家张丘建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。
百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？
public class Test05 { public static void main(String[] args) { //第1层循环，用于表示鸡翁的范围，初始化表达式的变量定义为 x=0，判断条件是x<=20 for(int x=0; x<=20; x++) { //第2层循环，用于表示鸡母的范围，初始化表达式的变量定义为 y=0，判断条件是y<=33 for(int y=0; y<=33; y++) { //这个时候，用于表示鸡雏的变量 z = 100 – x – y int z = 100 - x - y; //判断表达式 z%3==0 和表达式 5*x + 3*y + z/3 = 100 是否同时成立 if(z%3==0 && 5*x+3*y+z/3==100) { System.out.println(x+","+y+","+z); } } } }} 有这样的一个数组，元素是{68,27,95,88,171,996,51,210}。求出该数组中满足要求的元素和，
要求是：求和的元素个位和十位都不能是7，并且只能是偶数
public class Test06 { public static void main(String[] args) { //定义一个数组，用静态初始化完成数组元素的初始化 int[] arr = {68, 27, 95, 88, 171, 996, 51, 210}; //定义一个求和变量，初始值是0 int sum = 0; //遍历数组，获取到数组中的每一个元素 for(int x=0; x<arr.length; x++) { //判断该元素是否满足条件，如果满足条件就累加 if(arr[x]%10!=7 && arr[x]/10%10!=7 && arr[x]%2==0) { sum += arr[x]; } } //输出求和变量的值 System.out.println("sum:" + sum); }} 定义一个方法，用于比较两个数组的内容是否相同
public class Test07 { public static void main(String[] args) { //定义两个数组，分别使用静态初始化完成数组元素的初始化 int[] arr = {11, 22, 33, 44, 55}; //int[] arr2 = {11, 22, 33, 44, 55}; int[] arr2 = {11, 22, 33, 44, 5}; //调用方法，用变量接收 boolean flag = compare(arr,arr2); //输出结果 System.out.println(flag); } //定义一个方法，用于比较两个数组的内容是否相同 public static boolean compare(int[] arr, int[] arr2) { //首先比较数组长度，如果长度不相同，数组内容肯定不相同，返回false if(arr.length != arr2.length) { return false; } //其次遍历，比较两个数组中的每一个元素，只要有元素不相同，返回false for(int x=0; x<arr.length; x++) { if(arr[x] != arr2[x]) { return false; } } //最后循环遍历结束后，返回true return true; }} 已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引。
并在控制台输出找到的索引值。如果没有查找到，则输出-1
public class Test08 { public static void main(String[] args) { //定义一个数组，用静态初始化完成数组元素的初始化 int[] arr = {19, 28, 37, 46, 50}; //键盘录入要查找的数据，用一个变量接收 Scanner sc = new Scanner(System.in); System.out.println("请输入要查找的数据："); int number = sc.nextInt(); //调用方法 int index = getIndex(arr, number); //输出索引变量 System.out.println("index: " + index); } //查找指定的数据在数组中的索引 public static int getIndex(int[] arr, int number) { //定义一个索引变量，初始值为-1 int index = -1; //遍历数组，获取到数组中的每一个元素 for(int x=0; x<arr.length; x++) { //拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量,并结束循环 if(arr[x] == number) { index = x; break; } } //返回索引 return index; }} 已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值交换，
交换后的数组 arr = {50, 46, 37, 28, 19}; 并在控制台输出交换后的数组元素。
public class Test09 { public static void main(String[] args) { //定义一个数组，用静态初始化完成数组元素的初始化 int[] arr = {19, 28, 37, 46, 50}; //调用反转的方法 reverse(arr); //遍历数组 printArray(arr); } public static void reverse(int[] arr) { //循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引 for (int start = 0, end = arr.length - 1; start <= end; start++, end--) { //变量交换 int temp = arr[start]; arr[start] = arr[end]; arr[end] = temp; } } public static void printArray(int[] arr) { System.out.print("["); for (int x = 0; x < arr.length; x++) { if (x == arr.length - 1) { System.out.print(arr[x]); } else { System.out.print(arr[x] + ", "); } } System.out.println("]"); }} 在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。
public class Test10 { public static void main(String[] args) { //定义一个数组，用动态初始化完成数组元素的初始化，长度为6 int[] arr = new int[6]; //键盘录入评委分数 Scanner sc = new Scanner(System.in); //由于是6个评委打分，所以，接收评委分数的操作，用循环改进 for(int x=0; x<arr.length; x++) { System.out.println("请输入第" + (x + 1) + "个评委的打分："); arr[x] = sc.nextInt(); } //printArray(arr); //定义方法实现获取数组中的最高分(数组最大值)，调用方法 int max = getMax(arr); //定义方法实现获取数组中的最低分(数组最小值) ，调用方法 int min = getMin(arr); //定义方法实现获取数组中的所有元素的和(数组元素求和) ，调用方法 int sum = getSum(arr); //按照计算规则进行计算得到平均分 int avg = (sum - max - min) / (arr.length - 2); //输出平均分 System.out.println("选手的最终得分是：" + avg); } public static int getSum(int[] arr) { int sum = 0; for(int x=0; x<arr.length; x++) { sum += arr[x]; } return sum; } public static int getMin(int[] arr) { int min = arr[0]; for(int x=1; x<arr.length; x++) { if(arr[x] < min) { min = arr[x]; } } return min; } public static int getMax(int[] arr) { int max = arr[0]; for(int x=1; x<arr.length; x++) { if(arr[x] > max) { max = arr[x]; } } return max; } //遍历数组 public static void printArray(int[] arr) { System.out.print("["); for (int x = 0; x < arr.length; x++) { if (x == arr.length - 1) { System.out.print(arr[x]); } else { System.out.print(arr[x] + ", "); } } System.out.println("]"); }}来源地址：https://blog.csdn.net/qq_39997939/article/details/123449889
--结束END--
本文标题: Java基础语法
本文链接: https://www.lsjlt.com/news/375630.html(转载时请注明来源链接)
有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341
下载Word文档到电脑，方便收藏和打印～
2024-04-03
2024-04-03
2024-04-01
2024-01-21
2024-01-21
2024-01-21
2024-01-21
2023-12-23
回答
回答
回答
回答
回答
回答
回答
回答
回答
回答
官方手机版
微信公众号
商务合作
0