第五天 方法【悟空教程】

第05天 方法

第1章 方法

1.1 方法概述

软件的本质是为我们提供了解决日常事务的许多功能。在Java当中通过方法的方式来完成这些功能。即Java中的某个方法提供了某种功能，供我们人类解决问题。

我们可以将一个完整功能的代码组织成一个方法，在再次完成相同的功能时，便可以直接以整体的方式调用该功能，而不需要再将具体实现过程完整重复编写一遍。

main方法就是一个特殊的方法。作为程序入口，供JVM调用。

我们将不同功能定义成不同方法。供其他方法调用。最先接触方法时，我们定义不同的方法，供main方法直接调用。

1.2 方法的定义及使用

方法是对现实功能的一个抽象，便于对功能的复用。在一个类中可以有多个方法，多个方法是平等关系。

在很多语言当中，相同的概念使用函数来命名。

1.2.1 方法定义格式

在Java中，声明一个方法的具体语法格式如下：

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

执行语句

………

return 返回值;

}

对于上面的语法格式中具体说明如下：

• 修饰符：方法的修饰符比较多，有对访问权限进行限定的，有静态修饰符static，还有最终修饰符final等，这些修饰符在后面的学习过程中会逐步介绍。目前使用固定的public static修饰符
• 返回值类型：方法返回值的数据类型
• 参数类型：调用方法时传入参数的数据类型
• 参数名：是一个变量，用于接收调用方法时传入的数据
• return关键字：用于结束方法以及返回返回值
• 返回值：被return语句返回的值，该值会返回给调用者

1.2.2 方法的使用格式

1.2.2.1 方法的使用：

所有的方法定义出来，都是为了让别的方法使用的。永远不被别人调用的方法，其定义是没有意义的。

使用格式

在前边讲解引用数据类型的简单使用时，我们已经使用过方法

使用格式即：对象名.方法名(对应参数)

当一个类中有多个方法，多个方法之间可以相互直接调用，无需创建对象

使用格式：方法名(参数);

注意

方法必须先定义再使用

方法的定义顺序跟调用无关

/*

方法:方法就是对功能的封装,可以提高代码的复用性

工厂:

制造钢铁:原料矿石

制造牛奶:原料奶牛

定义方法的格式:

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

执行语句

………

return 返回值;

}

对于上面的语法格式中具体说明如下：

修饰符：方法的修饰符比较多，有对访问权限进行限定的，有静态修饰符static，还有最终修饰符final等，

这些修饰符在后面的学习过程中会逐步介绍。目前使用固定的public static修饰符

返回值类型：方法返回值的数据类型

参数类型：调用方法时传入参数的数据类型

参数名：是一个变量，用于接收调用方法时传入的数据

return关键字：用于结束方法以及返回返回值

返回值：被return语句返回的值，该值会返回给调用者, 返回值的数据类型一定要与返回值类型统一

方法调用格式:

方法名(参数);

*/

public class Demo01Method{

public static void main(String[] args){

//调用方法

int c = add(3,4);//7

System.out.println("c = " + c);

}

//定义求两个整数和方法 3 4

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

System.out.println("求两个整数的和方法开始");

int sum = a + b;

System.out.println("求两个整数的和方法结束");

return sum;//7

}

}

后来的我们

主演：井柏然 / 周冬雨 / 田壮壮

猫眼电影演出 广告

购买

1.2.2.2 调用方法介绍：求和方法编写

public class Demo01Method {

/*

* 写一个方法，用于求和。

* 两个明确： 返回值类型 int 参数列表 int a,int b

*/

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

/*int c = a + b;

return c;*/

return a + b;

}

}

• 求和方法的调用(有明确返回值)
  • 使用格式：方法名(参数);
  • 单独调用，没有意义

sum(10,20);

• 输出调用，有意义，但是不够好，因为我不一定非要把结果输出

System.out.println(sum(10,20));

• 赋值调用，推荐方式

int s = sum(10, 20);

// s+=100;

System.out.println("s:"+s);

• 求和方法的调用图解

1.2.3 定义格式注意事项

a) 返回值类型

可以返回任意类型,包含基本数据类型与引用数据数据类型

如果没有返回值，则使用void

b) return

结束方法的同时如果定义的返回值类型不是void，则同时将结果返回给调用者。

当返回值类型为void时，return后可以不跟返回值

当返回值类型为void时，可以省略，Java会自动补齐

c) 返回值

该方法运算的数值结果，该结果会通过return返回给调用者

有时结果运行后没有返回值。（买东西与买服务）

返回值的数据类型一定要与返回值类型统一

d) 方法名

方法的名称，区分不同方法的依据之一

定义符合小驼峰式 wordWordWord

e) 形式参数

是形式参数的数据类型，在定义时没有赋值，在方法使用时一定有值，所以可以使用该变量完成逻辑

是一个变量，用于存储调用方法时传递给方法的实际数值

