java编程基础 if else，switch，while，do while，for，array，类和对象

• 开发java程序需要安装JDK并配置环境变量，开发工具建议使用免费开源eclipse

点击->跳转到JDK 下载安装配置教程
https://blog.csdn.net/qq_41408088/article/details/105506105

---

点击我跳转 > Eclipse下载地址
Eclipse 使用教程 https://blog.csdn.net/qq_36798713/article/details/79530056

• 第1章：编写第一个java程序 Hello world

public class HelloWorld {

	// main函数是程序的主入口
	public static void main(String[] args) {
		// 打印结果输出到控制台输出
		System.out.println("Hello world");
	}
}

打印结果为: Hello World
总结：你已经学会第一个Java程序，继续努力，勤能补拙

• 第2章：学习java 8种基本数据，变量声明和使用

序号	数据类型	位数	默认值	取值范围	举例说明
1	byte(位)	8	0	-2^7 - 2^7-1	byte b = 10;
2	short(短整数)	16	0	-2^15 - 2^15-1	short s = 10;
3	int(整数)	32	0	-2^31 - 2^31-1	int i = 10;
4	long(长整数)	64	0	-2^63 - 2^63-1	long l = 10l;
5	float(单精度)	32	0.0	-2^31 - 2^31-1	float f = 10.0f;
6	double(双精度)	64	0.0	-2^63 - 2^63-1	double d = 10.0d;
7	char(字符)	16	’ ’	0 - 2^16-1	char c = ‘c’;
8	boolean(布尔值)	8	false	true、false	boolean bool = true;

java有8种基本数据类型(byte、short、int、long、float、double、char、boolean)
4 种整数类型(byte、short、int、long)
2 种浮点数类型(float、double)
1 种字符类型(char)
1 种布尔类型(boolean)

---

注意：int a = 10 ; 等号为赋值符号 ，10赋值给a，并不是 a等于10

算术运算符	解释	举例说明	结果解释	结果
+	加	int a=1；a+1;	和	a=2
-	减	int a=1；a-1;	差	a=0
*	乘	int a=1；a*1;	积	a=1
/	除	int a=1；a/1;	商	a=1
%	取余	int a=3；a%2;	余	a=1
++	自增	int a=1; a++;	和	a=2
- -	自减	int a=1; a- -;	差	a=0

注意：在判断一个数是否为偶数，不要使用除2==0，应该使用取余2==0 比如 8/2==4 ，8%2==0

public class VariableDemo {

	//main函数程序主入口
	public static void main(String[] args) {
		// 满足声明变量规则 数据类型 变量名 = 值;
		// 变量的使用，使用 变量名*2
		byte b = 10;// 声明 一个byte类型的变量 值=10
		System.out.println("b 变量名+2 打印结果： "+(b+2));// + 加 结果 12
		short s = 10;
		System.out.println("s 变量名-2 打印结果： "+(s-2));// - 减 结果 8.0
		int i = 10;
		System.out.println("i 变量名*2 打印结果： "+(i*2));// * 乘 结果 20
		long l = 10l;
		System.out.println("l 变量名/2 打印结果： "+(l/2));// / 除 结果 5
		float f = 10.0f;
		System.out.println("f 变量名*2.5 打印结果： "+f*2.5);
		double d = 10.0d;
		System.out.println("d 变量名*3.50 打印结果： "+d*3.50);
		char c = '男';
		System.out.println("c 变量名 打印结果： "+c+"人");
		boolean bool = true;
		System.out.println("bool 变量名 打印结果： "+bool);
	}
}

b 变量名+2 打印结果： 12
s 变量名-2 打印结果： 8.0
i 变量名2 打印结果： 20
l 变量名/2 打印结果： 5
f 变量名2.5 打印结果： 25.0
d 变量名*3.5 打印结果： 35.0
c 变量名 打印结果： 男人
bool 变量名 打印结果： true

---

总结：合理使用变量可以提高代码可读性，可维护性，拒绝使用没有任何语义化的变量比如pingguo(苹果) 应当使用apple

• 第3章：学习if else条件语句判断

