华清远见重庆中心—JAVA基础阶段技术总结/个人总结

ggk911

已于 2023-01-09 08:46:49 修改

阅读量533

点赞数

文章标签： java jvm 开发语言

于 2022-11-14 22:26:30 首次发布

本文链接：https://blog.csdn.net/ggk911/article/details/127856019

版权

文章目录

Java基础知识
运算符
循环
数组
学习中遇见的问题
- Scanner输入问题使用方法netInt()后netLine()会为空
- ArrayIndexOutOfBoundsException数组索引错误
错题解析
基础总结

Java基础知识

概述

Java是1995年Sun公司发布，如今被Oracle收购

下载安装Java时从Oracle官网下载，最好下载LTS长期维护版本。Java8，Java11，Java17

Java是一门半编译半解释的面向对象语言

由于Java虚拟机JVM的存在，可以全平台运行。

Java程序运行过程

public class Test{
	public static void main(String[] ars){
		System.out.println("Hello world");
	} 
}

编辑的是.java文件，称为源文件。通过javac命令进行编译，生成同名的 .class字节码文件，再虚拟机上解释该文件运行。

Java的分类

JavaSE
JavaEE
JavaME

JavaME称为Java微型版，用于开发移动应用，早期的塞班系统中会使用，如今已经淘汰

JavaSE称为Java标准版，是java的核心和基础，也是JavaME和JavaEE的核心。可以用于开发桌面端程序。如IDEA就是用java开发的。

JavaEE称为Java企业版，用于开发WEB应用。Java 的留下全靠JavaEE。WEB应用如门户网站、电子商务、电子政务等服务器都是由JavaEE实现。

Java为什么流行

java是一门“半解释半编译”的“面向对象”语言

java有很多优点，尤其是这几点：

简单
安全
开源
多线程
半解释半编译
面向对象

Java能够跨平台运行的原理

Java有一个最大的特点就是跨平台：“一处编译，处处运行”。

Java有一个核心：JVM，Java Virtual Machine称为Java虚拟机，它用于解释Java的字节码文件。

在不同的平台上，安装JVM后，就能解释当时编译的字节码文件。

开发人员在编辑Java代码后，会保存为.java的源文件，

将源文件金国编译后，会生成。class的字节码文件，

由JVM解释字节码文件。

安装Java后，会安装JVM和JRE。

JDK和JRE

JDK全程Java开发工具包Java Development Kit。包含了JRE，Java的调试、编译等工具。

JRE全程Java运行环境Java Runtime Environment。包含了JVM，java运行工具等。

（jdk（jre（jvm）））

第一个Java程序

public class Main {

    public static void main(String[] args) {
        System.out.println("Hello world");
    }
}

Java程序的运行流程

编辑.java源文件——》javac命令编译——》生产.class文件——》java命令由JVM解释运行

集成开发环境IDE

Integrated Development Environment

集成了编辑源代码、调试、运行等功能的工具称为IDE。

Java的IDE有很多，如Eclipse、MyEclipsse、STS、IDEA等都是集成开发环境。

当前的主流是IDEA。

Java程序中的注意事项

要写代码，必须想创建class，class称为类，是一个java程序的基本组成单位
每个能够运行的java程序，有且只有一个main方法，称为主方法/入口函数，是程序的启动
符合
- Java中的符号全部都是英文状态下的符号，可以在输入法中设置中文状态使用英文标点
- “{}”必须成对出现。用于定义类、定义方法和定义代码块
- “[]”必须成对出现。用于定义数组、使用数组
- “()”必须成对出现。用于表示方法的参数
- “空格”用于分割关键字和代码。可以是一个空格，也可以是多个
- “.”用于调用某个类或对象的属性和方法
- “;”用于表示一句代码的结束，大括号后不需要加分号
换行和缩进
- 在每出现一次大括号时，就要进行一次缩进

Java程序中的注释

注释可以对代码进行解释说明或屏蔽不用的代码。编译时无视注释，注释分为

单行注释快捷键：ctrl + /

//123

多行注释快捷键：ctrl + shift + /

文档注释

/**
 * 文档注释
 * 通常用于解释整个java类或某个方法或某个变量，
 * 最终可以通过java命令自动生成文档
 */

IDEA快捷键

ctrl+X 删除一行

ctrl+shift+f10 运行

ctrl+shift+方向键移动选中的代码块

变量.sout 回车快捷输出

ctrl+alt+L 调格式

条件 . if 快速生成if

IDEA在粘贴多行字符时自动转义符换行加拼接

编程语言的命名规则

驼峰命名法

如果用多个单词描述一个内容，除首字母外，其他单纯首字母大写。

如studentsName、empId

帕斯卡命名法

使用单词首字母去全部大写

Java中的标识符

Java中的英文、方法名和变量名称统称为标识符。

类名使用帕斯卡命名法
方法名和变量名使用驼峰命名法
命名时做到“见名知意”

非强制性，约定俗成的内容

Java中标识符的命名规则

标识符使用字母、数字、下划线和$组成
不能以数字开头
不能使用Java中的关键字（保留字）

强制要求，无法编译

Example：

类名 Test Person Animal Cat UserController StudentService
变量名 age lastName firstName
方法名 login() findEmpById(int id)
常量 COUNTRY_NAME

Java中的数据类型

Java中分为两大数据类型：原始（基本）类型和引用类型

原始类型

整型

