java循环

package com.momo.demo;

import java.util.Scanner;

/*

• 注意：做判断的时候不仅要考虑正确数据，边界数据，错误数据
• */

public class Demo1 {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("输入成绩：");

int score = sc.nextInt();

/* if(score>=85&&score<=100){ System.out.println("A"); } else if (score>=75&&score<85) { System.out.println("B"); } else if (score>=60&&score<75) { System.out.println("C"); }else if(score>=0&&score<60){ System.out.println("D"); } else { System.out.println("输入不合法"); }*/ if(score<0||score>100){ System.out.println("不合法"); }else{ if(score>=85&&score<=100){ System.out.println("A"); } else if (score>=75&&score<85) { System.out.println("B"); } else if (score>=60&&score<75) { System.out.println("C"); }else{ System.out.println("D"); } }

}

}

-练习：键盘输入月份，输入对应季节(3种写法)

一，选择结构

1，switch

-格式：

switch(表达式){

case 值1:

语句体1;

break;

case 值1:

语句体1;

break;

.....

default:

语句体n+1;

break;

}

-解释：

表达式的取值：byte，short,int,char,枚举，String

case后面的值是将来和表达式进行比较的值

break表示中断，结束switch语句

default 表示所有的值都不匹配的时候执行default对应的语句体

和if种的else类似

-流程：

先计算表达式的值

然后和case的值依次比较，一旦有对应的值，就执行对应的语句体

遇到break就会结束switch语句，执行switch之外代码

如果所有的case值都不匹配，最后执行default语句对应的语句体

-注意：

case后面只能是常量，不能是变量，

多个case后面的值不能一样

default可以不写，不建议，除非判断的值是几个固定的值

break也不可以不写，不建议，可能会产生case穿透问题

default不一定要最后，没有省略break放在哪里都没有关系

如果省略了break，那么可能影响代码的结果

switch语句的结束条件

遇到break

执行到程序末尾

package com.momo.demo;

import java.util.Scanner;

public class Demo2 {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

String s = sc.nextLine();

switch (s){ case "A": System.out.println("a"); break; case "B": System.out.println("b"); break; default: System.out.println("sdfsdf"); // break; } }

}

package com.momo.demo;

import java.util.Scanner;

public class Demo3 {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

int i = sc.nextInt();

char ch = (char) i;

switch (ch){

case 'A':

System.out.println("aaa");

break;

case 'B':

System.out.println("bbb");

break;

}

}

}

-练习：键盘输入月份，输出对应季节(2种写法)

2，在判断的时候，有2种选择if和switch 那么，以后判断的时候到底用哪个？ -区别： if的场景： 针对boolean判断 针对范围判断 针对常量值判断 switch场景： 针对常量值判断

package com.momo.demo;

//输出5次 我爱美女

/*

• 如果次数很多很多呢？ 基本做法就不合适了
• 代码都是重复的
• 如果次数过多，无法保证次数的准确性
• 为了解决这样的问题，提供了循环结构
• /

public class Demo4 {public static void main(String[] args) {/

System.out.println("我爱美女");

System.out.println("我爱美女");

System.out.println("我爱美女");

System.out.println("我爱美女");*/

for (int i = 0; i < 50; i++) { System.out.println("我爱大长腿"); }

}

}

二，循环结构

1，循环结构可以在满足条件的情况下，反复执行某一段代码

这个被重复执行的代码叫做 循环体语句

我们需要在合适的时候结束循环，否则会成为死循环

2，组成

-初始化语句：一条或多条语句，完成初始化操作

-判断条件语句：是一个boolean类型表达式，由这个来决定循环是否继续执行

-循环体语句：要多次执行的代码

-控制条件语句：是在每一次循环结束后，下一次循环开始前执行

通过控制条件种的变量，可以让循环在合适的时候结束

3，分类

for循环

while循环

do...while循环

4，for循环

-格式：

1 2 3