比较运算符	解释	举例说明	结果解释	结果
-	-	假如 int a = 1; boolean flag = false;	-	-
==	相等	flag = 1；a == 1;	真	flag=true
!=	不相等	flag =1； a != 1;	假	flag=false
<	大于	flag = 1；a < 1 ;	假	flag=false
>	小于	flag = 1；a > 1 ;	假	flag=false
<=	小于或等于	flag = 1；a <= 1;	真	flag=true
>=	大于或等于	flag = 1；a >= 1;	真	flag=true

逻辑运算符	解释	举例说明	结果解释	结果
-	假如 int a=1; boolean flag = true;	-	-	-
||	或运算符 如果任何两个操作数任何一个为true，条件为true	flag=(a==1 || a!=2);	真	true
&&	与运算符 当且仅当两个操作数都为true，条件才为true	flag =(a==1 && a!=2);	真	true
!	非运算符 如果条件为true，则逻辑非运算符将得到false	flag = !flag;	假	false

代码优化：|| 只要有一个条件满足就执行，后面判断将会被忽略，一般把容易满足的条件放左边。&&只要有一个失败则不执行，一般把容易不满足的放左边

public class Condition {

// main函数是程序的主入口
	public static void main(String[] args) {

		// 初始化参数
		int seconds = 10;//成绩10 单位秒
		String sex = "女";//性别

		// if 会判断条件表达式是否为true  true进入if 否则进入else
		if (seconds == 10) {
			// true就进入 if代码块中{ }
			System.out.println(seconds == 10);
			System.out.println("你进入决赛!");
			
			// equals()比较字符串是否相等
			if (sex.equals("男")) {
				System.out.println("进入男子组!");
			}else{
				System.out.println("进入女子组!");
			}
			
		} else {
			// false 进入else代码块中{ }
			System.out.println(seconds == 10);
			System.out.println("别灰心，下次继续加油！");
		}
	}
}

打印结果: true
打印结果: 你进入决赛!
打印结果: 进入男子组!

---

总结： if 主要用于流程控制，条件表达式满足执行if，不满足执行else 在嵌套if else中也是如此

• 第4章：学习switch 选择结构

import java.util.Scanner;

public class ChoiceStructDemo {

	// main函数是程序的主入口
	public static void main(String[] args) {
		// Scnner 用于用户输入值到控制台中
		Scanner input = new Scanner(System.in);
		
		// nextInt()代表用户输入必须是一个Int类型数字
		// String next(),double nextDouble()...
		System.out.println("请选择一个与今天星期对应的数字:(1 , 2 , 3, 4, 5, 6, 7)");
		int week = input.nextInt();// 获取用户输入第一个值
		
		// 把 number变量值放入 switch表达式中(number)
		// switch(表达式)的结果必须是整数1 2 3...,字符 a b c...或枚举量值这里占时不做学习。
		switch (week) {
		case 1: // 当用户输入的是 1
			System.out.println("打印结果: 今天星期一，怎么还不放假");// 打印结果
			break;// break 当代码执行到break 不管下面是否执行完都会直接跳出switch
		case 2: 
			System.out.println("打印结果: 今天星期二，怎么还不放假");
			break; 
		case 3:
			System.out.println("打印结果: 今天星期三，怎么还不放假");
			break;
		case 4:
			System.out.println("打印结果: 今天星期四，明天星期五啦开心");
			break;
		case 5:
			System.out.println("打印结果: 今天星期五，终于要放假啦");
			break;
		case 6:
			System.out.println("打印结果: 今天星期六，阳光真好，舒服");
			break;
		case 7:
			System.out.println("打印结果: 今天星期日,快乐时光总是这么短暂!");
			break;
		default:// defalut 当用户输入的值和case值不匹配 默认进入default执行代码
			System.out.println("打印结果: 作业还没有写");
			break; //跳出switch选择结构
		}
		System.out.println("打印结果: switch执行结束");
	}
}

用户输入: 1
打印结果: 今天星期一，怎么还不放假
打印结果: switch执行结束
用户输入: 5
打印结果: 今天星期五，终于要放假啦
打印结果: switch执行结束
用户输入: 10
打印结果: 作业还没有写
打印结果: switch执行结束

---

总结：switch 选择结构用于比如菜单，这种可以预知可列举固定选择