/*

定义方法的注意事项:

a) 返回值类型

可以返回任意类型,包含基本数据类型与引用数据数据类型

如果没有返回值，则使用void

b) return

结束方法的同时如果定义的返回值类型不是void，则同时将结果返回给调用者。

当返回值类型为void时，return后可以不跟返回值

当返回值类型为void时，return可以省略，Java会自动补齐

c) 返回值

该方法运算的数值结果，该结果会通过return返回给调用者

有时结果运行后没有返回值。（买东西与买服务）

返回值的数据类型一定要与返回值类型统一

d) 方法名

方法的名称，区分不同方法的依据之一

定义符合小驼峰式 wordWordWord

e) 形式参数

是形式参数的数据类型，在定义时没有赋值，在方法使用时一定有值，所以可以使用该变量完成逻辑

是一个变量，用于存储调用方法时传递给方法的实际数值

*/

public class Demo02Method{

public static void main(String[] args){

//调用唐僧生孩子方法

//String xingMing = shengHaiZi(36);

//System.out.println("名字是: " + xingMing);

//唐僧生一群孩子方法

String[] xingMings = shengYiQunHaiZi(108);

for(int i=0; i<xingMings.length; i++){

System.out.println("第"+(i+1)+"孩子的姓名是: " +xingMings[i]);

}

//坐月子的方法

zuoYueZi(1800);

}

//定义一个唐僧生孩子方法

public static String shengHaiZi(int month){

System.out.println("怀了"+month+"个月,终于生孩子了!");

String name = "糖三角";

return name;

}

//定义一个唐僧生一群孩子方法

public static String[] shengYiQunHaiZi(int month){

System.out.println("怀了"+month+"个月,终于生了一群孩子了!");

String[] names = {"孙悟空","猪八戒","沙师弟","白龙马"};

return names;

}

//定义一个坐月子的方法

public static void zuoYueZi(int day){

System.out.println("在床上躺了"+day+"天!");

//return;

}

}

1.2.4 定义格式void与参数详解：

1.2.4.1 Void修饰的方法

• 格式

修饰符 void 方法名(参数类型 参数名1，参数类型 参数名2…) {

方法体;

return 返回值;

}

• 没有明确返回值的函数调用:
  • 其实就是void类型方法的调用
  • 只能单独调用
• 案例

写一个方法，在控制台输出10次HelloWorld案例。

public class Demo01Method {

public static void main(String[] args) {

//单独调用

printHelloWorld();

}

//在控制台输出10次HelloWorld案例。

public static void printHelloWorld() {

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

System.out.println("HelloWorld");

}

}

}

1.2.4.2 Void修饰方法练习

1.2.4.2.1 定义一个方法，传递一个整数(大于1)，在控制台打印1到该数据的值。

public class Demo02Method {

public static void main(String[] args) {

printNumber(10);

System.out.println("-------------------");

printNumber(100);

}

//在控制台打印1到该数据n的值

public static void printNumber(int n) {

for(int x=1; x<=n; x++) {

System.out.println(x);

}

}

}

1.2.4.2.2定义一个方法，把所有的水仙花数打印在控制台

public class Demo03Method {

public static void main(String[] args) {

printFlower();

}

//把所有的水仙花数打印在控制台

public static void printFlower() {

for(int x=100; x<1000; x++) {

int ge = x%10;

int shi = x/10%10;

int bai = x/10/10%10;

if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x){

System.out.println(x);

}

}

}

}

1.2.5 方法参数传递问题

1.2.5.1 参数传递概述

可以理解当我们要调用一个方法时，我们会把指定的数值，传递给方法中的参数，这样方法中的参数就拥有了这个指定的值，可以使用该值，在方法中运算了。这种传递方式，我们称为参数传递。

• 在这里，定义方法时，参数列表中的变量，我们称为形式参数
• 调用方法时，传入给方法的数值，我们称为实际参数

1.2.5.2 参数是基本类型及图解

n 形式参数的改变不影响实际参数。

public class Demo01Args {

public static void main(String[] args) {

// 定义变量

int a = 10;

int b = 20;

System.out.println("a:" + a + ",b:" + b);// a:10,b:20

change(a, b);

System.out.println("a:" + a + ",b:" + b);// a:10,b:20

}

public static void change(int a, int b) { // a=10,b=20

System.out.println("a:" + a + ",b:" + b);// a:10,b:20

a = b; // a=20;

b = a + b;// b=40;

System.out.println("a:" + a + ",b:" + b);// a:20,b:40

}

}

1.2.5.3 参数是引用类型及图解

public class Demo02Args {

public static void main(String[] args) {

// 定义数组

int[] arr = { 1, 2, 3, 4, 5 };

// 遍历数组

for (int x = 0; x < arr.length; x++) {

System.out.println(arr[x]);

}

System.out.println("----------------");

change(arr);

for (int x = 0; x < arr.length; x++) {

System.out.println(arr[x]);

}

}

public static void change(int[] arr) {

for (int x = 0; x < arr.length; x++) {

// 如果元素是偶数，值就变为以前的2倍

if (arr[x] % 2 == 0) {

arr[x] *= 2;

}

}

}

}

1.2.6 多个方法可以共同访问成员变量

当一个类中定义了多个方法时，在方法A中定义的局部变量无法在方法B中直接访问。此时可以将变量定义在成员位置(类中方法外)，供多个方法同时访问。

使用static修饰的方法只能访问被static修饰的成员变量。

/*

多个方法之间不可以使用各自的局部变量

多个方法都可以使用成员变量,但是现在的方法都是用static修饰的,所以要访问成员变量,成员变量也必须被static修饰

成员变量:类的里边,方法的外边

*/

