- 开发java程序需要安装JDK并配置环境变量，开发工具建议使用免费开源eclipse
- 第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基础知识
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