• 第5章：学习while循环和do-while循环

while 循环学习

public class LoopDemo {
	// main函数是程序的主入口
	public static void main(String[] args) {
		// 声明一个int类型值
		int number = 1;

		// while(表达式)的值是一个boolean值
		// true 再循环一次 ， false 执行while(){}外的代码
		while (number < 11) {//当number值大于10时循环结束 10=10 11>10
			System.out.println("打印结果：打印第" + number + "份简历");
			// number++ 等同 number = number + 1; 自增加 1
			number++;
		}
		System.out.println("打印结果：while 循环结束");
	}
}

打印结果：打印第1份简历
打印结果：打印第2份简历
打印结果：打印第3份简历
打印结果：打印第4份简历
打印结果：打印第5份简历
打印结果：打印第6份简历
打印结果：打印第7份简历
打印结果：打印第8份简历
打印结果：打印第9份简历
打印结果：打印第10份简历
打印结果：while 循环结束

---

总结： while 减少重复代码工作，合理使用while循环让我们代码更加简洁容易维护

do-while 循环学习

import java.util.Scanner;

public class DoWile {

	public static void main(String[] args) {

		Scanner input = new Scanner(System.in);
		System.out.println("--------启动程序do while--------");
		
		// 初始化参数
		String str = ""; // 设置用户输入字符为空
		boolean flag = false;// 设置默认状态为 false
		int count = 0; // 设置执行次数为 0
		
		do { // do-while 和 while 区别在于不管第一次是否为true都会执行一次
			
			// 接受用户输入的值
			System.out.println("是否继续(y/n)");
			str = input.next();
			
			// 对用户输入的值进行判断 y n 任意字符
			if ("y".equals(str)) {
				flag = true; // 修改用户操作状态
				System.out.println("-->操作成功");
			} else if ("n".equals(str)) {
				flag = false;
				System.out.println("--->程序结束");
			} else {
				System.out.println("---->输入错误!");
			}
			
			// 计数
			count++;
			// 打印执行次数
			System.out.println("----->执行[" + count + "]次");
			
			// while(boolean) 表达式必须是一个boolean类型的值 true 或者 false
		} while (flag);
	}
}

打印结果：--------启动程序do while--------
打印结果：是否继续(y/n)
用户输入：y
打印结果：–>操作成功
打印结果：----->执行[1]次
打印结果：是否继续(y/n)
用户输入：y
打印结果：–>操作成功
打印结果：----->执行[2]次
打印结果：是否继续(y/n)
用户输入：n
打印结果：—>程序结束
打印结果：----->执行[3]次

---

总结： while 和 do while 都可以减少重复代码工作，区别在于do while 至少执行一次，而while可能会一次都不会执行

• 第6章：学习for循环,并求出0-100偶数之和

public class ForLoop {

	public static void main(String[] args) {

		// 利用for循环 求出 0,1,2........100偶数之和

		// 初始化参数
		int sum = 0;
		// 起始值 ; 条件表达式; 末尾循环体
		for (int i = 0; i <= 100; i++) {

			// 1%2==1 2%2==0 4%2==0
			if (i % 2 == 0) {
				// sum = sum + i;
				sum += i;
			}
		}
		// 打印最终结果
		System.out.println("打印结果: [" + sum + "]");
	}
}

打印结果: [2550]

---

总结：在for循环中，循环控制变量的起始值和修改都放在语句头部分，形式较简洁，且特别适用于循环次数已知的情况

• 第7章：学习数组声明、for循环遍历、foreach循环遍历、冒泡排序算法

 array数组基本用法学习

public class ArrayDemo {

	public static void main(String[] args) {

		// 声明数组[] 有以下4种
		// 数组用于存储同一数据类型
		// 数据类型[] 变量名 = new 数据类型[数组长度] //数组长度是固定的
		int[] array1 = new int[5];// 建议使用
		String array2[] = new String[5];
		double[] array3 = { 1, 2, 3, 4, 5 }; // 建议使用
		short[] array4 = new short[] { 1, 2, 3, 4, 5 };

		System.out.println("数组长度: [" + array4.length + "]");
		// for(int i = 0 ; i < 5 ; i++)
		for (int i = 0; i < array4.length; i++) {

			// 数组访问元素使用下标访问 array4[0] 值1
			System.out.println("打印结果: array4[" + i + "] 值为:" + array4[i]);
		}
		
		
		System.out.println("foreach 循环打印数组结果");
		int i = 0;
		// for(数据类型 迭代名 :变量名)
		for (short s : array4) {
			System.out.println("打印结果: array4[" + i++ +"] 值为:" + s);
		}
	}
}
		