1Byte=8bit 00000000~11111111 256
- byte
- short
- int
- long
浮点型
- float单精度浮点型，赋值时在数字后加f或F
- double双精度浮点型
字符型
- char，赋值时可以用单引号引起来的字符或一个数字，或是数字ascii中的数字或者是一个转义字符ascii码（\t、\n）

转义字符

\t
\n 换行
\"
\'
\b 退格
\r 回车
\\ 字符“\”
\0 null

布尔型

boolean

类型名	所占字节大小	范围
byte	1字节	-128~127
short	2字节	-32768~32767
int	4字节	-2,147,483,648~2,147,483,647
long	8字节	-9,223,372,036,854,775,808~9,223,372,036,854,775,807
float	4字节
double	8字节
char	2字节	单引号的一个字符
boolean		true/false

再程序中直接写出的整数默认是int类型

再程序中直接写出的小数默认是double类型

原始类型之间的数据类型转换

隐式类型转换（自动）
整型数据可以直接保存到浮点型中

占用字节小的数据类型的变量，可以直接保持到占用字节大数据类型的变量中

short s=123;
int i=s;

显示类型转换

占用字节大的数据类型的变量，默认无法保持到占用字节小的数据类型的变量中，

如果要强制保存，需要强制类型转换。

语法：（目标类型）带转换的变量

int num=123;
byte a=(byte)num;//未超出范围，结果无误
byte a=(byte)128;//超出范围，溢出-128

引用类型

类
接口
数组

变量

在内存中的一块区域。由于这块区域终端数据可以发送变化，所以称为变量。

内存中的变量，相当于酒店中的房间。房间的类型就是变量的类型，房间的房号就是变量的名称，房间中住的人就是变量的值。

定义变量，就是在内存中申请一块想要数据类型的空间，并对其命名的过程。

定义变量

语法：数据类型变量名；

如果要同时定义多个相同类型的变量，可以：数据类型变量名1，变量名2.。。；

如

//年龄
int age=18;
//年月日
int year;
int month;
int day;
//利率
double interestRate;
//电话号码
String phoneNumber;

给变量赋值

语法：变量名 = 值；

int i;
i=10;

变量初始化

语法：数据类型变量名 = 值；

如果在定义变量的时候能确定其中保存的数据，可以直接在定义变量的时候赋值。

将定义变量和给变量赋值

int i =19;

变量注意事项

在一对大括号中变量只能出现一次
给变量赋值是，赋值符号“=”左边通常是一个变量名，右边可以是一个具体值也可以是另一个赋了值的变量名（不超出其范围），再可以是一个表达式（不超出其范围）。
如果同时定义多个类型系统的变量，可以只写一个数据类型
必须以字母、下划线、或者美元符$开头；以美元符$ 开头命名的变量虽然能够编译通过但是不建议使用；
中文也可以作为命名开头且编译也能通过，但是不建议使用。
除开头外后面的部分可以有字母、下划线、美元符$以及数字组成；
虽然变量名不限制长度，但能表达清楚命名的含义即可；
变量名不可以和java的关键字冲突；
再命名中大小写是又区别的，即使由同一个单词命名但是有个别字母的大小写的区别，产生的就是两个不同的变量。

int a=1,b=2,c=3,d=4,e=5,f=6;

运算符

算术运算符

需要两个操作数参与，如果由浮点数参与运算，结果为浮点型。

符号	作用	说明
+	加	如果两个操作数都是数值型的数据，+用于计算。如果两个操作数有一端是字符串，+用于拼接字符串。
-	减	只能用于数值型数据。
*	乘	只能用于数值型数据。
/	除	只能用于数值型数据。如果两个整数相除，结果只保留整数部分（商）。
%	模	只能用于数值型数据。商一定是整数。

注意

如果同时多个符号一起使用，遵循数学中的四则运算规则，先乘除，后加减
运算时最终结果的数据类型，以所以参与运算的操作数中所占字节最大的类型为准

关系运算符

需要两个操作数参与

符号	作业
>	大于
<	小于
>=	大于等于
<=	小于等于
!=	不等于
==	等于

注意

==用于判断相等，=用于赋值
==用于比较两个原始类型的值或引用类型的内存地址
关系运算的结果为true/false

逻辑运算符

符号	作业	说明
&&	and与	符号两端需要两个表达式，判断如果都为true，整体结果则为true，如果有一段姐夫哦为false整体结果为false。
\|\|	or或	符号垄断需要两个表达式，判断如果都为false，整体结果则为false，如果有一端结果为true，整体结果为true。
！	not非	是一个弹幕运算符，只有一个表达式参与运算。“！表达式”不是对原表达式的结果取相反值。

补充：位运算符

符号	作业
&	按位与。计算的结果与&&相同，但过程不同。符号两端的表示都会执行判断。
\|	按位或。计算的结果与\|\|相同，但过程不同。符号两端的不是都会执行判断。
^	按位异或。将操作数转换为二进制后，按位比较，如果相同结果为0，不同结果为1，最终二进制结果转换为十进制。
>>	按位右移。将第一个操作数转换为二进制后，向右移第二个这才是对于的位数，再将结果装换位十进制。
<<	按位左移。

注意

&&和||也称为短路运算。如果能通过第一个表达式觉得最终的结果，则不用判断第二个表达式。
通常情况下，使用&&和||提高代码执行效率。

赋值和复合赋值运算符

符号	作用
=	赋值运算符。将符号右侧的内容赋值给符号左侧的变量。
+=	复合赋值运算符。i+=3;相当于i=i+3;
-=	i-=1; ==
*=
/=
%=

注意

复合赋值运算的流程是：

将符号两端的整体进行对应的算数运算后，将结果赋值给符号左侧的变量中。