for(初始化语句;判断条件语句;控制条件语句){

4

循环体语句;

}

-流程：1243243243243....直到条件为假

a，执行初始化语句

b，执行判断条件语句，看结果是真还是假

真：继续执行

假：循环结束，执行循环之外代码

c，执行循环体语句

d，执行控制条件语句，回到b

for (int i = 0; i < 50; i++) { System.out.println("我爱大长腿"); }

-注意：

判断条件语句必须是boolean类型

循环体语句如果只有一条语句，{}可以不写，但是如果是多条语句必须写

建议永远不要省略

-练习：统计并输出水仙花数

5，while循环

-格式：

初始化语句;

while(判断条件语句){

循环体语句;

控制条件语句;

}

int i = 0;

while (i<50){

System.out.println("来了，老美。。。");

i++;

}

-统计并输出水仙花数

6,for和while区别

-for和while是可以相互转换，但是还是有些区别的

使用区别：

控制条件控制的那个变量(初始化语句定义的变量)

for循环结束后不能被访问，而在while循环结束后还可以访问

场景区别： for适合针对一个明确的范围进行操作 while比较适合针对循环次数不明确的操作

package com.momo.demo;

/*

-练习：珠穆朗玛峰的高度是8848m。假设有一张足够大的纸，默认厚度是0.01m

问，要对折多少次才能保证纸的厚度不低于珠峰的高度？

• 分析：
• 定义统计变量 默认是 0

对比的厚度8848 884800

初始厚度0.01 1

每次对折后的厚度变化 是之前的2倍

每次对折之后判断厚度，没有超过884800 统计变量++

因为我们不知道要对折多少次？所以选用while

• */

public class Demo5 {

public static void main(String[] args) {

int count = 0;

int end = 884800;

int start = 1;

while(start<end){ count++; start *= 2; System.out.println(count+"次之后的厚度是："+start); } System.out.println(count);

}

}

7，do..while

-格式：

初始化语句;

do{

循环体语句；

控制条件语句;

}while(判断条件语句);

-流程：

a，初始化语句

b，循环体语句

c，控制条件语句

d，判断条件语句，看结果是真还是假

假：循环结束，执行循环之外代码

真：继续执行，回到b

-特点：即使条件为假，至少也会执行一次循环体

int i = 0;

do{

System.out.println("来啊，。。。");

i++;

}while (i<50);

-循环注意事项： 死循环 一定要注意控制条件语句，别忘了。。 最简单的死循环格式： for(;;){} while(true){}

三，循环嵌套

1，就是循环语句的语句体又是一个循环

package com.momo.demo;

/*

• 输出如图形
• 
  

• 
  
• 基本做法可以满足要求，但是不能满足不断变化需求
• 5行8列？ 。。。。。10000行800000列......
• 就会出现我们之前所说的问题
• 代码重复，次数不准确，所以要用循环改进
• /

public class Demo7 {public static void main(String[] args) {/ System.out.println("");System.out.println("");

System.out.println("*****");*/

//先考虑一行，看如何满足变化需求 /*System.out.print("*"); System.out.print("*"); System.out.print("*"); System.out.print("*"); System.out.print("*");*/ /* for (int i = 0; i < 5; i++) { System.out.print("*"); } System.out.println(); for (int i = 0; i < 5; i++) { System.out.print("*"); } System.out.println(); for (int i = 0; i < 5; i++) { System.out.print("*"); } System.out.println();*/ /* * 当我要多行，循环语句又重复了，继续用循环来改进 * */

//循环嵌套

