kai_Childe

基于java的外卖点餐系统部分模块设计（无界面版）

大家好，本次带来的是基于java的外卖点餐系统部分模块设计（无界面版），也算是对这一个月所学的检测吧，由于还没学习前端，所有只能在控制台进行界面模拟，可能存在一些小bug，望大家指正。

文章目录

一、创建实体类
- Administrator（管理员类）
- Client（客户类）
- Dishes（菜品类）
- OrderForm（订单类）
二、管理类
- DAO（管理类接口）
- AdminManagement（管理员管理类）
- ClientManagement（客户管理类）
- DishesManagement（菜品管理类）
- OrderManagement（订单管理类）
三、界面类

一、创建实体类

本项目一个有4个实体类：Administrator（管理员类）、Client（客户类）、Dishes（菜品类）、OrderForm（订单类）。

Administrator（管理员类）

import java.util.ArrayList;
import java.util.List;

/**
 * 管理员类
 * 
 * @author Administrator
 *
 */

public class Administrator {
	/** 管理员ID */
	private int aid;
	/** 账号 */
	private String azhangHao;
	/** 密码 */
	private String amiMa;

	public Administrator() {
		this(1001, "sunkai", "sunkai001");
	}

	private Administrator(int aid, String azhangHao, String amiMa) {
		super();
		this.aid = aid;
		this.azhangHao = azhangHao;
		this.amiMa = amiMa;
	}
	
	public int getAid() {
		return aid;
	}

	public void setAid(int aid) {
		this.aid = aid;
	}

	public String getAzhangHao() {
		return azhangHao;
	}

	public void setAzhangHao(String azhangHao) {
		this.azhangHao = azhangHao;
	}

	public String getAmiMa() {
		return amiMa;
	}

	public void setAmiMa(String amiMa) {
		this.amiMa = amiMa;
	}

	@Override
	public String toString() {
		return "管理员id:" + aid + ", 账号:" + azhangHao + ", 密码:" + amiMa;
	}
}

Client（客户类）

import java.text.DateFormat;
import java.text.FieldPosition;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Date;

/**
 * 客户类
 * 
 * @author Administrator
 *
 */

public class Client {
	/** 客户id */
	private int cid;
	/** 客户名 */
	private String cname;
	/** 性别 */
	private String sex;
	/** 密码 */
	private String cmiMa;
	/** 送餐地址 */
	private String songCanDiZhi;
	/** 手机号 */
	private String shouJiHao;
	/** 创建时间 */
	private LocalDate chuangJianShiJian;

	private Client() {
		// TODO Auto-generated constructor stub
	}

	public Client(int cid, String cname, String sex, String cmiMa, String songCanDiZhi, String shouJiHao) {
		super();
		this.cid = cid;
		this.cname = cname;
		this.sex = sex;
		this.cmiMa = cmiMa;
		this.songCanDiZhi = songCanDiZhi;
		this.shouJiHao = shouJiHao;
		chuangJianShiJian = LocalDate.now();
	}

	public Client(int cid, String cname, String sex, String cmiMa, String shouJiHao) {
		super();
		this.cid = cid;
		this.cname = cname;
		this.sex = sex;
		this.cmiMa = cmiMa;
		this.shouJiHao = shouJiHao;
		chuangJianShiJian = LocalDate.now();
	}

	public int getCid() {
		return cid;
	}

	public void setCid(int cid) {
		this.cid = cid;
	}

	public String getCname() {
		return cname;
	}

	public void setCname(String cname) {
		this.cname = cname;
	}

	public String getSex() {
		return sex;
	}

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

	public String getCmiMa() {
		return cmiMa;
	}

	public void setCmiMa(String cmiMa) {
		this.cmiMa = cmiMa;
	}

	public String getSongCanDiZhi() {
		return songCanDiZhi;
	}

	public void setSongCanDiZhi(String songCanDiZhi) {
		this.songCanDiZhi = songCanDiZhi;
	}

	public String getShouJiHao() {
		return shouJiHao;
	}

	public void setShouJiHao(String shouJiHao) {
		this.shouJiHao = shouJiHao;
	}

	public LocalDate getChuangJianShiJian() {
		return chuangJianShiJian;
	}
	@Override
	public String toString() {
		return "客户id：" + cid + ", 客户名：" + cname + ", 性别：" + sex + ", 密码：" + cmiMa + ", 送餐地址："
				+ songCanDiZhi + ", 手机号:" + shouJiHao + ", 创建时间:" + chuangJianShiJian;
	}
}

Dishes（菜品类）

import java.time.LocalDate;

/**
 * 菜品类
 * 
 * @author Administrator
 *
 */

public class Dishes {
	/** 菜品ID */
	private int dno;
	/** 菜品名 */
	private String dname;
	/** 菜品类型 */
	private String dleiXin;
	/** 上架时间 */
	private LocalDate dshangJiaShiJian;
	/** 单价 */
	private double dshouJia;
	/** 月销售量 */
	private int dyueXiaoShouLiang;
	/** 总数量 */
	private int dzonShuLiang;

	private Dishes() {
		// TODO Auto-generated constructor stub
	}

	public Dishes(int dno, String dname, String dleiXin, double dshouJia,int dzonShuLiang) {
		super();
		this.dno = dno;
		this.dname = dname;
		this.dleiXin = dleiXin;
		this.dshangJiaShiJian = LocalDate.now();
		this.dshouJia = dshouJia;
		this.dzonShuLiang =  dzonShuLiang;
	}

	public int getDno() {
		return dno;
	}

	public void setDno(int dno) {
		this.dno = dno;
	}

	public String getDname() {
		return dname;
	}

	public void setDname(String dname) {
		this.dname = dname;
	}

	public String getDleiXin() {
		return dleiXin;
	}

	public void setDleiXin(String dleiXin) {
		this.dleiXin = dleiXin;
	}

	public LocalDate getDshangJiaShiJian() {
		return dshangJiaShiJian;
	}

	

	public double getDshouJia() {
		return dshouJia;
	}

	public void setDshouJia(double dshouJia) {
		this.dshouJia = dshouJia;
	}

	public int getDyueXiaoShouLiang() {
		return dyueXiaoShouLiang;
	}

	public void setDyueXiaoShouLiang(int dyueXiaoShouLiang) {
		this.dyueXiaoShouLiang = dyueXiaoShouLiang;
	}

	public int getDzonShuLiang() {
		return dzonShuLiang;
	}

	public void setDzonShuLiang(int dzonShuLiang) {
		this.dzonShuLiang = dzonShuLiang;
	}

	@Override
	public String toString() {
		return "菜品id：" + dno + ", 菜品名：" + dname + ", 菜品类型：" + dleiXin + ", 上架时间："
				+ dshangJiaShiJian + ", 单价：" + dshouJia + ", 月销售量：" + dyueXiaoShouLiang
				+ ", 总数量：" + dzonShuLiang;
	}
}

OrderForm（订单类）

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Map;

public class OrderForm {
	/**订单号*/
	private int oid;
	/**订单创建时间*/
	private LocalDateTime datetime;
	/**菜品id及购买数*/
	private Map<Integer,Integer> dnoAndshuLian;
	/**客户id*/
	private int cid;
	/**总价格*/
	private double zonJiaGe;
	/**订单状态*/
	private int dingDanZhuangTai;
	
	
	public OrderForm() {
		// TODO Auto-generated constructor stub
	}


	public OrderForm(int oid, Map<Integer, Integer> dnoAndshuLian, int cid, double zonJiaGe,
			int dingDanZhuangTai) {
		super();
		this.oid = oid;
		this.datetime = LocalDateTime.now();
		this.dnoAndshuLian = dnoAndshuLian;
		this.cid = cid;
		this.zonJiaGe = zonJiaGe;
		this.dingDanZhuangTai = dingDanZhuangTai;
	}
	
	
	
	public int getOid() {
		return oid;
	}


	public void setOid(int oid) {
		this.oid = oid;
	}


	public LocalDateTime getDatetime() {
		return datetime;
	}


	public void setDatetime(LocalDateTime datetime) {
		this.datetime = datetime;
	}


	public Map<Integer, Integer> getDnoAndshuLian() {
		return dnoAndshuLian;
	}


	public void setDnoAndshuLian(Map<Integer, Integer> dnoAndshuLian) {
		this.dnoAndshuLian = dnoAndshuLian;
	}


	public int getCid() {
		return cid;
	}


	public void setCid(int cid) {
		this.cid = cid;
	}


	public double getZonJiaGe() {
		return zonJiaGe;
	}


	public void setZonJiaGe(double zonJiaGe) {
		this.zonJiaGe = zonJiaGe;
	}


	public int getDingDanZhuangTai() {
		return dingDanZhuangTai;
	}


	public void setDingDanZhuangTai(int dingDanZhuangTai) {
		this.dingDanZhuangTai = dingDanZhuangTai;
	}


	//返回由菜品id和购买数拼接成的字符串
	public StringBuffer sk() {
		StringBuffer s = new StringBuffer();
		dnoAndshuLian.entrySet().stream().forEach(e->{
			s.append("\n菜品id:"+e.getKey().toString()+"\t购买数："+e.getValue().toString());
		});
		return s;
	}

	//将订单创建的时间格式改为yyyy.MM.dd HH:mm:ss
	public String ks() {
		return datetime.format(DateTimeFormatter.ofPattern("yyyy.MM.dd HH:mm:ss"));
	}