自增自减运算符

只有一个操作数参与运算，称为单目运算符

符号	作用
++	将结果加一
–	将结果减一

注意

a++或++a相当于a+=1或a=a+1。–同理
如果++或–独立成行使用，无论符号在前在后，都将结果+1或-1
如果++或–不是单独成行
- 符号在前，先+1或-1计算后在使用值
- 符号在后，先使用值后在+1或–1计算

条件运算符

三目运算符，有三个操作数参与。是一个简化版的双分支条件语句。

表达式1?表达式2:表达式3

首先运算表达式1，如果结果为true，执行问号后的表达式2; 如果结果为false，执行冒号后的表达式3。整个表达式的最终结果为表达式2或表达3。

三位一体，运算后的值为其中范围最大的值

((x>4) ? 99.9 :9)
其结果为：9.0

运算符的优先级

小括号>>单目运算符>>算术运算符>>关系运算符>>逻辑运算符>>条件运算符>>赋值/复合赋值运算符

多种数据类型参与运算，其结果以字节最大的为准。

条件语句

if语句

单分支if语句

如果一件事情满足则执行

if(判断条件){//布尔值条件
	执行代码
}

双分支

if(){

}else{

}

多分支

if(){

}else if(){

}else if(){

}else{

}

if嵌套

if(){
	if(){
	
	}
}

if嵌套不要嵌套太多层，会导致代码可读性变低

if嵌套可以改造成if（）{return}形式，让程序满足条件时，不再执行后续内容。

注意

if或else后的大括号可以不写，但只能跟一句执行语句。

switch语句

开关语句

如果一个变量的值能够列举出时，使用switch语句更为简洁。

变量不能为Long类型

switch(变量){
    case 1:
        break;
    case 2:
        break;
    case 3:
        break;
    default:
        break;
}

注意

switch小括号中的变量只能是非long的整型、字符型char、字符串String和枚举类型

小括号中的变量类型要与case后的值的类型相匹配

如果有某个case后的内容和变量值匹配，执行case后的代码，如果没有任何case匹配，执行 default后的代码

break和default可以省略。如果不写break，在某个case匹配时，执行玩相应的代码后继续执行后续case后的代码，直到遇到break或没有代码为止

如果多个case后执行的内容一致，可以省略break，将统一要做的代码放在最后的case后

if语句与switch语句的选择

如果条件能够一一列举出来时，使用switch语句更为简洁
如果条件是一个范围是，中年使用if语句，如大于100
switch语句可以改为if语句，if语句不一定能改为switch语句

if语句和switch语句中的return关键字

if语句中可以使用return关键字不在执行后续的代码。可以使用这一点将原本的嵌套改成if-return的形式。

int a=3,b=4,c=5;
if(a+b<=c || a+c<=b || b+c<=a){
System.out.println("不能组成三角形");
return;
}
if(a==b && b==c){
System.out.println("等边");
}else if(a==b || a ==c || b==c){
System.out.println("等腰");
}else{
System.out.println("普通");
}

switch语句中，也可以使用return，但会造成switch语句之后的代码不执行，所以一般不在switch 语句中使用return;

循环

如果要重复执行某些代码时，使用循环语句。

while

while(循环条件){//小括号中的条件结果为boolean值
满足循环条件时重复执行的代码
}

执行流程先执行小括号中的内容，如果结果为true，执行大括号中的内容，再循环执行小括号中的内容，判断如果为false则停止循环。

while循环有可能一次都不执行。

do-while

do{
满足循环条件时重复执行的代码
}while(循环条件);

执行流程先执行一次do大括号中的内容，再判断while小括号中的内容，如果成立，再次执行do大括号中的内容，如果不成立，停止循环。

do-while循环至少执行一次

while和do-while的区别

while循环可能一次都不执行，do-while循环至少会执行一次

for

//表达式1为定义循环变量
//表达式2为判断循环条件
//表达式3为更新循环变量
for(表达式1;表达式2;表达式3){
循环体
}

执行流程首先执行表达式1，再执行表达式2，如果表达式2的结果为true，执行循环体，再执行表达式3，再执行表达式2判断，如果表达式2的结果为false，结束循环

for循环特殊情况

//for循环特殊情况
//可以使用外部定义的循环变量
int i = 0;
for (;i<=10;i += 2) {
System.out.println(i);
}
//可以在循环体重更新循环变量
int i = 0;
for (;i<=10;) {
System.out.println(i);
i += 2;
}
//两个分号必不可少，如果都不写表达式，是一个死循环
int i = 0;
for (; ; ) {
if (i > 10) {
break;
}
System.out.println(i);
i += 2;
}

循环控制

break和return

所有的循环都可以使用break和return停止循环。
break是停止循环后，继续执行循环之外的内容。
return是结束方法，不再执行return之后的内容。

continue

在循环语句中，使用continue，可以停止本次循环，不再执行continue之后的代码，直接进行下一次循环。

循环总结

如果已知循环次数，推荐使用for循环。如遍历数组、集合等。
如果未知循环次数，推荐使用while循环。 while循环和for循环可以相互转换
do-while循环至少执行一次，for循环和while循环有可能一次都不执行

循环嵌套

如果一个重复的过程还需要将其整体重复执行时，可以使用循环嵌套。

如循环判断密码是否输入正确，正确后循环打印功能菜单。

循环嵌套就是循环一个循环。

//用*打印矩形
//将循环一行这件事再循环5次
for (int n = 1; n <= 5; n++) {
//循环打印一行
for (int i = 1; i <= 10; i++) {
System.out.print("*");
}
System.out.println();
}