/*

* 外层循环控制的是行

* 内层循环控制的是列

* //

for (int i = 0; i < 5; i++) {

System.out.print("");}System.out.println();}/

//20行60列 for (int j = 0; j < 20; j++) { for (int i = 0; i < 60; i++) { System.out.print("*"); } System.out.println(); }

}

}

1 2 3 for (int j = 0; j < 3; j++) { 4 5 6 for (int i = 0; i < 5; i++) { 7 System.out.print("*"); } 8 System.out.println(); } 124576576576576576...直到内循环为假8324576576576直到内循环为假8 ....直到外循环为假 外循环执行一次，内循环要执行一圈

2，练习

-打印图形

*

**

**

*

**

**

*

等腰三角形

-打印九九乘法表

11=112=2 2*2=4

...

3,跳转控制语句

-作用：想让循环执行到某一步的时候就结束它

-为了实现这样的作用，java提供了break，continue，return来实现

语句的跳转和中断

break 中断

continue 继续

return 返回

4，break

-场景

在switch中使用

在循环中使用(加入判断)

-作用：

结束switch语句

跳出单层循环

跳出多层循环

带标签跳出

格式：

标签名:循环语句

break 标签名

package com.momo.demo;

public class Demo8 { public static void main(String[] args) { for (int i = 0; i < 10; i++) { if(i==3){ break; } System.out.println("我爱美女。。。。"); } System.out.println("之外代码。。"); } }

package com.momo.demo;

public class Demo9 {

public static void main(String[] args) {

wc:for (int j = 0; j < 3; j++) {

nc: for (int i = 0; i < 5; i++) {

if(i==3){

// break;

// break nc;

break wc;

}

System.out.print("*");

}

System.out.println();

}

}

}

5，continue

-场景：在循环中使用

-作用：结束本次循环，执行下一次循环

跳出单层循环

跳出多层循环

带标签跳出

格式：

标签名:循环语句

break 标签名

package com.momo.demo;

public class Demo10 {

public static void main(String[] args) {

for (int i = 0; i < 10; i++) {

if(i==3){

continue;

}

System.out.println("我爱美女。。。。"+i);

}

System.out.println("之外代码。。"); }

}

package com.momo.demo;

public class Demo11 {

public static void main(String[] args) {

wc:for (int j = 0; j < 3; j++) {

nc: for (int i = 0; i < 5; i++) {

if(i==3){

//continue;

// continue nc;

continue wc;

}

System.out.print("*");

}

System.out.println();

}

}

}

package com.momo.demo;

/*

• 输出2次？
• 输出7次？
• 输出13次？
• */

public class Demo12 {

public static void main(String[] args) {

for (int i = 1; i <= 10; i++) {

if(i%3==0){

//?

// break;

// continue;

System.out.println("我爱钱。。。。"+i);

}

System.out.println("我爱钱。。。。"+i);

}

}

}

6，return

-这个关键字不是为了跳出循环，主要用来结束一个方法，跳转到上层调用者

package com.momo.demo;

/*

• 表面看起来也可以结束循环，实际上它是结束了方法
• */

public class Demo13 {

public static void main(String[] args) {

for (int i = 0; i < 10; i++) {

if(i==3){

return;

}

System.out.println("我爱美女。。。。");

}

System.out.println("之外代码。。");

}

}

-练习题：小明妈妈每天给小明2.5元，他都会存起来

但是当这天是是存钱的第5天或第5天的倍数，他就会花掉

6元钱，问要多少天小明可以存够不少于100元？

四，方法

1，概述

-方法就是完成了特定功能的代码块

2，格式

参数列表

-修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,...){

方法体(完成特定功能的代码);

return 返回值;

}

3,解释：

-修饰符：现在就用 public static

-返回值类型：就是代码执行完成后产生的结果的数据类型

-方法名：符合明明规范，方法调用

-参数：

实际参数：实际参与运算的值

形式参数：就是方法定义上的，用来限制和接收实际参数的

-参数类型：数据类型

-参数名：变量名

-return： 结束方法

-返回值：就是实际结果，由return返回给调用者

4，要求

-要写好一个方法，就必须先确定2个内容：

返回值类型：结果的数据类型

参数列表：

要几个参数，每个参数的数据类型是什么

5，编写第一个方法

