javaday03

1 分支结构... 1

1.1 if. 1

1.1.1 概述... 1

1.1.2 形式... 1

1.1.3 练习1：商品打折... 1

1.2 [了解]switch. 1

1.2.1 概述... 1

1.2.2 形式... 1

1.2.3 练习1：数字匹配... 1

2 循环结构... 1

2.1 for. 1

2.1.1 概述... 1

2.1.2 形式... 1

2.1.3 练习1：打印0到10. 1

2.1.4 练习2：打印10到0. 1

2.1.5 练习3：打印8,88,888,8888,1

2.2 嵌套for循环... 1

2.2.1 概述... 1

2.2.2 形式... 1

2.2.3 入门案例... 1

2.2.4 练习1：打印左直角三角形... 1

2.2.5 练习2：打印99乘法表... 1

3 方法... 1

3.1 概述... 1

3.2 形式... 1

3.3 练习1：方法调用... 1

3.4 练习2：方法传参... 1

3.5 练习3：返回值... 1

4 [预习]方法的重载... 1

4.1 概念... 1

4.2 练习1：数字求和... 1

5 拓展... 1

5.1 练习1：打印右直角三角形... 1

5.2 练习2：打印全三角形... 1

5.3 求[1,100]以内的偶数和... 1

5.4 求[1,100]以内的奇数个数... 1

1 分支结构

1.1 if

1.1.1 概述

顺序结构的程序虽然能解决计算、输出等问题，但不能做判断再选择。

对于要先做判断再选择的问题就要使用分支结构。

1.1.2 形式

单分支

if(判断条件){满足条件的代码}

多分支

if(判断条件){

满足条件的代码

}else{

不满足条件的代码

}

嵌套分支

if(判断条件1){

代码1

}else if(判断条件2){

代码2

}else if(判断条件3){

代码3

}else if(判断条件4){

代码4

}else{

谁都不满足的代码

}

1.1.3 练习1：商品打折

创建day03工程

创建cn.tedu.ifdemo包

创建Test1_If.java

接收用户输入的原价。

满1000打9折。

满2000打8折。

满5000打5折。

package cn.tedu.ifdemo;

import java.util.Scanner;

//测试商品打折