穷举法

将所有可能的情况一一列举出来

//鸡兔同笼 笼子里有若干鸡和兔，头一共35，腿一共94，鸡兔各几只？
for (int ji = 0; ji <= 35; ji++) {
	for (int tu = 0; tu <= 35; tu++) {
		if (ji + tu == 35 && 2 * ji + 4 * tu == 94) {
			System.out.println("鸡：" + ji + "兔：" + tu);
		}
	}
}
//百元买百蛋 花够100元买够100个蛋 鸡蛋3个1元 鸭蛋1个3元 鹅蛋1个5元
for (int jd = 0; jd <= 100; jd++) {
	for (int yd = 0; yd <= 100; yd++) {
		for (int ed = 0; ed <= 100; ed++) {
			//整数间相除为整数，这里鸡蛋的价格需要用浮点数表示
			if (jd + ed + yd == 100 && 3 * yd + 5 * ed + jd / 3.0 == 100){
				System.out.println("鸡蛋：" + jd + "鸭蛋：" + yd + "鹅蛋：" + ed);
			}
		}
	}
}

数组

概念

一组类型相同的数据的有序集合。

关于数组

实际在内存中是一块连续的空间。是保存数据的区域

数组定义是需要确定大小和数据类型，不可改变

定义数组是的变量保存的是实际内存空间的地址。

实际中保存的数据称为元素，每个元素有一个唯一的位置，称为索引（下标）从0开始。

可以通过数组的索引给数组赋值或读取数组中某个索引的值。

定义数组

数据类型[] 数组名 =new 数据类型[数组大小];

数组初始化

语法：数组名 = new 数据类型[数据大小];

数据类型[] 数组名 =new 数据类型[]{元素1，元素2，元素3、、、};

数据类型[] 数组名 ={元素1，元素2，元素3.。。。};

//定义一个保存数组的变量nameList
String[] nameList;
//在内存中申请一块连续空间，将这个空间的地址板寸到变量nameList中		
nameList = new String[10];

定义数组的同时初始化

语法：数据类型[] = new 数据类型[数据大小];

double[] = new double[10];

给数据赋值

动态赋值

int[] list = new int[10];
list[0]=123;
list[1]=123;
list[2]=123;

静态赋值

注意

数组一但初始化后，数组大小不能该v，其中的元素类型要统一
数组的索引范围是[0，大小-1]，使用时不能超出范围。在编译时无法识别的是否超出，但运行时会抛出“数组索引溢出”异常
数组一但初始化后，如果没有赋值，默认有初始值
数组可以通过“数组名.length()”获取长度

数组数据类型	默认值
String 引用类型	null
Int 整型	0
boolean	false
char 字符	空白字符
float 浮点	0.0

读取数组中的元素

通过"数组名[索引]"来读取元素

String[] nameList={"王海","刘涛","赵敏"};
System.out.println(nameList[0]);
System.out.println(nameList[1]);
System.out.println(nameList[2]);

可以通过循环给数组赋值和读取元素

//定义一个数组保存同学的姓名，循环接收后打印所有。
Scanner sc = new Scanner(System.in);
//定义数组
String[] stuName = new String[3];
//循环赋值
for (int i = 0; i < 3; i++) {
System.out.println("请输入第"+(i+1)+"位同学的姓名");
stuName[i] = sc.next();
}
//循环读取
System.out.println("当前学生列表");
for (int i = 0; i < stuName.length; i++) {//通过“数组名.length”获取数组的长度
System.out.print(stuName[i]+"\t");
}
//增强for循环 for(数据类型 变量名 : 数组或集合){}
for (String name : stuName) {
System.out.print(name + "\t");
}
System.out.println()

增强for循环

专门用于遍历数组或集合元素的一种循环语法：for(数据类型变量名 : 数组名){}

String[] list = {"admin","qwe","aaa"};
//使用增强for循环遍历
for(String name : list){
System.out.println(name);
}

冒泡排序

数组中每相邻的两个元素进行比较，如果不满足排序的规则，交换位置。

int[] num = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
        //长度-1轮
        for (int i = 0; i < num.length - 1; i++) {
            //一轮交换12次
            for (int i1 = 0; i1 < num.length - 1; i1++) {
                //交换
                int tem = 0;
                if (num[i1] > num[i1 + 1]) {
                    tem = num[i1 + 1];
                    num[i1 + 1] = num[i1];
                    num[i1] = tem;
                }
            }
            //输出
            System.out.print((i + 1) + "轮");
            for (int a : num) {
                System.out.print(a + " ");
            }
            //每轮换行
            System.out.println();
        }

数组工具类Arrays

Arrays是jdk提供的用于处理数组的工具类。包含了如排序、复制、填充等方法，这些方法都是静态方法，直接通过Arrays调用。