package com.momo.demo;

/*

• 需求：写一个求2个数之和的方法
• 分析：
• 返回值类型： int
• 参数列表: int a,int b
• */

public class Demo14 {

public static void main(String[] args) {

}

public static int sum(int a,int b){

int c = a+b;

return c;

}

}

6，特点

-不调用不执行

7，如何调用(有明确返回值方法的调用)

package com.momo.demo;

/*

• 需求：写一个求2个数之和的方法
• 分析：
• 返回值类型： int
• 参数列表: int a,int b
• 
  
• 如何调用(有明确返回值的方法)
• 单独调用：没有意义
• 输出调用:有意义，不建议
• 无法进行下一步操作
• 赋值调用：建议
• /

public class Demo14 {public static void main(String[] args) {//不能嵌套，方法和方法是平级的/

int c = a+b;

return c;

}*/

//单独调用

// sum(3,4);//7

//输出调用 // System.out.println(sum(4,5)); //赋值调用 int i = sum(4,7); System.out.println(i);

}

//不调用不执行

public static int sum(int a,int b){

int c = a+b;

return c;

}

}

package com.momo.demo;

public class Demo15 {

public static void main(String[] args) {//第一步，程序入口

int a = 3;

int b = 5;//第二步，定义2个变量(实参)

int i = sum(a,b);//第三步，调用方法 ，第七步：把返回的结果8赋值给i

System.out.println(i);//第八步：输出结果

}

//不调用不执行

public static int sum(int a,int b){//第四步，把mian中的a和b的值，传递给sum方法的a和b

int c = a+b;//第五步：计算结果8，赋值给c

return c;//第六步：通过return把结果返回8

}

}

8,方法练习

-键盘输入3个数，返回最大值

....

9,方法的注意事项 -不调用不执行 -方法和方法是平级的，不要嵌套 -如果方法有明确返回值，方法中一定要有return，并且要返回一个结果

10，没有明确返回值的方法 void类型方法

-调用方式

只能单独调用

package com.momo.demo;

/*

• 需求：输出如下图形

• /

public class Demo16 {public static void main(String[] args) {/

for (int i = 0; i < 3; i++) {

for (int j = 0; j < 5; j++) {

System.out.print("");}System.out.println();}/

/* //4行6列 for (int i = 0; i < 4; i++) { for (int j = 0; j < 6; j++) { System.out.print("*"); } System.out.println(); }*/ /* * 需求发生改变，代码都是一样的，只是行和列的数值改变了 * 也就是说上面的代码就是一个完成了特定功能的代码，应该用方法来封装，提高复用性 * */ //有了方法后 printStar(3,5); System.out.println("-------------------"); printStar(6,9); //输出调用 不能 // System.out.println(printStar(2,5));//此处不允许使用 '空' 类型 //赋值调用 不能 // void v = printStar(3,6);非法的表达式开始

}

/*

• 写一个方法：可以打印任意行和列的方法
• 返回值类型： void
• 参数列表：int h,int l
• / public static void printStar(int h,int l){ for (int i = 0; i < h; i++) { for (int j = 0; j < l; j++) { System.out.print("");

}

System.out.println();

}

}

}

-方法练习：键盘输入一个整数x，输出对应的xx乘法表

10，方法的重载

-在同一个类中，存在多个方法名相同，但是参数列表不同的现象叫做重载

-和返回值无关，只看方法名和参数列表

-参数列表不同：

参数个数不同

参数类型不同

顺序不同也可以

-在调用的时候，虚拟机会通过参数列表的不同来区分同名的方法

package com.momo.demo;

/*

• 随着需求不断增加，提供了对应的方法，这个本身没有问题
• 问题在于方法名越来越多了，将来要找到对应的方法很难找
• 名字也很难在做到见名知意了
• 但是他们都是求和的方法，求和一般就称为 sum
• 为了解决这个麻烦的问题，针对这种情况：
• 多个方法的功能相同，参数列表不同的情况，java
• 允许他们的名字一样，这种情况专业的叫法叫： 方法的重载
• /

public class Demo17 {public static void main(String[] args) {/

System.out.println(sum3int(3,4,5));*/