public class Demo03Method{

//int x;//错误: 无法从静态上下文中引用非静态 变量 x

static int x;

public static void main(String[] args){

x = 100;

System.out.println("x = " + x);

//调用method2方法

method2();

}

//方法1

public static int method1(int a){

int b = 10;

System.out.println(a*b);

return a*b;

}

//方法2

public static void method2(){

//System.out.println(a*b);// 错误: 找不到符号 方法2不能使用方法1里边的变量

//x = 200;

System.out.println("x = " + x);

}

}

1.3 方法定义练习

分别定义如下方法：

1.3.1 无返回值无参数方法，如打印3*3的矩形

1.3.2 有返回值无参数方法，如键盘录入得到一个整数

1.3.3 无返回值有参数方法，如打印指定M*N的矩形

1.3.4 有返回值有参数方法，如求三个数的平均值

/*

定义方法的练习;

无返回值无参数方法，如用*打印3*3的矩形

无返回值有参数方法，如用*打印指定M*N的矩形

有返回值无参数方法，如键盘录入得到一个整数

有返回值有参数方法，如求三个数的平均值

*/

import java.util.Scanner;

public class Demo04Method{

public static void main(String[] args){

//调用打印矩形方法

//printJX();

//调用打印不同矩形方法

//printJuXing(9,9);

//printJuXing(7,6);

//调用获取整数的方法

int a = getNumber();

System.out.println("a = " + a);

//调用求3个小数平均数方法

double b = pingJun(3.0,4.0,5.0);

System.out.println("b = " + b);

}

/*

无返回值无参数方法，如用*打印3*3的矩形

返回值类型: void

方法名: printJX

参数列表: 空

*/

public static void printJX(){

/*

***

***

***

*/

for(int i=0; i<3; i++){//控制打印行数

for(int j=0; j<3; j++){//控制每行打印几个

System.out.print("*");

}

System.out.println();

}

}

/*

无返回值有参数方法，如用*打印指定M*N的矩形

返回值类型: void

方法名: printJuXing

参数列表: int m, int n

*/

public static void printJuXing(int m, int n){

for(int i=0; i<m; i++){//控制打印行数

for(int j=0; j<n; j++){//控制每行打印几个

System.out.print("*");

}

System.out.println();

}

}

/*

有返回值无参数方法，如键盘录入得到一个整数

返回值类型: int

方法名: getNumber

参数列表: 空

*/

public static int getNumber(){

Scanner sc = new Scanner(System.in);

System.out.println("请输入一个整数: ");

int number = sc.nextInt();

return number;

}

/*

有返回值有参数方法，如求三个小数的平均值

返回值类型: double

方法名: pingJun (avg)

参数列表: double a,double b,double c

*/

public static double pingJun(double a,double b,double c){

//double avg = (a + b + c)/3;

return (a + b + c)/3;

}

}

1.3.5 获取两个数据中的较大值

public class Demo03MethodTest {

public static void main(String[] args) {

//创建对象

Scanner sc = new Scanner(System.in);

//接收数据

System.out.println("请输入第一个数据：");

int x = sc.nextInt();

System.out.println("请输入第二个数据：");

int y = sc.nextInt();

//调用方法

int max = getMax(x,y);

System.out.println("max:"+max);

}

// 返回两个数中的较大值

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

if (a > b) {

return a;

} else {

return b;

}

}

}

1.3.6 比较两个数据是否相等

public class Demo04MethodTest {

public static void main(String[] args) {

//创建对象

Scanner sc = new Scanner(System.in);

//接收数据

System.out.println("请输入第一个数据:");

int a = sc.nextInt();

System.out.println("请输入第二个数据:");

int b = sc.nextInt();

//调用方法

boolean flag = compare(a,b);

System.out.println("flag:"+flag);

}

//比较两个数是否相等

public static boolean compare(int a,int b){

if(a==b){

return true;

}else {

return false;

}

}

}

1.3.7 获取三个数据中的较大值

public class Demo05MethodTest {

public static void main(String[] args) {

//创建对象

Scanner sc = new Scanner(System.in);

//接收数据

System.out.println("请输入第一个数据：");

int a = sc.nextInt();

System.out.println("请输入第二个数据：");

int b = sc.nextInt();

System.out.println("请输入第三个数据：");

int c = sc.nextInt();

//调用方法

int max = getMax(a,b,c);

System.out.println("max:"+max);

}

// 返回三个数中的最大值

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

if (a > b) {

if (a > c) {

return a;

} else {

return c;

}

} else {

if (b > c) {

return b;

} else {

return c;

}

}

}

}

1.4 方法重载

在同一个类中，不能出现两个完全一样的方法。但是如果有多个功能，而这些功能大致相同只是某些已知量不同时，可以将两个方法的名称定义成相同的，而参数不同。这些相同名称不同参数的方法之间是重载关系。

1.4.1 方法重载定义

在同一个类中，出现方法名相同而参数列表不同，这样定义方法叫做方法重载。

这样的设计优化了程序设计

如：求3个数，4个数的和

方法定义：与求两数逻辑类似，求3、4个数和的方法中中只有参数不同。方法名与求两数的方法名相同，三个方法互为重载关系