常用方法	作业
sort（数组）	将输入中的元素升序排序。
sort（数组，起始位置，结束位置）	对数组中[起始位置，结束卫视）区间的元素升序排序
fill（数组，值）	使用指定值对数组中的所有元素进行填充。
fill（数组，起始位置，结束位置）	使用指定值对数组中[起始位置，结束位置)区间的元素进行填充。
copyOf（数组，新数组长度）	赋值数组并指定复制后的数组的长度。得到复制后的新数组。
asList（一组数据）	减一组数据装换为List集合。
equals（数组1，数组2）	判断两个数字是否相同，得到判断的布尔值。一模一样才得true。

学习的sample

定义变量表示一个小写字母，输出它的大写形式

如定义char word=‘q’，输出Q

import java.util.Scanner;

public class Work01 {
    public static void main(String[] args) {
        System.out.print("请输入一个小写字母：");
        Scanner scanner = new Scanner(System.in);
        String b = scanner.next();
        char c = b.charAt(0);
        System.out.println((char) (c-32));

    }
}

控制台输入圆的半径，计算圆的周长和面积并输出

如输入2，输出周长：xxxx，面积：xxxx

Scanner scanner = new Scanner(System.in);
        System.out.print("请输入输入圆的半径：");
        int a = scanner.nextInt();
        System.out.println("周长为:"+Math.PI*2*a+"面积为:"+a*a*Math.PI);

控制台输入3个数，输出最大值、最小值、总和和平均值

如输入1，2，2，输出最大为2，最小为1，总和为5，评价为1.7

Scanner scanner = new Scanner(System.in);
        System.out.print("请输入第一个数：");
        int a = scanner.nextInt();
        System.out.print("请输入第二个数：");
        int b = scanner.nextInt();
        System.out.print("请输入第三个数：");
        int c = scanner.nextInt();
        int max = a > b ? a:b;
        max = max > c ? max: c;
        int min = a > b ? b:a;
        min = min > c ? c: min;
        int sum=a+b+c;
        float svg=(float) sum/3;
        System.out.println("Max:"+max+"min:"+min+"sum:"+sum+"svg:"+svg);

控制台输入1个4位数，输出所有数之和

如输入3257，输出17

Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个四位数：");
        int a = scanner.nextInt();
        int ge = a%10;
        int shi = a/10%10;
        int bai = a/100%10;
        int qian = a/1000;
        System.out.println(ge+shi+bai+qian);

控制台输入金额，根据金额输出吃什么

如输入10，输出吃小面

 Scanner scanner = new Scanner(System.in);
        System.out.println("小面10￥；抄手11￥；饺子12￥；炒饭13￥");
        System.out.println("您想要吃什么呢？");
        String a = scanner.next();
        if (a.equals("小面")) {
            System.out.println("收费10￥");
        } else if (a.equals("抄手")) {
            System.out.println("收费11￥");
        } else if (a.equals("饺子")){
            System.out.println("收费12￥");
        } else if (a.equals("炒饭")){
            System.out.println("收费13￥");
        }

用空格切分字符串并输出

Scanner scanner = new Scanner(System.in);
        System.out.print("请输入输入：");
        String a = scanner.nextLine();
        String [] arr = a.split("\\s+");
        System.out.println(arr.toString());
        for(String ss : arr){
            System.out.println(ss);
        }

打印如下菜单

请选择功能：
1：注册
2：登录
3：退出
输入：1
进入注册功能
 /**
   * 请选择功能：
   * 1：注册
   * 2：登录
   * 3：退出
   * 输入：1
   * 进入注册功能
   */
        System.out.println("请选择功能：\n" +
                "1：注册\n" +
                "2：登录\n" +
                "3：退出\n");
            Scanner scanner = new Scanner(System.in);
            int a = scanner.nextInt();
            switch (a){
                case 1:
                    System.out.println("进入注册界面");
                    break;
                case 2:
                    System.out.println("进入登录页面");
                    break;
                case 3:
                    System.out.println("您已退出");
                    break;
            }

在这里插入图片描述

输入一个四位号码，判断个位和百位之和

8的倍数，一等奖

5，二等奖

3，三等奖

其他，谢谢参与

如输入1234，三等奖

int a = 0;
        Scanner scanner = new Scanner(System.in);
        while (a<999||a>10000) {
            System.out.println("输入一个四位号码");
            a = scanner.nextInt();
        }
        int ge = a%10, bai = a/100%10, sum=ge+bai;
        if (sum%8==0) System.out.println("一等奖");
        else if (sum%5==0) System.out.println("二等奖");
        else if (sum%3==0) System.out.println("三等奖");
        else System.out.println("谢谢参与");

在这里插入图片描述

输入年份和月份，输出共多少天

        /**
         * 输入年份和月份，输出共多少天
         * 1、3、5、7、8、10、12是大月，有31天；2月平年是28天，闰年是29天；
         * 4、6、9、11是小月，有30天。
         */
        Scanner scanner = new Scanner(System.in);
        System.out.print("输入年份和月份：");
        String  a = scanner.nextLine();;
        String out="";
        String[] arr = a.split("\\s+");
        while (Integer.parseInt(arr[1])>12||Integer.parseInt(arr[1])<1){
            System.out.print("输入年份和月份：");
            a = scanner.nextLine();
            arr = a.split("\\s+");
        }
        switch (Integer.parseInt(arr[1])){
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                out = "31";
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                out = "30";
                break;
            case 2:
                if (isRunnian_v2(Integer.parseInt(arr[0]))) out = "29";
                else out = "28";
                break;
        }
        System.out.println(arr[0] + "年的"+ arr[1] +"月有" + out + "天");

isRunnian_v2()

public static boolean isRunnian_v2(int year){
        boolean a = false;
        a = (year%4==0&&year%100!=0)||year%400==0?true:false;
        return a;
    }

在这里插入图片描述

1000~1999中有两个数字相同的次数（1个数字）

        /**
         * 1000~1999中有两个数字相同的次数（1个数字）
         * 分析有三种形式
         * 1100
         * 1001
         * 1010
         * 每种形式的1都不能与0相同
         * 1100 一位！=三位&&一位！=四位 && 二位！=三位&& 二位！=四位
         */
         int num=0;
        for (int i = 1000; i < 2000; i++) {
            int ge = i%10;
            int shi = i/10%10;
            int bai = i/100%10;
            int qian = i/1000;

            if(qian==bai&&shi!=ge&&qian!=shi&&qian!=ge&&bai!=shi&&bai!=ge || qian!=bai&&shi==ge&&qian!=shi&&qian!=ge&&bai!=shi&&bai!=ge || bai==shi&&qian!=ge&&bai!=qian&&bai!=ge&&shi!=qian&&shi!=ge || bai!=shi&&qian==ge&&bai!=qian&&bai!=ge&&shi!=qian&&shi!=ge || qian==shi&&bai!=ge&&qian!=bai&&qian!=ge&&shi!=bai&&shi!=ge || qian!=shi&&bai==ge&&qian!=bai&&qian!=ge&&shi!=bai&&shi!=ge){//个位与十位相同
                num++;
                System.out.print(i+" ");
                if(num%30==0) System.out.println("");
            }
        }
        System.out.println(num);

控制台输出

打印99乘法表

/**
         * 99乘法表
         */
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + i * j + "\t");
            }
            System.out.print("\n");
        }

