华清远见重庆中心—后端基础阶段技术总结/个人总结
后端基础阶段技术总结
JAVA概述
1、java的历史
Oak（橡树）语言，由Green开发团队开发，主要用于微型嵌入式设备编程，第一次提出了开源协议 。
Java之父 詹姆斯.高斯林
经历过Sun公司接手之后，最终由Oracle收购，1995年语言更名为Java，正式发布JDK1.0
1996年 Java（此时JDK1.2）应对发展需求，分为三个重要方向：
J2SE : Java标准语法(这是学习Java开发体系的必备基础)
J2ME : 微型嵌入式领域的编程（例如：塞班系统应用，但后来没有普及）
J2EE ：企业级开发（使用Java语言开发服务器）
(J2SE---->Java SE, J2ME---->Java ME, J2EE---->Java EE)
2006年JDK1.6开源所有的代码
2、JDK安装
进入JDK官网，找到JDK11的下载地址：
选中对应的 系统 以及 下载版本
下载完成后，直接进行安装
安装后，可以在控制台查看是否安装成功
WIN+R键启动运行窗口
在运行窗口输入cmd，并回车“确认”
在命令提示符窗口中输入java -version
说明java环境已经安装完成
3、JDK卸载
1.在windows搜索中，找到控制面板
2.双击打开控制面板，在右上角启用类别，选择程序中的卸载程序选项
3.在卸载程序页面中查看需要卸载的JDK文件，并双击
4.卸载完成后可以查看安装路径，是否卸载干净
4、JDK版本切换
1.启动运行窗口，并输入regedit
2.在注册表中逐一打开 HKEY_LOCAL_MACHINI , SOFTWARE , JavaSoft
3.在Java Plug-in中修改主体版本即可
IDEA的下载
认识JetBrains
官网：JetBrains: 软件开发者和团队的必备工具
目前在世界上的主流开发软件：IDEA 、WebStorm 、PyCharm
特点：1）智能的代码提示功能（就像我们使用的输入法）
2）最新的开发支持（github 、框架 、辅助插件 、代码测试······）
3）代码的自动保存（不需要程序员自己手动保存）
安装IDEA
下载最新版本的idea
IntelliJ IDEA – 领先的 Java 和 Kotlin IDE (jetbrains.com.cn)
下载完成后，直接安装IDEA即可
IDEA和webstorm激活方案（最新版）
1、进入JETBRA.IN CHECKER | IPFS
2、选中可用代理任意链接进入该网站，点击如图所示内容下载 jetbra.zip ，不要关闭该网站
3、下载后为一个随机文件名称（如图）
请将此文件的名称更改为可用的简单名称，并解压至对应目录，如图示
（请注意！该文件主要用于激活使用 ，删除后，激活也就失效）
里面的文件结构如图
4、打开vmoptions文件
如果你要激活IDEA，则修改 idea.vmoptions
如果你要激活webstorm，则修改 webstorm.vmoptions
修改内容如下：(设置到对应ja-netfilter.jar 的路径)，其中我设置的是D盘下的路径，大家可以根据自己的实际情况设置。
5、关闭IDEA或者webstorm后再重启
6、打开之前的网站复制激活码
7、将激活码填写在需要激活的webstorm或者IDEA上，直接激活（如图）
(此方法可以激活JetBrains下的所有的产品)
IDEA环境的认识
顶部
File:
点击File后会打开菜单
New ：新建内容（文件、文件夹、项目等）
Open ：打开指定文件或者指定的目录
Open Recent ：打开最近打开过的文件或者目录
Class Project ：关闭当前项目窗口
Settings ：设置整个IDEA的环境
Project Structure ：设置项目
SavaAll ：保存所有内容
Exit ：退出IDEA
View
查看IDEA环境中的视图设置
Code
对Code进行分析和管理
Refactor
对文件进行重命名、移动、复制
Build
对文件进行构建
Run
运行文件 或者 开启DEBUG模式
Tools
内部或者外部工具的使用
Git
对代码进行git分布式管理
Window
窗口工具
Help
帮助
中部
项目目录区域
编码或者代码显示区
底部
TODO :展示需要去做的任务
Problems : 项目中出现的问题
Git ：分布式托管
Terminal :控制台
Profiler :性能测试平台
Run : 运行后的结果展示
IDEA中新建项目与文件
新建一个Java项目
1、在项目界面选择新建一个项目
2、在创建项目的界面选择对应的项目类型进行创建
3、选择对应的JDK版本后，选择Next
4、接着选择Next默认内容后，来到项目名称的定义页面
5、在底部的设置中可以看到more_settings,选择Finish后建立该项目
新建一个文件
1、选择需要创建的文件位置（比如此刻我们需要创建对应的内容到day01下，因此我们选中day01文件夹）
2、选择day01下的src文件
3、右键新建（package）包名
4、我们暂时都将包名命名为com.js,后期我们会解释这里的package是什么
5、新建好package之后，我们选中新建好的package，新建Java Class
6、采用驼峰法为这个文件命名
7、 完成新建流程
新建目录与Java文件
新建目录
点击顶部主目录，右键新建一个文件夹
新建Java代码文件
1、在day01下方新建一个src目录
2、在src下新建一个File文件，Hello.java
如何运行.java文件
1）打开IDEA底部的Terminal
2)通过cd命令进入src
3)运行.java文件
4).java的代码 Hello.java
public class Hello{
public static void main(String[] args){
System.out.println("Hello World");
}
}新建Module
1、新建Module
2、新建一个day01的Module将原来的day01覆盖
3、覆盖之后（如图）
新建Java文件的注意点
1、在src下新建一个package 选中src右键 --> New --> Package
2、Package（包）的命名： | com、cn、org... | 名称缩写、公司缩写 | 项目名称 | 例如： com.fs.test
3、Package是什么,文件夹（目录）结构 com.fs.test com目录下有fs目录，fs目录下有test目录
选中Package右键，新建一个java Class文件 5、新建的java文件的名称（尽量使用全英文）的首写字母必须要大写。 例如：Demo01
JDK是什么
JDK 全称是 Java Development Kits 的缩写，翻译过来为Java开发工具包
在JDK中有运行.java文件的虚拟机（解释器）
知识点：
1、java的源文件 开发文件是以什么方式结尾 .java
2、虚拟机 解析.java文件
我们接下来一一解答以下问题：
1、什么是虚拟机
指通过软件模拟的具有完整硬件系统功能的、运行在一个完全隔离环境中的完整计算机系统
比如：我们在电脑中用的手机模拟器，就是一个由软件模拟的虚拟机
在Java中的虚拟机，指的是专门为了解析.java文件存在的一种软件
虚拟机，英文为 Virtual Machine，而Java虚拟机被人成为JVM（即Java Virtual Machine）
2、JDK中除了虚拟机还有哪些内容
JRE ： Java Runtime Envirment (Java运行时环境 ，运行.java文件的核心内容)
JDK 包含JRE，JRE中有JVM。
3、虚拟机运行.java文件的原理
Java11 之前
java命令：将.java文件编译成.class文件（这里的.class为字节码文件，机器是无法识别的）
javac命令：将.class文件解释成对应的二进制命令
Java11 后
java命令：将.java文件直接解释成对应的二进制命令
所以我们既可以说Java是一门编译解释语言，也可以说是一门解释语言。
（区别与编译语言）
4、什么是解释型语言
首先要了解两个概念：编译语言、解释语言
1、编译语言是指定文件，编译到指定位置，生成指定的二进制文件，特点：效率高、速度快 （C语言）
2、解释语言是指定文件，解释到任何位置，生成指定的二进制文件，特点：跨平台性好
Java的数据类型
Java的数据类型分为
基本数据类型
引用数据类型
基本数据类型包括
数值类型 ：byte , short , int , long , float , double
字符类型 ：char
布尔值类型 ：boolean(true , false)
基本数据类型的表示方式
基本数据类型介绍
代码编写简介
简要介绍
public 公共的，公有的（可以被其他文件访问）
class + 类名 ： 定义一个类
重点：public 修饰了class，那么类的名称必须和.java文件名称保持一致
class没有public修饰，那么类名可以任意
在同一文件中可以定义多个类，但public的类只能有一个
入口方法；main方法
重点：1、入口方法，除了形参的名称可以变之外，其余内容不可变
2、java文件运行起来时，一定会执行main方法（入口方法）
形参：args
代码的结尾要使用;（英文分号）
变量
简而言之，一个可以装载”字面量“的容器
变量的声明，就是在内存中申请一块想要数据类型的空间，并对其命名的过程
声明变量
语法 ：数据类型 变量名称;
如果要同时定义多个相同类型的变量，可以： 数据类型 变量名1， 变量名2.......；
变量的初始化
语法 ：变量名称 = 数据值（字面量）
（在方法内，如果一个变量仅仅只声明，那么它不可以被使用，只有被初始化后才能被使用。）
重点 ：
数据类型 要与数据值（字面量）保持一致
数据类型(基本数据类型)：byte short int long float double char boolean
保持一致：int整数类型 === 2整数类型
eg :
int c = "张三"; //编译错误：有红线的代码区域(int是整数型对应的应该是整数 ， “张三”是字符串)
变量的名称，规则（前、中后）：
1、变量名称的开头只能以_或$(￥ 人民币),英文字母 定义
2、变量名称的中间只能以_或$(￥ 人民币),英文字母,数字 定义
补充 ：
1、变量不能重名
2、变量名称的大小写敏感，字母大小写对Java来说，是不同的（敏感）
3、变量可以多个一起定义
注释
文档注释
可以注释一个方法，或者一个类
快捷方式： /** + Enter
单行注释
注释一行内容（内容上边，或者结尾右侧）对变量或者常量注释，对某一行代码进行解释
快捷方式： Ctrl + /
多行注释
注释一个代码片段（方法、方法中的某几行）
快捷方式 /* + Enter
标识符
标识符的定义：
为 ”变量、类（接口）、方法“ 进行命名的符号
标识符构成：
1、标识符的开头只能以_、$、字母
2、标识符的中间和结尾以_、$、字母、数字为主要内容
3、不能以关键字或者特殊字符命名,(长度、大小写、换行)
4、见名知意(对变量进行特殊的名称定义，会帮助我们或者其他开发者理解程序功能,翻译软件)
标识符常见的命名方式：
驼峰法
eg : 我的苹果 ==> my apple ==> myApple MyApple
小驼峰法 首写字母小写 主要用于变量、方法命名
大驼峰法 首写字母大写主要用于类 或者接口命名
2、下划线隔断法
eg : 我的苹果 ==> my_apple
关键字 ：50个常见关键字
其中有5个常见的保留字：goto const (true,false,null)
goto const 已经被弃用 true,false,null 作为值的类型存在java中
基本数据类型
整数类型：int （byte short long）
结论：无论数值类型以何种方式表示，都是以十进制输出
所有整数数值类型默认为int
整数类型：long
为什么要用long类型？ int数值范围无法表示的情况下
注意：long类型数值后需要加上L或者l
eg :
浮点类型：float
注意：float定义浮点数类型时，需要加上F或者f
浮点类型: double
所有小数数值类型默认为double
科学进制E ： E表示10的多少次方
字符类型：char （基本数据类型）
char类型只能用单引号,单引号中只有一个字符或者数字
转义字符
定义 ：具有特殊的格式意义的字符
\n 换行 \t 制表符 \r 回车
基本数据类型转化
基本数据类型转化的原因：数值之间表示数值范围的大小关系
数值范围大小：byte < short < int < long < float < double
整数类型 byte < short < int < long
大范围的数值类型 ==> 小范围的数据类型 ：强制转化
口诀：大转小要强转
注意！运算方向是从右往左
小范围的数值类型 ==> 大范围的数据类型 ：自动转化
口诀：小转大自动转
注意！运算方向是从右往左
浮点型由于表示数的范围有特殊方式（不同于整数），所以 int < long < float
整数值的默认类型是int，小数值的默认类型是double
补充：
1、char类型右侧是ASCII码的编码数值，而不是简单的int类型
2、数值类型的值不可以强制转化为boolean值
运算符
算数运算符
两数相除：
1、两数都是整数类型，求整数商
2、两数任意一个是浮点数，求浮点数的商
注意
如果同时多个符号一起使用，遵循数学中的四则运算规则，先乘除，后加减
运算时最终结果的数据类型，以所以参与运算的操作数中所占字节最大的类型为准
关系运算符
需要两个操作数参与
注意
==用于判断相等，=用于赋值
==用于比较两个原始类型的值或引用类型的内存地址
关系运算的结果为true/false
逻辑运算符
逻辑运算符的左右两侧，必须是布尔表达式
&& 与：一假即假 （当所有布尔表达式中有为false的条件，结果必然为false）
||或：一真即真（当所有布尔表达式中有为true的条件，结果必然为true）
!非：！取相反的布尔表达式的值
注意：非的一侧必须是布尔表达式
短路与：&&
条件1 && 条件2 && 条件3 ...
如果”条件1“为false，那么后续的条件就没有判断的必要
短路或 ||：
如果前面的条件为真，那么后续的条件没有必要判断
补充：位运算符
逻辑与：&
条件1 & 条件2 & 条件3 ...
即便”条件1“为false，后续的条件仍要继续判断
逻辑或 |：
即便前面的条件为真，后续的条件依旧需要判断
注意
&&和||也称为短路运算。如果能通过第一个表达式觉得最终的结果，则不用判断第二个表达式。
通常情况下，使用&&和||提高代码执行效率
与或的混合判断：
逻辑与 的优先级高于 逻辑或，所以先执行与运算
注意：非运算 高于”与，或“运算。（仅次于括号的优先级）
赋值和复合赋值运算符
赋值运算符 = ：1、优先等级最低 2、从右往左运算
赋值运算的扩展运算符： += -= /= *= %=
注意
复合赋值运算的流程是：
将符号两端的整体进行对应的算数运算后，将结果赋值给符号左侧的变量中
自增自减运算符
只有一个操作数参与运算，称为单目运算符
b（变量）的值，与b++,++b （表达式）的值是有区别的
++，--在变量”左侧“和“右侧”的区别
判断依据： 看运算符在前，还是变量在前
如果运算符在前，则先对值进行自加，再将值赋值给左侧
如果是变量在前，则先把值赋值给左侧，再自加
注意
a++或++a相当于a+=1或a=a+1。–同理
如果++或–独立成行使用，无论符号在前在后，都将结果+1或-1
如果++或–不是单独成行
符号在前，先+1或-1计算后在使用值
符号在后，先使用值后在+1或–1计算
运算符的优先级
小括号>>单目运算符>>算术运算符>>关系运算符>>逻辑运算符>>条件运算符>>赋值/复合赋值运算符
多种数据类型参与运算，其结果以字节最大的为准。
字符串拼接符
重点：
字符串拼接符的判断依据：+ 的任意一侧有字符串出现时，它就是拼接符
字符串拼接符 与普通的加减运算的优先级一致
拼接符的使用会直接消耗内存，执行效率低
运算符优先级
比较
数值类型比较
public class Demo1 {
public static void main(String[] args) {
//数值类型比较
int a = 1;
int b = 2;
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);//false
System.out.println(a != b);//true
//a > b 表达式值 true false ：布尔表达式
}
}
字符类型的比较
public class Demo1 {
public static void main(String[] args) {
//字符类型比较
char c1 = 'a';//97
char c2 = 'b';//98
//字符类型的比较是通过ASCII所对应的十进制编码进行比较
System.out.println(c1 > c2);//false
System.out.println(c1 < c2);//true
System.out.println(c1 > 96);//true
}
}
字符串类型的比较
public class Demo1 {
public static void main(String[] args) {
//字符串类型的比较:字符串不能用大小关系比较
String s1 = "a";
String s2 = "b";
System.out.println(s1 == s2);
System.out.println(s1 != s2);
}
}
位运算比较
& 按位与 ：二进制比较，对位都为1结果为1
| 按位或 ：二进制比较，对位都为0结果为0
^ 异或： 二进制比较，对位不相同结果为1
交换两个数的值（1）
public class Demo1 {
public static void main(String[] args) {
//交换两个数的值
int a = 3;
int b = 7;
a = b;// b=7 a=7
b = a;// a=7 b=7
int tmp;//需要定义一个中间变量
tmp = b;
b = a;
a = tmp;
System.out.println("a = " + a);
System.out.println("b = " + b);
}
}
交换两个数的值（2）
public class Demo1 {
public static void main(String[] args) {
//交换两个数的值
int a = 3;
int b = 7;
a = a+b;// a=10 b=7
b = a-b;// a=10 b=3
a = a-b;// b=3 a=7
System.out.println("a = " + a);
System.out.println("b = " + b);
}
}
表达式
有运算符参与的运算公式
算数表达式
赋值表达式
（赋值运算的优先等级最低，从右往左运算）
布尔表达式
（最终结果是boolean）
逻辑表达式
（结果是boolean）
三目运算表达式
三目运算表达式结构 ：条件 ？ 选项1 : 选项2
返回值是选项1或者选项2的值
描述：当条件成立时，返回选项1的值，否则返回选项2的值
eg:
问题：
public class Demo1 {
public static void main(String[] args) {
//问题：现有 a b c 三个数，判断谁最大？ 谁最小？
int a = 1;
int b = 2;
int c = 3;
//原理：首先判断a b谁最大，然后再将 a b中的最大数跟c进行比较
// int max = a > b ? a : b;
// max = max > c ? max : c;
int max = a > b ? a : b > c ? a > b ? a : b : c;
System.out.println("最大值:" + max);
int min = a < b ? a : b;
min = min < c ? min : c;
System.out.println("最小值:" + min);
}
}
条件语句
if语句（如果）
格式：if(布尔表达式){ 执行语句 }
描述：如果布尔表达式成立，就会执行“执行语句”，否则直接跳过这一次判断
案例： 大于等于60分：成绩及格
public class Demo1 {
public static void main(String[] args) {
double score = 90;
if(score >= 60){
System.out.println("成绩及格");
}
System.out.println("结束");
}
}
if...else 语句
格式：if(布尔表达式){ 执行语句 }else{ 执行语句 }
描述：如果布尔表达式成立，就会执行if中的“执行语句”，否则执行else中的“执行语句”
public class Demo1 {
public static void main(String[] args) {
double score = 90;
if(score >= 60){
System.out.println("成绩及格");
}else{
System.out.println("不及格");
}
}
}
if...else if 语句
格式：if(布尔表达式){ 执行语句 }else if(布尔表达式){ 执行语句 }
描述：
如果if中布尔表达式成立，就会执行if中的“执行语句”
如果else if中布尔表达式成立，就会执行else if中的“执行语句”
随着条件的增多，我们可以增加else if的数量
案例：大于等于90 :优秀 80~90:良好 60~80：合格 ~60：差
public class Demo1 {
public static void main(String[] args) {
double score = 90;
if(score >= 90){
System.out.println("优秀");
}else if(score >= 80){
System.out.println("良好");
}else if(score >= 60) {
System.out.println("合格");
}else{
System.out.println("差");
}
}
}
switch语句
语句格式：switch(数据值或变量){ case 值1:...; case 值2 :...;... }
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
//选项卡：选择1 选择2 选择3...
int n = 2; //选择的数据变量
switch (n){
case 1:
System.out.println("n为1");
break;//通过break可以终止整个switch语句
case 2:
System.out.println("n为2");
break;//通过break可以终止整个switch语句
case 3:
System.out.println("n为3");
break;//通过break可以终止整个switch语句
}
System.out.println("switch语句执行完成");
}
}
注意：1、switch括号中一般是变量，变量需要指定特殊的数据类型(byte short int char String(Character))
switch不可以设置的类型有：long,double,float
2、有无break的情况（break 跳出（停止）switch语句）,没有break情况，程序会继续往后执行。
3、关于if语句与switch的区别：switch不能判断范围条件.
4、default 除了case之外的其他条件，（default为了程序健壮性）
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
int m = 5;//选择的数据变量
switch (m){
case 1:
System.out.println("1");
break;
case 2:
System.out.println("2");
break;
case 3:
System.out.println("3");
break;
default://不存在前面所有条件的情况
System.out.println("其它数字");
break;
}
}
}
循环
循环是什么：解决重复代码问题
举例：重复打印Hello World 50遍
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
String n ="hello world";
for(int i = 0; i < 50; i++){
System.out.println(i+":"n);
}
}
}
循环的特殊结构
死循环:循环没有结束条件
for循环
for循环格式 for(初始化内容;结束循环条件;变化方式){...}
初始化内容：int i = 0
结束循环条件: i < 5 (布尔表达式)
变化方式: i++
eg:
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
for(int i=0,j=10;i < 9 && j > 3;j--,i++){
System.out.println(i + ":" + j);
}
}
}
for循环执行顺序
九九乘法表 for循环嵌套的代表案例
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
//1 ~ 9
// i 行
for(int i = 1; i <= 9;i++){
// j 列
for(int j = 1;j <= i;j++){
//\t制表符，让所有加制表符的内容对齐
System.out.print(i + " x " + j + " = " + i * j + "\t");
}
System.out.println();
}
}
}
while 循环
while循环格式 while(布尔表达式){ ... }
eg:
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
int a = 1;
while (a < 10){
a++;
System.out.println(a);
}
}
}
while循环特殊形式
while死循环 : while(true){}
什么时候用：for循环、while循环
for循环用于，已知的循环次数
while循环用于，结束条件（直到什么时候停止）
do-while 循环
格式： do{ 执行代码 }while(布尔表达式);
eg:
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
int a = 10;
while(a < 10){
a++;
System.out.println(a);
}
int b = 10;
do{
b++;
System.out.println(b);
}while(b < 10);
}
}
while 和 do-while的区别
do-while 是先执行再判断 while是先判断再执行
break 和 continue关键字
break 在switch中，退出switch
break 在循环中出现，退出循环
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
for(int i = 0; i < 10; i++) {//循环次数，循环过程i的变化
if (i == 5) {
break;//退出循环，后续程序将不再执行。
}
System.out.println(i);
}
}
}
continue 在循环中出现，跳过本地循环，开始下一次循环(本质：continue 到 i++ 开始下一次循环)
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
for(int i = 0; i < 10; i++){//循环次数，循环过程i的变化
if(i == 5){
continue;//阻止后续程序的执行，但不会退出循环。
}
System.out.println(i);
}
}
}
作业2：通过break和continue优化输入年月日
public class Demo07 {
//作业：输入年月日，算出是这一年的第几天
public static void main(String[] args) {
int year = 2023;
int month = 7;
int day_month = 2;// day of week 星期几 ; day of month 一个月第几号; day of year 一年第几天
//一年中的第几天
int day_year = 0;
int Feb = 28;
//判断平年或闰年
if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0){
Feb = 29;
}
if(month > 1) {
int m = month - 1;
//月份 31 30 Feb
// while (m > 0) {
while (true){
switch (m) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
day_year += 31;
break;//结束switch
case 2:
day_year += Feb;
break;//结束switch
default:
day_year += 30;
break;//结束switch
}
m--;
if(m == 0){
break;//结束循环
}
}
}
//break 在循环中，就是结束循环, 在switch中就是结束switch。
//最后加上这个月已经过的日期
day_year += day_month;
System.out.println("您输入的是：" +year+ "年" +month+ "月" +day_month + "日");
System.out.println("这是该年中的第" + day_year + "天");
}
}
阶乘！
比如3！ = 3 x 2 x 1
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
//输入一个整数，求概述的阶乘
int n = 23;
//定义一个结果集
int result = 1;
// >= >
for(int i = n; i > 0; i--){
result *= i;
System.out.print(i + " x ");
}
System.out.println();//换行
System.out.println(n + "的阶乘为：" + result);
}
}
打印三角形
public class Demo09 {
//打印三角形 (等边三角形)
//*
//**
//***
//****
public static void main(String[] args) {
//循环
int n = 4;
for(int i = 0; i < n; i++){
//注意：外循环与内循环中的初始化变量不能重名
for(int j = 0;j < i + 1; j++){
System.out.print("*");
}
//换行
System.out.println();
}
}
}
猜数游戏完整版
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int m = (int)(Math.random() * 101);
while (true){
System.out.println("请输入一个0~100之间数:");
int n = scan.nextInt();
if(n > m){
System.out.println("输入过大");
}else if(n < m){
System.out.println("输入过小");
}else{
System.out.println("猜对了");
break;
}
}
}
}
作业
问：有一只猴子在在海滩捡到一堆桃子
分成了5份，多出了一个被猴子扔掉,取了其中一份，留下其余四份
先后总共来了5只猴子，做了同样的事情。 请问这堆桃子至少有多少个
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
for(int i = 1; i < 10000; i++){
int a = i;
if(a % 5 == 1){
a = (a - 1) / 5 * 4;
if(a % 5 == 1){
a = (a - 1) / 5 * 4;
if(a % 5 == 1){
a = (a - 1) / 5 * 4;
if(a % 5 == 1){
a = (a - 1) / 5 * 4;
if(a % 5 == 1){
System.out.println(i);
break;
}
}
}
}
}
}
}
}
作业1：分解质因数
(质数：只能被1或者自身整除的数)
因数：乘法的各参数
例如：输入 6 输出 6 = 3 x 2 输入 12 输出 12 = 3 x 2 x 2
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
int number = 12;
//1 ~ number : 1不是质数
int a = 2;
System.out.print(number + " = ");
while(true){
if(number % a == 0){
number = number / a;
System.out.print(a);
if(number == 1){//已经除尽了
break;//退出循环
}else{
System.out.print(" x ");
}
}else{//如果a的值除不尽，将a逐渐增加
a++;
}
}
}
}
作业2：回文数（输出1000以内的所有回文数）
回文数：数值对称 11 121 131 11211
import java.util.Scanner;
public class Work02 {
//回文数（1000以内的所有回文数）
//回文数：数值对称 11 121 131 11211
public static void main(String[] args) {
for( int i=0 ; i<10 ; i++ ) {
System.out.println(i + "是回文数");
}
for( int i=10 ; i<100 ; i++){
int g=i%10;
int s=i/10;
if(g==s){
System.out.println(i+"是回文数");
}
}
for(int i=100 ; i<1000 ; i++){
int g=i%10;
int b=i/100;
if (g==b){
System.out.println(i+"是回文数");
}
}
}
}
作业3：水仙花数（求1000以内的所有水仙花数）
三位数分别求三次幂的和 是自己本身
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
for(int a = 1; a <= 9; a++){
for(int b = 0; b <= 9; b++){
for(int c = 0; c <= 9; c++){
if(a * 100 + b * 10 + c == a * a * a + b * b * b + c * c * c){
System.out.println(a * 100 + b * 10 + c);
}
}
}
}
}
}
作业4：ATM机程序
要求：
1）进入程序时，提示功能选项 取款 存款 查询 退出
2）模拟完成存款、取款、查询功能
3）用户只要不退出就能一直操作
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
double money = 200;
boolean status = true;
Scanner scan = new Scanner(System.in);
System.out.println("-----Welcome----");
while (status) {
System.out.println("请选择：1）取款 2）存款 3）查询 4）退出");
int n = scan.nextInt();
switch (n) {
case 1:
System.out.println("请输入取款金额：");
double m = scan.nextDouble();
if (money - m >= 0) {
money -= m;
System.out.println("取款成功");
} else {
System.out.println("您的余额不足");
}
break;
case 2:
System.out.println("请输入存款金额：");
double c = scan.nextDouble();
money += c;
System.out.println("存款成功");
break;
case 3:
System.out.println("您的余额:");
System.out.println(money);
break;
case 4:
status = false;
System.out.println("已退出");
break;
default:
break;
}
}
}
}
作业5：抛小球
以一个高度抛出小球，小球弹起高度的一半后，再次下落
当小球弹了n次，它距离地面的距离为多少
求小球总共走了多长距离
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
int n = 6;
double h = 100;
double sum = 0;
for(int i = 0; i < n; i++){
sum += h;
//特殊：从右往左运算.
sum += h = h / 2;
}
System.out.println(sum);
}
}
数组
简单定义：将一类数据方到一个整体中
专业定义：将数据类型相同的数据，放到一个集合中
数组的定义方式
静态初始化 2、动态初始化
静态初始化
定义：在构建数组时就给予初始化的值
数组类型： 数据类型[]、变量[]
数组初始化 {数组元素,数组元素,....}
动态初始化
先构建数组的对象，然后在逐一赋值初始化
基本格式： 数据类型[] 变量名 = new 数据类型[数组的长度]
注意：数组的类型决定了元素是什么样的类型
数组元素
取出指定的数组元素：数组元素都具有下标值，下标值从0开始
通过”数组变量[下标值]“将数组元素取出
取不到”下标不存在“的值，报运行错误
遍历数组
可以通过length这个属性(变量)获取数组的长度
import java.util.Arrays;
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
//获取数组内所有元素
int[] a={1,2,3};
for(int i = 0; i < a.length; i++ ){//0~2
System.out.println(a[i]);
}
//取出数组中的最后一个元素
System.out.println(a[a.length - 1]);
//2、将数组内容全部输出到打印语句 [I@5594a1b5地址
// System.out.println(a);
// 工具类 Arrays (java.util.Arrays)
System.out.println(Arrays.toString(a));
}
}
数组空间
public class Demo03 {
public static void main(String[] args) {
//数组空间
int[] a = {1,2,3};
//1)数组a的地址，指向了1，2，3元素所在的堆内存空间
//2)而数组a的地址等于 1元素所在空间的地址。
//3)1，2，3元素所在的堆内存空间的地址是连续的
//对指定下标的数组元素赋值，可以直接修改该数组
a[1] = 4;
//动态初始化过程
//new: 对象创建
//虽然new int[3] 开辟了三个空间，但是空间中是有指定类型的默认值
int[] b = new int[3];
System.out.println(b[0]);//输出默认值0
b[0] = 1;
System.out.println(b[0]);
//其他类型数组的默认值
float[] n1 = new float[3];//默认值0.0
char[] n2 = new char[3];
System.out.println(n2[0]);//空字符
boolean[] n3 = new boolean[3];
System.out.println(n3[0]);//false
//引用数据类型的默认值
String[] n4 = new String[3];
System.out.println(n4[0]);//null 空对象
}
}
问题
控制输入对应的n值，创建一个n长度的随机数数组
数组元素不能重复
import java.util.Arrays;
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
int[] rands = new int[20];
for(int i = 1; i <= 20; i++){
rands[i - 1] = i;
}
int[] arr = new int[10];
for(int i = 0; i < arr.length; i++){
//随机下标
int n = (int)(Math.random() * rands.length);
if(rands[n] != 0){
arr[i] = rands[n];
rands[n] = 0;
}else{
i--;
}
}
System.out.println(Arrays.toString(arr));
}
}
数组复制
import java.util.Arrays;
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
int[] a = {1,2,3,4,5,6};
//问：如实现数组复制 从哪里开始复制（start），到哪里停止复制（end）
// 数组 ===> 新的数组 （数组长度要确认） length = end - start + 1
int start = 2;
int end = 3;
int[] b = new int[end-start+1];
int m = 0;//b数组的下标
for(int i = 0; i < a.length; i++){
if(i >= start && i <= end){
b[m] = a[i];
m++;
}
}
System.out.println(Arrays.toString(b));
}
}
数组复制 System.arraycopy
System.arraycopy(src,srcPos,dest,destPos,length)
src : 被复制的数组（从哪个数组复制）
srcPos : 从src的哪个下标开始复制
dest : 粘贴到的数组
destPos : 从dest的哪个下标开始粘贴
length : 复制的数据元素的长度
import java.util.Arrays;
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
int[] a = {1,2,3,4,5,6};
int[] c = {7,8,9,10,11,12};
System.arraycopy(a,2,c,2,2);
System.out.println("c数组：" + Arrays.toString(c));
System.out.println("a数组：" + Arrays.toString(a));
}
}
数组扩容
注意：数组本身在定义之后，不可以增减长度
import java.util.Arrays;
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
int[] a = {1,2,3};
//在a数组中添加一个为4的元素
//System.arraycopy
int[] b = new int[a.length + 1];
System.arraycopy(a,0,b,0,a.length);
b[3] = 4;
System.out.println(Arrays.toString(b));
a = b; //引用地址的赋值。
// double[] c = new double[3];
// c = a;//数组能够赋值，是因为有相同的数组类型，类型不同就不能相互赋值。
System.out.println(Arrays.toString(a));
//数组阔容的办法
//Arrays.copyOf(src,length)
// src:需要扩容的数组
// length:扩容的长度
int[] c = {1,2,3};
// c = Arrays.copyOf(c,4);
// c = Arrays.copyOf(c,2);
// System.out.println(Arrays.toString(c));
//比较地址是不是同一个
System.out.println(c == Arrays.copyOf(c,2));
}
}
练习
生成一个20长度的随机数数组
分成一个奇数数组 偶数数组
方法1：
import java.util.Arrays;
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
int[] a = new int[20];
for(int i = 0; i < a.length; i++){
a[i] = (int)(Math.random()*100);
}
int[] even = {}; //偶数数组 空数组
int[] odd = {}; //奇数数组
//方式一:使用扩容方式实现奇偶数组分离
for(int i = 0; i < a.length; i++){
if(a[i] % 2 == 0){//偶数
even = Arrays.copyOf(even,even.length + 1);
even[even.length - 1] = a[i];
}else{//奇数
odd = Arrays.copyOf(odd,odd.length + 1);
odd[odd.length - 1] = a[i];
}
}
System.out.println("偶数数组:" + Arrays.toString(even));
System.out.println("奇数数组:" + Arrays.toString(odd));
}
}
方法2：特殊的排序方式
import java.util.Arrays;
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
int[] a = new int[20];
for(int i = 0; i < a.length; i++){
a[i] = (int)(Math.random()*100);
}
for(int j = 0; j < a.length - 1; j++){
for(int i = 0; i < a.length - 1; i++){
if(a[i] % 2 == 0 && a[i+1] % 2 == 1){
int tmp;
tmp = a[i];
a[i] = a[i+1];
a[i+1] = tmp;
}
}
}
System.out.println(Arrays.toString(a));
}
}
冒泡排序
原理图
import java.util.Arrays;
public class Demo08 {
//冒泡排序 (原理图)
public static void main(String[] args) {
int[] a = {5,4,3,2,1};
//通过推理,总共有a.length - 1 次排序
for(int j = 0; j < a.length - 1; j++){
//一次排序
//1.考虑倒数的第二位元素结束: i < a.length - 1
//a.length - 1 - j : 考虑到不用比较的次数
for (int i = 0; i < a.length - 1 - j; i++){
//2.前面的数和后面的数比较大小
if(a[i] > a[i+1]){
//3.交换
int tmp;
tmp = a[i];
a[i] = a[i+1];
a[i+1] = tmp;
}
}
System.out.println(Arrays.toString(a));
}
System.out.println(Arrays.toString(a));
}
}
排序函数
import java.util.Arrays;
public class Demo09 {
//排序函数
public static void main(String[] args) {
int[] a = {5,4,3,2,1};
Arrays.sort(a);//从小到大的排序
System.out.println(Arrays.toString(a));
}
}
问题
["红","蓝","绿","蓝","红","绿"]
按照:' 绿 < 蓝 < 红 '的规则排序
import java.util.Arrays;
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
String[] b = {"红","蓝","绿","蓝","红","绿"};
for(int j = 0; j < b.length - 1; j++){
for(int i = 0; i < b.length - 1; i++){
if(b[i] == "蓝" && b[i+1] == "绿" || b[i] == "红" && b[i+1] == "蓝"|| b[i] == "红" && b[i+1] == "绿" ){
String tmp;
tmp = b[i];
b[i] = b[i+1];
b[i+1] = tmp;
}
}
}
System.out.println(Arrays.toString(b));
}
}
二维数组
一维数组：
int[] a = {1,2,3};
int[] b = {3,4,5};
int[] c = {6,7,8};二维数组 : 二维数组的元素是一维数组
定义方式 int[][] 数组名称
如 ： int[][] d = {a,b,c};
二维数组的定义方式:
静态初始化
int[][] n1 = {{1,2,3},{3,4,5}};动态初始化
理解方式一: new int[行][列]
理解方式二: new int[有几个一维数组][这些一维数组中有几个元素]
int[][] n2 = new int[3][3];
int[][] n3 = new int[3][];// = {[],[],[]};//元素是三个空的一维数组静态初始化的特殊形式:每个元素中数组是不同的长度
int[][] n4 = {{1,2,3},{5},{6,7}};length 数组长度
System.out.println(n4.length);//有多少个一维数组
System.out.println(n4[n4.length - 1].length);//指定一维数组中的元素个数
二维数组的遍历
import java.util.Arrays;
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
int[][] n4 = {{1,2,3},{5},{6,7}};
for(int i = 0; i < n4.length; i++){
for(int j = 0; j < n4[i].length; j++){
System.out.print(n4[i][j]);
}
}
}
}
控制台输入
java.util.Scanner
1、引入Scanner工具 ：import java.util.Scanner;
2、新建Scanner的对象： Scanner scan = new Scanner(System.in);
3、先使用System.out.println("请输入内容:");
4、使用scan.nextXXX 定义输入值的类型。
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入内容:");
int n = scan.nextInt();//整数
// double n = scan.nextDouble();//浮点数
// String n = scan.nextLine();//字符串
System.out.println("刚才输入了:" + n);
}
}
随机数
Math.random() 创建一个随机0~1的数（且不包含1） double类型
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
//生成一个0~1的数（且不包含1）
System.out.println(Math.random());
//0~10 的一个随机整数
System.out.println((int)(Math.random() * 11));
}
}
作业1：石头剪刀布游戏
import java.util.Scanner;
public class Demo14 {
public static void main(String[] args) {
//作业：石头剪刀布游戏
//要求：1、采用随机数，生成一个“石头、剪刀、布”的值（String）
// 2、要求用户输入“石头、剪刀、布”，任意值
// 3、判断用户赢，还是电脑赢。
//要求1：三个随机数
int n = (int)(Math.random() * 3);
//n == 0 "石头"
//n == 1 "剪刀"
//n == 2 "布"
String robot = "石头";
if(n == 1){
robot = "剪刀";
}else if(n == 2){
robot = "布";
}
//要求2：用户输入
// Scanner scan = new Scanner(System.in);
// System.out.println("请输入你猜测的手势：");
String user = "石头";
//要求3：判断输赢 （枚举）
if(robot == "石头" && user == "布"){
System.out.println("用户赢");
}else if(robot == "石头" && user == "剪刀"){
System.out.println("电脑赢");
}else if(robot == "石头" && user == "石头"){
System.out.println("平局");
}
if(robot == "剪刀" && user == "布"){
System.out.println("电脑赢");
}else if(robot == "剪刀" && user == "剪刀"){
System.out.println("平局");
}else if(robot == "剪刀" && user == "石头"){
System.out.println("用户赢");
}
if(robot == "布" && user == "布"){
System.out.println("平局");
}else if(robot == "布" && user == "剪刀"){
System.out.println("用户赢");
}else if(robot == "布" && user == "石头"){
System.out.println("电脑赢");
}
}
}
作业2：输入年月日，算出是这一年的第几天
要求用户分别输入 年月日：（闰年）
算出这是这一年的第几天
public class Work01 {
//作业：输入年月日，算出是这一年的第几天
public static void main(String[] args) {
int year = 2023;
int month = 7;
int day_month = 2;// day of week 星期几 ; day of month 一个月第几号; day of year 一年第几天
//一年中的第几天
int day_year = 0;
int Feb = 28;
//判断平年或闰年
if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0){
Feb = 29;
}
//if语句的特殊写法
//注意：if语句可以不加{} 但是只能约束它后面的第一条语句
// if(Feb > 100)
// System.out.println("1");
// System.out.println("2");
// if else if
if(1 < month) day_year += 31;
if(2 < month) day_year += Feb;
if(3 < month) day_year += 31;
if(4 < month) day_year += 30;
if(5 < month) day_year += 31;
if(6 < month) day_year += 30;
if(7 < month) day_year += 31;
if(8 < month) day_year += 31;
if(9 < month) day_year += 30;
if(10 < month) day_year += 31;
if(11 < month) day_year += 30;
//最后加上这个已经过的日期
day_year += day_month;
System.out.println("您输入的是：" +year+ "年" +month+ "月" +day_month + "日");
System.out.println("这是该年中的第" + day_year + "天");
}
}
作业2：通过Switch语句优化
public class Demo02 {
//作业：输入年月日，算出是这一年的第几天
public static void main(String[] args) {
int year = 2023;
int month = 7;
int day_month = 2;// day of week 星期几 ; day of month 一个月第几号; day of year 一年第几天
//一年中的第几天
int day_year = 0;
int Feb = 28;
//判断平年或闰年
if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0){
Feb = 29;
}
//if语句的特殊写法
//注意：if语句可以不加{} 但是只能约束它后面的第一条语句
// if(Feb > 100)
// System.out.println("1");
// System.out.println("2");
switch(month - 1){
case 11:day_year += 30;
case 10:day_year += 31;
case 9:day_year += 30;
case 8:day_year += 31;
case 7:day_year += 31;
case 6:day_year += 30;
case 5:day_year += 31;
case 4:day_year += 30;
case 3:day_year += 31;
case 2:day_year += Feb;
case 1:day_year += 31;
}
//最后加上这个月已经过的日期
day_year += day_month;
System.out.println("您输入的是：" +year+ "年" +month+ "月" +day_month + "日");
System.out.println("这是该年中的第" + day_year + "天");
}
}
作业：计算BMI指数
输入用户体重、身高 算出对应的BMI指数
输出该用户的身体状况
import java.util.Scanner;
public class Work02 {
//计算BMI指数
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入身高(米):");
double height = scan.nextDouble();
System.out.println("请输入体重(千克):");
double weight = scan.nextDouble();
double bmi = weight / (height * height);
System.out.println(bmi);
if(bmi < 18.5){
System.out.println("偏瘦");
}else if(bmi < 24){
System.out.println("正常");
}else{
System.out.println("偏胖");
}
}
}
作业：猜数游戏
指定范围内让用户输入一个数字
生成随机数，判断该用户输入过大，过小，成功猜对
import java.util.Scanner;
public class Work03 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入一个0~10之间数:");
int n = scan.nextInt();
int m = (int)(Math.random() * 11);
if(n > m){
System.out.println("输入过大");
}else if(n < m){
System.out.println("输入国小");
}else{
System.out.println("猜对了");
}
}
}
作业：商店找零
要求输入单价、数量、用户支付的金额，然后输出找零的数值（考虑现实情况）
import javax.swing.*;
public class Work04 {
public static void main(String[] args) {
int number = 12;
double price = 2.39;
double pay = 100;
//分：四舍五入
//思路：结余的钱 - 0.05 ?
double n = pay - number * price;
//将小数变为整数
double m = n * 10;//小数点右移一位
if(m - (int)m >= 0.5){//四舍五入的条件
m += 1;
}
m = (int)m;//舍去小数部分
n = m / 10;//小数点左移一位
//Math.round() 四舍五入
System.out.println("商品总价：" + number * price);
System.out.println("用户支付：" + pay);
System.out.println("找零:" + n);
}
}
阶段总结
在JAVA中，如何跳出当前多重嵌套循环？
方法1：通过break标签跳出多重循环
方法2：循环条件限制（外层循环受到内层循环控制，通过控制内外层循环条件跳出循环）
方法3：内层循环抛出异常（通过内层循环抛出的异常跳出循环）
2、JDK和JRE有什么区别？
JDK全称为Java Development Kit ，是java开发工具包，是程序员使用java语言编写java程序所需的开发工具包。
JRE全称为 Java Runtime Environment ,是java运行时的环境，包含了java虚拟机，java基础类库，是使用java语言编写的程序运行所需要的软件环境。
JDK是提供给程序员使用的，JRE是提供给想运行java程序的用户使用的。包含关系：JDK包含了JRE
3、=、==、和equls的区别
=赋值运算符
比如：a =b就是把b的值赋予给了a
==操作符
操作符专门用来比较变量的值是否相同。
基本数据类型：比较的是他们的值是否相同
引用数据类型：比较的是他们的内存地址是否是同一个地址
引用类型对象变量其实是一个引用，他们的值是指向对象所在的内存地址，而不是对象本身。
equls方法
equls方法常用来比较对象的内容是否相同
java中所有的类都是继承于Object这个超类的，在Object类中定义的equls方法：
未重写equls方法的类：Object中的equls方法实际使用的也是==操作符，比较的是他们的内存地址是否同一地址
重写了equls方法的类：实现该类自己的equls方法比较逻辑（一般是比较对象的内容是否相同）。
比如：String：比较字符串内容。Integer：比较对应的基本数据类型int的值是否相同
4、string是基础数据类型吗？基础的数据类型有哪些？
String不是基础的数据类型。
基础数据类型一共有8种，分别是整数型（byte ,int , short , long) ,浮点型（float , double）, 字符型（char）,布尔型（boolean）。
基础类型
整型
byte 8字节
short 16字节
int 32字节
long 64字节
浮点型
float 32字节
double 64字节
字符型
char
布尔型
boolean
5、如何实现数组和List之间的转换？
数组转List使用Arrays.asList()方法
List转数组使用list.toArray()方法