public static int add(int a,int b) {逻辑} //两个数加法

public static int add(int a,int b,int c) {逻辑} //三个数加法

public static int add(int a,int b,int c,int d) {逻辑} //四个数加法

方法使用：main方法中直接调用

/*

方法重载:在一个类中方法名相同,参数列表不同

*/

public class Demo05Overload{

public static void main(String[] args){

System.out.println(add(10,20,30,40));

}

//两个数加法

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

System.out.println("调用两个数相加");

return a + b;

}

//三个数加法

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

System.out.println("调用三个数相加");

return a + b + c;

}

//四个数加法

public static int add(int a,int b,int c,int d) {

System.out.println("调用四个数相加");

return a + b + c + d;

}

}

1.4.2 重载的注意事项

a) 重载方法参数必须不同：

参数个数不同，如method(int x)与method(int x,int y)不同

参数类型不同，如method(int x)与method(double x)不同

参数顺序不同，如method(int x,double y)与method(double x,int y)不同

b) 重载只与方法名与参数类型相关与返回值无关

如void method(int x)与int method(int y)不是方法重载，不能同时存在

c) 重载与具体的变量标识符无关

如method(int x)与method(int y)不是方法重载，不能同时存在

/*

重载的注意事项

a) 重载方法参数必须不同：

参数个数不同，如method(int x)与method(int x,int y)不同

参数类型不同，如method(int x)与method(double x)不同

参数顺序不同，如method(int x,double y)与method(double x,int y)不同

b) 重载只与方法名与参数类型相关与返回值无关

如void method(int x)与int method(int y)不是方法重载，不能同时存在

c) 重载与具体的变量标识符无关

如method(int x)与method(int y)不是方法重载，不能同时存在

*/

public class Demo06Overload{

public static void main(String[] args){

//求两个小数的和

//double sum = add(3.1,3.4);

//System.out.println("sum = " + sum);

//求两个整数的和

//System.out.println(add(100,200));

System.out.println(add(100,200.0));

System.out.println(add(3.14,200));

}

//两个数加法

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

System.out.println("调用先int两个数相加");

return (int)(a + b);

}

//两个数加法

/*

c) 重载与具体的变量标识符无关

如method(int x)与method(int y)不是方法重载，不能同时存在

public static int add(int x,double y) {

System.out.println("调用先int两个数相加");

return (int)(x + y);

}

*/

//两个数加法

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

System.out.println("调用先int两个数相加");

return (a + b);

}

//两个数加法

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

System.out.println("调用先double两个数相加");

return a + b;

}

//两个数小数加法

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

System.out.println("调用两个小数相加");

return a + b;

}

//三个数加法

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

System.out.println("调用三个数相加");

return a + b + c;

}

//四个数加法

public static int add(int a,int b,int c,int d) {

System.out.println("调用四个数相加");

return a + b + c + d;

}

}

1.4.3 练习

1.4.3.1 比较两个数据是否相等。

参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，并在main方法中进行测试

public class Demo02MethodTest {

public static void main(String[] args) {

// 调用

System.out.println(compare(10, 20));//整数默认为int类型

System.out.println("-------------");

System.out.println(compare((byte)10, (byte)20));

System.out.println("-------------");

System.out.println(compare((short)10, (short)20));

System.out.println("-------------");

//System.out.println(compare((long)10, (long)20));

System.out.println(compare(10L, 20L));

}

// 两个byte类型的

public static boolean compare(byte a, byte b) {

System.out.println("byte");

// 第一种写法

// boolean flag = a==b?true:false;

// return flag;

// 第二种写法

// boolean flag = a == b;

// return flag;

// 第三种写法

return a == b;

}

// 两个short类型的

public static boolean compare(short a, short b) {

System.out.println("short");

return a == b;

}

// 两个int类型的

public static boolean compare(int a, int b) {

System.out.println("int");

return a == b;

}

// 两个long类型的

public static boolean compare(long a, long b) {

System.out.println("long");

return a == b;

}

}

第2章 方法案例

2.1 方法案例---超市购物小票方法封装

2.1.1 案例介绍与演示

将超市购物小票案例中，键盘录入部分封装为方法。

将switch语句完成的三个分支代码逻辑封装为3个方法

当用户输入1时，让用户输入所要购买的商品数量

当用户输入2时，给用户打印出对应的购物小票

当用户输入3时，退出系统

2.1.2 案例分析

a) 案例回顾

在超市购物小票案例中，我们使用了switch分为3个case执行用户选择的三个不同的操作：1输入购买数量 2打印购物小票 3退出系统

b) 所需封装的方法分析

案例中所需要封装的方法大致分为两种：

1：键盘录入数字与键盘录入字符串方法的封装

2：switch中三个case分支都是一个完整逻辑，均可以进行方法封装

