一.前提内容
0.什么是java
官方定义:Java是一门面向对象的高级编程语言,不仅吸收了C语言的各种优点,还摒弃了C里难以理解的多继承、指针等概念,因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表,极好地实现了面向对象理论,允许程序员以优雅的思维方式进行复杂的编程。Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。
通俗一点的解释:==Java是一种计算机语言,是计算机与人类沟通的语言==。当我们学会了Java语言,写一段Java代码,计算机就能明白我们想要干啥,前提是你的代码是正确的。同时Java也叫编程语言,我们使用Java编写程序,让计算机按照程序干活。学了Java我们就可以对外说我们是敲代码的,是码农,干编程的。
java语言的特点:
1.简洁有效
j ava语言是一种相当简洁的“面向对象”程序设计语言,它省略了c++语言中所有的难以理解容易混淆的特性,更加严谨简洁。
2.可以植性
不需要做太多修改,就可以在不同平台运行。
3.面向对象
面向对象的发展到现在已经形成了一个包含,面向对象的系统分析,面向对象的系统设计和面向对象的程序设计,完整体系所做为一个现代编程语言,是不能偏高“面向对象”这一方向的java语言也不咧外。
4.解释型
java语言是一种解释性语言,相当于c/c++语言来说,用java语言写出来的程序效率低,执行速度慢,但它可以通过在不同平台上运行java解释器,对java代码进行解释,来实现“一次编写,到处运行”的目标,为了达到目标,牺牲效率还是值得的,而且,现在
的计算机技术日新月异,运算速度也越来越快,用户不会感到太慢。
5.适合分布式计算
Java语言具有强大的。易于使用联网能力,非常合适开发分布式计算和程序。java应用程序可以像访问本地文件系统那样子通过URl访问远程对象。
使用java语言编写Socker通信程序比使用任何其他语言都简单,而且它还十分适用于公共网关接口(CGl)脚本的开发,另外还可以使用java小程序(Applet),java服务器页面(javaserver Page JSP)、Servlet等手段来构建更丰富的网页。
6.有较好的性能
java由于是解释性语言,所以它的执行效率相对就会慢一点,但java语言采用了下面俩种手段,使其有较好的性能。
(1)java语言源程序编写完成后,先使用java伪编译器进行伪编译,将其转换为中间码(字节码)再解释
(2)提供了一种“准实时”(Just-in-Time jit )编译器,当需要更快的速度时,可以使用jit编译器将字节码转换机器码,然后将其缓冲下来,这样速度就会更快。
7.健壮,防范于未然的特征
java语言在伪编译时,做了许多早期潜在问题的检查,,并且运行时又做了一些相应的检查,可以说是一种严格的“编译器”
它的这种“防范于未然”的手段将许多程序中的错误都扼杀在摇篮之中,经常有许多在其他语言中必须通过运行才会暴露出来的错误,在编译阶段就被发现了。
另外,在java语言中还具备了许多保证程序稳定,健壮的特性,有效的减少了错误,也使java应用程序更加健壮。
8.具备多线程处理能力
线程是一种轻量级进程,是现代设计必不可少的一种特性。多线程处理能力使程序具有更好的交互性,实时性。
java在多线程处理方面性能超群,具有让设计者惊喜的强大功能,而且在Java语言中进行多线程处理也很简单。
9.具有较高的安全性
java语言在设计时在安全性方面考虑的很仔细,使java语言成为目前最安全的一种程序设计语言。
尽管sun公司曾经许诺:通过java可以轻松构建出防病毒,防黑客的系统,但就在JDK(java Development Kit)1.0发布不久后,美国princeton大学的一组安全专家发现了Java1.0安全特性第一咧错误,从此Java安全方面的问题开始被关注。不过发现的安全隐患都很微不足道,Java开发组还称:他们对安全方面的bugs非常重视,会对这些发现的bugs立即进行修复,另外,由于sun公司开放了java解释器的细节,所以有助于通过各界力量共同发现。防范制止这些安全隐患。
10.是一种动态语言
java 是一种动态语言,表现在俩方面
java语言中可以简单查询运行的信息
java可以将新代码加入到一个正在运行的程序中。
11.是一种中兴结构
java编译器生成的是一种中性的对象文件格式,也就是说,java编译器通过伪编译后,将生成一个与任何计算机体系统无关的“中性”的字节码
java这种中性结构并不是java首创的,在java出现 之前UCSDpascal系统就已在一种商业产品中做到这一点,另外,在UCSDpascal之前也有这种方式的先例,如在Nikaus Wirth实现的 跑 ascal语言中就蔡依林这种了这种结构降低一些性能,以换取更好的可移植性和通用性的方法。
实现的pascal语言中就采用了这种结构降低一些性能,以换取更好的可移植性和通用性的方法。
java 的这种字节码经过了许多精心的设计,使其能够很好地兼容于当今大多数流行的计算机系统,在任何机器上都易于动态翻译成为机器代码。
Java程序的运行机制和Java虚拟机
计算机高级语言类型主要有编译和解释型俩种java是俩种类型的集合,在java中源文件名称的后缀为java,之后通过编译使*java的文件生成一个*。class文件,在计算机执行*。classs文件,但是此时执行*.class的计算机并不是一个物理上可以看到的计算机,而是java自己设计的一个计算机--Jvm.java 也是通过JVM进行可移植操作的。
在java中所有都是在JVM看(java Vitrual Machine ) 上运行的。JVM是在一台计算机上由软件或硬件模拟的计算机。java 虚拟机(JVM)读取并处理经编译的、与平台无关的字节码class文件,java解释器负责将java虚拟机的代码在特定的平台上运行。
java中的关键字:
abstract | assert | boolean | break | byte | case | catch |
char | class | continue | const | default | do | double |
else | extends | enum | final | finally | float | for |
goto | if | Iimplements | import | instanceof | int | inierface |
long | short | new | package | private | protected | public |
retum | short | static | synchronized | super | strictfp | this‘ |
throw | throws | transient | try | void | volatile | while |
面关键字要注意3点:
虽然 goto const 在java中并没有任何意义,却也是保留字,他们与其他关键字一样,在程序中不能用来作为自定义的标识符。
true false null 虽然不是关键字,但是作为一个单独标志类型,也不能直接使用。
assert和enum关键字是java新增的内容,assert是在jdk1.4中增加进来,而enum是在jdk1.5后增加进来的。
不用强行去记关键字,慢慢熟练运用,多加练习
习题
打印
**********************
*******java*******
********************
System.out.println("*****************");
答:
System.out.println("*******java*******");
System.out.println("*****************");
1.注释
1.注释种类 :单行注释,多行注释,文本注释。
“写注释方便阅读理解以及维护”
Ctrl + / 单行注释(对当前行进行注释)
Ctrl + Shift + / 对选中的代码进行多行注释。
2.转义符
把字符转义为原本的意思或特殊的意思。\表示转义符。
转义符 | 含义 | 用法 |
\" | 转义为原本意思 | System.out.println("\""); |
\ | 转义为制表符 | System.out.println("hello\tworld"); |
\n\ | 表示换行符 | System.out.println("你好\n\"帅哥\""); |
3.标志符
标志符就是取名字的规范 .有以下要求:
1.最好是字母、数字、下划线、$组成
2.不能以数字开头
3.不能是Java的关键字4.尽量语义化,简单明了,方便阅读
命名有:
类名首字母大写(大驼峰命名)
举例: class Student{}变量名:第二个单词开始首字母大写(小驼峰命名)
举例: double money = 6.88;
double applePrice = 7.5;
开发JAVA程序,需要三个步骤:编写代码,编译代码,运行代码
public class HelloWord{ public static void main(String[] args){ System.out.println("HelloWord!"); } }
注意:其中目录名称必须与代码一致
--------------------------------------------------------------------------------------------------------------------------------
要求:
1.安装和环境配置JDK的。
2.编写了java类原码。
---------------------------------------------------------------------------------------------------------------------------------
二.常量与变量
1.常量
常量就是在程序运行过程中,其值不可以发生改变的量(列如:var = 10)
类型 | 含义 | 数据类型 |
整数 | 所有的整数 | 0,1,567,-9 |
浮点数 | 所有的小数 | 0.0,-0.1,3.55 |
字符 | 单引号引起来,只能写一个字符,必须有内容 | 'a' , ' ' , '好' |
字符串 | 双引号引起来,可以写多个字符,也可以不写 | "A", "Hello" , "你好" ,"" |
布尔值 | 只有两个值,流程控制语句中使用 | true, false |
空常量 | 只有一个值(引用数据类型讲解)没有任何数据 | null |
2.变量
变量是用来存放程序中的数据可以改变的值。也是内存中的一块区域。
列如:
int num = 10; num = 30; sytem。out。println(“num的内容是:“+num) system。out。println(”num*num = “ + num*num) System.out.println(x);nnum的内容是30;
num * num = 900;
程序的第二行使用//声明的部分是java的注释部分,注释助于程序的阅读,它在编译时不会被编译,里面可以写任意的内容。
public class 是java 中的关键字,表示的是定义一个类,在java中所有的操作都是由类组成的,关于类的概念以后会有有点解释,Testjava是程序中类的名称。因为主办法编写在此类之中,所以本书将该类称为主类。
在同一个作用域内,不能有两个同名的变量,否则报错,变量可以定义在同一行
-
变量的定义格式:
数据类型 变量名 = 初始值;
-
变量记录的数据程序运行过程中是可以发生改变的:
变量名 = 值;
定义Demo类 class Demo{
主方法定义Demo类 public static void main (String[] args){
输出信息 System.out.println("Hello World!!!");
三.数据类型与数据转换
(1).数据类型
有四类一共8种:
1. 基本数据类型:
类型 | 数值 | 含义 |
整数 | byte short int long | 每个占用的空间大小不同,建议int |
浮点 | float double | 占用的空间以及精度不同,小数显示 |
字符 | char | 一个字符 |
布尔 | boolean | 只能表示true和false |
整数类型分四种不同的类型:
字节型(byte)、短整型(short)、整型(int)默认、长整型(long)
2. 引用数据类型:
类型 | 数值 | 含义 |
字符串 | String | 数组,函数,对象 Enum枚举 |
类 | class | |
接口 | interface |
3.数值的取值范围:
序号 | 数据类型 | 大小 | 数值范围 |
---|---|---|---|
1 | long(长整形) | 64 | -9223372036854775808~9223372036854775807 |
2 | int(整形) | 32 | -2147483648~2147483647 |
3 | short(短整形) | 16 | -32768~2147483647 |
4 | byte(位) | 8 | -128~127 |
5 | char(字符) | 2 | 0-255 |
6 | float(单精度) | 32 | -3.4E38(-3.4*10(38次方))~3.4E38(3.4(38)) |
7 | double(双精度) | 64 | -1.7E308(-1.7*10(308次方)~1.7E308(1.7*10(308次方)) |
如果输入超过本生数值数据会溢出,
声明一个整数的值,任何1及加2.
例题
class Data Demoo{
public static void main(String[] args){
int max = Integer.MAX_VALUE;
System.out.println("整型的最大值:"+max);
System.out.println("整形最大值+1:+(max+1)");
System.out.println("整形最大值+2" + (max+2));
(2)数据类型转化
小范围的数字类型可以自动转化为大范围的数字类型。
byte-->short--->int--->long--->float--->double
特殊: 字符类型可以转化为int类型。
转换又分为自动转换和强制转换。
1.自动转换
public class Test07 {
public static void main(String[] args) {
byte b=15;
short s=b;//byte类型自动转化为short
float f=s;
double d=f;
int a='A';//把字符类型自动转化为整数类型。每个字符对应一个ascii的数字
System.out.println(a);
}
}
2.强制转换
大范围的数字类型需要强制转化为小范围的数字类型。
byte<--short-<--int---long---float---double
语法: 数据类型 变量名=(数据类型) 变量;
容易出现数据溢出。
int a1=18885;
byte b1=(byte) a1; //强制转化。出现溢出
System.out.println(b1);
使用强制类型转换,防止数据溢出
public class DataDemo03{
public static void main (String[] args){
int max = Integer.MAX_VALUE:
System.out.println("整形的最大值:" +max);
System.out.println("整形最大值 + 1: " + (max+1));
System.out.println("整型最大值 + 2: " + (max+2L));
System.out.println("整形最大值 + 2:” + ((long)max+2));
}}
四.运算符
算术运算符:
进行数字运算的。包含的符号: +,-,*, /, %, ++,--
public class Test{
public static void main(String[] args) {
double a=14.0;
int b=3;
double c=a+b; //整型自动转化小数
// c=a*(b--); //++在后 1.先运算 再自身+1
c=a*(--b); //++在前 1.先自身+1 在参与运算
System.out.println("c====="+c);
System.out.println("a+b="+c);
c=a-b;
System.out.println("a-b="+c);
c=a*b;
System.out.println("a*b="+c);
c=a/b; //两个整数进行运算得到的结果还是整数
System.out.println("a/b="+c);
c=a%b; //取余
System.out.println("a%b="+c);
// --a;//递增1 a=a-1;
// System.out.println(a);
}
}
赋值运算符:
赋值运算符: =, +=,-=,/=, *=, %=
a+=b; ---- a=a+(b)
public class Test{
public static void main(String[] args) {
int a=20;
int b=10;
// a+=b; //a=a+b
// System.out.println(a);
// a-=b; //a=a-b;
// System.out.println(a);
a*=b+1; //a=a*(b+1)
System.out.println(a);
}
}
关系运算符:
关系运算符得到的结果都是boolean类型。true
public class Test{
public static void main(String[] args) {
int a=15;
int b=15;
System.out.println("a>b===="+(a>b));//false
System.out.println("a<b===="+(a<b));//false
System.out.println("a>=b===="+(a>=b));//true
System.out.println("a<=b===="+(a<=b));//true
System.out.println("a==b===="+(a==b));//true
System.out.println("a!=b===="+(a!=b));//false
}
}
逻辑运算符:
&& :俩个条件满足 || :满足其中一个条件 ! :变成相反意思
public class Test {
public static void main(String[] args) {
int a=10;
int b=15;
int c=10;
boolean f1=a<b&&b>c;//a>b返回的是true 且 a>c返回的结果也是true时
System.out.println(f1);
boolean f2=a>b||b>c;
System.out.println(f2);
boolean f3=!(a>b||b>c);
System.out.println(f3);
}
}
三目运算符:
语法:
表达式?值1: 值2
public class Test{
public static void main(String[] args) {
int age = 25;
String s = age > 18 ? "成年" : "未成年";
System.out.println(s);
}
}
位运算符:
它是关于二进制的逻辑运算符,他会对二进制每一个进行相应的逻辑运算。
了解: 把一个十进制转化为二进制。
&:与 二进制的数字都是1 返回的结果是1 如果由一个为0的则返回0
| : 或 和逻辑运算符少一个
^: 异或 相同则为0 不同则1
public class Test {
public static void main(String[] args) {
int a=5; //101
int b=4; //100
int c=a&b; //100 4
int d=a|b; //101 5
int f=a^b; //001 1
System.out.println("c==="+c);
System.out.println("d==="+d);
System.out.println("f==="+f);
}
}
五.对象
输入对象
Scanner输入对象,里面包含next(),nextInt();
next()输入字符串的
nextInt()输入整数的。
例如:
public class Test{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);//输入对象。
System.out.println("请输入姓名:");
String n=sc.next(); //在控制台输入的字符串 赋值给变量s
System.out.println("请输入年龄:");
int a=sc.nextInt();
System.out.println("你输入的内容:"+n);
System.out.println("你输入的年龄:"+a);
}
}
public class Test{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入性别:");
String sex=sc.next(); //把控制台输入的内容赋值给变量sex
System.out.println("请输入年龄:");
int age=sc.nextInt();
String r= sex.equals("女")&&age>18?"女朋友":"朋友"; //基本类型可以使用== 如果是引用类型 equals.
System.out.println(r);
}
}
输出对象
面向对象
六.条件控制语句
各位同学,今天我们学习一个全新的知识——程序流程控制。什么是流程控制呢?说白了就是控制程序的执行顺序。
先给同学们介绍一下,程序有哪些流程控制、以及Java提供了哪些方案来控制程序的执行顺序?
程序的流程控制一般分为3种:顺序结构、分支结构、循环结构
顺序结构:就是不加任何控制,代码从main方法开始自上而下执行
分支结构:就是根据条件判断是true还是false,有选择性的执行哪些代码。在Java语言中提供了两个格式if 、 switch
循环结构:就是控制某一段代码重复执行。在Java语言中提供了三种格式,for、while、do-while
il分支
if它的作用,是用于对条件进行判断,判断的结果只可能有两个值true或者false,然后根据条件判断的结果来决定执行那段代码。
在Java中if分支有三种格式
1.if 第一种形式执行流程如下:
如果 条件表达式 为true,就执行下面的语句体
如果 条件表达式 为false,就不执行
// 需求:测量用户体温,发现体温高于37度就报警。
double t = 36.9;
if(t > 37){
System.out.println("这个人的温度异常,把他赶紧带走~~");
}
2.if 第二种形式执行流程如下:
如果 条件表达式 为true,就执行下面的语句体1
如果 条件表达式 为false,就执行else下面的语句体2
// 需求2:发红包,你的钱包余额是99元,现在要发出90元
// 如果钱够触发发红包的动作,如果钱不够,则提示:余额不足。
double money = 19;
if(money >= 90){
System.out.println("发红包成功了~");
}else {
System.out.println("余额不足~~");
}
3.if 第三种形式执行流程如下:
如果 条件表达式1 为false,就继续判断条件表达式2;
如果 条件表达式2 为true,就执行下面的语句体;
如果 条件表达式2 为false,就继续判断条件语句体3;
如果 条件表达式3 为true,就执行下面的语句体3
如果 条件表达式3 为false,就继续判断后面的表达式;
....
如果前面所有条件表达式判断都为false,就执行最后的else语句中的代码
// 需求3:某个公司有一个绩效系统,根据员工的打分输出对应的绩效级别。[0,60) D [60,80) C [80,90) B [90,100] A
int score = 298;
if(score >= 0 && score < 60) {
System.out.println("您的绩效级别是: D");
}else if(score >= 60 && score < 80){
System.out.println("您的绩效级别是: C");
}else if(score >= 80 && score < 90){
System.out.println("您的绩效级别是: B");
}else if(score >= 90 && score <= 100){
System.out.println("您的绩效级别是: A");
}else {
System.out.println("您录入的分数有毛病~~");
}
switch分支
1.switch 分支的作用,是通过比较值来决定执行哪条分支代码
需求:做个电子备忘录,在控制台分别输出周一到周五的工作安排
周一:埋头苦干,解决bug
周二: 请求大牛程序员帮忙
周三:今晚啤酒、龙虾、小烧烤
周四:主动帮助新来的女程序解决bug
周五:今晚吃鸡
周六:与王婆介绍的小芳相亲
周日:郁郁寡欢、准备上班。
String week = "周三";
switch (week){
case "周一":
System.out.println("埋头苦干,解决bug");
break;
case "周二":
System.out.println("请求大牛程序员帮忙");
break;
case "周三":
System.out.println("今晚啤酒、龙虾、小烧烤");
break;
case "周四":
System.out.println("主动帮助新来的女程序解决bug");
break;
case "周五":
System.out.println("今晚吃鸡");
break;
case "周六":
System.out.println("与王婆介绍的小芳相亲");
break;
case "周日":
System.out.println("郁郁寡欢、准备上班");
break;
default:
System.out.println("您输入的星期信息不存在~~~");
}
2.判断
- 如果是对一个范围进行判断,建议使用if分支结构
- 如果是与一个一个的值比较的时候,建议使用switch分支结构
for循环
1.for循环的格式和流程
我们想要在控制台打印输出3个HelloWorld
//需求:打印3行Hello World
for(int i = 0; i < 3; i++) {
System.out.println("Hello World");
}
如下图所示,是按照下面的① ② ③ ④, ② ③ ④... 的顺序来执行的;
当②条件为true时,再依次执行③④代码,然后回到②继续判断
当②条件为false时,就结束循环
/for循环格式:
for (初始化语句; 循环条件; 迭代语句) {
循环体语句(重复执行的代码);
}初始化语句:一般是定义一个变量,并给初始值
循环条件:一般是一个关系表达式,结果必须是true或者false
迭代语句:用于对条件进行控制,一般是自增或者自减
循环语句体:需要重复执行的代码
2.for循环案例
求和:
//1.掌握使用for循环批量产生数据。
for (int i = 1; i <= 100; i++) {
System.out.println(i);
}
//2.需求:求1~100中所有整数的和
int sum = 0;
//定义一个循环,先产生1-100,这100个数
for (int i = 1; i <= 100; i++) {
//每产生一个数据,就把这个数和sum累加
sum += i; //sum = sum + i;
}
System.out.println("1-100的数据和:" + sum);
上面代码执行时:
i=1时:sum=0+1; sum=1;
i=2时:sum=1+2; sum=3;
i=3时:sum=3+3; sum=6;
i=4时:sum=6+4; sum=10;
...
i=100时: sum+=99; sum=5050
求奇数和:
需求:求1~100之间奇数的和
//1)定义一个变量用于求和
int sum1 = 0;
//2)定义一个循环产生1-100之间的奇数
for (int i = 1; i < 100; i+=2) {
// i = 1 3 5 7 ...
//3)让需要求和的数据和sum1累加,
sum1 += i;
}
System.out.println("1-100之间的奇数和:" + sum1);
上面代码执行时:
初始化sum1=0;
当i=1时:sum1+=1; sum1=1;
当i=3时:sum1+=3; sum1=4;
当i=5时:sum1+=5; sum1=9;
...
当i=99时:sum1+=99; sum1=2500
第二种
//1)首先需要定义一个求和变量,这里命名为sum2
int sum2 = 0;
//2)再遍历得到所有需要求和的数据(1~100之间的所有整数)
for (int i = 1; i <= 100; i++) {
//i = 1 2 3 4 5 6 ... 99 100
//3)在求和之前先对数据判断,如果是奇数,才和sum1累加;否则什么也不干
if(i % 2 == 1){
// i = 1 3 5 7 9 ... 99
sum2 += i;
}
}
System.out.println("1-100之间的奇数和:" + sum2);
while循环
while循环——格式和流程
// 需求:打印5行Hello World
int i = 0;
while (i < 5) {
// i = 0 1 2 3 4
System.out.println("Hello World");
i++;
}
流程
while循环案例
分析:首先由于不知道折叠多少次,我们可以选择用while循环
1)纸张的初始化厚度为0.1毫米,珠峰的高度为8848860毫米
double peakHeight = 8848860;
double paperThickness = 0.1;
2)每次折叠纸张的厚度为原来的两倍,这是需要循环执行的
while(纸张厚度<8848860){
纸张厚度*=2;
}
3)需要求折叠的次数,可以用一个变量来记录折叠的次数
int 次数 = 0;
while(纸张厚度<8848860){
纸张厚度*=2;
次数++; //每次折叠次数累加
}
结果:等循环结束之后,打印记录次数的值,就是折叠多少次了。
// 1、定义变量记住珠穆朗玛峰的高度和纸张的高度。
double peakHeight = 8848860;
double paperThickness = 0.1;
// 3、定义一个变量count用于记住纸张折叠了多少次
int count = 0;
// 2、定义while循环控制纸张开始折叠
while (paperThickness < peakHeight) {
// 把纸张进行折叠,把纸张的厚度变成原来的2倍。
paperThickness = paperThickness * 2;
count++;
}
System.out.println("需要折叠多少次:" + count);
System.out.println("最终纸张的厚度是:" + paperThickness);
do-while循环
do-while循环——格式和流程
如下图所示:do-while循环的执行流程,是按照① ②③④ ②③④... 的顺序执行的。
我们会发现,do-while循环的特点是先执行,再判断的。即使条件不成立,也会先执行一次。
1. for循环 和 while循环(先判断后执行);
do...while (先执行后判断)
2.for循环和while循环的执行流程是一模一样的,
功能上无区别,for能做的while也能做,反之亦然。
如果已知循环次数建议使用for循环,如果不清楚要循环多少次建议使用while循环。
3 for循环中控制循环的变量只在循环中使用
while循环中,控制循环的变量在循环后还可以继续使用
死循环
//for死循环
for ( ; ; ){
System.out.println("Hello World1");
}
//while死循环
while (true) {
System.out.println("Hello World2");
}
//do-while死循环
do {
System.out.println("Hello World3");
}while (true);
七.循环嵌套
循环嵌套就是在循环里面在放一个循环,实现循环嵌套。
执行流程就是 : 外部执行一次, 内部都会执行完一轮。
使用for 打印以下内容
********
********
********
********
********
i=0时; i<3为true;进入循环
//j的取值从0到5,执行一轮,打印5次“我爱你”
for (int i = 1 ; j <= 5; j++){
System.out.println("我爱你:" + i)
}
里面循环完成后, 执行外面的i++;i的值:
i=1时; i<3true: 进入循环
//j的取值从0到5,又执行一轮,打印5次"我爱你"
for(int j = 1; j <= 5; j++) {
System.out.println("我爱你:" + i);
}
内层循环执行完之后,执行外层的i++; i的值2
i=2时:i<3为true; 进入循环
//j的取值从0到5,再执行一轮,打印5次"我爱你"
for(int j = 1; j <= 5; j++) {
System.out.println("我爱你:" + i);
}
内层循环执行完之后,执行外层的i++; i的值3
i=3时:i<3为false; 外层循环结束
练习
//1)先写一个循环用来在一行中打印5个"*"
for (int j = 1; j <= 5; j++) {
System.out.print("*"); // 不换行
}
System.out.println(); //换行
System.out.println("-----------------");
//2)再将第一步的代码套一层循环,执行4次,就可以打印4行
for (int i = 1; i <= 4; i++) {
for (int j = 1; j <= 5; j++) {
System.out.print("*"); // 不换行
}
System.out.println(); //换行
}
八.跳转语句 break 。 continue
-
break作用:跳出并结束当前所在循环的执行
-
continue作用:结束本次循环,进入下一次循环
案例
// 1、break:跳出并结束当前所在循环的执行。
// 场景:假如你又有老婆了,你犯错了,你老婆罚你说:5句我爱你
// 说到第三句的时候心软了,让你别再说了。
for (int i = 1; i <= 5; i++) {
System.out.println("我爱你:" + i);
if(i == 3){
// 说明已经说完了第三句了,心软了。
break; // 跳出并结束当前所在循环的执行。
}
}
案例 2
// 2、continue:跳出当前循环的当次执行,直接进入循环的下一次执行。
// 场景: 假如你有老婆,你犯错了,你老婆罚你洗碗5天。
// 第三天的时候,你表现很好,第三天不用洗碗,但是不解恨,第四天还是要继续的。
for (int i = 1; i <= 5; i++) {
if(i == 3) {
// 已经到了第三天,第三天不用洗的。
continue;
}
System.out.println("洗碗:" + i);
}
需要注意的是break和continue不是任何地方都可以使用的
break : 只能用于结束所在循环,或者结束所在switch分支的执行
continue : 只能 在 循环 中进行使用。