第五天 方法【悟空教程】
第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
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
for(int j=0; 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
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
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调用退出程序方法
}
---------------------商场库存清单-------------------------------
品牌型号尺寸价格配置库存数
MacBookAir13.36988.88i5处理器4GB内存128G固态硬盘5
ThinkPadT450 14.05999.99i5处理器4GB内存500G硬盘10
ASUS-FL580015.64999.5i7处理器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
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
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
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
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
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
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
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] + ", ");
}
}
}
}
网友评论