	@Override
	public String toString() {
		return "订单号:" + oid + ", 订单创建时间:" + ks() + ", 客户id:" + cid+sk()
				+ "\n总价格：" + zonJiaGe + ", 订单状态：" + dingDanZhuangTai ;
		
	}
}

二、管理类

本系统共有1个接口加4个管理类：DAO（管理类接口）、AdminManagement（管理员管理类）、ClientManagement（客户管理类）、DishesManagement（菜品管理类）、OrderManagement（订单管理类）

DAO（管理类接口）

import java.util.List;

public interface DAO<T> {

	/** 添加T类型对象到Map中 */
	boolean insert(T t);

	/** 根据id获取Map中的元素 */
	T findById(int id);

	/** 返回map中的所有元素值集 */
	List<T> findAll();

	/** 根据id删除Map中的元素 */
	boolean delete(int id);

}

AdminManagement（管理员管理类）

* 管理员管理类
 * 采用单例模式（饿汉式）
 * @author Lenovo
 *
 */
import com.sunkai.chengyuanlei.Administrator;

public class AdminManagement {
	/**创建管理员对象 ,同时只允许一个管理员对象存在*/
	private static Administrator admin = new Administrator();
	/**创建管理员管理对象*/
	private static AdminManagement am = new AdminManagement();
	
	private AdminManagement() { }
	
	public static AdminManagement toAdmin() {
		return am;
	}
	
	/**管理员登录*/
	public boolean guanLiYuanDengLu(String s1,String s2) {
		boolean bl = false;
		if(admin.getAzhangHao().equals(s1)&&admin.getAmiMa().equals(s2)) {
			bl = true;
		}
		return bl;
		
	}
}

ClientManagement（客户管理类）

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.sunkai.chengyuanlei.Client;
import com.sunkai.chengyuanlei.Dishes;

public class ClientManagement implements DAO<Client> {
	/**存储客户信息的map集合，键为客户id、值为客户信息*/
	private static Map<Integer, Client> map = new HashMap<>();
	/**存储当前登录的客户id*/
	private static int id;
	
	public static int getId() {
		return id;
	}
	
	@Override
	/** 将客户信息存到Map集合中 */
	public boolean insert(Client t) {
		boolean bl = true;
		if (map.containsKey(t.getCid())) {
			bl = false;
		} else {
			map.put(t.getCid(), t);
		}
		return bl;
	}

	@Override
	/** 根据客户ID查询客户信息 */
	public Client findById(int id) {
		Client d = null;
		if (map.containsKey(id)) {
			d = map.get(id);
		}
		return d;
	}

	@Override
	/** 返回所有客户信息所构成的集合 */
	public List<Client> findAll() {
		Collection<Client> values = map.values();
		return new ArrayList(values);
	}

	@Override
	/** 根据ID删除客户信息 */
	public boolean delete(int id) {
		boolean bl = true;
		if (map.containsKey(id)) {
			map.remove(id);
		} else {
			bl = false;
		}
		return bl;
	}
	
	
	/** 将客户信息进行分页显示,每页最多5条信息 */
	public List<Client> fenYe(List<Client> list, int a) {
		int b = list.size() / 5;
		int c = list.size() % 5;
		if (a > b && c == 0 || a > (b + 1)) {
			
		} else if (a == (b + 1) && c != 0) {
			list = list.subList(5 * (a - 1), list.size());
		} else {
			list = list.subList(5 * (a - 1), 5 * a);
		}
		return list;
	}

	/** 查看所有客户信息,以分页的方式显示，每页最多显示5条信息 */
	public List<Client> fenYeXianShi(int a) {
		List<Client> list = findAll();
		//接收第a页的菜品信息的集合
		list = fenYe(list, a);
		return list;
	}
	
	/**用户登录*/
	public boolean yonHuDengLu(String s1,String s2) {
		boolean bl = false;
		List<Client> list = findAll();
		for(Client c:list) {
			if(c.getShouJiHao().equals(s1)&&c.getCmiMa().equals(s2)) {
				id = c.getCid();
				bl = true;
			}
		}
		return bl;
	}
	
	/**修改密码（当前登录用户）*/
	public boolean xiuGaiMiMa(String s) {
		boolean bl = false;
		//密码限制：只能是6-10位的数字或字母
		if(s.matches("^[1-9a-zA-Z]\\w{5,9}")) {
			map.get(id).setCmiMa(s);
			bl = true;
		}
		return bl;
		
	}
	
	/**显示当前登录用户的信息*/
	public Client xianShiDangQianYonHu() {
		return map.get(id);
	}
	
	

}

DishesManagement（菜品管理类）

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.stream.Collector;
import java.util.stream.Collectors;

/**
 * 菜品管理类
 */

import com.sunkai.chengyuanlei.Dishes;

public class DishesManagement implements DAO<Dishes> {
	/** 存储菜品信息的Map集合，键为菜品ID，值为菜品类 */
	private static Map<Integer, Dishes> map = new HashMap<>();

	@Override
	/** 添加菜品信息到Map集合 */
	public boolean insert(Dishes t) {
		boolean bl = true;
		if (map.containsKey(t.getDno())) {
			bl = false;
		} else {
			map.put(t.getDno(), t);
		}
		return bl;
	}

	@Override
	/** 根据id获取菜品信息 */
	public Dishes findById(int id) {
		Dishes d = null;
		if (map.containsKey(id)) {
			d = map.get(id);
		}
		return d;
	}

	@Override
	/** 返回所有菜品信息所构成的集合 */
	public List<Dishes> findAll() {
		Collection<Dishes> values = map.values();
		return new ArrayList(values);
	}

	@Override
	/** 删除指定ID的菜品 */
	public boolean delete(int id) {
		boolean bl = true;
		if (map.containsKey(id)) {
			map.remove(id);
		} else {
			bl = false;
		}
		return bl;
	}

	/** 将菜品信息进行分页显示,每页最多5条信息 */
	public List<Dishes> fenYe(List<Dishes> list, int a) {
		int b = list.size() / 5;
		int c = list.size() % 5;
		if (a > b && c == 0 || a > (b + 1)) {
			
		} else if (a == (b + 1) && c != 0) {
			list = list.subList(5 * (a - 1), list.size());
		} else {
			list = list.subList(5 * (a - 1), 5 * a);
		}
		return list;
	}

	/** 查看所有菜品信息,以分页的方式显示，每页最多显示5条信息 */
	public List<Dishes> fenYeXianShi(int a) {
		List<Dishes> list = findAll();
		//接收第a页的菜品信息的集合
		list = fenYe(list, a);
		return list;
	}

	/** 查看指定类别的菜品信息 */
	public List<Dishes> anLeiBie(String s) {
		List<Dishes> list = findAll();
		// 筛选符合要求的菜品，并返回新的集合
		list = list.stream().filter(d -> d.getDleiXin().equals(s)).collect(Collectors.toList());
		return list;
	}

	/** 根据菜品ID修改菜品价格 */
	public boolean xiuGaiJiaGe(int id, double b) {
		List<Dishes> list = findAll();
		Dishes d = findById(id);
		boolean bl = true;
		if (d != null) {
			d.setDshouJia(b);
		} else {
			bl = false;
		}
		return bl;
	}

	/** 显示所有菜品(按菜品销量从高到低排序输出) */
	public List<Dishes> xianShiSuoYouCaiPin(int a) {
		List<Dishes> list = findAll();
		// 将所有菜品信息按照销售量从高到低排序
		list = list.stream().sorted((d1, d2) -> d2.getDyueXiaoShouLiang() - d1.getDyueXiaoShouLiang())
				.collect(Collectors.toList());
		//将排好序的菜品信息进行分页
		list = fenYe(list,a);
		return list;
	}

	/** 根据菜品类别显示所有菜品 */
	public List<Dishes> genJuLeiBie(int a) {
		List<Dishes> list = findAll();
		//将类别一样的菜品信息放到一起
		list = list.stream().sorted((d1,d2)->d1.getDleiXin().compareTo(d2.getDleiXin())).collect(Collectors.toList());
		//然后将菜品信息进行分页
		list = fenYe(list, a);
		return list;

	}

}

OrderManagement（订单管理类）

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.sunkai.chengyuanlei.Client;
import com.sunkai.chengyuanlei.OrderForm;

public class OrderManagement implements DAO<OrderForm> {
	/**存储订单信息的map集合，键为订单id、值为订单信息*/
	Map<Integer, OrderForm> map = new HashMap<>();
	
	@Override
	/**添加订单信息到集合中*/
	public boolean insert(OrderForm t) {
		boolean bl = true;
		if (map.containsKey(t.getCid())) {
			bl = false;
		} else {
			map.put(t.getCid(), t);
		}
		return bl;
	}

	@Override
	/**根据定订单id获取订单信息*/
	public OrderForm findById(int id) {
		OrderForm o = null;
		if (map.containsKey(id)) {
			o = map.get(id);
		}
		return o;
	}

	@Override
	/**返回所有订单信息构成的集合*/
	public List<OrderForm> findAll() {
		Collection<OrderForm> values = map.values();
		return new ArrayList(values);
	}

	@Override
	/**根据订单id删除订单*/
	public boolean delete(int id) {
		boolean bl = true;
		if (map.containsKey(id)) {
			map.remove(id);
		} else {
			bl = false;
		}
		return bl;
	}
	