/*

超市管理系统案例:用方法进行封装

------------------超市购物系统-----------------

1:输入购买数量 2:打印购物小票 3:退出系统

请输入您要进行的操作:

分析:

1:初始化系统(进货)

while(true){

2:展示功能菜单

3:获取用户键盘输入的功能选项

4:根据用户输入的功能选项完成对应的功能,用switch语句完成

输入1:实现输入购买数量功能(购买)

输入2:实现打印购物小票功能(打印)

输入3:实现退出系统功能(退出)

输入不存在的数字:您输入有误,请重新输入

}

分析方法封装:

方法1:获取键盘输入的整数

返回值类型: int

方法名: getNumber

参数列表: 空

方法2:case1:购买方法

返回值类型: void

方法名: buy

参数列表: 空

方法3:case2:打印方法

返回值类型: void

方法名: printTicket

参数列表: 空

方法4:case3:退出方法(可选)

返回值类型: void

方法名: exit

参数列表: 空

*/

import java.util.Scanner;

public class SuperMarketMange{

//1:初始化系统(进货)

//先定义3组15个变量用来记录商品信息

//定义少林寺酥饼核桃

static String slsName = "少林寺酥饼核桃";//商品名称

static String slsID = "(090115)";//商品id

static double slsPrice = 15.50;//商品单价

static int slsNumber = 0;//商品数量

static double slsMoney = 0;//商品金额

static String xjName = "新疆美味羊肉串";

static String xjID = "(090028)";

static double xjPrice = 16.00;

static int xjNumber = 0;

static double xjMoney = 0;

static String skName = "尚康杂粮牡丹饼";

static String skID = "(090027)";

static double skPrice = 14.50;

static int skNumber = 0;

static double skMoney = 0;

public static void main(String[] args){

//TODO把参数修改为定义在成员变量位置

//不知道系统运行几次,所以用while循环

while(true){

//2:展示功能菜单

System.out.println("------------------超市购物系统-----------------");

System.out.println("1:输入购买数量 2:打印购物小票 3:退出系统");

System.out.println("请输入您要进行的操作:");

//3:获取用户键盘输入的功能选项

//Scanner sc = new Scanner(System.in);//TODO 删除创建Scanner对象

int choose = getNumber();//TODO 把用对象的方式获取键盘输入的整数,换成用方法的方式获取

//4:根据用户输入的功能选项完成对应的功能,用switch语句完成

switch(choose){

case 1:

//TODO 输入1:实现调用输入购买数量功能的方法(购买)

buy();

break;

case 2:

//TODO 输入2:实现调用打印购物小票功能方法(打印)

printTicket();

break;

case 3:

//TODO 输入3:实现调用退出系统功能方法(退出)

exit();

break;

default:

//输入不存在的数字:您输入有误,请重新输入

System.out.println("您输入有误,请重新输入!");

break;

}

}

}

/*

方法1:获取键盘输入的整数

返回值类型: int

方法名: getNumber

参数列表: 空

*/

public static int getNumber(){

Scanner sc = new Scanner(System.in);

int number = sc.nextInt();

return number;

}

/*

方法2:case1:购买方法

返回值类型: void

方法名: buy

参数列表: 空

*/

public static void buy(){

System.out.println("请输入您要购买"+slsName+"的数量:");

slsNumber = getNumber();//TODO 把用对象的方式获取键盘输入的整数,换成用方法的方式获取

System.out.println("请输入您要购买"+xjName+"的数量:");

xjNumber = getNumber();//TODO 把用对象的方式获取键盘输入的整数,换成用方法的方式获取

System.out.println("请输入您要购买"+skName+"的数量:");

skNumber = getNumber();//TODO 把用对象的方式获取键盘输入的整数,换成用方法的方式获取

//计算每种商品购买的价钱

slsMoney = slsNumber * slsPrice;

xjMoney = xjNumber * xjPrice;

skMoney = skNumber * skPrice;

}

/*

方法3:case2:打印方法

返回值类型: void

方法名: printTicket

参数列表: 空

*/

public static void printTicket(){

//计算:商品种类

int goodsItem = 3;

//计算:商品数量

int goodsNumner = slsNumber + xjNumber + skNumber;

//计算:商品总金额

double goodsMoney = slsMoney + xjMoney + skMoney;

//打印小票

//票头

System.out.println(" 欢 迎 光 临 ");

System.out.println("品名 售价 数量 金额");

System.out.println("------------------------------------------------");

//票体

System.out.println(slsName+slsID+" "+slsPrice+" "+slsNumber+" "+slsMoney);

System.out.println(xjName+xjID+" "+xjPrice+" "+xjNumber+" "+xjMoney);

System.out.println(skName+skID+" "+skPrice+" "+skNumber+" "+skMoney);

System.out.println("------------------------------------------------");

//票脚

System.out.println(" "+goodsItem+" 项商品 共计: "+goodsNumner+" 件");

System.out.println("总计: " + goodsMoney);

System.out.println("凭此小票换取发票!");

}

/*

方法4:case3:退出方法(可选)

返回值类型: void

方法名: exit

参数列表: 空

*/

public static void exit(){

System.out.println("程序结束!");

System.exit(0);//结束正在运行java虚拟机 0-正常退出

}

}

2.2 扩展练习：

2.2.1 1.在全班同学中随机的打印出一名同学名字。

我们对本案例进行分析，得出如下分析结果：

• 存储全班同学名字
• 打印全班同学每一个人的名字
• 在班级总人数范围内，随机产生一个随机数，查找该随机数所对应的同学名字

该案例须有以下3个内容：