public class Test1_If {

public static void main(String[] args) {

//1、接收用户输入的原价

double price = new Scanner(System.in).nextDouble();

//2、判断，计算折后价

double now = price;//记录折后价

if(price> = 5000) {//满5000

now = price*0.5;//打5折

}else if(price >= 2000) {//满2000

now = price*0.8;//打8折

}else if(price >= 1000) {//满1000

now = price*0.9;//打9折

}

System.out.println("折后价"+now);

}

1.2 [了解]switch

1.2.1 概述

当一个case成立，从这个case向后穿透所有case，包括default。

直到程序结束或者遇到break程序才结束。

1.2.2 形式

switch(整型表达式（只支持byte，short，char能转换成int的这种）){

case 1 : syso(1);break;

case 2 : syso(2);

case 3 : syso(3);

case 4 : syso(4);

case 5 : syso(5);

default:syso(0);

}

1.2.3 练习1：数字匹配

package cn.tedu.ifdemo;

//测试switch语法

public class Test2_Switch {

public static void main(String[] args) {

int a = 1;

//1、小括号里的参数类型是整型：byte short int char jdk1.5后String

switch(a) {

//3、当匹配到了case，并且没有break，会向后穿透所有case包括default

//4、break可以结束程序

case 1 : System.out.println(1);break;

case 'a' : System.out.println(2);break;

case 20 : System.out.println(3);break;

//2、如果没有匹配的case就会执行default

default:System.out.println(0);

}

2 循环结构

2.1 for

2.1.1 概述

循环结构是指在程序中需要反复执行某个功能而设置的一种程序结构。

它由循环体中的条件，判断继续执行某个功能还是退出循环。

根据判断条件,循环结构又可细分为先判断后执行的循环结构和先执行后判断的循环结构。

2.1.2 形式

for(循环的开始位置;循环的条件;更改条件){

循环体

}

2.1.3 练习1：打印0到10

package cn.tedu.fordemo;

//测试for循环结构

public class Test3_For {

public static void main(String[] args) {

//打印0到10

// for(循环的开始位置;循环的条件;更改条件) {

//i记录每次获取到的值

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

System.out.println(i);

}

2.1.4 练习2：打印10到0

//打印10到0

for( int i = 10 ; i >= 0 ; i--) {

System.out.println(i);

}

2.1.5 练习3：打印8,88,888,8888,

//打印8,88,888,8888,

for( int i = 8 ; i <= 8888 ; i=i*10+8) {

System.out.print(i+","); //加个逗号组织成用逗号隔开的数据格式

}

2.2 嵌套for循环

2.2.1 概述

根据外层的条件，判断里层能否执行，如果能执行，就把里层代码都循环完毕后，再继续执行外层，继续判断。

2.2.2 形式

for(循环的开始位置 ; 循环的条件 ; 更改条件 ){//外循环

for(循环的开始位置 ; 循环的条件 ; 更改条件 ){//内循环

循环体

}

2.2.3 入门案例

总结1：外循环执行1次，内循环执行多次

总结2：外循环控制行，内循环控制列

package cn.tedu.fordemo;

//测试嵌套for循环

public class Test4_For2 {

public static void main(String[] args) {

//总结1：外循环执行1次，内循环执行多次

//当i=1是，输出i的值1，并且输出j的值12345

//当i=2是，输出i的值2，并且输出j的值12345

//当i=3是，输出i的值3，并且输出j的值12345

for( int i = 1 ; i <= 3 ; i++ ) {//外循环，执行3次

System.out.println(i);

for( int j = 1 ; j <= 5 ; j++ ) {//内循环，执行5次

System.out.println(j);

}

//总结2：外循环控制行，内循环控制列

//外循环能执行5次，所以可以打印5行

//内循环能执行3次，所以每行可以打印3列

for( int i = 1 ; i <= 5 ; i++ ) {//外循环，执行5次

for( int j = 1 ; j <= 3 ; j++ ) {//内循环，执行3次

System.out.print("*");

}

System.out.println();//换行

}

2.2.4 练习1：打印左直角三角形

***

****

*****

package cn.tedu.fordemo;

//嵌套for的练习

public class Test5_For3 {

public static void main(String[] args) {

***

****

*****

i j

1 1

2 2

3 3

4 4

5 5

//当i = 1，准备打印第一行，但是打印几列，内循环决定。j<=1，能执行1次，所以第一行打印一个*，在打印换行。

//当i = 2，准备打印第二行，但是打印几列，内循环决定。j<=2，能执行2次，所以第二行打印两个*，在打印换行。

//...

for(int i = 1 ; i <= 5 ; i++) {//外循环，执行5次

for(int j = 1 ; j <= i; j++) {//内循环，变化跟外循环一致，j随着i改变

System.out.print("*");//同一行展示*

}

System.out.println();//换行

}

2.2.5 练习2：打印99乘法表

1*1=1

2*1=2 2*2=4

3*1=3 3*2=6 3*3=9

4*1=4 4*2=8 4*3=12 4*4=16

5*1=5 5*2=10 5*3=15 5*4=20 5*5=25

6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36

7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49

8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64

9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81

//99乘法表

for(int i = 1 ; i <= 9 ; i++) {//外循环，执行9次

for(int j = 1 ; j <= i ; j++) {//内循环，变化跟外循环一致，j随着i改变

// System.out.print("2*1=2");

// 其中，第一个数字是行i，第二个数字是列是j，第三个数字是乘积

//如果字符串需要在前面和后面都动态拼接数据，" + ? + "

System.out.print(i+"*"+j+"="+i*j+" ");

}

System.out.println();//换行

}

3 方法

3.1 概述

被命名的代码块 main(){ }，

可以含参数可以不含参数，

可以提高代码的复用性。

3.2 形式

方法的修饰符方法的返回值方法的名字 ( 参数列表 ) { 代码/方法体 }

3.3 练习1：方法调用

package cn.tedu.method;

//测试方法的使用

public class Test6_Method {

public static void main(String[] args) {

System.out.println(1);

method();//1、方法间的调用

System.out.println(2);

}

//创建method()

//方法的修饰符方法的返回值方法的名字( 参数列表 ) { 代码/方法体 }

public static void method() {

System.out.println(3);

System.out.println(4);

System.out.println(5);

}

3.4 练习2：方法传参

package cn.tedu.method;

//测试方法的使用

public class Test6_Method {

public static void main(String[] args) {

// System.out.println(1);

// method();//1、方法间的调用

// System.out.println(2);

method2(10);//2、方法间的传参，调用时传的参数---实参

method3("10",5);//2.1、传多个参数，逗号隔开

}

//TODO 创建method3("jack",5)参数类型 参数名---形参

//其中，参数类型必须和调用时的参数类型一致

public static void method3(String n,int a) {

//+是做字符串的拼接，两个数字之间+用来做加法运算

//只要有字符串类型的用+都是拼接字符串

System.out.println(n+a);//105

}

//TODO 创建method2(10)

//方法的修饰符方法的返回值方法的名字( 参数类型参数名 ) { 代码/方法体 }

public static void method2(int number) {

System.out.println(number);

}

//创建method()

//方法的修饰符方法的返回值方法的名字( 参数列表 ) { 代码/方法体 }

public static void method() {

System.out.println(3);

System.out.println(4);

System.out.println(5);

}

3.5 练习3：返回值

package cn.tedu.method;

//测试方法的使用

public class Test6_Method {

public static void main(String[] args) {

//// System.out.println(1);

//// method();//1、方法间的调用

//// System.out.println(2);

// method2(10);//2、方法间的传参，调用时传的参数---实参

// method3("10",5);//2.1、传多个参数，逗号隔开

int result = method4(10,5);//3、方法的返回值

System.out.println(result);

}

//TODO method4(10,5)

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

//return关键字，可以把运算结果，返回，调用位置

return a+b;

}

//TODO 创建method3("jack",5) 参数类型参数名---形参

//其中，参数类型必须和调用时的参数类型一致

public static void method3(String n,int a) {

//+是做字符串的拼接，两个数字之间+用来做加法运算

//只要有字符串类型的用+都是拼接字符串

System.out.println(n+a);//105

}

//TODO 创建method2(10)

//方法的修饰符方法的返回值方法的名字( 参数类型参数名 ) { 代码/方法体 }

public static void method2(int number) {

System.out.println(number);

}

//创建method()

//方法的修饰符方法的返回值方法的名字( 参数列表 ) { 代码/方法体 }

public static void method() {

System.out.println(3);

System.out.println(4);

System.out.println(5);

}

4 [预习]方法的重载

4.1 概念

方法重载是指在一个类中定义多个同名的方法，

但要求每个方法具有不同的参数列表(也就是说参数的个数和类型不同)。

程序调用方法时，可以通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法。

4.2 练习1：数字求和

package cn.tedu.method;

//测试方法重载

//重载的意义：如果提供了多个同名方法，不同的就是参数列表，

//意义就是为了方便外界的调用，体现程序的灵活性

public class Test7_Overload {

public static void main(String[] args) {

//重载：方法名相同+参数列表不同(参数的个数或者类型不同)

int sum = method(10,5);

System.out.println(sum);

String sum2 = method("jack",10,5);

System.out.println(sum2);

String sum3 = method(10,5,"jack");

System.out.println(sum3);

}

//创建method(10,5,"jack")

public static String method(int a,int b,String c) {

return a+b+c;//15jack

}

//创建method("jack",10,5)

public static String method(String n,int o,int p){

return n+o+p;//jack105

}

//创建method(10,5) -- 其中，10和5是实参，a和b是形参

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

return a+b;

}

5 拓展

5.1 练习1：打印右直角三角形

***

****

*****

package day999;

public class a {

public static void main(String[] args) {

//输出5行

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

//空格三角

for(int x=5;x>i;x--){

System.out.print(" ");

}

//*号三角

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

System.out.print("*");

}

System.out.println();

}

5.2 练习2：打印全三角形

***

*****

*******

*********

package day999;

public class a {

public static void main(String[] args) {

//打印5行

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

//打印空格的倒三角

for(int j=5;j>=i;j--){

System.out.print(" ");

}

//打印*号的正三角

for(int k=1;k<=i*2-1;k++){

System.out.print("*");

}

System.out.println();

}

5.3 求[1,100]以内的偶数和

//0、定义变量，记录偶数的和

int sum = 0;

//1、获取100以内的每个数

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

//2、判断，如果是偶数求和

if(i%2==0) {//如果是偶数

sum = sum + i;//修改sum的值，记录偶数和

}

System.out.println(sum);//2550

5.4 求[1,100]以内的奇数个数

//0、定义变量，记录奇数个数

int count = 0;

//1、获取100以内的每个数

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

//2、判断，如果是奇数

if(i%2==1) {//如果是奇数

count++;//遇到奇数就把count值+1

}

System.out.println(count);//50

posted @ 2020-05-25 15:26 白驼山庄庄主阅读(86) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

欧阳锋醉心于九阴真经的日子

javaday03

1 分支结构

1.1 if

1.1.1 概述

1.1.2 形式

1.1.3 练习1：商品打折

1.2 [了解]switch

1.2.1 概述

1.2.2 形式

1.2.3 练习1：数字匹配

2 循环结构

2.1 for

2.1.1 概述

2.1.2 形式

2.1.3 练习1：打印0到10

2.1.4 练习2：打印10到0

2.1.5 练习3：打印8,88,888,8888,

2.2 嵌套for循环

2.2.1 概述

2.2.2 形式

2.2.3 入门案例

2.2.4 练习1：打印左直角三角形

2.2.5 练习2：打印99乘法表

3 方法

3.1 概述

3.2 形式

3.3 练习1：方法调用

3.4 练习2：方法传参

3.5 练习3：返回值

4 [预习]方法的重载

4.1 概念

4.2 练习1：数字求和

5 拓展

5.1 练习1：打印右直角三角形

5.2 练习2：打印全三角形

5.3 求[1,100]以内的偶数和

5.4 求[1,100]以内的奇数个数

公告