	/**显示当前登录用户的订单*/
	public OrderForm yonHuDingDan() {
		List<OrderForm> list = findAll();
		OrderForm order = null;
		for(OrderForm o: list) {
			if(o.getCid()==ClientManagement.getId()) {
				order = o;
			}
		}
		return order;
	}
	
	/** 将订单信息进行分页显示,每页最多5条信息 */
	public List<OrderForm> fenYe(List<OrderForm> list, int a) {
		int b = list.size() / 5;
		int c = list.size() % 5;
		if (a > b && c == 0 || a > (b + 1)) {
	
		} else if (a == (b + 1) && c != 0) {
			list = list.subList(5 * (a - 1), list.size());
		} else {
			list = list.subList(5 * (a - 1), 5 * a);
		}
		return list;
	}

	/** 查看所有订单信息,以分页的方式显示，每页最多显示5条信息 */
	public List<OrderForm> fenYeXianShi(int a) {
		List<OrderForm> list = findAll();
		//接收第a页的菜品信息的集合
		list = fenYe(list, a);
		return list;
	}
	
	/**根据订单ID修改订单状态
	 * （0:未支付 1：已支付 2：配送中 3：已完成）*/
	public boolean xiuGaiDinDanZhuangTai(int a,int b) {
		boolean bl = false;
		if(map.containsKey(a)) {
			map.get(a).setDingDanZhuangTai(b);
			bl = true;
		}
		return bl;		
	}
}

三、界面类

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Scanner;
import com.sunkai.chengyuanlei.Client;
import com.sunkai.chengyuanlei.Dishes;
import com.sunkai.chengyuanlei.OrderForm;
import com.sunkai.guanlilei.AdminManagement;
import com.sunkai.guanlilei.ClientManagement;
import com.sunkai.guanlilei.DishesManagement;
import com.sunkai.guanlilei.OrderManagement;

public class Main {
	/** 创建Scanner对象，用于从对象接收数据 */
	private static Scanner sc = new Scanner(System.in);
	/** 创建管理员管理对象 */
	private static AdminManagement am = AdminManagement.toAdmin();
	/** 创建用户管理对象 */
	private static ClientManagement client = new ClientManagement();
	/** 创建菜品管理对象 */
	private static DishesManagement dm = new DishesManagement();
	/** 创建订单管理对象 */
	private static OrderManagement om = new OrderManagement();
	/** 定义一个用于生成用户id的变量，初始值为10001,每创建一个用户就+1 */
	private static int cid = 10001;
	/** 定义一个用于生成菜品id的变量，初始值为10001,每添加就一条菜品信息就+1 */
	private static int did = 10001;
	/** 定义一个用于生成订单id的变量，初始值为10001,每生成一个订单就+1 */
	private static int oid = 10001;

	/** 首页界面，包含：登录、注册、退出选项 */
	public void shouYeJieMian() {
		System.out.println("==========呆呆的餐厅=========");
		System.out.println("===========[1]登录==========");
		System.out.println("===========[2]注册==========");
		System.out.println("===========[0]退出==========");
		String a = sc.next();
		switch (a) {
		case "1":
			// 登录
			dengLuJieMian();
			break;
		case "2":
			// 注册
			zhuCeJieMian();
			break;
		default:
			// 退出
			return;
		}
	}

	/** 登录界面 */
	public void dengLuJieMian() {
		System.out.println("=========登录界面========");
		System.out.print("用户名：");
		String s1 = sc.next();
		System.out.print("密码：");
		String s2 = sc.next();
		// 先判断登录对象是否为管理员
		if (am.guanLiYuanDengLu(s1, s2)) {
			// 登录成功进入管理员功能界面
			guanLiYuanGonNengJieMian();
			// 如果管理员验证未通过，再进行客户登录验证
		} else if (client.yonHuDengLu(s1, s2)) {
			// 登录成功进入客户功能界面
			yonHuGonNengJieMian();
		} else {
			System.out.println("=====登录失败，请重新登录=====");
			dengLuJieMian();
		}
	}

	/** 用户注册界面 */
	public void zhuCeJieMian() {
		System.out.println("======注册界面======");
		System.out.print("名称：");
		String s1 = sc.next();
		System.out.print("性别：");
		String s2 = sc.next();
		System.out.print("送餐地址：");
		String s3 = sc.next();
		String s4;
		String s5;
		while (true) {
			System.out.print("手机号：");
			s4 = sc.next();
			System.out.print("密码：");
			s5 = sc.next();
			if (s4.matches("^1[0-9]{10}") && s5.matches("^[1-9a-zA-Z]\\w{5,9}")) {
				break;
			} else {
				System.out.println("手机号或密码错误");
			}
		}
		if (client.insert(new Client(cid, s1, s2, s5, s3, s4))) {
			// 用户创建成功，cid加一，供下一位用户创建时使用
			cid++;
			System.out.println("=======创建成功=======");
		} else {
			System.out.println("=======创建失败=======");
		}
		System.out.println("请牢记手机号和密码，这将是您登录本系统的凭证");
		System.out.println("=======[1]登录=======");
		System.out.println("=======[0]退出=======");
		String s = sc.next();
		switch (s) {
		case "1":
			// 登录界面
			dengLuJieMian();
			break;
		default:
			// 退出系统
			return;
		}
	}

	/** 管理员功能界面 */
	public void guanLiYuanGonNengJieMian() {
		System.out.println("================管理员===============");
		System.out.println("=============[1]添加菜品==============");
		System.out.println("=============[2]查看所有菜品信息========");
		System.out.println("=============[3]查看指定类别的菜品信息====");
		System.out.println("=============[4]根据菜品id修改菜品价格====");
		System.out.println("=============[5]删除指定id的菜品=========");
		System.out.println("=============[6]添加客户===============");
		System.out.println("=============[7]查看客户列表============");
		System.out.println("=============[8]删除指定id的客户=========");
		System.out.println("=============[9]订单列表显示=============");
		System.out.println("=============[10]根据订单id修改订单状态====");
		System.out.println("=============[11]返回首页界面=============");
		System.out.println("=============[0]退出系统================");
		String s1 = sc.next();
		switch (s1) {
		case "1":
			// 添加菜品
			tianJiaCaiPin();
			break;
		case "2":
			// 查看所有菜品信息
			chaKanSuoYoucaiPinXinXiJieMian();
			break;
		case "3":
			// 查看指定类别的菜品信息
			chaKanZhiDingLeiBieCaiPinXinXi();
			break;
		case "4":
			// 根据菜品id修改菜品价格
			genKJuCaiPinIdXiuGaiCaiPinJiage();
			break;
		case "5":
			// 删除指定id的菜品
			shanChuZhiDingIdDeCaiPin();
			break;
		case "6":
			// 添加客户
			tianJiaYonHuJieMian();
			break;
		case "7":
			// 查看客户列表
			chaKanKeHuLieBiaoJieMian();
			break;
		case "8":
			// 删除指定id的客户
			shanChuZhiDingIdDeKeHu();
			break;
		case "9":
			// 订单列表显示
			xianShiDingDanLieBiaoJieMian();
			break;
		case "10":
			// 根据订单id修改订单状态
			genKJuDinDanIdXiuGaiDinDanZhuangTai();
			break;
		case "11":
			// 返回首页界面
			shouYeJieMian();
		default:
			// 退出系统
			return;
		}
	}

	/** 用户功能界面 */
	public void yonHuGonNengJieMian() {
		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("=============[7]返回首页界面=============");
		System.out.println("=============[0]退出系统===============");
		String s1 = sc.next();
		switch (s1) {
		case "1":
			// 显示所有菜品
			xianShiSuoYoucaiPinJieMian();
			break;
		case "2":
			// 根据菜品类别显示所有菜品
			genJuCaiPinLeiBieXianShiSuoYouCaiPin();
			break;
		case "3":
			// 点餐
			dianCanJieMian();
			break;
		case "4":
			// 查看订单
			chaKanDingDan();
			break;
		case "5":
			// 修改密码
			xiuGaiMiMa();
			break;
		case "6":
			// 个人信息显示
			geRenXinXiXianShi();
			break;
		case "7":
			// 返回首页界面
			shouYeJieMian();
		default:
			// 退出系统
			return;
		}
	}

	/** 添加菜品 */
	public void tianJiaCaiPin() {
		System.out.println("============添加菜品=========");
		System.out.print("菜品名：");
		String s1 = sc.next();
		System.out.print("菜品类型：");
		String s2 = sc.next();
		System.out.print("单价：");
		double d1 = sc.nextDouble();
		System.out.print("总数量：");
		int i1 = sc.nextInt();
		if (dm.insert(new Dishes(did, s1, s2, d1, i1))) {
			// 菜品添加成功，did加一，供下一个菜品添加时使用
			did++;
			System.out.println("========添加成功=======");
		} else {
			System.out.println("=======添加失败=====");
		}
		System.out.println("=======[1]继续添加=====");
		System.out.println("=======[2]返回上一层=====");
		System.out.println("=======[0]退出系统======");
		String s3 = sc.next();
		switch (s3) {
		case "1":
			// 继续添加
			tianJiaCaiPin();
			break;
		case "2":
			// 返回管理员功能界面
			guanLiYuanGonNengJieMian();
			break;
		default:
			// 退出系统
			return;
		}
	}

	/** 查看所有菜品信息界面 */
	public void chaKanSuoYoucaiPinXinXiJieMian() {
		System.out.println("======所有菜品信息======");
		int a = 1;
		// 查看所有菜品信息(分页显示)
		chaKanSuoYoucaiPinXinXi(a);

	}