在这里插入图片描述

计算1!+2!+…+10!

		/**
         * 1!+2!+3!++++10!==?
         */
        int sum = 0;//最终
        for (int i = 1; i <= 10; i++) {
            int sum1 = 1;//阶乘
            for (int j = 1; j <= i; j++) {
                sum1*=j;//
            }
            System.out.println(i+"的阶乘："+sum1);
            sum+=sum1;
        }
        System.out.println(sum);

在这里插入图片描述

猴子吃桃。假如一只猴子第一天摘了若干桃子，吃了一半多一个，第二天继续吃了剩下的一半多一个。。。到第十天吃了最后一个。第一天摘了几个？

        int peach =1;//最后的桃子
        for (int i = 9; i > 0; i--) {
            peach=(peach+1)*2;
            System.out.println("第"+ i +"天，有"+ peach +"桃子");
        }
        System.out.println("共有："+peach);

在这里插入图片描述

打印1-10000以内的完数。完数：如果一个数的非自身因子和等于它本身，这个数称为完数。如6的因子1+2+3=6，所以称6是一个完数如28的因子1+2+4+7+14=28，所以称28是一个完数

        for (int i = 1; i < 10000; i++) {
            int sum = 0;
            for (int j = 1; j < i; j++) {
                if (i%j==0)sum+=j;
            }
            if (sum==i){
                System.out.print(i+" ");
            }
        }

在这里插入图片描述

实现猜数游戏

选择难度：简单[1,100]，困难：[1,1000]，地狱：[1,10000]，生成指定范围内的一个数

进行猜数，如果正确游戏结束，如果错误，继续猜并告知猜大了还是小了

根据猜对时所用的次数输出中几等奖

		Scanner s = new Scanner(System.in);
        System.out.println("你想和我玩个游戏吗？？？？？？？？？？？？？？？？？？\nYES or NO");
        if (s.next().toUpperCase().equals("YES")) {
            boolean flag = true;
            System.out.print("欢迎来到幸运儿的游戏！！你会有三个选择：\n1.噩梦：你将在1 ~ 9999999中选择\n2.普通：你将在1 ~ 9999中选择\n3.简单：你将在1 ~ 99中选择\n请做出你的选择：");
            //模式
            int mode = 0;
            //范围
            int end = 1;
            //次数
            int times = 0;
            switch (s.nextInt()) {
                case 1:
                    end = 9999999;
                    break;
                case 2:
                    end = 9999;
                    break;
                case 3:
                    end = 99;
                    break;
                default:
                    flag = false;
                    System.out.println("看来你是不想玩这个游戏！！！");
                    break;
            }
            while (flag) {
                //随机数生成
                Random rd = new Random();
                int suijis = rd.nextInt(end) + 1;
                //System.out.println(suijis + "test");
                //重复玩循环
                boolean flag1 = true;
                while (flag1) {
                    System.out.print("那唯一的数字是？？--");
                    //猜数字
                    int a = s.nextInt();
                    //次数
                    times++;
                    if (a == suijis) flag1 = false;
                    else if (a > suijis) System.out.println("大了");
                    else if (a < suijis) System.out.println("小了");
                }
                if (times == 1) System.out.println(times + "次！你就是天选！");
                else if (times > 1 && times <= 3) System.out.println(times + "次！这就是命中注定！");
                else if (times > 3 && times <= 6) System.out.println(times + "次！平庸之辈！");
                else if (times > 6 && times <= 10) System.out.println(times + "次！下下之选！");
                else  System.out.println(times + "次！你玷污了我的游戏！");
                System.out.println("再来一次？？");
                if (s.next().toUpperCase().equals("YES")) flag = true;
                else {
                    System.out.println("那实在是太可惜了！！！！！！！！！！！！！！！");
                    flag = false;
                }
            }
        } else {
            System.out.println("那实在是太可惜了！！！！！！！！！！！！！！！");
        }

在这里插入图片描述

实现石头剪刀布游戏

用1-2-3表示石头-剪刀-布

用户每次输入一个数，电脑每次自动生成一个数，根据游戏规则判断输赢

