java教程(2023-3-8)
第一章：HelloWorld
1.java语言介绍
public class MainTest {
public static void main(String[] args) {
//软件分为系统软件和应用软件
//人机交互方式： 图形化界面 命令行方式
/*
常用的DOS命令：
1.切换盘符：
盘符 :
2.创建文件夹
md 文件名
3.查看目录
dir
4.进入文件夹
cd 文件夹名
5.删除文件
rd 文件名
语言=语法+逻辑
第一代：计算机语言
第二代：汇编语言
第三代：高级语言
java语言概述：
java
javase java标准版
javaee java企业版
javame java小型版本
什么是jdk：
是java程序开发工具包 包含jre和开发人员使用的工具
jre是java运行时 的环境 包含jvm和运行时 所需的核心类库
运行环境就是 jvm
jdk=jre+开发工具集
jre=jvm+Java 标准类库
jdk版本的选择：
jdk版本的选择：通过企业的使用数量来确定
Spring框架来决定：使用jdk17版本来适用spring框架版本
jdk下载和安装
java官网下载jdk18
安装 安装的过程路径不要出现中文
配置path环境变量：
右键此电脑 属性 高级系统设置 环境变量 把路径赋值粘贴到变量值里面即可
建议使用java_home的方式去配置 变量名和变量值 名值对结构的方式去配置
在java进阶部分需要使用到java_home的内容
jdk17的安装
*/
//1.书写一个HelloWorld程序
//类 +类名{}
System.out.println("Hello World!");
//乱码问题 出现乱码问题 把保存类型改为ASCII
/*
1.java程序编写：
步骤1：编写 将java代码编写在.java结尾的源文件中
步骤2：编译 针对于.java结尾的源文件进行编译 格式 javac 源文件名.java
步骤3：运行 针对于编译后生成的字节码文件 进行解释运行 格式 java 字节码文件名
2.针对于编写过程说明：
class HelloWorld{
public static void main(String[] args){
System.out.println("Hello World");
}
}
其中class是关键字 表示类 后缀跟着类名称
main()方法的格式是固定的 public static void main(String[] args){}
java程序严格区分大小写
main方法是程序的入口 如果非要有变化 只能变化String[] args结构 可以写成 String args[]
args全称为 argument 简写为args
从控制台输出数据的操作：
System.out.pringtln("Hello World");
每一条语句必须以分号结束
System.out.print(); 区别就是换行和不换行的问题
3.编译：
如果编译不通过 可以考虑的问题：
1.查看编译的文件名 文件路径是否错误
2.查看代码中是否存在语法问题
编译以后会生成一个或多个字节码文件 每一个字节码文件对应一个java类
针对于运行的说明：
我们是针对于字节码文件对应的java类进行解析运行的 要注意区分大小写
可能存在运行时 异常 在第九章中去解决
一个源文件中可以声明多个类 但是最多只能有一个类实用public进行声明 且要求声明为public的类名与源文件名相同
注释和单行注释：
// 单行注释
文档注释(java特有)
针对于单行注释和多行注释 其作用就是起到解释说明的作用
对程序进行调试
注意：
单行注释和多汗注释中的信息不参与编译
注释不能嵌套注释 不能嵌套使用
文档注释：
文档注释内容可以被jdk提供的工具 javadoc所解析 生成一套网页文件形式的体现该程序的说明文档
javaapi文档：
jdk的说明书 帮助文档 类似于字典
java核心机制：
java优点：跨平台性
面向对象性
安全性
简单性
高性能
功能说明：
jvm 是一个虚拟的计算机 是java程序的运行环境 jvm具有指令集并使用不同的存储区域
自动的内存管理 内存分配 内存回收
*/
/*
@author math
@version 1.2.2
*/
System.out.println(1+3);
System.out.println(1/0);
System.out.println("姓名：吴邪");
System.out.println("地址：吴山居");
System.out.println("职业：盗墓");
/*
复习：
java基础学习：
第一阶段 java基本语法
java概述 关键字 标识符 变量 运算符 流程控制 条件控制 选择结构 循环结构 数组
第二阶段：java面向对象
类及类的内部成员
面向对象三大特征
其他关键字的使用
第三阶段：java高级应用
异常处理 多线程 io六 集合框架 放射 网络编程 新特性 其他api
软件开发相关内容：
硬件+软件
软件 即一系列特点序列组织的计算机数据和指令的集合 有系统软件和应用软件之分
系统软件：即操作系统 window Linux Android
应用软件：即os之上的应用程序
人机交互方式：图形化界面（GUI）
命令行交互方式： dir 传递 cd.. cd/ cd\ md rd等
计算机编程语言
语言的分代：
第一代：机器语言
第二代:汇编语言
第三代：高级语言
面向对象的语言 c++ java python go JavaScript
面向过程的语言
java的一个发展史：
jdk1.0
环境的搭建：
jdk jre jvm
环境变量的配置 尽量配置java_home
hello world的编写：
class Tets{
public static void main(String[] args ){
System.out.println("你好");
}
}
面试题：
1.一个.java源文件是否可以包括多个类 ？有什么限制？
--是的
限制是有且仅有一个类实用public进行声明
且要求声明为public的类的类名与源文件名相同
2.java的优势：
跨平台性
安全性
简单性
高性能
面向对象性
健壮性
java的社区体系比较繁荣
3.java中是否存在内存溢出 内存泄漏 如何解决 ？举例说明
存在
内存泄漏
4.如何看待java是一门半编译半解释语言：
*/
}
}
第二章：变量与运算符
1.标识符
class A{
public static void main(String[] args){
/*
java关键字：
被java语言赋予了特殊的含义 用做专门用途的字符串(或单词)
例如： class public void null true等
标识符：
--测试标识符的使用：
什么是标识符：
比如类名 方法名 变量名 包名 常量名
标识符的命名规则：
--由26个英文字母组成 0-9 —— $组成
数字不可以开头
不可以使用关键字和保留字 但能包含关键字 和保留字
java中严格区分大小写 长度无限制
标识符不能包含空格
3.规范：
标识符的命名规范：
包名 多个单词组成时 所有字母都小写
类名 接口名 ：多单词组成时 所有的单词的首字母大写
变量名 方法名：多单词组成时 第一个单词首字母小写 第二个单词开始就大写
常量名：驼峰命名法
*/
System.out.println("计算机科学与技术学院");
int age=90;
String name="吴邪";
System.out.println("姓名："+name+"年龄："+age);
/*for(int i=0;i<100;i++){
System.out.println("你好 计算机科学与技术学院");
}*/
B b=new B();
b.test();
}
}
class B{
void test(){
System.out.println("你好 我是类B中的方法！ 计算机科学与技术学院");
}
}
2.变量
class A{
public static void main(String[] args ){
/*
变量：
变量是程序中不可缺少的组成单位 最基本的存储单元
内存中的一个存储单位 该区域的数据可以在同一个类型分为中不断变化
变量的构成 包含三个要素：数据类型 变量名 存储的值
java中变量的声明的个数：数据类型 变量名=变量值
int age=19;
变量的作用：用于在内存中保存数据
使用变量注意：
java中的变量按照实际类型来分类：
基本数据类型（8种）：
整型：byte short int long
浮点型：float double
字符型：char
布尔型：boolean
引用类型：
类(class)
数组(array)
接口(interface)
枚举(enim)
注解(annotation)
记录(record)
定义变量时 变量名要遵循标识符命名的规范和规则
说明：
变量都有其作用域 变量在作用域里面是有效的 出了作用域就失效了
在同一个作用域内 不能声明两个同名的变量
变量在赋值时 必须满足变量的数据类型 并且在数据类型有效的范围内变化
*/
int age=90;//这个就是变量的初始化
char gender='男';//变量的声明
//综合来看 变量的初始化和声明可以合并起来
//因此可以使用以下方法：
int boy=1289;//这个就是同时声明和初始化变量
System.out.println("年龄为："+age);
B b=new B();
b.test();
//num=10;//这个由于在声明类型 即当前num变量没有提前定义 所以编译不通过
}
}
class B{
void test(){
System.out.println("我是 test方法");
int a=0;
int b=0;
System.out.println(a+b);
}
}
3.整型数据类型的使用
class A{
public static void main(String[] args ){
/*
整型数据类型的使用：
整型和浮点类型的使用：
byte(1字节=8bit) short(2字节) int(4字节) long(8字节)
*/
byte b1=12;
byte b2=127;
//byte b3=128;//编译不通过 超过了byte的存储范围
System.out.println("你好 计算机科学与技术");
short s1=122393;
int i=123393;
//1.声明long类型变量 时 需要提供后缀 后缀为小写l
long n=122338L;
//在开发中 定义整型变量 没有特殊情况 通常定义为int类型0、
}
}
4.浮点类型使用
class A{
public static void main(String[] args){
/*
foloat/double
*/
double i=12.3;
//声明long类型变量时 需要提供后缀 后缀为‘f’ 或‘F’
float j=212.2f;
System.out.println(i+j);
//在开发中 大家定义浮点型变量时 没有特殊情况的话 通常都声明double类型 因为精度更高
//float类型表示数的范围要大于long类型的表示范围 当时精度不高
//浮点数的精度不高 如果在开发中需要使用精度较高的精度 需要使用BigDecimal类替换浮点型变量
}
}
class A{
public static void main(String[] args)
{
//案例一：
//定义圆周率并赋值为3.14 现在有3个圆的半径为1.2 2.5 7 则他们的面积
//定义圆周率变量：
double pi=3.14;
//定义三个圆的半径
double radius1=1.2;
double radius2=2.5;
double radius3=7;
//计算面积：
double area1=pi*radius1*radius1;
double area2=pi*radius2*radius2;
double area3=pi*radius3*radius3;
System.out.println("圆面积1为："+area1+"圆面积2为："+area2+"圆面积3为："+area3);
//案例二：将华式温度转换为摄氏度 c=(F-32)/1.8
double F=80.0;
double c=(F-32)/1.8;
System.out.println("华温度："+c);
}
}
5.字符类型的使用
class A{
public static void main(String[] args){
//测试字符类型和布尔类型的使用
//1.字符类型 char(2字节)
//表示形式1：
//使用一对''表示 内部有且只能有一个字符串
char c1='a';
char c2='中';
System.out.println(c1+c2);
//表示形式2:直接使用Unicode值表示字符型字符型常量 '\uXXXX'
char c8='\u0036';
System.out.println("+"+c8);
//表示形式3：使用转义字符
char c9='\n';
char c10='\t';
System.out.println(c9+c10);
//表现形式4：使用具体的字符对应的数值(比如ASCII码)
char a=1;
}
}
6.布尔类型的使用
class A{
public static void main(String[] args){
/*
布尔值类型 Boolean
只有两个值 true false
*/
boolean b1=true;
boolean b2=false;
//1.常使用在流程控制语句中 比如 条件判断 循环结构
if(b1)
{
System.out.println("计算机");
} else{
System.out.println("你好");
}
//我们不谈Boolean类型占用空间的大小 但是在内存中分配的话 使用的是4个字节
}
}
7.基本数据类型变量间的自动类型提升规则
class A{
public static void main(String[] args){
/*
基本数据类型变量的运算规则
1.这里提到可以做运算的基本数据类型有7种 不包含Boolean类型
2.运算规则：
自动类型提升
强制类型转换
3.规则：
当容量小的变量与容量大的变量做运算时 结果自动转换为容量大的数据类型
说明：
此时的容量小或大 并非指内存空间的大小 而是指表示数据的大小
long(8字节) float(4字节)
byte-->short--->int--->long-->float1-->double
特殊情况：
byte，short--->int--->long-->float1-->double
*/
int i1=10;
long i2=i1;
byte b1=12;
int i3=b1;
//特殊的情况下：
byte b3=12;
short s1=10;
short s2=b3+s1;//这个编译不通过 最小要使用int来接收
//特别的：byte short类型的变量之间做运算 结果为int类型
//特殊情况2：char
char c1='a';
char c2=c1+b3;//这个也是编译不通过 最小用int
}
}
8.基本数据类型转换规则
class A{
public static void main(String[] args){
/*
强制类型转换：
规则：将取值范围小（或容量小）的类型自动提升为取值范围大（或容量大）的类型
1.强制类型转换需要使用强转符 () 在()内指明要转换为的数据类型
2.强制类型转换过程中可能导致精度损失
*/
double d1=19;
int i1=(int)d1;
long i2=120;
short s2=(short)i2;
System.out.println(s2);
double n=28829.21212;
int y=(int)n;
System.out.println(y);//这个就是导致了精度损失
}
}
9.String类的基本使用
class StringTest{
public static void main(String[] args){
/*
1.String类 属于引用类型 俗称字符串
2.String类型的变量 可以使用一对""方式进行赋值
3.String声明的字符串可以包含0个多个字符
String与基本数据类型的运算
包括布尔在内的有8种
String与基本数据类型运算只能做连接运算 使用+来表示
运算的结果是String类型
*/
String str1="hello World";
String str2="hello World";
System.out.println(str1==str2);//true
String str=str1+str2;//做连接运算
System.out.println(str);
//引用数据类型不不能转换为基本数据类型
//需要实现的话 可以使用Integer
int num3=Integer.parseInt(str);
System.out.println(num3+1);
}
}
10.String课后练习
class StringExer{
public static void main(String[] args){
String name="吴邪";
int age=24;
String gender="男";
double weight=120.89;
boolean isMarried=false;
String phonNumber="121212";
System.out.println("姓名\t"+name+"\t性别\t"+gender+"\t体重\t"+weight+"\t单身？\t"+isMarried+"\t电话号码\t"+phonNumber);
}
}
11.常见的进制及换算
class BinaryTest{
public static void main(String[] args){
/*
1.二进制;
*/
int num1=103;//十进制
int num2=0b011;//二进制
int num3=023;//八进制
int num4=0x2a;//十六进制
System.out.println(num1);
System.out.println(num2);
System.out.println(num3);
}
}
12.算数运算符
class Arithmetic{
public static void main(String[] args){
/*
1. + - * /
2.
*/
int m1=12;
int n1=5;
int a=m1/n1;
System.out.println(a);//因为变量是整型 所以强制转换 等于2
System.out.println(a*10);
//取模运算：%
int i=18;
int j=5;
System.out.println(i%j);//取余数 在开发中 经常用来判断是否能整除 一个数
//前++ 表示自增1
//先加加 先自增一 在赋值
int a1=10;
int b1=++a1;
System.out.println("\ta1\t"+a1+"\tb1\t"+b1);
//后++ 表示自增1
//先赋值 后自增一
int a2=100;
int b2=a2++;
System.out.println("\ta2\t"+a2+"\tb2\t"+b2);
//前-- 先自减一 在运算
//后-- 先运算 在自减一
System.out.println("********************************");
//提取一个三位数的个位 十位 百位
int num=153;
int ge=num%10;//个位
int shi=num/10/10;//十位
int bai=num/100;
System.out.println("\t个位\t"+ge+"\t百位\t"+bai+"\t十位\t"+shi);
}
}
13.赋值运算符
class SetValue{
public static void main(String[] args){
/*
/*赋值运算符：
1.= -= += /= %=
2.当两侧数据类型不一致 可以使用自动类型转换或使用强制类型转换原则进行处理
3.支持连续赋值
*/
int i=7;
long l=10;//自动类型提升
//1. +=
int m1=10;
m1+=5;//m1=m1+5
System.out.println(m1);
//这些操作不会改变变量本身的类型
byte by1=10;
by1+=5;//编译=编译+5操作会报错
System.out.println(by1);
int m2=1;
m2*=0.1;//m2=m2*0.2
System.out.println(m2);
}
}
14.比较运算符
class Compare{
public static void main(String[] args){
/*
1.== ！= < > >= <= 适用于除Boolean类型之外的其他7种基本数据类型
instanceof 在面向对象多态性
运算的结果为布尔型
补充：== != 适用于引用数据类型
2.区分 ==与= 一个是等于号 一个是赋值号
*/
int m1=10;
int m2=20;
System.out.println(m1 );
System.out.println(m2);
m1=m2;
boolean i= m1>m2;
System.out.println(i);
System.out.println(m1);
System.out.println(m2);
}
}
15.位运算符
class BigTest{
/*
位运算符：
*/
public static void main(String[] args){
//1.<< >> & |^ `
// 1针对数值类型的变量或常量进行运算 运算的结果也是数值
// 2.每向左移动因为 结构就是在原有的基础上*2（对于正数和负数都适用）
//对于右移运算：
//在一定范围内 每向右移动一位 结构就在原有的基础上/2 (对于正数负数都适用)
int num=7;
System.out.println("左移2位"+(num<<2));
System.out.println("右移2位"+(num>>2));
int num2=-7;
System.out.println("负数左移动1位"+(num2<<1));
System.out.println("负数右移动2位"+(num2>>2));
//无符号右移 >>>
//逻辑&
System.out.println(0&1);
//按位取反 0-1 1-0
System.out.println(~1101);
}
}
16.条件运算符
class ConditionTest{
public static void main(String[] args){
/*
条件运算符
-1.(条件表达式)?表达式1:表达式2
2.说明条件表达式结果是布尔
条件表达式结果为true 执行表达式1 否则表达式2
表达式1和表达式2需要的是相同的类型或兼容的类型
*/
String info= (2>1)?"你好":"你不好";//返回的结果类型取决于表达式的类型
System.out.println(info);
//获取两个整数的较大值
int m=20;
int n=10;
int max= (m>n)?m:n;
System.out.println("最大值是："+max);
//获取三个数的最大值
int i=20;
int j=30;
int k=40;
//先找到两个数中最大值
int tempMax=(i>j)?i:j;
int finalMax= (tempMax>k)?tempMax:k;
System.out.println("最终最大值为："+finalMax);
//字符集：
}
}
17.第二章：复习
/*
关键字，保留字
关键字：被java赋予特殊含义的字符串
官方规范有50个关键字
true false null虽然表示关键字 但是可以当做关键字来看待
保留字 goto const
标识符：
反是直接可以命名的地方都是标识符
比如类名 变量名 方法名 包名 常量名
记住 标识符命名的规则必须要遵守 否则编译不通过
记住：标识符的命名规范
见名知意
1.变量基本使用
三个要素 数据类型 变量名= 变量值
2.基本数据类型变量的使用
基本数据类型 整型 浮点型 字符型 布尔型
3.基本数据类型变量间的运算规则
4.基本类型提升
5.强制类型转换
6.String类的使用 与基本数据类型变量间的运算
7.关于进制间的认识
正数：原码 反码 补码三码相同
负数：原码 反码 补码不相同
8.运算符 算数运算符 赋值运算符 比较运算符 逻辑运算符 位运算符 条件运算符
面试题：
1.高效的计算2*8
使用位运算<<
2.&和&&区别
3.java中的基本数据类型 String是最基本的数据类型吗?
8种基本数据类型 String表示基本数据类型 是引用类型
4.java开发中计算金额使用什么数据类型
不能使用float或double 因为精度不够
使用BigDecimal替换 可以实现任意精度的数据运算
5.char类型变量中能不能存储一个文字 为什么
可以存储一个汉字 因为char使用Unicode字符集 包含了世界范围的所有的字符
6.代码分析：
short s1=1;
s1=s1+1 因为等号的右边是int类型 需要强转
short s1=1;
s+=1;//这个没有错
7.布尔占几个字节：
我们不谈几个字节 但是jvm在给布尔类型分配空间 布尔类型的变量占据四个字节
*/
第三章：流程控制语句
1.else-if语句
class ifElseTest{
/*
1分支结构：if-else条件判断语句
语法：
if(条件表达式){
代码块1;
}else{
代码块2;
}
if(条件表达式1){
}
else if(条件表达式2){代码块}
else if(条件表达式3){代码块}
else if(条件表达式4){代码块}
else{代码块}
*/
public static void main(String[] args){
int hearBeats=89;
if(hearBeats>=60&&hearBeats<100){
System.out.println("你需要检查！");
}else{
System.out.println("你不需要检查！");
}
//定义一个整数 判断是偶数还是奇数
int num=13;
if(num%2==0){
System.out.println("是偶数");
}else{
System.out.println("不是偶数");
}
//成绩100分 奖励车
//成绩90-99 奖励自行车
//成绩60-80 奖励旅游
int score=62;
if(score>60&&score<80){
System.out.println("旅游");
}else if(score>90&&score<99){
System.out.println("奖励自行车");
}else if(score==100){
System.out.println("奖励跑车");
}else{
System.out.println("继续努力！");
}
/*
多个表达式之间没有交集 则那个表达式那个在上面，那个在声明
下面都可以
如果多个表达式之间是包含关系 则需要将范围小的表达式声明在分为大的表达式上面
否则范围小的条件表达式不会被执行
*/
}
}
2.if-else嵌套使用
class ifElse{
public static void main(String[] args){
/*
从键盘输入三个整数 num1 num2 num3 对他们进行排序 并从小到大输出
*/
int num1=2,num2=2,num3=7;
int temp;
if(num1>num2){
if(num3>=num1){
System.out.println(num2+"**"+"**"+num1+"**"+num3);
}else if(num3<num2){
System.out.println(num3+"**"+""+num3+"***"+num1);
}else{
System.out.println(num1+"***"+num3+"***"+num2);
}
}else{
if(num3>=num2){
System.out.println(num1+""+num2+""+num3);
}else if(num3<num2){
System.out.println(num3+""+num1+""+num2);
}else{
System.out.println(num1+""+num3+""+num2);
}
}
}
}
3.输入类Scanner的使用
import java.util.Scanner;
class ScannerTest{
/*使用Scanner获取不同数据类型的步骤*/
public static void main(String[] args){
//1.使用Scanner获取不同数据类型的步骤
/* --导包 import java.util.Scanner
--提供或创建一个scanner；类的实例
--调用scanner类中的方法 获取指定类型的变量
--关闭资源
*/
//输入数字 来判断是否成年 壮年 老年
Scanner i=new Scanner(System.in);//创建类的实例
System.out.println("请输入！");
int age= i.nextInt();//调用类里面的方法
/*
输入方法 nextXXX();
*/
if(age<18){
System.out.println("你还未成年！");
System.out.println("你的年龄"+age);
}
System.out.println("请输入体重！");
double height=i.nextDouble();
if(height>90){
System.out.println("你要减肥了！");
}
/*
Scanner类中提供了获取 byte short int longfloat double Boolean String
注意：没有提供获取char的方法 如果需要的话 就是使用next().charAt(0);
*/
//关闭资源
i.close();
}
}
4.随机数
/*
如何获取一个随机数
*/
class RandomTest{
public static void main(String[] args){
//1.可以使用java提供java提供的api方法 Math类的Random方法
//random()调用以后会返回一个0.0到1.0范围的随机数
double di=Math.random();
System.out.println(di);
//获取一个0到100的随机数
System.out.println("0到100内的随机数："+(int)(di*100));
//获取[a,b]之间的随机数 (int) (Math.random())*(b-a+1)*a
}
}
5.switch-case的基本使用
class SwitchTest{
public static void main(String[] args){
/*
选择结构的使用：
1.语法格式
switch(表达式){
case 常量1：
//执行语句1;
break;
case 常量2：
//执行语句2;
break;
case 常量3：
//执行语句3;
break;
....
case 常量n：
//执行语句n
break;
default:
//语句
}
执行过程：
根据表达式中的值依次匹配case语句 一旦与某个case中的常量相等
就执行此case中的语句 执行完成之后
情况一：
遇到break 则执行break后 跳出当前的switch结构
情况二：没有遇到break 则继续执行其后的case语句
.....直到遇到break 或者执行完成所有的case及default中的语句 退出当前的switch-case语句
3.
*/
int num1=1;
switch(num1){
case 1:
System.out.println("你好啊");
break;
case 2:
System.out.println("你不好！");
break;
case 3:
System.out.println("计算机科学与技术");
default:
System.out.println("计算机软件工程");
}
}
}
6.for循环语句
class ForTest{
public static void main(String[] args){
/*
1.java中规范了三种循环结构： for while do-while
2.凡是循环结构一定湖有四要素：
1.初始化条件
2.循环条件--->重要 一定是要布尔类型的变量或者表达式
3.循环体
4.迭代条件
3.for循环的格式
for(初始化条件部分;循环条件;迭代条件){
循环体;
}
执行过程 初始化条件 循环条件 循环体 迭代条件 --初始化条件 循环条件 循环体 迭代条件 以此类推继续走
直到不满足循环条件
*/
//案例：输出100行的HeLloWorld
for(int i=0;i<100;i++){
System.out.println("HelloWorld！");
}
System.out.println("********************");
for(int j=0;j<100;j=j+1){
System.out.println("HelloWorld！");
}
System.out.println("******************");
/* int num=1;
for(System.out.println("a");num<3;System.out.println("c");num++){
System.out.println("b");//输出结果为abcbc
}*/
//需求3：遍历0-100以内的偶数 获取偶数的个数
int count=0;//记录偶数的个数
int sum=0;
for(int i=0;i<=100;i++){
if(i%2==0){
System.out.println("偶数为："+i);
count++;
}
sum+=i;//sum=sum+i 统计偶数的和
}
//输出偶数的个数
System.out.println("偶数个数为："+count);
System.out.println("偶数的和为："+sum);
}
}
/*
循环语句：
for
while
do-while
*/
7.for循环练习
class ForTest2{
public static void main(String[] args){
/*
输出所有的水仙花数 所谓水仙花数是指三位数 其各位上数字的立方和等于其本身
*/
//先遍历三位数
for(int i=100;i<999;i++){
//针对于每一个三位数 获取其个位上数值
int num1=i%10;
int num2=i/10%10;//取出10位
int num3=i/100;
//判断是否满足水仙花数的规则
if(i==num1*num1*num1+num2*num2*num2+num3*num3*num3){
System.out.println("水仙花数为："+i);
}
}
}
}
8.练习2：
class ForTest3{
public static void main(String[] args){
/*
输入两个正整数 m和n 求最大公约数和最小公倍数
*/
int m=12;
int n=20;
for(int i=1;i<12;i++){
//最大约数
if(m%i==0&&n%i==0){
System.out.println(i);
}
// System.out.println(i);
}
}
}
9.while循环的使用及练习
class WhileTest{
public static void main(String[] args){
/*
while 循环：
初始化条件
循环条件
循环体
迭代部分
while(循环条件)的格式：
{
循环体
迭代部分;
}
*/
//打印100遍HelloWorld
int i=0;
while( i<100){
System.out.println("HelloWorld");
i++;//这个一定要书写 不然就是死循环
}
}
}
import java.util.Scanner;
class WhileTest{
public static void main(String[] args){
/*
随机生成一个随机数 猜这个随机数多少
从键盘输入数 提示大了 如果小了 就提示小了 如果对了 就不要在猜了
并统计一共猜了多少次
提示：生成一个[a,b] 范围的随机数的方式 （int）(Math.random)*(b-a+1)+a)
*/
//1.生成一个1-100内的随机整数
int target=(int)(Math.random()*100)+1;
//2.使用Scanner 从键盘输入数
Scanner sc=new Scanner(System.in);
//3.使用循环结构 进行多次循环的对比和获取数据
System.out.println("请输入0-100内的数！");
int guss=sc.nextInt();
int guessCount=0;
while(target!=guss){
if(guss>target){
System.out.println("你输入的数据大了！");
}else if(guss<target){
System.out.println("你输入的数据小了！");
}
System.out.println("请输入0-100内的数！");
guss=sc.nextInt();
guessCount++;
}
//能结束循环 就意味着random和guess相等了
System.out.println("猜对了");
System.out.println("你共猜了"+guessCount+"次");
//关闭资源
sc.close();
}
}
class WhileTest2{
public static void main(String[] args){
/*
世界最高的山是珠穆朗玛峰 它的高度是8848米 假如我有一张足够大的纸
它的厚度是0.1毫米 请问 我折叠多少次 它可以折成珠穆朗玛峰的高度
*/
//1.声明珠穆朗玛峰的高度 纸的默认厚度
double paper=0.1;//单位毫米
double height=8848860;//单位毫米
int count=0;
//2.通过循环结构 不断调整纸的厚度 当纸的高度超过珠穆朗玛峰高度时停止循环
while(paper<=height){
paper*=2;
count++;
}
//3.定义变量来记录折纸的次数
System.out.println("纸的高度为："+(paper/1000)+"超过了珠穆朗玛峰的盖度");
//4.删除折了多少次：
System.out.println("折了多少次："+count);
}
}
10.do…while循环
class DoWhileTest{
public static void main(String[] args){
/*
do...while()循环：
格式：
do{
循环体;
}while(循环条件);
执行过程：
先判断后执行 初始化条件 循环体 迭代部分...
说明：
do..while()循环 至少执行一次循环体
*/
//遍历100以内的偶数 并且输出偶数的个数和总和
int i=1;
int sum=0;
int count=0;
do{
if(i%2==0){
System.out.println("偶数是："+i);
sum+=i;//偶数和
}
i++;
count++;
}while(i<=100);
System.out.println("偶数和为:"+sum);
System.out.println("次数为："+count);
}
}
import java.util.Scanner;
class doWhileTest{
public static void main(String[] args){
/*
do..while()循环在开发中使用的比较少
声明变量balance 并且初始化为0 用来表示银行账户余额 下面通过atm取款机来实现
===ATM===
1.存款
2.取款
3.显示余额
4、退出
请 选择 1-4
*/
//3.使用Scanner获取用户的选择
Scanner sc=new Scanner(System.in);
//1.定义变量
double balance=0;
boolean flag=true;//控制循环的结束
do{ //2.声明atm收款的界面
//就是四条输出语句
System.out.println("=======ATM取款机=======");
System.out.println("1.存款");
System.out.println("2.取款");
System.out.println("3.显示余额");
System.out.println("4 退出");
System.out.println("=======================");
//4.根据用户的选择 决定执行存款 取款 显示余额 退出等操作
int slection=sc.nextInt();
switch(slection){
case 1:
System.out.println("请输入存款金额！");
double money1= sc.nextDouble();
if(money1>0){
balance+=money1;
}
System.out.println("存钱成功！");
break;
case 2:
System.out.println("请输入取款金额！");
double money2=sc.nextDouble();
if(money2>0&&money2<=balance){
balance-=money2;
}
else{
System.out.println("输入的余额有误 或不足 请重新输入！");
}
System.out.println("存钱失败！");
break;
case 3:
System.out.println("账户余额为："+balance);
break;
case 4:
flag=false;
System.out.println("正在退出！欢迎使用~~");
break;
default:
System.out.println("输入有误！");
}
}while(flag);
//关闭资源
sc.close();
}
}
11.死循环使用
import java.util.Scanner;
class dieTest{
public static void main(String[] args){
/*
无限循环结构的使用：
1.格式 while(true){代码块..}
for(;;){代码块...}
*/
/*while(true){
System.out.println("你好 计算机科学与技术！");
}
for(;;){
System.out.println("你好！");
}
}
*/
//案例：从键盘输入个数不确定的整数 并判断读入的正数和负数的个数 输入为0结束
Scanner sc=new Scanner(System.in);
int postCount=0;//记录正数的个数
int negatCount=0;//记录负数的个数
while(true){
System.out.println("请输入一个整数");
int num=sc.nextInt();//获取用户输入的整数
if(num>0){
//整数
postCount++;
}else if(num<0){
negatCount--;
}else{
System.out.println("程序结束！");
break;
}
}
System.out.println("正数的个数为："+postCount);
//sc.colse();//关闭资源
}}
12.循环嵌套的使用
class ForForTEst{
public static void main(String[] args){
/*
嵌套循环的使用：
1.嵌套循环 是指一个循环结构A的循环体内是另一个循环结构B
--外层循环 ：循环结构A
--内层循环：循环结构B
内层循环充当了外层循环的循环体
对于两层循环来说 外层循环控制行数 内层循环控制列数
举例：外层循环执行m次 内层循环执行循环体执行m*n次
实际开发中 我们不会出现三层以上的嵌套循环
*/
for(int i=0;i<100;i++){
for(int j=0;j<i*j-1;j++){
System.out.println("**");
}
System.out.println();
}
}
}
class ForForTest{
public static void main(String[] args){
/*
使用循环嵌套打印一个菱形
*/
for(int i=1;i<=5;i++){
for(int j=1;j<=10-2*i;j++){
System.out.println("-");
}
for(int k=1;k<=2*i-1;k++){
System.out.println("* ");
}
System.out.println("");
}
}
}
class ForForTest{
public static void main(String[] args){
/*
使用循环嵌套打印一个菱形
*/
/*for(int i=1;i<=5;i++){
for(int j=1;j<=10-2*i;j++){
System.out.println("-");
}
for(int k=1;k<=2*i-1;k++){
System.out.println("* ");
}
System.out.println("");
}
*/
for(int i=1;i<=9;i++){
for(int j=0;j<=i;j++){
System.out.print(i+"*"+j+"="+i*j+"\t");
}
System.out.println();
}
}
}
13.关键字break和continue的使用
class BreakContiuneTest{
public static void main(String[] arg){
/*
break和continue关键字的使用：
break： 在循环结构中是结束当前循环结构 在此关键字的后面不能书写输出语句
switch-case
循环结构
continue： 结束当次循环
循环结构中
*/
for(int i=1;i<10;i++){
if(i%4==0){
continue;
}
else{
break;//直接结束循环
}
//System.out.println(i);
}
leable:for(int j=0;j<10;j++){
if(j%4==0){
System.out.println("第一个数是"+j);
break leable;//这个就是显式的结束for循环 用于循环层数过多选择结束
}else{
System.out.println("其他数"+j);
}
}
}
}