	/** 查看所有菜品信息 */
	public void chaKanSuoYoucaiPinXinXi(int a) {
		if (dm.fenYeXianShi(a).size() == 0) {
			System.out.println("暂无菜品信息");
			System.out.println("=======[1]继续查看=====");
			System.out.println("=======[2]返回上一层=====");
			System.out.println("=======[0]退出系统======");
			String s3 = sc.next();
			switch (s3) {
			case "1":
				// 继续查看
				chaKanSuoYoucaiPinXinXiJieMian();
				break;
			case "2":
				// 返回管理员功能界面
				guanLiYuanGonNengJieMian();
				break;
			default:
				// 退出系统
				return;
			}

		} else if (dm.fenYeXianShi(a).size() == 5) {
			for (Dishes d : dm.fenYeXianShi(a)) {
				System.out.println(d);
			}
			System.out.println("=======[1]上一页=====");
			System.out.println("=======[2]下一页=====");
			System.out.println("=======[3]返回上一层=====");
			System.out.println("=======[0]退出系统======");
			String s3 = sc.next();
			switch (s3) {
			case "1":
				// 上一页
				a--;
				chaKanSuoYoucaiPinXinXi(a);
				break;
			case "2":
				// 下一页
				a++;
				chaKanSuoYoucaiPinXinXi(a);
				break;
			case "3":
				// 返回管理员功能界面
				guanLiYuanGonNengJieMian();
				break;
			default:
				// 退出系统
				return;
			}
		} else {
			for (Dishes d : dm.fenYeXianShi(a)) {
				System.out.println(d);
			}
			System.out.println("=======[1]上一页=====");
			System.out.println("=======[2]返回上一层=====");
			System.out.println("=======[0]退出系统======");
			String s3 = sc.next();
			switch (s3) {
			case "1":
				// 上一页
				a--;
				chaKanSuoYoucaiPinXinXi(a);
				break;
			case "2":
				// 返回管理员功能界面
				guanLiYuanGonNengJieMian();
				break;
			default:
				// 退出系统
				return;
			}
		}
	}

	/** 查看指定类别菜品信息 */
	public void chaKanZhiDingLeiBieCaiPinXinXi() {
		System.out.println("========查看指定类别菜品信息=======");
		System.out.print("菜品类别：");
		String s1 = sc.next();
		if (dm.anLeiBie(s1).size() == 0) {
			System.out.println("=======无该类别菜品======");
		} else {
			for (Dishes d : dm.anLeiBie(s1)) {
				System.out.println(d);
			}
		}
		System.out.println("=======[1]继续查看=====");
		System.out.println("=======[2]返回上一层=====");
		System.out.println("=======[0]退出系统======");
		String s2 = sc.next();
		switch (s2) {
		case "1":
			// 继续查看
			chaKanZhiDingLeiBieCaiPinXinXi();
			break;
		case "2":
			// 返回管理员功能界面
			guanLiYuanGonNengJieMian();
			break;
		default:
			// 退出系统
			return;
		}
	}

	/** 根据菜品id修改菜品价格 */
	public void genKJuCaiPinIdXiuGaiCaiPinJiage() {
		System.out.println("==========根据菜品id修改菜品价格=========");
		System.out.print("菜品ID:");
		int a = sc.nextInt();
		System.out.print("菜品价格:");
		double d = sc.nextDouble();
		if (dm.xiuGaiJiaGe(a, d)) {
			System.out.println("=======修改成功======");
		} else {
			System.out.println("======修改失败，无对应菜品=====");
		}
		System.out.println("=======[1]继续修改=====");
		System.out.println("=======[2]返回上一层=====");
		System.out.println("=======[0]退出系统======");
		String s2 = sc.next();
		switch (s2) {
		case "1":
			// 继续修改
			genKJuCaiPinIdXiuGaiCaiPinJiage();
			break;
		case "2":
			// 返回管理员功能界面
			guanLiYuanGonNengJieMian();
			break;
		default:
			// 退出系统
			return;
		}
	}

	/** 删除指定id的菜品 */
	public void shanChuZhiDingIdDeCaiPin() {
		System.out.println("==========删除指定id的菜品=========");
		System.out.print("菜品ID:");
		int a = sc.nextInt();
		if (dm.delete(a)) {
			System.out.println("=======删除成功======");
		} else {
			System.out.println("======删除失败，无对应菜品=====");
		}
		System.out.println("=======[1]继续删除=====");
		System.out.println("=======[2]返回上一层=====");
		System.out.println("=======[0]退出系统======");
		String s2 = sc.next();
		switch (s2) {
		case "1":
			// 继续删除
			shanChuZhiDingIdDeCaiPin();
			break;
		case "2":
			// 返回管理员功能界面
			guanLiYuanGonNengJieMian();
			break;
		default:
			// 退出系统
			return;
		}
	}

	/** 添加用户界面 */
	public void tianJiaYonHuJieMian() {
		System.out.println("======添加用户界面======");
		System.out.print("名称：");
		String s1 = sc.next();
		System.out.print("性别：");
		String s2 = sc.next();
		System.out.print("送餐地址：");
		String s3 = sc.next();
		String s4;
		String s5;
		while (true) {
			System.out.print("手机号：");
			s4 = sc.next();
			System.out.print("密码：");
			s5 = sc.next();
			if (s4.matches("^1[0-9]{10}") && s5.matches("^[1-9a-zA-Z]\\w{5,9}")) {
				break;
			} else {
				System.out.println("手机号或密码错误");
			}
		}
		if (client.insert(new Client(cid, s1, s2, s5, s3, s4))) {
			// 用户添加成功，cid加一，供下一位用户创建时使用
			cid++;
			System.out.println("=======添加成功=======");
		} else {
			System.out.println("=======添加失败=======");
		}
		System.out.println("=======[1]继续添加====");
		System.out.println("=======[2]返回上一层====");
		System.out.println("=======[0]退出系统=======");
		String s = sc.next();
		switch (s) {
		case "1":
			// 继续添加
			tianJiaYonHuJieMian();
			break;
		case "2":
			guanLiYuanGonNengJieMian();
			break;
		default:
			// 退出系统
			return;
		}
	}

	/** 查看客户列表界面 */
	public void chaKanKeHuLieBiaoJieMian() {
		System.out.println("======所有客户信息======");
		int a = 1;
		// 查看所有客户信息(分页显示)
		chaKanKeHuLieBiao(a);

	}

	/** 查看客户列表 */
	public void chaKanKeHuLieBiao(int a) {
		if (client.fenYeXianShi(a).size() == 0) {
			System.out.println("暂无客户信息");
			System.out.println("=======[1]继续查看=====");
			System.out.println("=======[2]返回上一层=====");
			System.out.println("=======[0]退出系统======");
			String s3 = sc.next();
			switch (s3) {
			case "1":
				// 继续查看
				chaKanKeHuLieBiaoJieMian();
				break;
			case "2":
				// 返回管理员功能界面
				guanLiYuanGonNengJieMian();
				break;
			default:
				// 退出系统
				return;
			}
		} else if (client.fenYeXianShi(a).size() == 5) {
			for (Client d : client.fenYeXianShi(a)) {
				System.out.println(d);
			}
			System.out.println("=======[1]上一页=====");
			System.out.println("=======[2]下一页=====");
			System.out.println("=======[3]返回上一层=====");
			System.out.println("=======[0]退出系统======");
			String s3 = sc.next();
			switch (s3) {
			case "1":
				// 上一页
				a--;
				chaKanKeHuLieBiao(a);
				break;
			case "2":
				// 下一页
				a++;
				chaKanKeHuLieBiao(a);
				break;
			case "3":
				// 返回管理员功能界面
				guanLiYuanGonNengJieMian();
				break;
			default:
				// 退出系统
				return;
			}
		} else {
			for (Client d : client.fenYeXianShi(a)) {
				System.out.println(d);
			}
			System.out.println("=======[1]上一页=====");
			System.out.println("=======[2]返回上一层=====");
			System.out.println("=======[0]退出系统======");
			String s3 = sc.next();
			switch (s3) {
			case "1":
				// 上一页
				a--;
				chaKanKeHuLieBiao(a);
				break;
			case "2":
				// 返回管理员功能界面
				guanLiYuanGonNengJieMian();
				break;
			default:
				// 退出系统
				return;
			}
		}
	}

	/** 删除指定id的客户 */
	public void shanChuZhiDingIdDeKeHu() {
		System.out.println("==========删除指定id的客户=========");
		System.out.print("客户ID:");
		int a = sc.nextInt();
		if (client.delete(a)) {
			System.out.println("=======删除成功======");
		} else {
			System.out.println("======删除失败，无对应客户=====");
		}
		System.out.println("=======[1]继续删除=====");
		System.out.println("=======[2]返回上一层=====");
		System.out.println("=======[0]退出系统======");
		String s2 = sc.next();
		switch (s2) {
		case "1":
			// 继续删除
			shanChuZhiDingIdDeKeHu();
			break;
		case "2":
			// 返回管理员功能界面
			guanLiYuanGonNengJieMian();
			break;
		default:
			// 退出系统
			return;
		}
	}

	/** 显示订单列表界面 */
	public void xianShiDingDanLieBiaoJieMian() {
		System.out.println("======所有订单信息======");
		int a = 1;
		// 查看所有订单信息(分页显示)
		xianShiDingDanLieBiao(a);

	}