三局两胜

		Scanner s = new Scanner(System.in);
        System.out.println("石头剪刀布！听过起来很简单对吧！你有三次机会！？");

        Random rd = new Random();
        String[] arr = {"石头", "剪刀", "布", "输了", "赢了", "平局"};
        boolean flag1 = true;
        while (flag1) {
            boolean flag = true;
            //次数
            int a = 0;
            //赢得次数
            int c = 0;
            //平局次数
            int d = 0;
            //重复玩
            System.out.println("1.石头\n2.剪刀\n3.布");
            while (flag) {
                if (a > 2) break;
                //随机
                int suiji = rd.nextInt(3);
                int suiji1 = rd.nextInt(3);
                System.out.print("第" + (a + 1) + "把，我出的是" + arr[suiji1] + "你呢？！你的选择是？：");
                //输入
                int shuru = s.nextInt();
                a += 1;
                switch (shuru) {
                    //你出石头
                    case 1:
                        //判断
                        switch (suiji) {
                            //随机石头
                            case 0:
                                System.out.println(arr[5]);
                                if (suiji != suiji1) System.out.println("有点脑子！");
                                d++;
                                break;
                            //随机剪刀
                            case 1:
                                System.out.println("你" + arr[4]);
                                if (suiji != suiji1) System.out.println("有点脑子！");
                                c++;
                                break;
                            //随机布
                            case 2:
                                System.out.println("你" + arr[3]);
                                if (suiji != suiji1) System.out.println("骗到你了！！我出的是" + arr[suiji]);
                                break;
                        }
                        break;
                    //你出剪刀
                    case 2:
                        switch (suiji) {
                            //随机剪刀
                            case 1:
                                System.out.println(arr[5]);
                                if (suiji != suiji1) System.out.println("有点脑子！");
                                d++;
                                break;
                            //随机布
                            case 2:
                                System.out.println("你" + arr[4]);
                                if (suiji != suiji1) System.out.println("有点脑子！");
                                c++;
                                break;
                            //随机石头
                            case 0:
                                System.out.println("你" + arr[3]);
                                if (suiji != suiji1) System.out.println("骗到你了！！我出的是" + arr[suiji]);
                                break;
                        }
                        break;
                    //你出布
                    case 3:
                        switch (suiji) {
                            //随机石头
                            case 2:
                                System.out.println(arr[5]);
                                if (suiji != suiji1) System.out.println("有点脑子！");
                                d++;
                                break;
                            //随机剪刀
                            case 0:
                                System.out.println("你" + arr[4]);
                                if (suiji != suiji1) System.out.println("有点脑子！");
                                c++;
                                break;
                            //随机布
                            case 1:
                                System.out.println("你" + arr[3]);
                                if (suiji != suiji1) System.out.println("骗到你了！！我出的是" + arr[suiji]);
                                break;
                        }
                        break;
                    default:
                        System.out.println("再给你一次机会！");
                        flag = false;
                        break;
                }


            }
            if (c == 2 || c == 3 || c == 1 && d == 2) System.out.println("这局是你赢了！");
            else if (c == 1 && d == 1 || d == 3) System.out.println("我们打平了！");
            else System.out.println("你输掉了这局");
            System.out.println("再玩Y/N？");
            if (s.next().toUpperCase().equals("Y")) flag1 = true;
            else flag1 = false;
        }

在这里插入图片描述

模拟双色球开奖购买

在这里插入图片描述

//xuanze:选择的模式手动和机选 kaijiangsleeptime：选择后多久开奖suijisseqiusleeptime：开奖显示速度

public static int[] abc(int xuanze, int kaijiangsleeptime, int suijisseqiusleeptimetime) throws InterruptedException {
        int[] tongji = new int[7];
        System.out.print("\n====================================\n1.自选\n2.机选\n选择：\n");
        Scanner s = new Scanner(System.in);
        Scanner s1 = new Scanner(System.in);
        //自选或机选
        int xz = 0;
        //控制台输入
        //xz = s.nextInt();
        xz = xuanze;//机选测试
        //选择后的数组
        int[] xuanzeseqiu = new int[7];
        if (xz == 1) {
            //自选数组
            int[] zxseqiu = new int[7];
            //只装6位
            for (int i = 0; i < zxseqiu.length - 1; i++) {
                System.out.println("选择" + (i + 1) + "第个红球：");
                //装入
                zxseqiu[i] = s.nextInt();
                //大于31，小于1
                if (zxseqiu[i] > 31 || zxseqiu[i] < 1) i--;
                //重复
                for (int j = 0; j < i; j++) {
                    if (zxseqiu[i] == zxseqiu[j]) i--;
                }
            }
            int lanqiu = 0;
            System.out.println("选择蓝球：");
            lanqiu = s.nextInt();
            while (lanqiu < 1 || lanqiu > 16) {
                System.out.println("蓝球有误！\n选择蓝球：");
                lanqiu = s.nextInt();
            }
            zxseqiu[6] = lanqiu;
            //自选色球传给选择后的数组
            xuanzeseqiu = zxseqiu;
            System.out.println("您自选的号码如下：");
            showseqiu(zxseqiu, 0);
        } else if (xz == 2) {
            //机选
            int[] jxseqiu = new int[7];
            jxseqiu = seqiu();
            //机选色球传给选择后的数组
            xuanzeseqiu = jxseqiu;
            showseqiu(jxseqiu, 0);
        } else {
            System.out.println("ERROR");
        }
        System.out.println("\n！！！！！！即将开奖！！！！！！");
        Thread.sleep(kaijiangsleeptime);
        //随机色球
        int[] kaijiang = seqiu();
        showseqiu(kaijiang, suijisseqiusleeptimetime);
        //红球中的位数
        int red = 0;
        //中奖信息
        String info = "";
        //那外层for一个一个跟内层for比较（6位red），红球中的位数++
        for (int i = 0; i < xuanzeseqiu.length - 1; i++) {
            for (int i1 = 0; i1 < kaijiang.length - 1; i1++) {
                if (xuanzeseqiu[i] == kaijiang[i1]) red++;
            }
        }
        //判断
        //中了蓝球
        if (xuanzeseqiu[6] == kaijiang[6]) {
            switch (red) {
                case 0:
                case 1:
                case 2:
                    info = "六等奖";
                    tongji[6]++;
                    break;
                case 3:
                    info = "五等奖";
                    tongji[5]++;
                    break;
                case 4:
                    info = "四等奖";
                    tongji[4]++;
                    break;
                case 5:
                    info = "三等奖";
                    tongji[3]++;
                    break;
                case 6:
                    info = "一等奖";
                    tongji[1]++;
                    break;
            }
        } else { //没中蓝球
            switch (red) {
                default:
                    info = "倒霉蛋就是你！";
                    tongji[0]++;
                    break;
                case 4:
                    info = "五等奖";
                    tongji[5]++;
                    break;
                case 5:
                    info = "四等奖";
                    tongji[4]++;
                    break;
                case 6:
                    info = "二等奖";
                    tongji[2]++;
                    break;
            }
        }
        System.out.println("\n" + info);
        for (int i : tongji) {
            System.out.print(i + " ");
        }
        return tongji;
    }