数组长度: [5]
打印结果: array4[0] 值为:1
打印结果: array4[1] 值为:2
打印结果: array4[2] 值为:3
打印结果: array4[3] 值为:4
打印结果: array4[4] 值为:5
<---------foreach 循环打印数组结果--------->
打印结果: array4[0] 值为:1
打印结果: array4[1] 值为:2
打印结果: array4[2] 值为:3
打印结果: array4[3] 值为:4
打印结果: array4[4] 值为:5

---

总结：数组用于存储同一数据类型，获取数组中值通过下标取值，下标从0开始，存取方便使用简单，缺点固定长度

学习冒泡排序算法

public class BubbleSort {

	public static void main(String[] args) {

		// 声明一个无序数组
		int[] array = { 7, 3, 2, 1, 5 };

		// 排序前原数组
		System.out.print("排序前数组:");
		for (int i : array) {
			System.out.print(i + "\t");

		}
		System.out.println("\n");


		// for(i = 0; i< 5-1 ;0++)
		for (int i = 0; i < array.length - 1; i++) {
		
			// for(int j = 0; j < 5-1-0; 0++)
			// for(int j = 0; j < 5-1-1; 1++)
			// for(int j = 0; j < 5-1-2; 2++)...
			for (int j = 0; j < array.length - 1 - i; j++) {
				if (array[j] > array[j + 1]) { // array[0] > array[1] = 7 > 3

					int temp = array[j]; // temp = array[0] = 7
					array[j] = array[j + 1];// array[0] = array[1] = 3
					array[j + 1] = temp;// array[1] = temp = 7
				}
				//每次循环减少一次比较
				System.out.print(array[j] + "\t");

			}
			System.out.println();
		}


		// 排序后打印数组
		System.out.print("\n排序后数组:");
		for (int i : array) {
			System.out.print(i + "\t");
		}
		System.out.println();
	}
}

打印结果: 排序前数组:7 3 2 1 5
打印结果: 排序后数组:1 2 3 5 7

---

总结：冒泡排序算法在Java笔试面试题中出现几率非常大，他的一个逻辑算法就是每次拿第一个数比较后面一个数，谁大两数交换，每次循环减少一次比较次数。冒泡排序口诀：外层for循环数组.length-1,内层for循环数组.length-1-i,然后两数比较交换

• 第8章：学习类与对象，方法的调用

/**
 * 学生类
 * @author Gawain
 * @version 1.0
 */
public class Student {

	// 定义在类中变量为成员变量也称全局变量
	// 定义在方法中为变量为局部变量
	// 成员变量有默认值,局部变量没有默认值

	/**
	 * 学号 [1001]
	 * @param id
	 */
	public int id;

	/**
	 * 姓名 [张三]
	 * @param username
	 */
	public String username;

	/**
	 * 性别 [男]
	 * @param sex
	 */
	public char sex;

	/**
	 * 零花钱 [200.00]
	 * @param property
	 */
	public double money;

	// 修饰符有四种 public private default protected
	// public:公开的 所有人可以访问
	// private:私有的 只可以本类访问
	// default:默认的 就是不写修饰符
	// protected:受保护的 可以本类、同包或者子类访问
	// 方法声明: 修饰符 返回值 方法名([参数...]){方法体}
	public void showInfo() {
		// 打印学生信息
		System.out.println("学生信息 [学号=" + id + ", 姓名=" + username + ", "
				+ "性别=" + sex + ", 零花钱=" + money + "]");
	}