	/** 查看订单列表 */
	public void xianShiDingDanLieBiao(int a) {
		if (om.fenYeXianShi(a).size() == 0) {
			System.out.println("暂无订单信息");
			System.out.println("=======[1]继续查看=====");
			System.out.println("=======[2]返回上一层=====");
			System.out.println("=======[0]退出系统======");
			String s3 = sc.next();
			switch (s3) {
			case "1":
				// 继续查看
				xianShiDingDanLieBiaoJieMian();
				break;
			case "2":
				// 返回管理员功能界面
				guanLiYuanGonNengJieMian();
				break;
			default:
				// 退出系统
				return;
			}
		} else if (om.fenYeXianShi(a).size() == 5) {
			for (OrderForm d : om.fenYeXianShi(a)) {
				System.out.println(d);
			}
			System.out.println("=======[1]上一页=====");
			System.out.println("=======[2]下一页=====");
			System.out.println("=======[3]返回上一层=====");
			System.out.println("=======[0]退出系统======");
			String s3 = sc.next();
			switch (s3) {
			case "1":
				// 上一页
				a--;
				xianShiDingDanLieBiao(a);
				break;
			case "2":
				// 下一页
				a++;
				xianShiDingDanLieBiao(a);
				break;
			case "3":
				// 返回管理员功能界面
				guanLiYuanGonNengJieMian();
				break;
			default:
				// 退出系统
				return;
			}
		} else {
			for (OrderForm d : om.fenYeXianShi(a)) {
				System.out.println(d);
			}
			System.out.println("=======[1]上一页=====");
			System.out.println("=======[2]返回上一层=====");
			System.out.println("=======[0]退出系统======");
			String s3 = sc.next();
			switch (s3) {
			case "1":
				// 上一页
				a--;
				xianShiDingDanLieBiao(a);
				break;
			case "2":
				// 返回管理员功能界面
				guanLiYuanGonNengJieMian();
				break;
			default:
				// 退出系统
				return;
			}
		}
	}

	/** 根据订单id修改订单状态 */
	public void genKJuDinDanIdXiuGaiDinDanZhuangTai() {
		System.out.println("==========根据订单id修改订单状态=========");
		System.out.print("订单ID:");
		int a = sc.nextInt();
		System.out.print("订单状态(0:未支付 1：已支付 2：配送中 3：已完成):");
		int d = sc.nextInt();
		if (om.xiuGaiDinDanZhuangTai(a, d)) {
			System.out.println("=======修改成功======");
		} else {
			System.out.println("======修改失败，无对应订单=====");
		}
		System.out.println("=======[1]继续修改=====");
		System.out.println("=======[2]返回上一层=====");
		System.out.println("=======[0]退出系统======");
		String s2 = sc.next();
		switch (s2) {
		case "1":
			// 继续修改
			genKJuDinDanIdXiuGaiDinDanZhuangTai();
			break;
		case "2":
			// 返回管理员功能界面
			guanLiYuanGonNengJieMian();
			break;
		default:
			// 退出系统
			return;
		}
	}

	/** 显示所有菜品界面 */
	public void xianShiSuoYoucaiPinJieMian() {
		System.out.println("======所有菜品信息======");
		int a = 1;
		// 查看所有菜品信息(分页显示)
		xianShiSuoYoucaiPin(a);

	}

	/** 查看所有菜品信息 */
	public void xianShiSuoYoucaiPin(int a) {
		if (dm.fenYeXianShi(a).size() == 0) {
			System.out.println("暂无菜品信息");
			System.out.println("=======[1]继续查看=====");
			System.out.println("=======[2]返回上一层=====");
			System.out.println("=======[0]退出系统======");
			String s3 = sc.next();
			switch (s3) {
			case "1":
				// 继续查看
				xianShiSuoYoucaiPinJieMian();
				break;
			case "2":
				// 返回用户功能界面
				yonHuGonNengJieMian();
				break;
			default:
				// 退出系统
				return;
			}

		} else if (dm.fenYeXianShi(a).size() == 5) {
			for (Dishes d : dm.fenYeXianShi(a)) {
				System.out.println(d);
			}
			System.out.println("=======[1]上一页=====");
			System.out.println("=======[2]下一页=====");
			System.out.println("=======[3]返回上一层=====");
			System.out.println("=======[0]退出系统======");
			String s3 = sc.next();
			switch (s3) {
			case "1":
				// 上一页
				a--;
				xianShiSuoYoucaiPin(a);
				break;
			case "2":
				// 下一页
				a++;
				xianShiSuoYoucaiPin(a);
				break;
			case "3":
				// 返回用户功能界面
				yonHuGonNengJieMian();
				break;
			default:
				// 退出系统
				return;
			}
		} else {
			for (Dishes d : dm.fenYeXianShi(a)) {
				System.out.println(d);
			}
			System.out.println("=======[1]上一页=====");
			System.out.println("=======[2]返回上一层=====");
			System.out.println("=======[0]退出系统======");
			String s3 = sc.next();
			switch (s3) {
			case "1":
				// 上一页
				a--;
				xianShiSuoYoucaiPin(a);
				break;
			case "2":
				// 返回用户功能界面
				yonHuGonNengJieMian();
				break;
			default:
				// 退出系统
				return;
			}
		}
	}

	/** 根据菜品类别显示所有菜品 */
	public void genJuCaiPinLeiBieXianShiSuoYouCaiPin() {
		System.out.println("========查看指定类别菜品信息=======");
		System.out.print("菜品类别：");
		String s1 = sc.next();
		if (dm.anLeiBie(s1).size() == 0) {
			System.out.println("=======无该类别菜品======");
		} else {
			for (Dishes d : dm.anLeiBie(s1)) {
				System.out.println(d);
			}
		}
		System.out.println("=======[1]继续查看=====");
		System.out.println("=======[2]返回上一层=====");
		System.out.println("=======[0]退出系统======");
		String s2 = sc.next();
		switch (s2) {
		case "1":
			// 继续查看
			genJuCaiPinLeiBieXianShiSuoYouCaiPin();
			break;
		case "2":
			// 返回用户功能界面
			yonHuGonNengJieMian();
			break;
		default:
			// 退出系统
			return;
		}
	}

	/** 点餐界面 */
	public void dianCanJieMian() {
		// 存储用户所点菜品的id和购买数
		Map<Integer, Integer> map = new LinkedHashMap<Integer, Integer>();
		// 存储用户所点菜品的总价格
		int sum = 0;
		System.out.println("============点餐界面===========");
		s: while (true) {
			System.out.println("菜品id及购买数：");
			// 菜品id
			int a = sc.nextInt();
			// 购买数量
			int b = sc.nextInt();
			if (dm.findById(a) != null) {
				if (dm.findById(a).getDzonShuLiang() < b) {
					b = dm.findById(a).getDzonShuLiang();
				}
				map.put(a, b);
				sum += (dm.findById(a).getDshouJia() * b);
				System.out.println("======[1]继续点餐=====");
				if (sum != 0) {
					System.out.println("======[2]结算========");
				}
				System.out.println("======[3]返回上一界面========");
				System.out.println("======[0]退出系统========");
				String s1 = sc.next();
				switch (s1) {
				case "1":
					continue s;
				case "2":
					break;
				case "3":
					yonHuGonNengJieMian();
					break;
				default:
					return;
				}
				if (om.insert(new OrderForm(oid, map, ClientManagement.getId(), sum, 0))) {
					oid++;
					dm.findById(a).setDyueXiaoShouLiang(dm.findById(a).getDyueXiaoShouLiang() + b);
					dm.findById(a).setDzonShuLiang(dm.findById(a).getDzonShuLiang() - b);
					System.out.println("=======点餐成功，一共" + sum + "元，请付款=======");
					// 付款
					fuKuan(sum);
					System.out.println("======[1]返回上一界面========");
					System.out.println("======[0]退出系统========");
					String s2 = sc.next();
					switch (s2) {
					case "1":
						yonHuGonNengJieMian();
						break;
					default:
						return;
					}
				}
			} else {
				System.out.println("======[1]继续点餐=====");
				System.out.println("======[2]返回上一界面========");
				System.out.println("======[0]退出系统========");
				String s1 = sc.next();
				switch (s1) {
				case "1":
					continue s;
				case "2":
					yonHuGonNengJieMian();
					break;
				default:
					return;
				}
			}
		}
	}

	/** 付款 */
	public void fuKuan(int sum) {
		System.out.print("付款：");
		sum -= sc.nextInt();
		if (sum == 0) {
			System.out.println("=======付款成功,请稍等，美食稍后就好=====");
		} else if (sum < 0) {
			System.out.println("==付款成功，找您" + (-sum) + "元===");
		} else {
			System.out.println("===还差" + sum + "元，请继续付款===");
			fuKuan(sum);
		}
	}

	/** 用户查看订单 */
	public void chaKanDingDan() {
		System.out.println("=====您的订单如下=====");
		System.out.println(om.yonHuDingDan());
		System.out.println("======[1]继续查看========");
		System.out.println("======[2]返回上一界面========");
		System.out.println("======[0]退出系统========");
		String s1 = sc.next();
		switch (s1) {
		case "1":
			chaKanDingDan();
		case "2":
			yonHuGonNengJieMian();
			break;
		default:
			return;
		}
	}