//生成双色球数组
public static int[] seqiu() {
        int[] qiu = new int[7];
        Random rd = new Random();
        qiu[6] = rd.nextInt(15) + 1;
        //外层输入数组
        for (int i = 0; i < qiu.length - 1; i++) {
            //装进去
            qiu[i] = rd.nextInt(30) + 1;
            //循环检测在i之前的数是否重复，j从索引0开始一直到i索引，如果重复，此次输入作废
            for (int j = 0; j < i; j++) {
                if (qiu[i] == qiu[j]) i--;
            }
        }
        return qiu;
    }
//显示
 public static void showseqiu(int[] qiu, int showsudo) throws InterruptedException {
        for (int i = 0; i < qiu.length; i++) {
            if (i == 0) {
                Thread.sleep(showsudo);
                System.out.print("红球号码：");
            }
            if (i == 6) {
                System.out.print("\n蓝球号码：");
            }
            Thread.sleep(showsudo);
            System.out.print(qiu[i] + " ");

        }
    }

在这里插入图片描述

//统计100次
int[] a = new int[7];
        int[] b = new int[7];
        for (int i = 0; i < 100; i++) {
            a = abc(2, 0, 0);
            for (int j = 0; j < 7; j++) {
                b[j]+=a[j];
            }
        }
        System.out.println("\n====================================");
        for (int i : b) {
            System.out.print(i + " ");
        }

在这里插入图片描述

100次只有6次六等奖

学习中遇见的问题

Scanner输入问题使用方法netInt()后netLine()会为空

ArrayIndexOutOfBoundsException数组索引错误

数组的索引下标为0~长度-1，因为直接访问Array[数组长度]索引报错，访问在范围内即可解决。

数组名[数组名.length-1];

错题解析

以下哪个数据无法使用char类型保存:c

A. ‘a’ B. 100 C. “a” D. ‘\n’

这题靠的是char类型能存储的数据，

char：赋值时可以单引号引起来的字符或一个数字，或是数字ascii中的数字或者是一个转义字符ascii码

编译运行以下程序后，关于输出结果的说明正确的是:c
public static void main(String args[ ]){
int x=4;
System.out.println(“value is “+ ((x>4) ? 99.9 :9));
}
A.输出结果为：value is 99.99 B.输出结果为：value is 9
C.输出结果为：value is 9.0 D.编译错误

三位一体，运算后的值为其中范围最大的值

以下对变量名的定义无法通过编译的是:d

A.$abc B. abc123 C. _a_b_c D.123abc

必须以字母、下划线、或者美元符$开头；以美元符$ 开头命名的变量虽然能够编译通过但是不建议使用；
中文也可以作为命名开头且编译也能通过，但是不建议使用。

下列代码段的输出结果是：c
public static void main(String[] args) {
int x = 5;
boolean b1 = true;
boolean b2 = false;
if ((x >= 4) && !b2)
System.out.print("1 ");
if (b1 && b2)

System.out.print(“3”);

System.out.print("2 ");
}

A. 2 B. 1 C. 1 2 D. 2 3

太不细心了第二个if后没有大括号

下列代码段编译和运行的结果是：d
public static void main(String[] args) {
for (int i = 0; i <= 10; i++) {

if (i > 6) break;
}
System.out.println(i);

}

A.输出 6 B.输出 7 C.输出 10 D.编译错误

输出在for循环外，变量i未定义

基础总结

因为是科班更多的是复习了一遍Java基础，理解起来很简单，要注意的是逻辑思维的锻炼，怎么用分支，怎么用循环，一个业务的整体逻辑要通顺，最好不要边写边想，用中文注释把流程走一遍了来，按着注释来写，再具体问题具体解决，千万不要，边想边写，写到一半发现整体逻辑错了，或漏了一些功能，太费时间了，也不要一个人闷头一个人想逻辑，借助网络，你所遇到的困难，你的前辈一定遇见过，多善于使用搜索引擎，这并不可耻。
再就是做题的问题，说实话IDE用多了，在纸上的代码就看起来不舒服了，做题的时候就会把{}漏看掉，没有缩进也会不好阅读，看来要锻炼下。以上