	public static void main(String[] args) {
		// 创建学生对象1
		// 对象创建:类名 对象名 = new 类名();
		Student student1 = new Student();
		// 学生对象1调用类中showInfo方法
		student1.showInfo();

		// 创建学生对象2
		Student student2 = new Student();
		// 对象成员变量赋值: 对象名.成员变量 = 值 ;
		student2.id = 1001; // 学号 = 1001
		student2.username = "张三"; // 姓名 = 张三
		student2.sex = '男'; // 性别 = 男
		student2.money = 200.00; // 零花钱  = 200.00

		// 学生对象2调用类中showInfo方法
		student2.showInfo();

		// 创建学生对象3
		Student student3 = new Student();
		student3.id = 1002;
		student3.username = "李四";
		student3.sex = '男';
		student3.money = 100.00;

		// 学生对象3调用类中showInfo方法
		student3.showInfo();
	}

}

打印结果：学生信息 [学号=0, 姓名=null, 性别=， 零花钱=0.0]
打印结果：学生信息 [学号=1001, 姓名=张三, 性别=男， 零花钱=200.0]
打印结果：学生信息 [学号=1002, 姓名=李四, 性别=男， 零花钱=100.0]

---

总结：使用对象存储数据，让我们数据更好管理完整性，假如让你去声明100个人所有信息，使用对象你只需要使用 new 100次 完全不用担心变量名会重复并且更加好方便存取，方法可以提高代码复用性。

• 第9章：深刻理解类和对象之间的关系

/**
 * 学生类
 * @author Gawain
 * @version 1.0
 */
public class Student {

	/**
	 * 私有成员成员变量
	 */
	private int id;
	private String username;
	private char sex;
	private double money;

	/**
	 * 提供公共的属性 get/set方法
	 * @return
	 */
	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}

	public double getMoney() {
		return money;
	}

	public void setMoney(double money) {
		this.money = money;
	}

	// 方法声明: 修饰符 返回值 方法名([参数...]){方法体}
	// 类中的方法有四种 :无参无返回、无参有返回、有参无返回，有参有返回方法

	// showInfo() 无参无返回
	public void showInfo() {
		// 打印学生信息
		System.out.println("学生信息 [学号=" + id + ", 姓名=" + username + ", " + "性别=" + sex + ", 零花钱=" + money + "]");
	}

	// toString() 无参有返回方法
	@Override
	public String toString() {
		return "Student [id=" + id + ", username=" + username + ", sex=" + sex + ", money=" + money + "]";
	}

	// 需求:炫富 比谁钱多,谁钱多就打印出相差金额
	// toString() 有参无返回方法
	public void compare1(Student stu) {
		// this关键字指向的是本类成员变量，而参数传递分值传递和引用传递   (这里为引用传递)
		if (this.money > stu.money) {
			System.out.println(this.username + "比"+stu.username +"零花钱多:" + (this.money - stu.money) + "元");
		} else {
			System.out.println(stu.username + "比" + this.username + "零花钱多:" + (stu.money - this.money) + "元");
		}
	}

	// 需求:炫富 比谁钱多,谁钱多 就返回钱多的学生的钱
	// toString() 有参有返回方法
	public double compare2(double moneny) {
		if (this.money > money) {
			return this.money;
		}
		return money;
	}

	public static void main(String[] args) {

		// 创建学生对象1
		Student student1 = new Student();
		// 对象成员变量赋值: 对象名.成员变量 = 值 ;
		student1.setId(1001);// 学号 = 1001
		student1.setUsername("张三");// 姓名 = 张三
		student1.setSex('男'); // 性别 = 男
		student1.setMoney(200.00);// 零花钱 = 200.00

		// 无参无返回 方法
		student1.showInfo();

		// 创建学生对象2
		Student student2 = new Student();
		student2.setId(1002);
		student2.setUsername("李四");
		student2.setSex('男');
		student2.setMoney(100.00);

		// 无参有返回 方法
		System.out.println(student2.toString());

		// 有参无返回 方法
		student1.compare1(student2); // 把对象当做参数传递
		// 有参有返回 方法
		System.out.println("学生零花钱最多是：" + student1.compare2(student2.money) + "元");

	}

}

打印结果：学生信息 [学号=1001, 姓名=张三, 性别=男, 零花钱=200.0]
打印结果：Student [id=1002, username=李四, sex=男, money=100.0]
打印结果：张三比李四零花钱多:100.0元
打印结果：学生零花钱最多是：200.0元