	/** 用户修改密码 */
	public void xiuGaiMiMa() {
		System.out.println("=========修改密码(密码限制：只能是6-10位的数字或字母,不能0开头)========");
		System.out.print("新密码：");
		String s1 = sc.next();
		if (client.xiuGaiMiMa(s1)) {
			System.out.println("=====修改成功，请牢记密码=====");
		} else {
			System.out.println("=====修改失败，请注意密码格式===");
		}
		System.out.println("======[1]继续修改========");
		System.out.println("======[2]返回上一界面========");
		System.out.println("======[0]退出系统========");
		String s2 = sc.next();
		switch (s2) {
		case "1":
			xiuGaiMiMa();
			break;
		case "2":
			yonHuGonNengJieMian();
			break;
		default:
			return;
		}
	}

	/** 个人信息显示 */
	public void geRenXinXiXianShi() {
		System.out.println("=====以下是您的个人信息=====");
		System.out.println(client.xianShiDangQianYonHu());
		System.out.println("======[1]继续显示========");
		System.out.println("======[2]返回上一界面========");
		System.out.println("======[0]退出系统========");
		String s2 = sc.next();
		switch (s2) {
		case "1":
			geRenXinXiXianShi();
			break;
		case "2":
			yonHuGonNengJieMian();
			break;
		default:
			return;
		}
	}
}

测试：

public class Test {

	public static void main(String[] args) {
		Main m = new Main();
		m.shouYeJieMian();
	}

}

你可能感兴趣的:(java)