• 存储所有同学姓名
• 总览全班同学姓名
• 随机点名其中一人，打印到控制台

随机点名器明确地分为了三个功能。如果将多个独立功能的代码写到一起，则代码相对冗长，我们可以针对不同的功能可以将其封装到一个方法中，将完整独立的功能分离出来。

而在存储同学姓名时，如果对每一个同学都定义一个变量进行姓名存储，则会出现过多孤立的变量，很难一次性将全部数据持有。此时，我们可以使用数组解决多个数据的存储问题。

代码实现:

/*

随机点名器:

1.存储全班同学名字

2.打印全班同学每一个人的名字

3.在班级总人数范围内，随机产生一个随机数，查找该随机数所对应的同学名字

*/

import java.util.Scanner;

import java.util.Random;

public class RandomStudent{

public static void main(String[] args){

//1.存储全班同学名字

//定义一个String类型数组用来存储同学姓名

String[] array = new String[3];

//调用存储全班同学姓名的方法

addStudentNmaes(array);

//2.打印全班同学每一个人的名字

printStudentNames(array);

//3.在班级总人数范围内，随机产生一个随机数，查找该随机数所对应的同学名字

String name = randomStudent(array);

//打印随机到的学生的姓名

System.out.println("随机到的学生的姓名: " + name);

}

/*

存储全班同学姓名的方法

方法的名字:addStudentNmaes

方法的返回值:void

方法的参数列表:String[] array

*/

public static void addStudentNmaes(String[] arr){

//创建Scanner对象

Scanner sc = new Scanner(System.in);

//遍历数组,为数组中元素赋值

for(int i=0; i<arr.length; i++){

System.out.println("请输入第"+(i+1)+"个,学生的姓名: ");

arr[i] = sc.next();

}

}

/*

打印全班同学每一个人的名字

方法的名字:printStudentNames

方法的返回值:void

方法的参数列表:String[] array

*/

public static void printStudentNames(String[] arr){

System.out.println("=====================全班同学的姓名=========================");

//遍历数组

for(int i=0; i<arr.length; i++){

System.out.println("第"+(i+1)+"个学生的姓名: " + arr[i]);

}

System.out.println("=============================================================");

}

/*

在班级总人数范围内，随机产生一个随机数，查找该随机数所对应的同学名字

方法的名字:randomStudent

方法的返回值:String

方法的参数列表:String[] array

*/

public static String randomStudent(String[] arr){

//创建Random对象

Random r = new Random();

//在班级总人数范围内，随机产生一个随机数

int index = r.nextInt(arr.length);//[0,arr.length)

//在数组中查找该随机数所对应的同学名字

String name = arr[index];

return name;

}

}

2.2.2 2.现在，我们将原有的库存管理案例，进行业务逻辑的封装。

将对下列功能进行方法封装：

• 打印库存清单功能
• 库存商品数量修改功能
• 退出程序功能

/*

库存管理案例

-------------库存管理------------

1.查看库存清单

2.修改商品库存数量

3.退出

请输入要执行的操作序号：

每一项功能操作，我们采用方法进行封装，这样，可使程序的可读性增强。

选择“1.查看库存清单”功能，则控制台打印库存清单

选择“2.修改商品库存数量”功能，则对每种商品库存数进行更新

选择“3.退出”功能，则退出库存管理，程序结束

分析:

1.采用数组定义商品信息

while(true){

2.展示功能菜单,获取用户键盘输入的功能序号

3.根据用户输入的功能序号,选择对应的功能,采用switch语句完成

选择1,调用查看库存清单方法

选择2,调用修改商品库存数量方法

选择3调用退出程序方法

}

---------------------商场库存清单-------------------------------

品牌型号 尺寸 价格 配置 库存数

MacBookAir 13.3 6988.88 i5处理器4GB内存128G固态硬盘 5

ThinkPadT450 14.0 5999.99 i5处理器4GB内存500G硬盘 10

ASUS-FL5800 15.6 4999.5 i7处理器4GB内存128G固态硬盘 18

-------------------------------------------------------------------

总库存数:33

库存商品总金额:184935.3

*/

import java.util.Scanner;

