键盘录入数据、流程控制语句、方法、方法重载

发表于 | 更新于 | 分类于 | 评论数： | 阅读次数：

键盘录入

1、在类（class）上面导包

​ 格式：

1
import java.util.Scanner;

2、创建键盘录入对象

​ 格式：

1
Scanner sc = new Scanner(System.in);

3、通过对象的方法获取键盘录入的数据

1
2
3
int x = sc.nextInt();
String str = sc.nextLine();
...

Java语言三种结构

Java语言三种结构：顺序结构、选择结构、循环结构

顺序结构

是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的，即写在前面的先执行，写在后面的后执行，从上往下，依次执行。

1
2
3
4
System.out.println("a");
System.out.println("b");
System.out.println("c");
//顺序结构，自上而下执行，依次输出a,b,c

选择结构

选择结构包括if语句和switch语句

if语句

​ 格式一：

1
2
3
if(boolean类型的表达式或值){
	语句体  //当()内表达式为true时进入大括号执行语句体
}

​ 案例：

1
2
3
4
if(4>3){
	System.out.println("执行的该语句");
}
//  控制台会打印出"执行的该语句"

​ 格式二：

1
2
3
4
5
if(条件){
	条件为真，执行这个括号里面的代码
}else{
	条件为假，执行这个括号里面的代码
}

​ 案例：

1
2
3
4
5
6
if(10+2>5-3){
	System.out.println("这是真的");
}else{
	System.out.println("这是假的");
}
// 运行结果为"这是真的"

​ 三元运算符能实现的，都可以采用if语句实现，但反之不成立

​ 什么时候if语句实现不能用三元改进呢? 当if语句控制的操作是一个输出语句的时候就不能改写

​ 格式三：

1
2
3
4
5
6
7
8
9
if(条件1){
    语句体1 //满足条件1则执行此处
}else if(条件2){
    语句体2  //满足条件2则执行此处
}
...
else{
    语句体n+1  //条件1、2、...n都不满足则执行此处语句
}

​ 案例：获取三个数最大值

1
2
3
4
5
6
7
8
9
10
11
int a=100;
int b=10;
int c=18;
if(a>b&&a>c){
	max=a;
}else if(b>a&&b>c){
	max=b;
}else{
	max=c;
}		
System.out.println("最大值是："+max);