---

总结：类是对象抽象，对象是类的实例。这句话意思，学生类不是 具体事物或者人，因为你不知道具体代表是哪一位学生，而对象是类的实例说的是，学生有学号，有姓名，有性别等等他们是唯一的是真实存在的，你是可以说出他们叫什么名字，他的学号是多少。灵活使用各种类型方法可以让我们提高代码复用性，可用性，一般有返回值方法使用的更多一些。

• 第10章：java项目之吃货联盟
  项目结构树
  - - foodieUnion_service // 项目名称
  - - - com.prosay.foodie // 包名
  - - - - Order.java 订单类
  - - - - OrderManager.java // 订单管理类
  - - - - - - - - createOrder() // 订餐
  - - - - - - - - printOrder() // 查看订单
  - - - - - - - - signOrder() // 签收订单
  - - - - - - - - deleteOrder() // 删除订单
  - - - - - - - - praise() // 菜品点赞
  - - - - FoodieUnionSystem.java // 吃货联盟系统入口类
  - - - - - - - - mian() // 程序入口

***********************Order.java****************************

package com.prosay.foodie;

/**
 * 吃货联盟 订单类
 */
public class Order {
	String[] names = new String[4]; // 订餐人姓名
	String[] dishMegs = new String[4]; // 保存菜品名及份数
	int[] times = new int[4]; // 送餐时间
	String[] addresses = new String[4]; // 保存送餐地址
	int[] states = new int[4]; // 保存订单状态: 0表示已预订，1表示已完成
	double[] sumPrices = new double[4]; // 保存订单的总金额

}

**************************OrderManager.java*************************

package com.prosay.foodie;

import java.util.Scanner;

/**
 * 吃货联盟 订单管理类
 */
public class OrderManager {
	String[] disNames = { "红烧带鱼", "鱼香肉丝", "时令蔬菜" };
	double[] prices = { 38, 20, 10 };
	int[] praiseNums = new int[3];
	Order oSet = new Order();// 创建OrderSet类的对象为oset

	// 实现初始化
	public void initial() {
		// 第一条订单
		oSet.names[0] = "张晴";
		oSet.dishMegs[0] = "红烧带鱼";
		oSet.times[0] = 12;
		oSet.addresses[0] = "天成路207";
		oSet.sumPrices[0] = 76.0;
		oSet.states[0] = 1;
		// 第二条订单
		oSet.names[1] = "张晴";
		oSet.dishMegs[1] = "鱼香肉丝";
		oSet.times[1] = 18;
		oSet.addresses[1] = "天成路207";
		oSet.sumPrices[1] = 80.0;
		oSet.states[1] = 0;

	}

	// 订餐
	public boolean createOrder() {//
		boolean isAdd = false;
		Scanner input = new Scanner(System.in);
		for (int i = 0; i < oSet.names.length; i++) {
			if (oSet.names[i] == null) {// 找到第一个为空的位置
				isAdd = true;// 可以订餐
				System.out.println("请输入订餐姓名：");
				String name = input.next();
				System.out.println("序号" + "\t" + "菜名" + "\t" + "单价" + "\t" + "点赞数");
				for (int k = 0; k < disNames.length; k++) {// 显示供选择的菜品信息
					String price = prices[k] + "元";
					String praiseNum = (praiseNums[k]) > 0 ? praiseNums[k] + "赞" : "0";
					System.out.println((k + 1) + "\t" + disNames[k] + "\t" + price + "\t" + praiseNum);

				}
				System.out.println("请选择您要点的菜品编号：");// 用户点菜
				int chooseDish = input.nextInt();
				System.out.println("请选择您需要的份数");
				int number = input.nextInt();
				String dishMeg = disNames[chooseDish - 1] + "" + number + "份";
				double sumprice = prices[chooseDish - 1] * number;
				double deliChaege = (sumprice >= 50) ? 0 : 5;// 餐费满50元，免送餐费
				System.out.println("请输入送餐时间（送餐时间是10点至20点之间整点送餐）");
				int time = input.nextInt();
				while (time < 10 || time > 20) {
					System.out.println("您的输入有误，请输入10-20之间的整数！");
					time = input.nextInt();
				}
				System.out.println("请输入送餐地址");
				String address = input.next();
				// 无需添加状态，默认是0，既已预定状态
				System.out.println("订餐成功！");
				System.out.println("您定的是：" + dishMeg);
				System.out.println("送餐时间是：" + time + "点");
				System.out.println("餐费" + sumprice + "元，送餐费" + deliChaege + "元，总计" + (sumprice + deliChaege) + "元");
				// 添加数据
				oSet.names[i] = name;
				oSet.dishMegs[i] = dishMeg;
				oSet.times[i] = time;
				oSet.addresses[i] = address;
				oSet.sumPrices[i] = sumprice + deliChaege;
				isAdd = false;
				break;
			} // if结束

		} // for循环结束

		if (isAdd) {
			System.out.println("对不起！您的餐带已满。");
			return false;
		} else {
			return true;
		}
	}