第十五届蓝桥杯软件赛C/C++大学A组个人省赛题解 2301_78234743 java
题解|#压缩字符串(一)#/***代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可***@4月末字节offer，51可以放松一下了从三月初开始零碎的投递，到三月底开始海投，三月的时候面试的机会其实很少，到4月初面试机会才逐渐多了起题解|#四则运算#importjava.util.*;//注意类名必须为Main,不要有任何package众远智慧离谱电话面2月底投的写完了笔试，
memcached的内存分配器是如何工作的？为什么不适用malloc/free！？为何要使用slabs？思维导图代码示例（java 架构) 用心去追梦 memcached java 架构
Memcached内存分配器工作原理Memcached使用了一种称为SlabAllocator的内存分配机制，它与传统的malloc/free不同。以下是关于为什么Memcached选择使用SlabAllocator而不是标准的内存分配方式的原因，以及其工作原理的关键点：1.SlabAllocator的优点减少碎片化：SlabAllocator通过预先分配固定大小的内存块（称为slabs），并将相
SpringBoot3+Vue3+NaiveUI博客后台管理系统源码 | 小蚂蚁云小蚂蚁开源后端 vue 架构低代码
项目介绍基于SpringBoot3、SpringSecurity、MybatisPlus、Vue3、TypeScript、Vite、NaiveUI、MySQL等技术栈实现的单体前后端分离后台管理系统；后端基于Java语言采用SpringBoot3、SpringSecurity、MybatisPlus、MySQL等主流技术栈，前端基于Vue3、TypeScript、Vite等技术栈实现，采用Naiv
小蚂蚁云后台管理系统|XiaoMaYi 小蚂蚁开源后端 vue
项目介绍基于SpringBoot3、SpringSecurity、MybatisPlus、Vue3、TypeScript、Vite、ElementPlus、MySQL等技术栈实现的单体前后端分离后台管理系统；后端基于Java语言采用SpringBoot3、SpringSecurity、MybatisPlus、MySQL等主流技术栈，前端基于Vue3、TypeScript、Vite等技术栈实现，采用
java抽取PDF指定范围页做新的PDF文件 vipwangjun epub java java pdf itextpdf PDF分割
因为公司有将首页提取出来做成一个单独的PDF文件.为了以后方便,直接就写一个方法.可以抽取任意范围的PDF页作为新的PDF./***截取pdfFile的第from页至第end页，组成一个新的文件名*@parampdfFile需要分割的PDF*@paramsavepath新PDF*@paramfrom起始页*@paramend结束页*/publicstaticvoidsplitPDFFile(Str
2021最全大厂Java面试题总结，备战2022春招~~ 老程不秃 Java 面试程序员 java 面试架构数据结构程序人生
前言2021年已不足一月，再过不久就要迎来2022年了，相信很多小伙伴在为跳槽做准备，每年的金三银四都是各大公司招聘程序员的最佳时期，在这段时间内有好多程序员为面试而发愁，不知道如何才能收到好的offer，拿到理想的薪资，实现自我的人生价值！所以小编特地分享出总结的一份480余页的面试手册。俗话说得好，他山之石，可以攻玉，多看多借鉴希望能对大家有所帮助✌。需要原文件学习的朋友们点赞+收藏，关注我之
JsonPath用法详解吴少凡 python 开发语言自动化 pycharm
JSONPath是一种信息抽取类库，是从JSON文档中抽取指定信息的工具，提供多种语言实现版本，包括Javascript、Python、PHP和Java。1、JSONPath安装:pipinstalljsonpath#如果安装太慢可以使用清华源来加速安装pipinstalljsonpath-ihttps://pypi.tuna.tsinghua.edu.cn/simple2、JSONPath语法J
java 获取pdf某页_java从一个pdf中取出指定页生成一个新的pdf weixin_39788131 java 获取pdf某页
publicstaticvoidpartitionPdfFile(StringpdfFile,StringnewFile,intfrom,intend){Documentdocument=null;PdfCopycopy=null;try{PdfReaderreader=newPdfReader(pdfFile);intn=reader.getNumberOfPages();if(end==0){
Git上传了秘钥如何彻底修改包括历史记录【从安装到实战详细版】 web2u git elasticsearch 数据库 spring boot java 后端
使用BFGRepo-Cleaner清除Git仓库中的敏感信息1.背景介绍在使用Git进行版本控制时，有时会不小心将敏感信息（如API密钥、密码等）提交到仓库中。即使后续删除，这些信息仍然存在于Git的历史记录中。本文将介绍如何使用BFGRepo-Cleaner工具彻底清除这些敏感信息。2.准备工作2.1环境要求Java运行环境（JRE8或更高版本）Git客户端需要清理的Git仓库2.2下载BFG访
Java 生成 PDF 文档如此简单五行星辰业务系统应用技术 pdf java maven
嘿，朋友！在Java里实现PDF文档生成那可真是个挺有意思的事儿，今儿个就来好好唠唠这个。咱有不少好用的库可以选择，下面就给你详细讲讲其中两个超实用的库，一个是iText，另一个是ApachePDFBox。用iText库生成PDF思路先把iText库给引入进来，这就好比给咱的Java项目装上了一个生成PDF的“神器”。创建一个Document对象，这个对象就像是一张白纸，咱要在上面绘制PDF的内容
Java面试题及答案汇总（二，马士兵Java全套百度云 Java独家笑程序员后端 java 面试
常用容器的图录：19.Collection和Collections有什么区别？java.util.Collection是一个集合接口（集合类的一个顶级接口）。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式，其直接继承接口有List与Set。Collections则是集
华为OD机试E卷 -boss的收入（Java & Python& JS & C++ & C ）算法大师最新华为OD机试华为od java python javascript c++c语言华为od机考e卷
最新华为OD机试真题目录：点击查看目录华为OD面试真题精选：点击立即查看题目描述一个XX产品行销总公司，只有一个boss，其有若干一级分销，一级分销又有若干二级分销，每个分销只有唯一的上级分销。规定，每个月，下级分销需要将自己的总收入（自己的+下级上交的）每满100元上交15元给自己的上级。现给出一组分销的关系，和每个分销的收入，请找出boss并计算出这个boss的收入。比如：收入100元，上交1
系统相关类——java.lang.Math （三）（案例详细拆解小白友好）励志去大厂的菜鸟 Java思想和方法 Java学习白话拆解Java java 开发语言服务器深度学习学习方法
前言：小编打算近期更俩三期类的专栏，一些常用的专集类，给大家分好类别总结和详细的代码举例解释。今天是第三个java.lang.Math类我们一直都是以这样的形式，让新手小白轻松理解复杂晦涩的概念，把Java代码拆解的清清楚楚，每一步都知道他是怎么来的，为什么用这串代码关键字，对比同类型的代码，让大家真正看完以后融会贯通，举一反三，实践应用！！！！①官方定义和大白话拆解对比②举生活中常见贴合例子、图
Spring Cloud入门-汇总篇(Hoxton版本) 2401_84049200 程序员 spring cloud 面试 spring
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！|9|SpringCloud入门-Bus消息总线(Hoxton版本)|https://blog.csdn.net/ThinkWon/article/details/103753372||10|SpringCloud入门-Sleuth服务链路跟踪(Hoxton版本)|https://blog.csdn
华为OD机试E卷 --选修课--24年OD统一考试（Java & JS & Python & C & C++）飞码创造者最新华为OD机试题库2024 华为od java javascript python js c语言
文章目录题目描述输入描述输出描述用例题目解析JS算法源码Java算法源码python算法源码c算法源码题目描述现有两门选修课，每门选修课都有一部分学生选修，每个学生都有选修课的成绩，需要你找出同时选修了两门选修课的学生，先按照班级进行划分，班级编号小的先输出，每个班级按照两门选修课成绩和的降序排序，成绩相同时按照学生的学号升序排序。输入描述第一行为第一门选修课学生的成绩，第二行为第二门选修课学生的
【前端】--- ES6下篇（带你深入了解ES6语法）心.c 前端 es6 ecmascript
前言：ECMAScript是JavaScript的标准化版本，由ECMA国际组织制定。ECMAScript定义了JavaScript的语法、类型、语句、关键字、保留字等。ES6是ECMAScript的第六个版本，于2015年发布，引入了许多重要的新特性，使JavaScript更加现代化。进制ES6中增加了二进制和八进制的写法：二进制使用前缀'0b'或'0B'，八进制使用前缀'0o'或'0O'二进制
java枚举转json 软件老王枚举 json
1、背景java后端的枚举类型，要展示到前端，提供给用户进行下拉选择，java后端需要封装enum为json字符串提供给前端，需要首先将枚举类型转为list，然后再转为json字符串。2、方案方案也很简单，使用EnumSet.allOf(TestEnum.class)，将数据获取到再塞到list中就可以了。代码如下：importcom.alibaba.fastjson.JSONObject;imp
Javaweb--SpringBoot 顾以沫 Java web spring boot java 数据库
1.SpringBoot入门简化Spring开发的一个框架，SpringBoot旨在帮助开发者快速搭建Spring框架。整个Spring的一个合集，可以简化配置2.微服务（1）微服务就是一种架构风格（2）微服务就是把一个项目拆分成独立的多个服务，并且多个服务是可以独立运行的，而每个服务都会占用线程。（3）通过HTTPS的方式进行互通每一个功能元素都是一个可以独立替换和独立升级的软件单元微服务(ma
Java 枚举类型用法我心向阳iu #Java进阶 Java面试知识点精讲 java jvm 开发语言
文章目录枚举1.1概述1.2定义格式1.3枚举的特点枚举中的抽象方法1.4枚举的方法枚举1.1概述为了间接的表示一些固定的值，Java就给我们提供了枚举枚举是指将变量的值一一列出来,变量的值只限于列举出来的值的范围内1.2定义格式格式publicenums{枚举项1,枚举项2,枚举项3;}注意:定义枚举类要用关键字enum示例代码
nutzboot框架入门优人qaq spring
引言NutzBoot是基于Nutz框架开发的一款轻量级、高效的JavaWeb开发脚手架，它旨在简化JavaWeb应用的开发与部署流程，为开发者提供便捷、高效的开发体验。核心特性自动配置：NutzBoot具备类似于SpringBoot的自动配置功能。它能够依据项目的依赖和配置，自动完成各类组件的初始化与配置。例如，若项目中添加了数据库相关依赖，NutzBoot会自动配置数据源和数据库连接池，极大减少
JAVA学习之路-基础篇一小张认为的测试 java最最基础 java
目录DOS命令在哪编写？怎么打开DOS命令窗口？常见的DOS命令关于windows操作系统文件扩展名的设置关于Java的加载与执行Java的特性前言我们都是逐梦路上的追逐着者，不约而同的，我们在这相遇我们试着成长，试着接受，试着面对我们所缺的不是面对困难的勇气而是肯定每一个看似不起眼的进步看似别人轻蔑的言语都证明了我们还在追逐着漫漫长路慢慢走慢慢懂DOS命令在哪编写？怎么打开DOS命令窗口？在DO
java枚举实现简单的控制台计算器 Roc-xb java 开发语言
本文教程主要是用java枚举的方式实现一个简单的加减乘除计算器。packagecom.ruoyi;importjava.util.Scanner;publicenumCalculator{ADDITION
基于 WPF 平台使用纯 C# 实现动态处理 json 字符串 code_shenbing WPF wpf c#json
一、引言在当今的软件开发领域，数据的交换与存储变得愈发频繁，JSON（JavaScriptObjectNotation）作为一种轻量级的数据交换格式，以其简洁、易读、便于解析和生成的特点，被广泛应用于各种应用程序中。在WPF（WindowsPresentationFoundation）平台开发的桌面应用里，我们常常需要与各种数据源交互，动态处理JSON字符串就成为了一项必备技能。本文将深入探讨如何
【Java】枚举类 Mr_EvanChen Java Java Enum 枚举类型
Java枚举知识点概念enum的全称为enumeration，是JDK1.5中引入的新特性。在Java中，被enum关键字修饰的类型就是枚举类型。形式如下：enumColor{RED,GREEN,BLUE}如果枚举不添加任何方法，枚举值默认为从0开始的有序数值。以Color枚举类型举例，它的枚举常量依次为RED：0，GREEN：1，BLUE：2。枚举的好处：可以将常量组织起来，统一进行管理。枚举的
Vue.js 单页应用（SPA）开发教程：从零开始构建你的第一个项目 Milk夜雨 vue.js vue.js 前端 javascript
单页应用（SPA，SinglePageApplication）是现代前端开发的主流模式。Vue.js是一个非常适合构建SPA的框架，它通过VueRouter实现页面导航，通过组件化开发和状态管理实现复杂的交互功能。本篇教程将带你了解SPA的基本概念，并一步步创建一个Vue.js单页应用。什么是单页应用（SPA）？单页应用是一种只有一个HTML页面，通过JavaScript动态加载内容的应用。特点包
Node.js的解释 web15085415935 面试学习路线阿里巴巴 node.js
1.Node.js入门教程1.1什么是Node.js？1.1.1Node.js是什么？Node.js是一个基于JavaScript的开源服务器端运行时环境，允许开发者用JavaScript编写服务器端代码。与传统的前端JavaScript主要运行在浏览器端不同，Node.js通过提供一个非阻塞的异步模型，允许开发者在服务器端创建高性能的网络应用程序。比喻：想象你把JavaScript看作是一个厨师
华为OD机试详解：分苹果问题的多语言实现与算法解析 m0_57781768 华为od 算法
华为OD机试详解：分苹果问题的多语言实现与算法解析在华为OD机试中，分苹果问题是典型的算法考题之一，考察了考生对于位运算的理解和应用。这道题的难点在于A和B两人的计算规则差异。A希望根据他的二进制加法规则来等分苹果，而B则希望在满足A的规则下，自己获得最多的苹果。本文将通过详细的解题思路及C++、Java、JavaScript、Python四种语言的实现，帮助你掌握这个问题的解决方法。题目描述A和
windows安装ES 我的棉裤丢了 elasticsearch 大数据搜索引擎
1.下载ES访问ES官网下载DownloadElasticsearch|Elastic2.配置环境变量ES_JAVA_HOME:D:\jdk-17.0.9ES_HOME:D:\elasticsearch-8.17.1-windows-x86_64\elasticsearch-8.17.13.添加一些ES的配置关闭ES安全认证打开elasticsearch-8.17.1\config\elastic
Spring Boot 集成 Redis 全解析翻晒时光 springboot spring boot redis
在当今快速发展的互联网应用开发中，性能和效率是至关重要的因素。Redis作为一款高性能的内存数据库，常被用于缓存、消息队列、分布式锁等场景，能够显著提升应用程序的响应速度和吞吐量。SpringBoot以其强大的自动配置和快速开发特性，成为众多Java开发者的首选框架。将SpringBoot与Redis集成，可以充分发挥两者的优势，构建出高效、稳定的应用系统。本文将详细介绍SpringBoot集成R
深入Java编程：经典课程设计案例剖析脑叔
本文还有配套的精品资源，点击获取简介：Java课程设计是提高编程技能的重要途径，包含了Java基础语法、面向对象编程、异常处理、集合框架、IO流、多线程、网络编程、数据库连接、GUI编程、设计模式以及单元测试等多个方面。本集合详细介绍了这些关键知识点，并通过经典案例教学，帮助学生和开发者巩固理论知识，提升解决实际问题的能力，为未来的软件开发工作奠定坚实基础。1.Java基础语法精讲1.1Java程
如何用ruby来写hadoop的mapreduce并生成jar包 wudixiaotie mapreduce
ruby来写hadoop的mapreduce，我用的方法是rubydoop。怎么配置环境呢： 1.安装rvm：不说了网上有 2.安装ruby：由于我以前是做ruby的，所以习惯性的先安装了ruby，起码调试起来比jruby快多了。 3.安装jruby： rvm install jruby然后等待安
java编程思想 -- 访问控制权限百合不是茶 java 访问控制权限单例模式
访问权限是java中一个比较中要的知识点,它规定者什么方法可以访问,什么不可以访问一:包访问权限; 自定义包: package com.wj.control; //包 public class Demo { //定义一个无参的方法 public void DemoPackage(){ System.out.println("调用
[生物与医学]请审慎食用小龙虾 comsci 生物
现在的餐馆里面出售的小龙虾,有一些是在野外捕捉的,这些小龙虾身体里面可能带有某些病毒和细菌,人食用以后可能会导致一些疾病,严重的甚至会死亡..... 所以,参加聚餐的时候,最好不要点小龙虾...就吃养殖的猪肉,牛肉,羊肉和鱼,等动物蛋白质
org.apache.jasper.JasperException: Unable to compile class for JSP: 商人shang maven 2.2 jdk1.8
环境： jdk1.8 maven tomcat7-maven-plugin 2.0 原因： tomcat7-maven-plugin 2.0 不知吃 jdk 1.8，换成 tomcat7-maven-plugin 2.2就行，即 <plugin>
你的垃圾你处理掉了吗?GC oloz GC
前序:本人菜鸟，此文研究学习来自网络，各位牛牛多指教　 1.垃圾收集算法的核心思想　　Java语言建立了垃圾收集机制，用以跟踪正在使用的对象和发现并回收不再使用(引用)的对象。该机制可以有效防范动态内存分配中可能发生的两个危险：因内存垃圾过多而引发的内存耗尽，以及不恰当的内存释放所造成的内存非法引用。　　垃圾收集算法的核心思想是：对虚拟机可用内存空间，即堆空间中的对象进行识别
shiro 和 SESSSION 杨白白 shiro
shiro 在web项目里默认使用的是web容器提供的session，也就是说shiro使用的session是web容器产生的，并不是自己产生的，在用于非web环境时可用其他来源代替。在web工程启动的时候它就和容器绑定在了一起，这是通过web.xml里面的shiroFilter实现的。通过session.getSession()方法会在浏览器cokkice产生JESSIONID，当关闭浏览器，此
移动互联网终端淘宝客如何实现盈利小桔子移動客戶端淘客淘寶App
2012年淘宝联盟平台为站长和淘宝客带来的分成收入突破30亿元，同比增长100%。而来自移动端的分成达1亿元，其中美丽说、蘑菇街、果库、口袋购物等App运营商分成近5000万元。可以看出，虽然目前阶段PC端对于淘客而言仍旧是盈利的大头，但移动端已经呈现出爆发之势。而且这个势头将随着智能终端(手机，平板)的加速普及而更加迅猛
wordpress小工具制作 aichenglong wordpress 小工具
wordpress 使用侧边栏的小工具，很方便调整页面结构小工具的制作过程 1 在自己的主题文件中新建一个文件夹(如widget)，在文件夹中创建一个php(AWP_posts-category.php) 小工具是一个类,想侧边栏一样，还得使用代码注册，他才可以再后台使用，基本的代码一层不变 <?php class AWP_Post_Category extends WP_Wi
JS微信分享 AILIKES js
// 所有功能必须包含在 WeixinApi.ready 中进行 WeixinApi.ready(function(Api) { // 微信分享的数据 var wxData = { &nb
封装探讨百合不是茶 JAVA面向对象封装
//封装属性方法将某些东西包装在一起，通过创建对象或使用静态的方法来调用，称为封装；封装其实就是有选择性地公开或隐藏某些信息，它解决了数据的安全性问题，增加代码的可读性和可维护性在 Aname类中申明三个属性，将其封装在一个类中：通过对象来调用例如 1： //属性将其设为私有姓名 name 可以公开
jquery radio/checkbox change事件不能触发的问题 bijian1013 JavaScript jquery
我想让radio来控制当前我选择的是机动车还是特种车，如下所示： <html> <head> <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js" type="text/javascript"><
AngularJS中安全性措施 bijian1013 JavaScript AngularJS 安全性 XSRF JSON漏洞
在使用web应用中，安全性是应该首要考虑的一个问题。AngularJS提供了一些辅助机制，用来防护来自两个常见攻击方向的网络攻击。一.JSON漏洞当使用一个GET请求获取JSON数组信息的时候（尤其是当这一信息非常敏感，
[Maven学习笔记九]Maven发布web项目 bit1129 maven
基于Maven的web项目的标准项目结构 user-project user-core user-service user-web src
【Hive七】Hive用户自定义聚合函数(UDAF) bit1129 hive
用户自定义聚合函数，用户提供的多个入参通过聚合计算(求和、求最大值、求最小值)得到一个聚合计算结果的函数。问题：UDF也可以提供输入多个参数然后输出一个结果的运算，比如加法运算add(3，5)，add这个UDF需要实现UDF的evaluate方法,那么UDF和UDAF的实质分别究竟是什么？ Double evaluate(Double a, Double b)
通过 nginx-lua 给 Nginx 增加 OAuth 支持 ronin47
前言：我们使用Nginx的Lua中间件建立了OAuth2认证和授权层。如果你也有此打算，阅读下面的文档，实现自动化并获得收益。SeatGeek 在过去几年中取得了发展，我们已经积累了不少针对各种任务的不同管理接口。我们通常为新的展示需求创建新模块，比如我们自己的博客、图表等。我们还定期开发内部工具来处理诸如部署、可视化操作及事件处理等事务。在处理这些事务中，我们使用了几个不同的接口来认证： &n
利用tomcat-redis-session-manager做session同步时自定义类对象属性保存不上的解决方法 bsr1983 session
在利用tomcat-redis-session-manager做session同步时，遇到了在session保存一个自定义对象时，修改该对象中的某个属性，session未进行序列化，属性没有被存储到redis中。在 tomcat-redis-session-manager的github上有如下说明： Session Change Tracking As noted in the &qu
《代码大全》表驱动法-Table Driven Approach-1 bylijinnan java 算法
关于Table Driven Approach的一篇非常好的文章： http://www.codeproject.com/Articles/42732/Table-driven-Approach package com.ljn.base; import java.util.Random; public class TableDriven { public
Sybase封锁原理 chicony Sybase
昨天在操作Sybase IQ12.7时意外操作造成了数据库表锁定，不能删除被锁定表数据也不能往其中写入数据。由于着急往该表抽入数据，因此立马着手解决该表的解锁问题。无奈此前没有接触过Sybase IQ12.7这套数据库产品，加之当时已属于下班时间无法求助于支持人员支持，因此只有借助搜索引擎强大的
java异常处理机制 CrazyMizzz java
java异常关键字有以下几个，分别为 try catch final throw throws 他们的定义分别为 try： Opening exception-handling statement. catch： Captures the exception. finally： Runs its code before terminating
hive 数据插入DML语法汇总 daizj hive DML 数据插入
Hive的数据插入DML语法汇总1、Loading files into tables语法：1) LOAD DATA [LOCAL] INPATH 'filepath' [OVERWRITE] INTO TABLE tablename [PARTITION (partcol1=val1, partcol2=val2 ...)]解释：1)、上面命令执行环境为hive客户端环境下： hive>l
工厂设计模式 dcj3sjt126com 设计模式
使用设计模式是促进最佳实践和良好设计的好办法。设计模式可以提供针对常见的编程问题的灵活的解决方案。工厂模式工厂模式（Factory）允许你在代码执行时实例化对象。它之所以被称为工厂模式是因为它负责“生产”对象。工厂方法的参数是你要生成的对象对应的类名称。 Example #1 调用工厂方法（带参数） <?phpclass Example{
mysql字符串查找函数 dcj3sjt126com mysql
FIND_IN_SET(str,strlist) 假如字符串str 在由N 子链组成的字符串列表strlist 中，则返回值的范围在1到 N 之间。一个字符串列表就是一个由一些被‘,’符号分开的自链组成的字符串。如果第一个参数是一个常数字符串，而第二个是type SET列，则 FIND_IN_SET() 函数被优化，使用比特计算。如果str不在strlist 或st
jvm内存管理 easterfly jvm
一、JVM堆内存的划分分为年轻代和年老代。年轻代又分为三部分：一个eden,两个survivor。工作过程是这样的：e区空间满了后，执行minor gc，存活下来的对象放入s0, 对s0仍会进行minor gc，存活下来的的对象放入s1中，对s1同样执行minor gc，依旧存活的对象就放入年老代中；年老代满了之后会执行major gc，这个是stop the word模式，执行
CentOS-6.3安装配置JDK-8 gengzg centos
JAVA_HOME=/usr/java/jdk1.8.0_45 JRE_HOME=/usr/java/jdk1.8.0_45/jre PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib export JAVA_HOME
【转】关于web路径的获取方法 huangyc1210 Web 路径
假定你的web application 名称为news,你在浏览器中输入请求路径： http://localhost:8080/news/main/list.jsp 则执行下面向行代码后打印出如下结果： 1、 System.out.println(request.getContextPath()); //可返回站点的根路径。也就是项
php里获取第一个中文首字母并排序远去的渡口数据结构 PHP
很久没来更新博客了，还是觉得工作需要多总结的好。今天来更新一个自己认为比较有成就的问题吧。最近在做储值结算，需求里结算首页需要按门店的首字母A-Z排序。我的数据结构原本是这样的： Array ( [0] => Array ( [sid] => 2885842 [recetcstoredpay] =&g
java内部类 hm4123660 java 内部类匿名内部类成员内部类方法内部类
　在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。内部类可以间接解决多继承问题,可以使用内部类继承一个类，外部类继承一个类，实现多继承。 &nb
Caused by: java.lang.IncompatibleClassChangeError: class org.hibernate.cfg.Exten zhb8015
maven pom.xml关于hibernate的配置和异常信息如下，查了好多资料，问题还是没有解决。只知道是包冲突，就是不知道是哪个包....遇到这个问题的分享下是怎么解决的。。 maven pom: <dependency> <groupId>org.hibernate</groupId> <ar
Spark 性能相关参数配置详解－任务调度篇 Stark_Summer spark cache cpu 任务调度 yarn
随着Spark的逐渐成熟完善, 越来越多的可配置参数被添加到Spark中来, 本文试图通过阐述这其中部分参数的工作原理和配置思路, 和大家一起探讨一下如何根据实际场合对Spark进行配置优化。由于篇幅较长，所以在这里分篇组织，如果要看最新完整的网页版内容，可以戳这里：http://spark-config.readthedocs.org/，主要是便
css3滤镜 wangkeheng html css
经常看到一些网站的底部有一些灰色的图标，鼠标移入的时候会变亮，开始以为是js操作src或者bg呢，搜索了一下，发现了一个更好的方法：通过css3的滤镜方法。 html代码： <a href='' class='icon'><img src='utv.jpg' /></a> css代码： .icon{-webkit-filter: graysc