switch语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
switch(常量/变量){
	case 值:
        执行的代码
	break;
	case 值:
        执行的代码
	break;
	case 值:
        执行的代码
	break;
	case 值:
        执行的代码
	break;
	default:
		执行的代码
	break;

注意：

1、switch语句支持的表达式的数据类型：byte 、short、 int、 char、JDK5以后可以是枚举、JDK7以后可以是String

2、case 后面的只能是常量，多个case后面的值不能出现相同的

3、default 可以写也可以不写，且功能的执行与位置无关，但是建议在最后，当所有case项都没有匹配上就会执行

4、break 结束整个switch语句，如果没有 break 会发生 case穿透，这种现象你可以利用

5、switch语句的结束条件：遇到break就结束了或者执行到末尾结束

案例一：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
int x = 2;
int y = 3;
switch(x){
default:
	y++;
case 3:
	y++;
case 4:
	y++;
}
System.out.println("y="+y);//6
-----------------------------------------------------
int x = 2;
int y = 3;
switch(x){
default:
	y++;
break;
case 3:
	y++;
case 4:
	y++;
}
System.out.println("y="+y); // 4

循环结构

循环结构包括for循环、while循环和do…while循环

for循环

1
2
3
for(初始化表达式语句;判断条件语句;控制条件语句) {
		循环体语句;
}

执行流程：

a:执行初始化表达式语句
b:执行判断条件语句,看其返回值是true还是false，如果是true，就继续执行，如果是false，就结束循环
c:执行循环体语句
d:执行控制条件语句
e:回到b继续执行

注意：初始化表达式语句只执行一次

案例：打印1~100的数

1
2
3
for(int i=1; i<=100; i++){
    System.out.println(i)
}

while循环

1
2
3
4
while(判断条件语句) {
	循环体语句;
	控制条件语句;
}

执行流程：先判断条件语句是否为true，若为true，则进入大括号执行循环语句和控制条件语句

案例：求1—100之间的和

1
2
3
4
5
6
7
int i=1;
int sum=0;
while (j<=100){
   sum+=j;
   j++;
}
System.out.println("和是 "+sum);

do …while循环

1
2
3
4
do {
	循环体语句;
	控制条件语句;
}while(判断条件语句);

执行流程：先执行do里面的代码一次，然后再去判断，while括号里面的条件是否成立，如果成立，就继续执行{}里面的语句，如果条件不成立，则循环结束

案例：

1
2
3
4
5
6
int i=2;
do{
    System.out.println("你好");
    i--;
}while (i>2); 
//执行一次do里面的代码

三种循环语句的区别

(1): do…while循环至少执行一次循环体。而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。

(2): 如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。

死循环

当控制条件语句控制的那个变量丢失时，循环结构可能进入死循环

两种最简单的死循环格式:

​ while(true){…}

​ for(; ; ){…}

控制跳转语句

什么是控制跳转语句：Java中的goto是保留字，目前不能使用。虽然没有goto语句可以增强程序的安全性，但是也带来很多不便， 比如想在某个循环执行到某一步的时候就结束，现在就做不了这件事情。为了弥补这个缺陷，Java就提供了break（中断），continue（继续）和return（返回）来实现控制语句的跳转和中断

  • break

    (1):在选择结构switch语句中

    (2):在循环语句中

    ​ 作用：常用于退出单层循环

    ​ 注意：离开使用场景的存在是没有意义的

  • continue

    ​ 在循环语句中

    ​ 作用：跳出一次循环，执行下一步操作

    ​ 注意：离开使用场景的存在是没有意义的

    案例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    for(int x=1; x<=10; x++) {
    	if(x%3==0) {
    		//在此处填写代码
    	}
    	System.out.println(“Java”);
    }
    	
    //我想在控制台输出2次:“Java“----braak;
    //我想在控制台输出7次:“Java“----continue;
    //我想在控制台输出13次:“Java“----System.out.println(“Java”);

  • return

    ​ 作用：return 就是退出一个方法

方法

​ 为了解决代码重复编写的问题，可以将一个功能的代码提取出来放在一个{}中，并为这段代码起个名字，所提取出来的代码可以被看作是程序中定义的一个方法，就是对一段功能逻辑的封装，以实现重复调用。

  • 格式
1
2
3
4
修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2 …){
    方法体;
    return 返回值;
}
  • 举例：定义一个方法求1~n的和并返回值
1
2
3
4
5
6
public static int getSum(int n){
	int sum=0;
    for(int i = 1; i<=n; i++){
		sum+=i;
	}
}
  • 主方法
1
public static void main(String[] args) {}

主方法是一个程序的入口，主方法是JVM来调用的，一个类中只能有一个主方法

  • 实参与形参

实参：调用方法时，传入的参数，叫做实际参数，简称实参，传常量，变量都可以。

形参：定义方法括号里面的参数，叫做形式参数，简称形参。形参的作用是，调用方法时，接收传过来的实参，多个形参你用逗号隔开。

  • 注意
1
2
3
4
5
方法不调用不执行
方法与方法是平级关系，不能嵌套定义
方法定义的时候参数之间用逗号隔开
方法调用的时候不用在传递数据类型
如果方法有明确的返回值，一定要由return带回一个值
  • 案例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//  需求：根据键盘录入的数据输出对应的乘法表
import java.util.Scanner;

public class MyTest {
	public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个行数");
        int i = sc.nextInt();
        //调用方法
        showChengFaBiao(i);
    }

    public static void showChengFaBiao(int a) {
        for (int i = 1; i <= a; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + (j * i) + "\t");
            }
            System.out.println();
        }
    }
}

方法重载

在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同（参数个数或者参数类型不同），与返回值无关。调用的时候，会根据参数个数和参数类型去匹配。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
private static int add(int i, int i1) {
        System.out.println("两个int参数方法调用了");
        return i + i1;
    }

    private static double add(int i, double i1) {
        System.out.println("一个int 一个double调用了");
        return i + i1;
    }

    private static int add(int i, int i1, int i2, int i3) {

        return i + i1 + i2 + i3;
    }

    private static int add(int i, int i1, int i2) {

        return i + i1 + i2;
	}
}
-------------本文结束感谢您的阅读-------------
0%