	// 查看餐袋
	public void printOrder() {
		System.out.println("序号\t订餐人\t餐品信息\t\t送餐时间\t送餐地址\t\t总金额\t订单状况");
		for (int i = 0; i < oSet.names.length; i++) {
			// 三目运算符: 条件表达式 ? 执行1 : 执行2  当条件满足执行1，否则执行2
			String state = oSet.states[i] == 0 ? "已预定" : "已完成";// 把0 1的状态改为用户所能明白的解释
			if (oSet.names[i] != null)
				System.out.println((i + 1) + "\t" + oSet.names[i] + "\t" + oSet.dishMegs[i] + "\t\t" + oSet.times[i]
						+ "\t" + oSet.addresses[i] + "\t\t" + oSet.sumPrices[i] + "元" + "\t" + state);
		} // for 结束
	}// printOrder 方法结束

	// 签收订单
	public void signOrder() {
		Scanner input = new Scanner(System.in);
		System.out.println("请输入定单序号");
		int orderNo = input.nextInt();
		boolean flag = false;
		for (int i = 0; i < oSet.names.length; i++) {
			if (oSet.names[i] != null && oSet.states[i] == 0 && orderNo == (i + 1)) {// 订单状态为0，改为已签收
				oSet.states[i] = 1;// 已经签收
				System.out.println("订单已经签收成功！");
				flag = true;
			} else if (oSet.names[i] != null && oSet.states[i] == 1 && orderNo == (i + 1)) {// 订单状态为1，已经签
				System.out.println("订单已经是签收状态");
				flag = true;
			}
		} // for 结束
		if (flag) {
			System.out.println("已签收");
		} else {
			System.out.println("没有此序号的订单");
		}
	}// signOrder 方法结束

	// 删除订单
	public void deleteOrder() {
		Scanner input = new Scanner(System.in);
		boolean delFlag = false;// 标记是否找到要删除的订单
		System.out.println("请输入要删除的订单号");
		int deleteId = input.nextInt();
		for (int i = 0; i < oSet.names.length; i++) {
			if (oSet.names[i] != null && oSet.states[i] == 1 && deleteId == (i + 1)) {// 状态值为已完成，
				delFlag = true;// 可以删除已经签收的了
				int index = 0;// 从后往前 到要删除的位置 ，移动
				for (int K = deleteId - 1; K < oSet.names.length - 1; K++) {
					oSet.names[K] = oSet.names[K + 1];
					oSet.addresses[K] = oSet.addresses[K + 1];
					oSet.dishMegs[K] = oSet.dishMegs[K + 1];
					oSet.states[K] = oSet.states[K + 1];
					oSet.sumPrices[K] = oSet.sumPrices[K + 1];
					oSet.times[K] = oSet.times[K + 1];
					index = K;// 记录的最后一次就是有内容的最后一个位置
				}
				// 最后储存了内容的一位清空
				oSet.names[index] = null;
				oSet.addresses[index] = null;
				oSet.dishMegs[index] = null;
				oSet.states[index] = 0;
				oSet.sumPrices[index] = 0;
				oSet.times[index] = 0;
				System.out.println("已经删除完毕");
				break;
			} else if (oSet.names[i] != null && oSet.states[i] == 0 && deleteId == (i + 1)) {// 状态值为已预定
				System.out.println("预定订单的状态不可删除"); // 预定订单的状态不可删除
				delFlag = true;
			}

		} // for结束

		if (delFlag) {
			System.out.println("已经执行完毕");
		} else {
			System.out.println("没有要删除的订单号！");
		}

	}// deleteOrder方法结束