public class StoreManage{

public static void main(String[] args){

//1.采用数组定义商品信息

//定义品牌型号信息数组

String[] brand = {"MacBookAir","ThinkPadT450","ASUS-FL5800"};

//定义尺寸信息数组

double[] size = {13.3,14.0,15.6};

//定义价格信息数组

double[] price = {6988.88,5999.99,4999.5};

//定义配置信息数组

String[] config = {"i5处理器4GB内存128G固态硬盘","i5处理器4GB内存500G硬盘","i7处理器4GB内存128G固态硬盘"};

//定义库存数信息数组

int[] count = {0,0,0};

while(true){

//2.展示功能菜单,获取用户键盘输入的功能序号

int choose = chooseFunction();

//3.根据用户输入的功能序号,选择对应的功能,采用switch语句完成

switch(choose){

case 1:

//选择1,调用查看库存清单方法

printStoreList(brand,size,price,config,count);

break;

case 2:

//选择2,调用修改商品库存数量方法

updateCount(brand,count);

break;

case 3:

//选择3调用退出程序方法

exit();

break;

default:

System.out.println("您输入的功能不存在,请重新输入!");

break;

}

}

}

/*

展示功能菜单,获取用户键盘输入的功能序号

方法名称:chooseFunction

方法返回值类型:int

方法参数列表:

*/

public static int chooseFunction(){

System.out.println("-------------库存管理------------");

System.out.println("1.查看库存清单");

System.out.println("2.修改商品库存数量");

System.out.println("3.退出");

System.out.println("请输入要执行的操作序号：");

//创建Scanner对象

Scanner sc = new Scanner(System.in);

int choose = sc.nextInt();//获取用户键盘输入的功能序号

return choose;

}

/*

查看库存清单方法

方法名称:printStoreList

方法返回值类型:void

方法参数列表:String[] brand,double[] size,double[] price,String[] config,int[] count

*/

public static void printStoreList(String[] brand,double[] size,double[] price,String[] config,int[] count){

//定义总库存数和总库存商品总金额

int totalCount = 0;

double totalPrice = 0.0;

//打印清单

//打印清单顶部

System.out.println("-------------------------商场库存清单-------------------------------");

System.out.println("品牌型号 尺寸 价格 配置 库存数");

//打印清单中部

for(int i=0; i<brand.length; i++){

if(i==1){

System.out.println(brand[i]+" "+size[i]+" "+price[i]+" "+config[i]+" "+count[i]);

}else{

System.out.println(brand[i]+" "+size[i]+" "+price[i]+" "+config[i]+" "+count[i]);

}

//计算总库存数和总库存商品总金额

totalCount += count[i];

totalPrice += price[i] * count[i];

}

System.out.println("---------------------------------------------------------------------");

//打印清单底部

System.out.println("总库存数: " + totalCount);

System.out.println("库存商品总金额: " + totalPrice);

}

/*

修改商品库存数量

方法名称:updateCount

方法返回值类型:void

方法参数列表:String[] brand,int[] count

*/

public static void updateCount(String[] brand,int[] count){

//创建Scanner对象

Scanner sc = new Scanner(System.in);

//遍历数组

for(int i=0; i<count.length; i++){

System.out.println("请更新"+brand[i]+"电脑的库存数量: ");

count[i] = sc.nextInt();//获取用户键盘输入新的库存数量

}

}

//退出程序

public static void exit(){

System.out.println("程序已退出!");

System.exit(0);//终止java虚拟机

}

}

第3章 本日自习作业：

3.1 知识点相关题

3.1.1 定义3个重载方法，求2个，3个，4个数的平均数

package StudentJavaSEday05;

/**

* 定义3个重载方法，求2个，3个，4个数的平均数

* @author 奋斗蒙

*

*/

public class Overloaded1 {

public static void main(String[] args) {

System.out.println(avg(10,20));

System.out.println(avg(10,20,30));

System.out.println(avg(10,20,30,40));

}

//两个数求平均数

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

return (a+b)/2;

}

//三个数求平均数

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

return (a+b+c)/3;

}

//四个数求平均数

public static int avg (int a ,int b,int c,int d){

return (a+b+c+d)/4;

}

}

3.1.2 接收一个字符串类型的数组，返回该数组中第2个元素，如果数组长度小于2，就返回”对不起，没有这个人”

package StudentJavaSEday05;

import java.util.Scanner;

/**

* 接收一个字符串类型的数组，返回该数组中第2个元素，如果数组长度小于2，就返回”对不起，没有这个人”

*

* @author 奋斗蒙

*

*/

public class ShuZu {

public static void main(String[] args) {

//数组中有第二个元素

String [] arr = {"刘备","关羽","张飞"};

String x = erYuanSu(arr); //调用方法

System.out.println(x);

//数组中没有第二个元素

String [] arr1 = {"赵云"};

String y = duiBuQi(arr1); //调用方法

System.out.println(y);

}

private static String duiBuQi(String[] arr1) {

if (arr1.length<2) {

return"对不起，没有这个人";

}else{

return arr1[1];

}

}

private static String erYuanSu(String[] arr) {

if (arr.length<2) {

return"对不起，没有这个人";

}else{

return arr[1];

}

}

}

3.1.3 定义方法,完成数组遍历

public class Demo01MethodTest {

public static void main(String[] args) {

// 定义数组

int[] arr = { 11, 22, 33, 44, 55 };

printArray1(arr);

printArray2(arr);

}

/*

* 按照以下格式遍历数组

* [元素1, 元素2, 元素3, ...]

*/

public static void printArray2(int[] arr) {

System.out.print("[");

for(int x=0; x<arr.length; x++){

if(x==arr.length-1){

System.out.println(arr[x]+"]");

}else {

System.out.print(arr[x]+", ");

}

}

}

/*

* 定义遍历数组的方法

* 两个明确：

* 返回值类型：void

* 参数列表：int[] arr

*/

public static void printArray1(int[] arr) {

for(int x=0; x<arr.length; x++){

System.out.println(arr[x]);

}

}

}

3.1.4 定义方法,获取数组的最值

