大学JAVA课设难？ 来
学完Java后，老师让写个课设，不知如何下手？
大学学习java课需要学的东西
最基本的变量类型、运算符、Java强大的面向对象一套、Java的各种IO、JavaGUI、Java异常处理、多线程、网络编程、JDBC，差不多就这么多吧。
课设： 管理系统
我们先来说说管理系统，做这个东西我们需要考虑三点，第一点是数据保存，第二点是数据展示，第三点是用户的操作逻辑，这里包含一些个保存数据的Java类，比如说User的话，这个类里面有用户的一些信息
然后考虑技术：
1.是否使用网络
2.是否使用数据库
基于这两点，我们大约可以分为3类，难度依次递增
1.本地的文件的
2.本地的数据库的
3.网络的数据库的
数据的操作
我们可以把数据保存到文件，也可以保存到数据库
但是他们都有一个操作，增删改查
1.文件实现增删改查
实现办法一：文件一行保存一个数据，在程序启动时把数据读进来实例化成一个一个的Java对象，然后保存到一个列表里面，然后后面的增加，删除，修改，查找都是在操作这个列表中的数据，在程序关闭的时候把这个列表中的所有数据全部有重新写入到那个文件中就可以实现，但是有个缺点，耗费内存，因为程序运行的时候，所有管理的数据都在内存中。但是好像大学的管理系统只是个练习，没有那个多数据，而且这个好实现。
举个例子
Java 保存数据的类
public class User {
private String name;
private int age;
private String sex;
..... getter and setter
}
数据文件格式
李四#30#男 张三#100#女
操作数据的类
public class UserDao {
private List<User> users = new ArrayList<User>();
public UserDao() throws Exception{
synchronized (UserDao.class) {
File file = new File("./dat/users.txt");
FileReader reader = new FileReader(file);
BufferedReader bReader = new BufferedReader(reader);
String line = null;
while ((line = bReader.readLine()) != null) {
User user = stringToUser(line);
users.add(user);
}
bReader.close();
reader.close();
}
}
/**
* 保存数据
* @throws Exception
*/
public void close() throws Exception {
File file = new File("./dat/users.txt");
FileWriter fileWriter = new FileWriter(file);
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
for (int i = 0; i < users.size(); i++) {
bufferedWriter.write(userToString(users.get(i)));
bufferedWriter.newLine();
}
bufferedWriter.close();
fileWriter.close();
}
/**
* 查找
* @param user
* @return
*/
public List<User> query(User user){
List<User> result = new ArrayList<User>();
for (int i = 0; i < users.size(); i++) {
User ap = users.get(i);
User tmp = new User(user.getName(),user.getAge(),user.getSex());
if (tmp.getName() == null) {
tmp.setName(ap.getName());
}
if (tmp.getAge() < 0) {
tmp.setAge(ap.getAge());
}
if (tmp.getSex() == null) {
tmp.setSex(ap.getSex());
}
if (ap.equals(tmp)) {
result.add(ap);
}
}
return result;
}
/**
* 删除
* @param user
* @return
*/
public int delete(User user) {
List<User> query = query(user);
for (int i = 0; i < query.size(); i++) {
users.remove(query.get(i));
}
return query.size();
}
/**
* 增加
* @param user
* @return
*/
public int add(User user) {
return users.add(user)?1:0;
}
public int update(User old,User update) {
List<User> query = query(old);
for (int i = 0; i < query.size(); i++) {
users.remove(query.get(i));
users.add(update);
}
return query.size();
}
private String userToString(User user) {
StringBuffer buffer = new StringBuffer();
buffer.append(user.getName()+"#");
buffer.append(user.getAge()+"#");
buffer.append(user.getSex());
return buffer.toString();
}
private User stringToUser(String str) {
String[] split = str.split("#");
User user = new User();
user.setName(split[0]);
user.setAge(Integer.parseInt(split[1]));
user.setSex(split[2]);
return user;
}
}
实现办法二：
和方法以类似，数据每行保存一个数据，但是程序启动时不会把所有数据读到内存中，查找时候逐行读取，但是Java的流文件是顺序读取，不能修改某个地方，所以需要用到RandomAccessFile来随机读取修改文件，实现比上个难，优点，耗费内存小，但是速度慢，因为在不断的读取设备文件。
我们这里以更新为例子
private File file = new File("./dat/users.txt");
private RandomAccessFile accessFile = null;
private int len = 20;
private long current = 0;
public RandomUserDao() throws Exception {
accessFile = new RandomAccessFile(file, "rw");
accessFile.seek(0);
current = accessFile.getChannel().size();
}
public int update(User old,User update) throws Exception {
accessFile.seek(0);
int read = 0,count = 0,up = 0;
byte[] data = new byte[len];
while ( (read = accessFile.read(data)) != -1 ) {
User toUser = stringToUser(new String(data,0,read).trim());
if (toUser.equals(old)) {
accessFile.seek(count);
accessFile.write(userToString(update).getBytes());
up++;
}
count += len;
}
return up;
}
2.数据库的增删改查
对于数据库的操作，其重点在SQL语句上，所以我们可以把操作数据库的可以大约分为两类：不改数据（查询），改数据（增加，修改，删除）
可以将他封装
public class JdbcTemplate {
private static JdbcTemplate jdbcTemplate;
private String url = null;
private String username = null;
private String password = null;
private String driver = null;
/**
* 使用单例模式
* @return
*/
public static JdbcTemplate getJdbcTemplate() {
synchronized (JdbcTemplate.class){
if (jdbcTemplate == null){
jdbcTemplate = new JdbcTemplate();
}
}
return jdbcTemplate;
}
private JdbcTemplate(){
this.url = SystemConfiguration.getProperty("jdbc.url");
this.username = SystemConfiguration.getProperty("jdbc.username");
this.password = SystemConfiguration.getProperty("jdbc.password");
this.driver = SystemConfiguration.getProperty("jdbc.driver");
try {
Class.forName(this.driver);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
/**
* 获取连接
* @return
*/
public Connection getConnection(){
try {
return DriverManager.getConnection(url,username,password);
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
/**
* 查询 返回map列表
* @param sql
* @param params
* @return
* @throws SQLException
*/
public List<Map<String,Object>> query(String sql, Object ...params) throws SQLException {
Connection connection = getConnection();
PreparedStatement statement = connection.prepareStatement(sql);
if (params != null){
for (int i = 0; i < params.length; i++) {
statement.setObject(i+1,params[i]);
}
}
/**
* 获取表头
*/
ResultSet resultSet = statement.executeQuery();
ResultSetMetaData meta = resultSet.getMetaData();
String[] header = new String[meta.getColumnCount()];
for (int i = 0; i < meta.getColumnCount(); i++) {
header[i] = meta.getColumnName(i+1);
}
List<Map<String,Object>> result = new ArrayList<Map<String, Object>>();
while (resultSet.next()){
Map<String,Object> map = new HashMap<String, Object>();
for (int i = 0; i < header.length; i++) {
map.put(header[i],resultSet.getObject(i+1));
}
result.add(map);
}
resultSet.close();
statement.close();
connection.close();
return result;
}
public <T> List<T> query(String sql, Class<T> cls, Object... params) throws SQLException {
List<Map<String, Object>> query = query(sql, params);
List<T> result = new ArrayList<T>();
for (int i = 0; i < query.size(); i++) {
try {
T instance = cls.newInstance();
Map<String, Object> map = query.get(i);
map.forEach((key,value)->{
try {
Field field = instance.getClass().getDeclaredField(getStandardName(key));
field.setAccessible(true);
field.set(instance,value);
} catch (NoSuchFieldException | IllegalAccessException e) {
e.printStackTrace();
}
});
result.add(instance);
} catch (Exception e) {
e.printStackTrace();
}
}
return result;
}
public String getStandardName(String name){
return name.replace("_","").toLowerCase();
}
public int modify(String sql,Object ...params) throws SQLException {
Connection connection = getConnection();
PreparedStatement statement = connection.prepareStatement(sql);
if (params != null){
for (int i = 0; i < params.length; i++) {
statement.setObject(i+1,params[i]);
}
}
return statement.executeUpdate();
}
}
我们举个例子
private JdbcTemplate jdbcTemplate;
public PersonDao(){
jdbcTemplate = JdbcTemplate.getJdbcTemplate();
}
public List<Person> query(Map<String,Object> condition) {
StringBuffer sql = new StringBuffer("select * from person where 1=1");
List<Object> objects = new ArrayList<Object>();
condition.forEach((key,value)->{
sql.append(" and "+key+"=?");
objects.add(value);
});
System.out.println(sql);
List<Person> query = null;
try {
query = jdbcTemplate.query(sql.toString(), Person.class,objects.toArray());
} catch (SQLException e) {
e.printStackTrace();
}
return query;
}
Java GUI
这个没有说的，界面可以参考我写的
一个完整的图书管理系统
需要代码的话
码云:https://gitee.com/soupcode/bookManager
CSDN: https://blog.csdn.net/weixin_41554210/article/details/105970406
网络
网络的话，需要把架构弄明白，每个用户通过套接字Socket连接，在每个用户连接到服务器的时候，服务器需要给这个用户分配一个线程去处理这个用户的请求
public class Server {
public static void main(String[] args) throws Exception{
ServerSocket serverSocket = new ServerSocket(8080);
while (true) {
Socket accept = serverSocket.accept();
InputStream inputStream = accept.getInputStream();
OutputStream outputStream = accept.getOutputStream();
new Thread() {
@Override
public void run() {
/**
* 这里需要处理业务
*
* 一般需要定义 发送信息的格式
* 比如说 客户端发过来
* adduser 张三 20 23
* 这里就会判断需要添加用户，去调用dao的添加用户
*
*/
}
}.start();;
}
}
}