//调用的时候jvm会自动区分 System.out.println(sum(3,4)); System.out.println(sum(3.0,4)); System.out.println(sum(3,4.0));

}

//需求：写一个求2个int数之和方法

public static int sum(int a,int b){

System.out.println("2ge int");

return a+b;

}

//已在类 com.momo.demo.Demo17中定义了方法 sum(int,int)

/* public static double sum(int a,int b){

return a+b;

}*/

//需求：写一个求3个int数之和方法

public static int sum(int a,int b,int c){

System.out.println("3ge int");

return a+b+c;

}

//需求：写一个求2个double数之和方法

public static double sum(double a,double b){

System.out.println("2ge double");

return a+b;

}

//需求：写一个求1个double和1个int数之和方法

public static double sum(double a,int b){

System.out.println("1ge double,1ge int");

return a+b;

}

//需求：写一个求1个int和1个double数之和方法

public static double sum(int a,double b){

System.out.println("1ge int 1gedoubl");

return a+b;

}

/* //需求：写一个求2个int数之和方法

public static int sum2int(int a,int b){

return a+b;

}

//需求：写一个求3个int数之和方法

public static int sum3int(int a,int b,int c){

return a+b+c;

}

//需求：写一个求2个double数之和方法

public static double sum2double(double a,double b){

return a+b;

}

//需求：写一个求1个double和1个int数之和方法

public static double sumdoubleint(double a,int b){

return a+b;

}

//需求：写一个求1个int和1个double数之和方法

public static double sunintdouble(int a,double b){

return a+b;

}*/

}

五，数组

1，概述

-为了解决操作多个变量麻烦的问题，java提供了数组

-数组是一个可以存储多个变量的容器

-一般多个变量的数据类型要一致

-数组是一个存储同一种数据类型的多个元素的集合体(容器)

-数组可以存储基本类型，也可以存储引用类型

2，定义格式

-数据类型[] 数组名; int[] arr;

-数据类型 数组名[]; int arr[];

-这2个只是定义格式，数组中是没有元素的(没有初始化)

int a;

3,如何对数组进行初始化

-初始化：就是给数组中的元素分配内存空间，并给每个元素赋值。

-初始化方式：

动态初始化：指定数组的长度，由系统分配默认值

静态初始化：指定每个元素值，由系统来决定长度

4，动态初始化

-格式：数据类型[] 数组名 = new 数据类型[数组长度];

int[] arr = new int[3];

new：给数组分配内存空间

-如何获取数组中的元素值？

数组中的每个元素都有编号，编号是从0开始的，这个编号叫做 索引

格式：数组名[索引]

package com.momo.demo;

public class Demo18 {

public static void main(String[] args) {

//int[] arr;

//System.out.println(arr);//可能尚未初始化变量arr

int[] arr = new int[3]; System.out.println(arr);//[I@4eec7777 地址值 /* 地址值对于我们来说没有意义，我们想要的是里面的元素值 数组名[索引] 可以获取 * */ System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); }

}

5，java的内存分配

-java程序运行的时候，需要在内存中占用内存空间。

为了能够提高效率，就对占用的空间进行了区域的划分

没有给区域都有特定的数据处理方式和管理方式。

栈： 局部变量

堆： new出来的

方法区： 面向对象

本地方法区： 系统

寄存器： cpu

-堆内存特点：

每一个在堆中new出来的都有地址值(唯一标识)

堆中的每个变量系统都会给默认值

byte,short,int,long 0

float,double 0.0

char 空字符

boolean false

引用类型 null

使用完成之后不会马上消失，而是变成垃圾，会在垃圾回收器空闲的时候被回收。