	// 点赞
	public void praise() {
		Scanner input = new Scanner(System.in);
		// 显示菜品信息
		System.out.println("序号" + "\t" + "菜品" + "\t" + "单价");
		for (int i = 0; i < disNames.length; i++) {
			String price = prices[i] + "元";
			String praiseNum = (praiseNums[i] > 0) ? praiseNums[i] + "赞" : "";
			System.out.println((i + 1) + "\t" + disNames[i] + "\t" + price + "\t" + praiseNum);
		}
		System.out.println("请选择您要点赞的菜品");
		int praiseNum = input.nextInt();
		praiseNums[praiseNum - 1]++;// 赞数+1
		System.out.println("点赞成功！");
		
	}// praise方法结束

}

**************************FoodieUnionSystem.java*************************

package com.prosay.foodie;

import java.util.Scanner;

/**
 * 吃货联盟 程序入口类
 */
public class FoodieUnionSystem {
	public static void main(String[] args) {

		// 创建一个订单管理对象
		OrderManager orderUtil = new OrderManager();
		
		// 初始化参数
		boolean flag = false; //订单状态
		int num = 0;// 用户输入值
		do {
			System.out.println("欢迎使用“吃货联盟订单系统”");
			System.out.println("***************************************”");
			System.out.println("1.我要订餐");
			System.out.println("2.查看餐带");
			System.out.println("3.签收订单");
			System.out.println("4.删除订单");
			System.out.println("5.我要点赞");
			System.out.println("6.退出系统");
			System.out.println("******************************************\n");
			Scanner input = new Scanner(System.in);
			System.out.println("请选择:");
			int choose = input.nextInt();
			switch (choose) {
			case 1:
				flag = orderUtil.createOrder();// 订餐
				break;
			case 2:
				orderUtil.printOrder();// 查看订单
				break;
			case 3:
				orderUtil.signOrder();// 签收订单
				break;
			case 4:
				orderUtil.deleteOrder();// 删除订单
				break;
			case 5:
				orderUtil.praise();// 点赞
				break;
			case 6:
				System.out.println("谢谢使用!!");
				System.exit(0); //退出系统
				break;
			}
			if (flag) {
				System.out.println("输出0返回！");
				num = input.nextInt();
			}
		} while (num == 0);
	}
}

进入吃货联盟系统

欢迎使用“吃货联盟订单系统”
***************************************”
1.我要订餐
2.查看餐带
3.签收订单
4.删除订单
5.我要点赞
6.退出系统
******************************************

请选择:
1
请输入订餐姓名：
张三
序号	菜名	单价	点赞数
1	红烧带鱼	38.0元	0
2	鱼香肉丝	20.0元	0
3	时令蔬菜	10.0元	0
请选择您要点的菜品编号：
1
请选择您需要的份数
10
请输入送餐时间（送餐时间是10点至20点之间整点送餐）
10
请输入送餐地址
深圳南山区
订餐成功！
您定的是：红烧带鱼10份
送餐时间是：10点
餐费380.0元，送餐费0.0元，总计380.0元
输出0返回！
0
欢迎使用“吃货联盟订单系统”
***************************************”
1.我要订餐
2.查看餐带
3.签收订单
4.删除订单
5.我要点赞
6.退出系统
******************************************

请选择:
2
序号	订餐人	餐品信息		送餐时间	送餐地址		总金额	订单状况
1	张三		红烧带鱼10份	10		深圳南山区	380.0元	已预定
输出0返回！
0
欢迎使用“吃货联盟订单系统”
***************************************”
1.我要订餐
2.查看餐带
3.签收订单
4.删除订单
5.我要点赞
6.退出系统
******************************************

请选择:
6
谢谢使用!!

总结：多练习几遍，第一遍熟悉，第二遍掌握，第三遍熟练，熟练生巧在练习过程中简化并优化代码

• 恭喜你学习完以上完以章节

总结：学习完以上案列练习，熟练掌握Java基础知识