public class Demo02MethodTest {

public static void main(String[] args) {

// 定义数组

int[] arr = { 34, 67, 10, 28, 59 };

//调用获取数组中的最大值的方法

int max = getMax(arr);

System.out.println("max:"+max);

//调用获取数组中的最小值的方法

int min = getMin(arr);

System.out.println("min:"+min);

}

//获取数组中的最小值的方法

public static int getMin(int[] arr) {

int min = arr[0];

for(int i=1; i<arr.length; i++) {

if(arr[i] < min) {

min = arr[i];

}

}

return min;

}

/*

* 获取数组中的最大值的方法

* 两个明确：

* 返回值类型：int

* 参数列表：int[] arr

*/

public static int getMax(int[] arr) {

int max = arr[0];

for(int i=1; i<arr.length; i++) {

if(arr[i] > max) {

max = arr[i];

}

}

return max;

}

}

3.1.5 定义方法,实现数组元素求和

public class Demo03MethodTest {

public static void main(String[] args) {

// 定义数组

int[] arr = { 1, 2, 3, 4, 5 };

//调用数组元素求和方法

int sum = sum(arr);

System.out.println("sum:"+sum);

}

/*

* 定义数组元素求和方法

* 两个明确：

* 返回值类型：int

* 参数列表：int[] arr

*/

public static int sum(int[] arr) {

int sum = 0;

for(int i=0; i<arr.length; i++) {

sum += arr[i];

}

return sum;

}

}

3.1.6 定义一个方法，计算并打印1—100的累加和；

public class Test01 {

public static void main(String[] args) {

getSum();

}

private static void getSum() {

int sum = 0;

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

sum += i;

}

System.out.println("1-100的累加和为："+sum);

}

}

3.1.7 定义一个方法，可以打印n行m列的“*”符号；m,n由形式参数决定

public class Test01 {

public static void main(String[] args) {

print(3,4);

}

private static void print(int m, int n) {

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

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

System.out.print("*");

}

System.out.println();

}

}

}

3.1.8 定义一个方法，计算1—n的累加和；n值由形参定义；将累加结果返回；

public class Test01 {

public static void main(String[] args) {

int sum = getsum(9);

System.out.println("1-n之间的累加为："+sum);

}

private static int getsum(int n) {

int sum = 0;

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

sum += i;

}

return sum;

}

}

3.1.9 定义一个方法，查找三个数的最大值，将结果返回；

public class Test01 {

public static void main(String[] args) {

int max = getMax(28,52,32);

System.out.println("三个数中最大值为："+max);

}

private static int getMax(int i, int j, int k) {

int a;

if(j > i){

a = i;

i = j;

j = a;

}

if(k > i){

a = i;

i = k;

k = a;

}

return i;

}

3.1.10 定义类Test2，定义main()方法，并添加以下重载方法：

• 定义方法getMax，可以求两个整数的最大值；
• 定义方法getMax，可以求三个整数的最大值；
• 定义方法getMax，可以求两个浮点数的最大值；

public class Test2 {

public static void main(String[] args) {

getMax(1, 2);

getMax(1, 2, 3);

getMax(1.1, 1.11);

}

private static void getMax(double d, double e) {

double max = d > e ? d : e;

System.out.println("两个小数中最大值为"+max);

}

private static void getMax(int i, int j, int k) {

int max = i > j ? (i > k ? i : k) : (j > k ? j : k);

System.out.println("三个整数中最大值为"+max);

}

private static void getMax(int i, int j) {

int max = i > j ? i : j;

System.out.println("两个整数中最大值为" + max);

}

}

3.2 代码题

3.2.1 输出nn乘法表。

要求：在主方法里键盘录入n(1<=n<=9)，并调用打印nn乘法表的方法。

//导Scanner类的包

package StudentJavaSEday05;

import java.util.Scanner;

/**

* 打印MN乘法口诀表

* @author 奋斗蒙

*

*/

public class Mn {

public static void main(String[] args) {

// 创建Scanner类的对象

Scanner sc = new Scanner(System.in);

System.out.println("请输入n的值：(1~9)");

// 调用方法，接收键盘录入的值

int n = sc.nextInt();

// 调用方法

printNN(n);

}

/*

* 需求：输出对应的nn乘法表 两个明确：

* 返回值类型：void

* 参数列表：int n

*/

public static void printNN(int n) {

for (int x = 1; x <= n; x++) {

for (int y = 1; y <= x; y++) {

System.out.print(y + "*" + x + "=" + y * x + "\t");

}

System.out.println();

}

}

}

3.2.2 编写方法将下面的数组元素前后互换

[11, 32，55, 47，79，23]

置换后的数组元素为：

[23, 79, 47, 55, 32, 11]

答案:

package StudentJavaSEday05;

/**

* [11, 32，55, 47，79，23] 置换后的数组元素为： [23, 79, 47, 55, 32, 11]

*

* @author 奋斗蒙

*

*/

public class ZhuanHuang {

public static void main(String[] args) {

int[] arr = { 11, 32, 55, 47, 79, 23 };

printArr(arr);

swapArr(arr);

printArr(arr);

}

public static void swapArr(int[] arr) {

for (int i = 0, j = arr.length - 1; i < j; i++, j--) {

int temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

}

}

public static void printArr(int[] arr) {

System.out.print("[");

for (int i = 0; i < arr.length; i++) {

if (i == arr.length - 1) {

System.out.println(arr[i] + "]");

} else {

System.out.print(arr[i] + ", ");

}

}

}

}