Fork me on GitHub
image frame

Yu han の BLog

Linux常用指令（续）

Linux 入门

2.0 常用命令- 建立链接

·Linux 中链接文件有两种：软链接，硬链接

··软链接： 相当于快捷方式，通过软链接可以修改源文件的内容
ln -s 源文件 链接文件

删除软链接，不影响源文件
删除源文件，软链接失效
··硬链接： 一个文件有多个名字，通过硬链接可以修改源文件的内容。
ln 源文件 链接文件

删除源文件，如果文件还有多个硬链接，则无影响

软硬链接区别：
·软链接可以指向 一个不存在的文件，硬链接不可以
·可以对目录创建软链接，而不能对目录创建硬链接
在这里插入图片描述

2.1 常用命令- 文件搜索

·在文本内部搜索 grep
grep ‘搜索内容’ 文件路径
在这里插入图片描述
grep ‘teacher’ ./test.txt 即搜索文本中与‘teacher’相关的行 ，关键字用红字标出

grep 内部搜索
选项：-n 查看结果的行数
-i 忽略大小写搜索
-v 取反搜索，搜索不是关键词范围的其他所有行
·grep 正则搜索
grep ‘^a’ 文件路径 【搜索以开头的行】

·在（linux）计算机中搜索文件 find
find 目标文件目录 选项 条件

在这里插入图片描述

2.2 常用命令-归档和压缩

·归档和解档

  • *tar -cvf 归档的文件名.tar 文件1 文件2

  • tar -xvf 档案文件名*

    选项f必须放到最后

·归档+压缩 和 解压+解档

·归档+压缩
tar -zcvf 归档的文件名.tar.gz 文件1 文件2
·解档+解压
tar -zcvf 归档的文件名.tar.gz
如果需要指定解档的目录：tar -zxvf 归档的文件名.tar.gc -C 要解压解档到的目录

2.2.1 常用命令-归档和压缩

·zip 压缩
压缩目录：zip -r xxx.zip
·unzip 解压缩
unzip xxx.zip

2.3 常用命令- 文件权限

在这里插入图片描述
·文件权限的构成
九个字母，三组 （权限拥有者 u ->user，权限组 g->group ,其他用户权限o-other） 所有用户权限 a

每一组权限可选的权限有：

r、w、x 具体权限如上图

2.4 常用命令- 权限修改

①字母表示法
  • ·权限修改指令 chmod
  • 用户： u g o a
  • 权限设置 ： +（增加）、-（撤销）、=（设置）
  • 具体权限： r/w/x
  • 用法： chmod 用户 + 具体权限 文件名

如： chmod u+’r’ test.txt 即为文件拥有者增加文件可读权限
chmod u=rwx 1.txt

②数字表示法

在这里插入图片描述
三位权限数字 ：第一位拥有者 第二位同组用户 第三位 其他用户

chomd 权限数字 文件路径

2.4 常用命令-用户管理

·切换用户
临时： sudo 命令
永久： su 用户名 输入用户名对应的密码

  1. sudo -s 输入当前用户的密码
  2. passwd 修改密码
  3. passwd 【修改当前用户的密码】
  4. passwd 【修改用户的密码】
  5. exit
    exit 如果当前没有用户在线，直接退出终端
如果多次切换用户，退出到上次登录的用户
    who
    用来查看当前系统的登录用户
    选项： -q 统计用户数量
    -u  显示最后一次操作距离现在的时间

2.5 常用命令- 关机 、重启

在这里插入图片描述

2.6 常用命令- 软件安装与卸载

Linux 软件安装三种方式

源代码包安装 deb 包安装 apt-get

源代码包安装需要先编译后安装，较为麻烦
deb包安装需要解决软件依赖问题
apt-get 方式较为省事，且安装一般不会出现问题，下做介绍

apt-get 方式 安装
**·配置软件镜像源  修改/etc/apt/source.list**

注意： 在使用 gedit /etc/apt/source.list 命令打开配置文件时，通常情况下会出现权限不够无法修改的情况，此时临时或永久提升权限可修改保存
gedit 文本编辑只在Ubuntu 发行版中有，在centOS中没有

命令：

  • sudo gedit /etc/apt/source.list
  • 更新软件源 sudo apt-get update
  • 安装软件 sudo apt-get install 软件包名
  • 卸载软件 sudo apt-get remove 软件包名称

2.7 ssh 远程登录

服务器端安装ssh server
sudo apt-get install openssh-server
·客户端登录

ssh 服务器用户名@服务器地址
如 ssh demo @192.168.150.112 –>123

2.8 编辑器 vim介绍及使用

三种模式：
  1. 命令模式（移动光标，复制，删除）
  2. 输入模式（编辑文件）
  3. 末行模式（保存文件，查找替换）
三种模式转换：

打开文件默认是命令模式——【a\i\o】->输入模式——【：】->末行模式

vim 操作

（1）.创建文件 ：vi 文件名——> i 进入编辑模式—>编辑模式—>【esc】到命令模式—>【：】进入末行模式—>wq保存并退出
（2）.进入输入模式
- i 光标前插入 I行首插入
- a 光标后 行尾
- o 光标下一行产生新行 O 光标上一行产生新行

（3）.进入命令模式
在任何状态下【esc】

Linux踩坑实践

Linux 入门

linux 常见发行版

  • CentOS
  • redHat
  • ubuntu
  • 本Blog 操作均以Ubuntu 18.04 -64 实践
附上百度云镜像链接（VMware,Ubuntu iso）：
链接：https://pan.baidu.com/s/1qLxVvxh5M2AfhWkknv9jIQ     
提取码：oe0t

一．Ubuntu 图形界面简介

在这里插入图片描述

二．Ubuntu 中文输入法及系统语言设置

– Ubuntu 系统语言环境设置（VMware默认安装为英文），此处设置为中文。
附链接：
https://blog.csdn.net/gys_20153235/article/details/80490880
– 搜狗拼音安装(选装)
由于搜狗输入法安装需要中文输入法框架fcitx 支持，而默认fcitx 在系统中没有安装，下面给出命令行安装方法

sudo add-apt-repository ppa:fcitx-team/nightly
Sudo apt-get update
Sudo apt-get install fcitx
以下是baidu 提供的安装方法

https://jingyan.baidu.com/article/b7001fe1a7d2c60e7382dd7c.html

三．常用软件安装

(1).编程工具

–java

<1> 安装jdk
1
2
3
apt install default-jre    y
apt-cache search openjdk
sudo apt-get install openjdk-8-jdk
<2> 安装代码工具

Java 编写代码主流使用eclipse 和 Idea，下面分别做安装方法介绍

·eclipse安装

①　打开终端，输入命令

1
sudo apt-get install eclipse

在这里插入图片描述
②　输入y/Y 确认继续
在这里插入图片描述
③　等待解包完成后可直接打开运行

·IDEA 安装
<1>.搜索Idea

进入官网，选择linux版本下载

在这里插入图片描述
<2>. 下载完成后解压提取到某个文件夹下，利用图形化界面文件管理器进入文件bin目录下，如
Downloads/idea-IC-191.7479.19/bin
在这里插入图片描述
在如上所示的文件目录下单击鼠标右键 ，选择在终端打开

<3>.进入该目录下终端后执行如下指令

1
2
sudo chmod a=+rx bin/idea.sh     --提升脚本文件读权限和可执行权限
sh idea.sh  --执行脚本文件

<4>.安装
如果前边一切进行顺利，此时出现安装窗口。
前边步骤相对较为简单，不做过多赘述，值得注意的是下图的窗口，用于选择是否要将IntelliJ IDEA与系统应用程序菜单集成。在几乎每一种情况下，答案是肯定的，否则，为了启动IntelliJ IDEA，我们必须手动执行idea.sh脚本，而这并不是最舒适的方式。因此选择【Next launch Script】创建启动器脚本。
在这里插入图片描述
<5>.在菜单搜索框中搜索idea,出现idae图标，添加到收藏夹，即可快捷启动。
在这里插入图片描述
–Python
因为Ubuntu系统 预装了Python3 Python2
在这里插入图片描述
所以不需要自己下载安装
Python 代码编写通常用pycharm和 idle(简单代码编写)，下提供两者的安装方式

<1>idle
在终端执行命令 sudo apt-get install idle
在这里插入图片描述

因为该软件发行商与idea为同一公司，所以安装步骤及其相似

  1. 下载完成后解压提取到某个文件夹下，利用图形化界面文件管理器进入文件bin目录下，如
    Downloads/pycharm-community-2019.1.3/bin
    在如上所示的文件目录下单击鼠标右键 ，选择在终端打开
    在这里插入图片描述
  2. 在终端输入如下指令进行安装
    chmod 555 pycharm.sh ——为pycharm.sh 脚本文件提升读和可执行权限
    sh pycharm.sh ——执行该命令后pycharm进入安装窗口，同样选择是否创建启动脚本是选择是【Next launch script】以创建快捷启动方式

(2)浏览器—三行命令安装chome

Wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
 sudo dpkg -i google-chrome*
 sudo apt-get install -f

四．解决linux系统自带火狐浏览器无法播放在线音乐问题

众所周知Tecent 巴巴一向无视linux, 理所当然，也就没有QQ music for linux 一说，当然其他平台也 好不到哪里去

那么想听音乐就只能网页在线播放喽，可是当音乐播放键||时，你会绝望的发现并没有声音，试了多次无果，于是转战chome ,就会发现geogle 还是有点东西，播放在线QQ music 毫无压力，回到Firefox，拿出开发工具查看控制台，看到原来是解码器不支持解码AAC,没办法，装一个喽。
控制台输入如下命令可安装大多数音频解码：

sudo apt-get install ubuntu-restricted-extras

安装后重启火狐，问题解决。

java CORBA 组件化编程

java 基础

一． 题目分析

1.编写组件相关接口，服务端程序及客户端程序，掌握组件化开发的概念，了解掌握CORBA模型及ORB机制。
2.掌握CORBA组件化编程方法。
3.理解接口在组件化编程中的具体运用。

二． CORBA模型分析

题目一：JAVA版CORBA程序——HelloWorld
要求编写实现显示“Hello，World！+班级+中文姓名”字符串。
组件结构图:

在这里插入图片描述

具体设计：
1 编写IDL接口HelloWorld.idl：

module sample{
interface HelloWorld{
wstring sayHello();
};
};
值得注意的是因为服务端程序重写sayHello（）函数时存在返回值为汉字的情况，所以此处将string返回值变成了wstring 。

2编译IDL接口：X:\corba>idlj –fall HelloWorld.idl

在配置好jdk环境变量的情况下，将cmd 窗口文件目录切换到Hello.idl文件所在的路径，输入上述命令，执行后有java-jdk-bin文件目录下的ldlj.exe在命令目录下生成一个文件夹。在此程序中，文件夹名称为sample。文件夹下Java文件如下：
在这里插入图片描述

3编写并编译服务器端和客户端文件HelloWorldServer.java，HelloWorldClient.java

在这里插入图片描述

4启动名字服务器：

tnameserv -ORBInitialPort 1050
@pause

5启动服务器端程序：

java HelloWorldServer -ORBInitialPort 1050
@pause

6启动客户端程序：

java HelloWorldClient -ORBInitialPort 1050
@pause

题目二：JAVA版CORBA程序——Counter

组件结构图：

在这里插入图片描述

具体设计：
1 编写IDL接口counter.idl：

module CounterApp{
interface Counter{
readonly attribute long value;
void inc();
void dec();
};
};

2编译IDL接口：X:\corba>idlj –fall counter.idl

在配置好jdk环境变量的情况下，将cmd 窗口文件目录切换到Hello.idl文件所在的路径，输入上述命令，执行后有java-jdk-bin文件目录下的ldlj.exe在命令目录下生成一个文件夹。在此程序中，文件夹名称为CountApp。文件夹下Java文件如下：
在这里插入图片描述

3编写并编译服务器端和客户端和对象实现文件Server.java， Client.java，CounterImpl.java 如图：

在这里插入图片描述

4启动名字服务器：

tnameserv -ORBInitialPort 1050
@pause

5启动服务器端程序：

java Server -ORBInitialPort 1050
@pause

6启动客户端程序：

java Client -ORBInitialPort 1050
@pause

三． 组件实现

1
HelloWorldClient.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import sample.*; 
import org.omg.CosNaming.*; 
import org.omg.CORBA.*; 
public class HelloWorldClient { 
public static void main(String args[]) { 
try{
ORB orb = ORB.init(args, null);
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService"); 
NamingContext ncRef = NamingContextHelper.narrow(objRef); 
NameComponent nc = new NameComponent("Hello",""); 
NameComponent path[] = {nc}; 
HelloWorld helloWorld = HelloWorldHelper.narrow(ncRef.resolve(path)); 
String hello = helloWorld.sayHello(); 
System.out.println(hello); 
} catch (Exception e) {
System.out.println("ERROR : " + e) ;
e.printStackTrace(System.out); 
}
}
}
HelloWorldServer.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import sample.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
import org.omg.CORBA.portable.*;
import org.omg.PortableServer.*;
class HelloWorldServant extends HelloWorldPOA{   //对象实现类
public String sayHello(){
return "\nHello World! 软件工程1703 焦宇珠\n";
}
}
public class HelloWorldServer{                  //服务程序
public static void main(String args[]){
try{
//初始化ORB
ORB orb = ORB.init(args, null);
//取根POA的引用
org.omg.CORBA.Object poaobj = orb.resolve_initial_references ("RootPOA");
org.omg.PortableServer.POA rootPOA = org.omg.PortableServer.POAHelper.narrow(poaobj);
org.omg.PortableServer.POAManager manager = rootPOA.the_POAManager();
//创建伺服对象 
HelloWorldServant objRef = new HelloWorldServant();
HelloWorld obj = objRef._this(orb);
//绑定命名服务 
NamingContext ncRef = NamingContextHelper.narrow(orb.resolve_initial_references("NameService"));
NameComponent nc = new NameComponent("Hello", ""); 
NameComponent path[] = {nc}; 
ncRef.rebind(path, obj);
//激活POA管理器 
manager.activate();
//等待处理客户程序的请求
System.out.println("HelloWorld is running!");
orb.run();
}catch (Exception e) { 
System.err.println("ERROR: " + e); 
e.printStackTrace(System.out); 
}
}
}

``
2
CounterImpl.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import CounterApp.*;
public class CounterImpl extends CounterPOA {
    private int count;   
    public CounterImpl(){   
        count = 0;   
    }   
    public void inc(){   
        count++;   
    }   
    public void dec(){   
        count --;   
    }   
    public int value(){   
        return count;   
    }   
}
Server.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import CounterApp.*;   
import java.io.*;   
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
import org.omg.CORBA.portable.*;
import org.omg.PortableServer.*;
public class Server {
public static void main(String[] args){
try{
ORB orb = ORB.init(args, null);
org.omg.CORBA.Object poaobj = orb.resolve_initial_references ("RootPOA");
org.omg.PortableServer.POA rootPOA = org.omg.PortableServer.POAHelper.narrow(poaobj);
org.omg.PortableServer.POAManager manager = rootPOA.the_POAManager();
CounterImpl c_impl = new CounterImpl();
Counter c = c_impl._this(orb);
NamingContext ncRef = NamingContextHelper.narrow(orb.resolve_initial_references("NameService"));
NameComponent nc = new NameComponent("Count", "");
NameComponent path[] = {nc}; 
ncRef.rebind(path, c);
FileOutputStream file = new FileOutputStream("Counter.ref");
PrintWriter writer = new PrintWriter(file);
String ref = orb.object_to_string(c);
writer.println(ref);
writer.flush();
file.close();
System.out.println("Server started."+" Stop:Ctrl-c");
rootPOA.the_POAManager().activate();
orb.run();
}catch(IOException ex){
System.out.println("File error:"+ex.getMessage());
System.exit(2);
}catch(Exception ex){
System.out.println("Exception: "+ex.getMessage());
System.exit(1);
}
}
}
Client.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import CounterApp.*;  
import java.util.*;   
import java.io.*;   
import org.omg.CORBA.*; 
import org.omg.CosNaming.*; 
public class Client {   
public static void main(String[] args){   
try{   
ORB orb = ORB.init(args, null);
org.omg.CORBA.Object obj = orb.resolve_initial_references("NameService"); 
NamingContext ncRef = NamingContextHelper.narrow(obj); 
NameComponent nc = new NameComponent("Count",""); 
NameComponent path[] = {nc};
String ref = null; 
try{   
Scanner reader = new Scanner(new File("Counter.ref"));   
ref = reader.nextLine();   
}catch(IOException ex){   
System.out.println("File error: "+ex.getMessage());   
System.exit(2);   
}   
obj = orb.string_to_object(ref);   
if(obj == null){   
System.out.println("Invalid IOR");   
System.exit(4);   
}   
Counter c = null;   
try{   
c = CounterHelper.narrow(obj);   
}catch(BAD_PARAM ex){   
System.out.println("Narrowing failed");   
System.exit(3);   
}   
int inp = -1;   
do{   
System.out.print("Counter value: "+c.value()+"\nAction(+/-/e)?");   
System.out.flush();   
do{   
try{   
inp = System.in.read();   
}catch(IOException ioe){}   
}while(inp != '+' && inp != '-' && inp != 'e');   
if(inp == '+')   
c.inc();   
else if(inp == '-')   
c.dec();   
}while(inp != 'e');   
}catch(Exception ex){   
System.out.println("Exception: "+ex.getMessage());   
System.exit(1);   
}   
}   
}

四． 测试调试及运行结果

①

启动服务器名字

在这里插入图片描述

启动服务器端

在这里插入图片描述

启动客户端

在这里插入图片描述

②

启动服务器端

在这里插入图片描述

启动客户端并进行测试

在这里插入图片描述

五． 经验归纳

通过此次程序设计了解掌握了组件化程序设计的方法，掌握了组件结构图的画法。
在配置jdk的过程中，从jdk1.8 的各种版本到jdk12都进行了装机尝试，jdk12虽是新版本，但其并不支持idlj 这种命令的编译执行。

java RGP 人物生成器

java 基础

一． 题目分析

1． 题目内容

1.功能描述
几乎所有的RPG游戏（一种源自《龙与地下城》的游戏类型）在进入游戏时都会让用户自己来创建自己喜欢的角色。本次上机要求编写一个简化的创建游戏角色的程序。

2.游戏角色应有的属性
本题目要求的游戏角色应有以下属性：名字、性别、种族、职业、力量、敏捷、体力、智力、智慧、生命值和魔法值。
名字：不超过50个字符。
性别：可以选择男性和女性。
种族：一共可选五个种族，人类、精灵、兽人、矮人和元素。
职业：可选六种职业，狂战士、圣骑士、刺客、猎手、祭司和巫师。
其余属性均为整数。
本题目要求首先用户输入角色姓名，然后由用户选择角色性别，然后由用户选择种族，然后选择职业，然后自动分配力量、敏捷、体力、智力和智慧属性，并计算生命值和魔法值。
生命值=体力20。
魔法值=（智力+智慧）10。
3.职业限制
很多职业会限制某些种族选择，例如兽人不能就职圣骑士等等，种族和职业的限制表如下：
种族/职业 狂战士 圣骑士 刺客 猎手 祭司 巫师
人类 允许 允许 允许 允许 允许 允许
精灵 不允许 不允许 允许 允许 允许 允许
兽人 允许 不允许 不允许 允许 允许 不允许
矮人 允许 允许 不允许 不允许 允许 不允许
元素 不允许 不允许 不允许 不允许 允许 允许
所以在要求用户选择职业时，输出信息里面只能有用户所选择种族可以就职的职业。
4.初始属性
本题目要求力量、敏捷、体力、智力和智慧要求是随机值（利用随机数函数来取得随机数），但是五项属性的总和应该是100，并且应该和职业相关。例如狂战士的体力和力量就要比较高，而巫师需要较高的智力，而祭司则需要较高的智慧。各职业初始属性的大致比例应遵从下表：
职业/属性 力量 敏捷 体力 智力 智慧
狂战士 40 20 30 5 5
圣骑士 25 15 30 20 10
刺客 20 35 20 15 10
猎手 15 40 15 10 20
祭司 15 20 15 35 15
巫师 10 20 10 20 40
例如，前面示意图中的祭司的初始属性，大致满足该比例，但是应该是随机的。
然后利用属性值计算生命值和魔法值。
5.显示信息
最后向用户显示该角色的所有信息，然后询问用户是否满意，如用户不满意则重新创建，若用户满意则程序结束，并将用户创建角色的相关信息写入文件保存。

2. 题目分析

  1. 掌握面向对象程序设计的方法。明确类与对象的概念，掌握面向对象设计七大原则；
  2. 掌握常见的设计模式以及类图的描述。
    通过面向对象的方法创建游戏人物，从而加深对面向对象编程的理解，掌握常用的设计方法及类图的 描述。

二． 类图设计

在这里插入图片描述

三． 程序实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
package 基础;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
//import java.io.Writer;
import java.util.Random;
import java.util.Scanner;

public class  RPGrole{
	private  static String rolename;//姓名
	private  static String sex;//性别
	private static String racial;//种族
	private static String career;//职业
	private static int strength,agility,physical,intellige,intelligence,life,magic;//力量,敏捷,体力,智力,智慧,生命值,魔法值

	public static void show() {
		System.out.println("角色姓名			"+rolename);
		System.out.println("角色性别			"+sex);
		System.out.println("种族			"+racial);
		System.out.println("职业			"+career);
		System.out.println("力量			"+strength);
		System.out.println("敏捷			"+agility);
		System.out.println("体力			"+physical);
		System.out.println("智力			"+intellige);
		System.out.println("智慧			"+intelligence);
		System.out.println("生命值			"+life);
		System.out.println("魔法值			"+magic);
	

	}

    Scanner sc = new Scanner(System.in);

	public static void getname() {
		System.out.println("请设置您的角色姓名");
			Scanner sc = new Scanner(System.in);
			 String rolename_def = sc.nextLine();
			 while(true) {
			 if(rolename_def.length()>50)
			 {System.out.println("您设置的角色名过长");
			 System.out.println("请设置您的角色姓名");
			 rolename_def = sc.nextLine();
			 }
			 else 
			 {rolename=rolename_def;
			 break;
			 }
			 }
	}
	public static void getsex()
	{
		System.out.println("请选择角色性别：1.男 2.女");
		   Scanner sc = new Scanner(System.in);
		int sex_def = sc.nextInt();
		switch(sex_def) {
		case 1:
		{
			sex = "男";
			break;
		}
		case 2:
		{
			sex = "女";
			break;
		}	
		}	
	}
	public  static void getracial()
	{
		int choose;
		System.out.println("请选择您游戏角色的种族：（0 人类 1 精灵 2 兽人 3 矮人 4 元素）");
		  Scanner sc = new Scanner(System.in);
		  choose  = sc.nextInt();
		  switch(choose) {
		  case 0:
			  racial="人类";break;  
		  case 1:
			  racial="精灵";break;
		  case 2:
			  racial="兽人";break;
		  case 3:
			  racial="矮人";break;
		  case 4:
			  racial="元素";break;
		 
	}
	}
	
	public static  void getcareer()
	{
	
		Scanner sc = new Scanner(System.in);
		
		int s;
		switch(racial)
		{
		case "人类":
			System.out.println("请选择您角色的职业:(1 狂战士 2 圣骑士 3  刺客 4 猎手 5 祭司 6 巫师)");
			s = sc.nextInt();
			switch(s) {
			case 1:
				career="狂战士";
				break;
			case 2:
				career="圣骑士";
				break;
			case 3:
				career="刺客";
				break;
			case 4:
				career="猎手";
				break;
			case 5:
				career="祭司";
				break;
			case 6:
				career="巫师";
				break;
			}
			break;
		case "精灵":
			System.out.println("请选择您角色的职业:( 1  刺客 2 猎手 3 祭司 4 巫师)");
			s = sc.nextInt();
			switch(s) {	
			case 1:
				career="刺客";break;
			case 2:
				career="猎手";break;
			case 3:
				career="祭司";break;
			case 4:
				career="巫师";break;
			}
			break;
		case "兽人":
			System.out.println("请选择您角色的职业:( 1  狂战士 2 猎手 3 祭司 )");
			s = sc.nextInt();
			switch(s) {
			case 1:
				career="狂战士";break;
			case 2:
				career="猎手";break;
			case 3:
				career="祭司";break;
			}
			break;
		case "矮人":
			System.out.println("请选择您角色的职业:( 1  狂战士 2 圣骑士 3 祭司 )");
			s = sc.nextInt();
			switch(s) {
			case 1:
				career="狂战士";break;
			case 2:
				career="圣骑士";break;
			case 3:
				career="祭司";break;
			}
		case "元素":
			System.out.println("请选择您角色的职业:( 1  祭司 2 巫师  )");
			s = sc.nextInt();
			switch(s) {
			case 1:
				career="祭司";break;
			case 2:
				career="巫师";break;
			}break;
			}
		
		}
	
	public  static void getProperty() {

        
        Random random = new Random();
         
        switch (career) {
            case "狂战士":
            	strength = random.nextInt(3) + 39;//力量
            	agility = strength/2;//敏捷
            	physical = strength-10;//体力
            	intelligence = strength/8;//智力
               
                break;
            case "圣骑士":
            	strength = random.nextInt(3) + 23;//力量
            	agility = strength-10;//敏捷
            	physical = agility*2;//体力
            	intelligence = agility+5;//智力
               
                break;
            case "刺客":
            	strength = random.nextInt(3) + 20;//力量
            	agility = strength*2-5;//敏捷
            	physical = strength;//体力
            	intelligence = physical-5;//智力
                
                break;
            case "猎手":
                strength = random.nextInt(3) + 13;//力量
                agility = strength*3-5;//敏捷
                physical = strength;//体力
                intelligence = physical-5;//智力
                
                break;
            case "祭司":
                strength = random.nextInt(3) + 13;//力量
                agility = strength+5;//敏捷
                physical = strength;//体力
                intelligence = physical+agility;//智力
               
                break;
            case "巫师":
            	strength = random.nextInt(3) + 8;//力量
            	agility = strength*2;//敏捷
            	physical = strength;//体力
            	intelligence = physical*2;//智力
               
                break;
        }
       intellige = 100-strength-agility-physical-intelligence;//智慧
       magic = (intelligence+intellige)*10;//魔法
       life = physical*20;//生命值
       
    }
	/*
	 * 菜单及用户反馈
	 */
	public static void feedback() throws FileNotFoundException, IOException, InterruptedException {
		Scanner sc = new Scanner(System.in);
		while (true)
		{
			getname();//姓名设置
			getsex();//性别
			getracial();//获得种族
			getcareer();//获得职业
			getProperty();//随机生成属性
			show();
			System.out.println("小主，对该角色您还满意吗   0 :满意 anykey: 也不行呀");
			System.out.println("如果您不满意将重新为您生成新角色 ，满意的话就直接保存文件了哦");
			String input = sc.nextLine();
            System.out.println(input);
			if(input.equals("0"))
			{
				File f = new File("RPG.txt");
				FileOutputStream fop = new FileOutputStream(f);
				OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");
				writer.append("                            召唤师角色创建详情 ");
				writer.append("\r\n");
				writer.append("	角色姓名		"+rolename);writer.append("\r\n");
				writer.append("  	角色性别		"+sex);writer.append("\r\n");
				writer.append(" 	种族			"+racial);writer.append("\r\n");
				writer.append("  	职业			"+career);writer.append("\r\n");
				writer.append(String.valueOf("  	力量			"+strength));writer.append("\r\n");
				writer.append(String.valueOf("  	敏捷			"+agility));writer.append("\r\n");
				writer.append(String.valueOf("  	体力			"+physical));writer.append("\r\n");
				writer.append(String.valueOf("  	智力			"+intellige));writer.append("\r\n");
				writer.append(String.valueOf("  	智慧			"+intelligence));writer.append("\r\n");
				writer.append(String.valueOf("  	生命值			"+life));writer.append("\r\n");
				writer.append(String.valueOf("  	魔法值			"+magic));writer.append("\r\n");
				writer.close();
				System.out.println("角色已创建，请在文件中查看");
				break;
			}
			else {
				System.out.println("角色重建  loading");
				Thread.sleep(5000);
				feedback();
				
			}
			}
		
	}
	public static void main(String[] args) throws FileNotFoundException, IOException, InterruptedException {
			System.out.println("欢迎来到地下城，亲爱的召唤师，请创建您的角色");
			System.out.println("==========================================");
			feedback();
		}
	}

四． 调试，测试及运行结果

调试断点单步跳入，跳过

在这里插入图片描述

角色重建

在这里插入图片描述

五． 个人心得

  1. 本次程序设计，深化了对面向对象编程的思想，了解掌握了UML （统一建模语言）类图和常用的设计模式，但是对七大法则运用及理解还是不够深入。
  2. 在编码时开始用this语句对全局变量赋值，所以getname(),getsex()等属性方法都是以动态方法来被调用，Java main()方法默认属性为static静态方法，这就导致了在主类创建对象调用函数是出现一系列问题，如 创建角色RPGrole 当正常调用函数时，需采用RPGrole.function()来实现，这是静态方法调用非静态方法时的方法，但是当函数有参调用上层函数的返回值时，就会出现问题，此时如果仍采用RPGrole.function(RPGrole.function()),虽然按照道理来说并没有什么问题，但是当实际操作起来就会发现这可能会导致函数的重复调用，所以，当函数非静态时，用函数调用函数用起来要慎重。
  3. 改进空间：将对象生成类与主类单独分开，更能体现OOP的思想，在主类中只完成对象的属性获取及参数设置，在对象类中对这些主类函数进行调用，生成想要角色。

java递归实现十进制数2的幂次表示

java 基础

1. 题目要求

任何一个正整数都可以用2的幂次方表示。例如：
　　　　137=2^7+2^3+2^0　　　　
同时约定幂次方用括号来表示，即ab 可表示为a（b）。
　　 由此可知，137可表示为：
　　　　 2（7）+2（3）+2（0）
进一步：7= 2^2+2+2^0 （21用2表示）
　　　　 3=2+2^0
所以最后137可表示为：
　　　　 2（2（2）+2+2（0））+2（2+2（0））+2（0）
　　 又如：
　　　　 1315=2^10 +2^8 +2^5 +2+2^0
所以1315最后可表示为：
　　 2（2（2+2（0））+2）+2（2（2+2（0）））+2（2（2）+2（0））+2+2（0）
　　输入：正整数（n≤20000）
输出：符合约定的n的0，2表示（在表示中不能有空格）
Input Format
一个正整数
Output Format
符合约定的n的0，2表示（在表示中不能有空格）
Sample Input
73
Sample Output
2(2(2)+2)+2(2+2(0))+2(0)

2.递归分析

递归出口：n=1或n=2，分别打印“2（0）”，“2”。之后结束递归。
在这里插入图片描述

3.代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
import java.util.Scanner;

public class nTobinarypow {
    public static void tpow(int n){

        if(n==1){
            System.out.print("2(0)");
            return;
        }
        if(n==2){
            System.out.print("2");
            return;
        }
        int temp=1;//2的幂次计算结果
        int c=0;//2的幂次
        while(temp<n){
            temp*=2;
            c++;
        }
        c-=1;
        if(n==temp/2){
            System.out.print("2(");
            tpow(c);
            System.out.print(")");
        }
        else 
        {
            if(temp/2==2){
                System.out.print("2");
                System.out.print("+");
                tpow(n-temp/2);

            }
            else {
                System.out.print("2(");
                tpow(c);
                System.out.print(")+");
                tpow(n-temp/2);
            }
        }

    }

    public static void main(String[] args) {
        System.out.println("请输入您想要转化的数值：（正整数哦）");
        Scanner sc= new Scanner(System.in);
        int input = sc.nextInt();
        System.out.println("转化结果为：");
        tpow(input);

    }
}

java实现十进制想任意进制转化

java 基础

一． 题目要求

题目：将非负十进制整数n转换成b进制。（其中b=2~16）

二． 算法设计思路及递归模型

递归出口：num=0 //此处num指递归后（num/base）=0,即商为0时递归结束。

在这里插入图片描述

三. 代码实现

递归实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package scale;

import java.util.Scanner;

public class recursion {
    public static String scale_Tobe(int base,int num){
        String str="";
        String wait="0123456789abcdef";
        if(num==0){
//            System.out.println(str);
            return " ";
        }
        else{
            str = scale_Tobe(base,num/base);
//           String temp= String.valueOf(wait.charAt(num%base));
//           System.out.println(str+temp);

            return str+wait.charAt(num%base);//缀加
        }

    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您想转化的十进制数：");
        int input_10= sc.nextInt();
        System.out.println("请输入您想转化的进制(2-16之间哦)");
        int input_base= sc.nextInt();
        System.out.println("转化为"+input_base+"进制结果为：");

        System.out.println(scale_Tobe(input_base,input_10));
    }

}

非递归实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package scale;

import java.util.Scanner;

public class nonerecursion {
    public static String conversion(int num ,int base) {//base 进制 num 欲转换数据
        String str = "";
        int remainder;//余数
        int consult = num;//商
        while (consult > 0) {
            remainder = num % base;
            consult = consult / base;

            //处理10-15之间a-f
            if (remainder > 9) {
                str = (char) ('a' + (remainder - 10)) + str;

            } else {
                str = remainder + str;
            }

        }
            return str;

    }




    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);
        System.out.println("请输入您要转化的十进制数");
        int input_num = sc.nextInt();
        System.out.println("请输入您想转化成进制");
        int input_base = sc.nextInt();
        System.out.println(conversion(input_num,input_base));


    }
}
}

四.运行截图

在这里插入图片描述

递归调用过程

（求3—>2进制=11）
在这里插入图片描述

java实现简单KFC

java 基础

一． 题目分析及要求

同学们应该都去麦当劳或肯德基吃过快餐吧？请同学们参考肯德基官网的信息模拟肯德基快餐店的收银系统，合理使用C++或Java或Python结合设计模式（2种以上）至少实现系统的以下功能：
1.正常餐品结算和找零。
2.基本套餐结算和找零。
3.使用优惠劵购买餐品结算和找零。
4.模拟打印小票的功能（写到文件中）。
基本要求：
1.实现功能测试代码，确保程序的健壮性。
2.画出使用的设计模式图。

二． 设计模式

单点食物
采用简单工厂模式，利用Java反射机制来实现食品类的实例化。
工厂类名 : ( SimFoodFactory )

套餐产品
采用抽象工厂模式，实现套餐系列产品的生成（三个）
工厂类名：（ComboOneFactory， ComboSecondFactory ，ComboThirdFactory ）

三． 类图设计

在这里插入图片描述

四． 算法实现

1.实体类 Food

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Food {
    public Integer id;
    public String name;
    public Double price;

    public Integer getId(){
        return id;

    }
    public String getName(){
        return name;
    }

    public Double getPrice(){
        return price;
    }

}

2.Drink 类，Eat 类 继承 Food基类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class Eat extends Food {
    public Float quality;

    public Float getQuality(){
        return quality;
    }
        @Override
                public String toString(){
            return "Eat{"+
                    "quality=" +quality+
                    ", id="+ id +
                    ", name='"+name +'\''+
                    ", price="+price+
        '}'  ;


}}
3.单种食物，单种饮料分别继承Eat 及 Drink
如：①食物单品
public class ChipsItem extends Eat {
    public ChipsItem() {
        this.id=1006;
        this.name="波纹霸王薯条";
        this.price=12.0;
        this.quality=50f;

    }
}

 ②饮料单品
public class BeerItem extends Drink {
    public BeerItem(){
        this.id = 1004;
        this.name = "百威啤酒";
        this.price= 15.0;
        this.capacity= 120f;
    }
}

4.简单工厂，通过反射机制加载食物类实例（单点）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import kfc.order.item.Food;

/**
 *
 * 简单工厂，反射加载食物类实例（单点食物）
 */

public class SimFoodFactory {
    public Food getFood(Class c){
        try{
            return (Food) Class.forName(c.getName()).newInstance();
        }catch (InstantiationException | IllegalAccessException| ClassNotFoundException e){
            e.printStackTrace();
        }
        return null;
    }


}

5.套餐组合通过CombFactory 接口的实现来加载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
mport kfc.order.item.Food;

import java.util.List;

/**
 * 抽象工厂，加载KFC组合套餐
 */
public interface CombFactory {
    List<Food> getCombo();
}



具体一号套餐
import kfc.order.item.BeerItem;
import kfc.order.item.ChickenItem;
import kfc.order.item.Food;

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

/**
 * 啤酒炸鸡 （1）号套餐
 */
public class ComboOneFactory implements CombFactory{
@Override
public List<Food> getCombo(){
        List<Food> foodOneList= new ArrayList<Food>();//存储套餐产品
        Food chick=new ChickenItem();//实例化套餐内的产品
        Food beer =new BeerItem();
        chick.price=chick.price-2;//套餐的优惠，炸鸡价格减2元
        beer.price=beer.price-1;//套餐的优惠，啤酒价格减1元
        foodOneList.add(chick);
        foodOneList.add(beer);
        return foodOneList;//返回套餐集合

        }
}

6.FoodControler 类 通过函数处理具体点餐事务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
import kfc.order.item.*;
import kfc.order.service.ComboOneFactory;
import kfc.order.service.ComboSecondFactory;
import kfc.order.service.ComboThirdFactory;
import kfc.order.service.SimFoodFactory;

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


public class FoodControler {
     static SimFoodFactory simFoodFactory = new SimFoodFactory();//简单工厂实例化
     static List<Food> foodList = new ArrayList<>();

    public  void service(){
        Scanner sc = new Scanner(System.in);

        String choose = sc.nextLine();
        switch (choose){
            case "7":
                foodList = new ComboOneFactory().getCombo();//抽象工厂产生套餐1
                break;
            case "8":
                foodList = new ComboSecondFactory().getCombo();//抽象工厂产生套餐2
                break;
            case "9":
                foodList = new ComboThirdFactory().getCombo();//抽象工厂产生套餐3
                break;
            case"1":
            //香辣炸鸡
               Food food_1= simFoodFactory.getFood(ChickenItem.class);//反射加载单品食物
                foodList.add(food_1);
                break;
            case"2":
                //香辣鸡腿堡
               Food food_2 = simFoodFactory.getFood(HamburgerItem.class);
                foodList.add(food_2);
                break;
            case"3":
                //薯条
               Food food_3 = simFoodFactory.getFood(ChipsItem.class);
                foodList.add(food_3);
                break;
            case"4":
                //美式
                Food food_4 = simFoodFactory.getFood(CafeItem.class);
                foodList.add(food_4);
                break;
            case"5":
                //可乐
               Food food_5 = simFoodFactory.getFood(CokeItem.class);
                foodList.add(food_5);
                break;
            case"6":
                //百威啤酒
               Food  food_6 = simFoodFactory.getFood(BeerItem.class);
                foodList.add(food_6);
                break;


          default:
              System.out.println("您所输入的点餐序号不存在");
              foodList = new ArrayList();
        }

}}

7.MainApp 类处理结算及顾客选择

1
其功能实现为其他类实例化对象当做方法参数使用

五． 测试截图

点餐界面截图

在这里插入图片描述

小票截图

在这里插入图片描述

六． 个人总结

Java Swing 可视化还未能掌握，因此此次程序设计只完成了基本要求。在程序编写中，对Java面向对象的思想有了更深的理解，也提升了编程中解决问题的能力。
在食物的实例化过程中，对建造者设计模式有了进一步的认识。同时对Java的反射机制有了一定的理解。

附 ： 源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package kfc.order.item;

public class Food {
    public Integer id;
    public String name;
    public Double price;

    public Integer getId(){
        return id;

    }
    public String getName(){
        return name;
    }

    public Double getPrice(){
        return price;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package kfc.order.item;

public class Eat extends Food {
    public Float quality;

    public Float getQuality(){
        return quality;
    }
        @Override
                public String toString(){
            return "Eat{"+
                    "quality=" +quality+
                    ", id="+ id +
                    ", name='"+name +'\''+
                    ", price="+price+
        '}'  ;


    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package kfc.order.item;

public class Drink  extends Food{
    public Float capacity;

    public Float getCapacity(){
        return capacity;

    }
    @Override
    public String toString(){
        return "Drink{"+
                "capacity=" +capacity+
                ", id="+ id +
                ", name='"+name +'\''+
                ", price="+price+
                '}';

    }
}
1
2
3
4
5
6
7
8
9
10
package kfc.order.item;

public class HamburgerItem  extends Eat {
    public HamburgerItem(){
        this.id = 1001;
        this.name = "香辣大虾堡";
        this.price = 22.0;
        this.quality = 10f;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
package kfc.order.item;

public class CokeItem extends Drink {
    public CokeItem(){
        this.id = 1003;
        this.name ="可口可乐";
        this.price = 11.0;
        this.capacity = 200f;

    }

}
1
2
3
4
5
6
7
8
9
10
11
package kfc.order.item;

public class ChipsItem extends Eat {
    public ChipsItem() {
        this.id=1006;
        this.name="波纹霸王薯条";
        this.price=12.0;
        this.quality=50f;

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
package kfc.order.item;

public class ChickenItem extends Eat{
    public ChickenItem(){
        this.id = 1002;
        this.name = "香辣鸡翅";
        this.price = 48.0;
        this.quality = 100f;

    }

}
1
2
3
4
5
6
7
8
9
10
package kfc.order.item;

public class CafeItem extends Drink {
     public CafeItem(){
         this.id = 1005;
         this.name ="美式咖啡";
         this.price = 17.0;
         this.capacity =100f;
     }
}
1
2
3
4
5
6
7
8
9
10
package kfc.order.item;

public class BeerItem extends Drink {
    public BeerItem(){
        this.id = 1004;
        this.name = "百威啤酒";
        this.price= 15.0;
        this.capacity= 120f;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
package kfc.order.service;

import kfc.order.item.Food;

import java.util.List;

/**
 * 抽象工厂，加载KFC组合套餐
 */
public interface CombFactory {
    List<Food> getCombo();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package kfc.order.service;

import kfc.order.item.BeerItem;
import kfc.order.item.ChickenItem;
import kfc.order.item.Food;

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

/**
 * 啤酒炸鸡 （1）号套餐
 */
public class ComboOneFactory implements CombFactory{
@Override
public List<Food> getCombo(){
        List<Food> foodOneList= new ArrayList<Food>();//存储套餐产品
        Food chick=new ChickenItem();//实例化套餐内的产品
        Food beer =new BeerItem();
        chick.price=chick.price-2;//套餐的优惠，炸鸡价格减2元
        beer.price=beer.price-1;//套餐的优惠，啤酒价格减1元
        foodOneList.add(chick);
        foodOneList.add(beer);
        return foodOneList;//返回套餐集合

        }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package kfc.order.service;

import kfc.order.item.CafeItem;
import kfc.order.item.Food;
import kfc.order.item.HamburgerItem;

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

/**
 * 咖啡和汉堡 （2）号套餐
 */

public class ComboSecondFactory implements CombFactory {
    public List<Food> getCombo(){
        List<Food> foodSecondList= new ArrayList<Food>();
        Food ham = new HamburgerItem();
        Food  cafe= new CafeItem();
        ham.price = ham.price-1;//套餐组合的优惠 汉堡减一元
        cafe.price = cafe.price-0.5;//套餐组合的优惠 咖啡减0.5元
        foodSecondList.add(cafe);
        foodSecondList.add(ham);
        return foodSecondList;

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package kfc.order.service;

import kfc.order.item.ChipsItem;
import kfc.order.item.CokeItem;
import kfc.order.item.Food;

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

/**
 * 可乐和薯条 （3）号套餐
 */
public class ComboThirdFactory implements CombFactory {
    @Override
    public List<Food> getCombo() {
        List<Food> foodThreeList = new ArrayList<Food>();
        Food chips = new ChipsItem();
        Food cola = new CokeItem();
        cola.price = cola.price - 1;//套餐组合的优惠
        chips.price = chips.price - 0.5;
        foodThreeList.add(chips);
        foodThreeList.add(cola);
        return foodThreeList;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package kfc.order.service;

import kfc.order.item.Food;

/**
 *
 * 简单工厂，反射加载食物类实例（单点食物）
 */

public class SimFoodFactory {
    public Food getFood(Class c){
        try{
            return (Food) Class.forName(c.getName()).newInstance();
        }catch (InstantiationException | IllegalAccessException| ClassNotFoundException e){
            e.printStackTrace();
        }
        return null;
    }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
package kfc.order.control;

import kfc.order.item.*;
import kfc.order.service.ComboOneFactory;
import kfc.order.service.ComboSecondFactory;
import kfc.order.service.ComboThirdFactory;
import kfc.order.service.SimFoodFactory;

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


public class FoodControler {
     static SimFoodFactory simFoodFactory = new SimFoodFactory();//简单工厂实例化
     static List<Food> foodList = new ArrayList<>();

    public  void service(){
        Scanner sc = new Scanner(System.in);

        String choose = sc.nextLine();
        switch (choose){
            case "7":
                foodList = new ComboOneFactory().getCombo();//抽象工厂产生套餐1
                break;
            case "8":
                foodList = new ComboSecondFactory().getCombo();//抽象工厂产生套餐2
                break;
            case "9":
                foodList = new ComboThirdFactory().getCombo();//抽象工厂产生套餐3
                break;
            case"1":
            //香辣炸鸡
               Food food_1= simFoodFactory.getFood(ChickenItem.class);
                foodList.add(food_1);
                break;
            case"2":
                //香辣鸡腿堡
               Food food_2 = simFoodFactory.getFood(HamburgerItem.class);
                foodList.add(food_2);
                break;
            case"3":
                //薯条
               Food food_3 = simFoodFactory.getFood(ChipsItem.class);
                foodList.add(food_3);
                break;
            case"4":
                //美式
                Food food_4 = simFoodFactory.getFood(CafeItem.class);
                foodList.add(food_4);
                break;
            case"5":
                //可乐
               Food food_5 = simFoodFactory.getFood(CokeItem.class);
                foodList.add(food_5);
                break;
            case"6":
                //百威啤酒
               Food  food_6 = simFoodFactory.getFood(BeerItem.class);
                foodList.add(food_6);
                break;


          default:
              System.out.println("您所输入的点餐序号不存在");
              foodList = new ArrayList();
        }



}}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
package kfc.order.control;

import kfc.order.item.Food;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Date;
import java.util.List;


public class  MoneyAnalyze {
    public   Double getMoneyCount(List<Food> list ){//,Double disCount,Double tickets){
        Double moneyCount = 0.0; //顾客应付钱数
        for (Food food:list){
            moneyCount += food.price;

        }//return moneyCount*disCount-tickets;  //计算折扣后应付钱数
        return moneyCount;
    }

    /**
     * 找零
     * @param inMoney 收入的钱数
     * @param  count 应收钱数
     */
    public  Double getChange( Double inMoney,Double count){
        return inMoney-count;
    }
    /**
     * 打印小票
     *
     */
    public  void receipt(List<Food>list ,Double disCount,Double tickets) throws IOException{

          Date currentTime = new Date();

          FileWriter fileWriter= new FileWriter("receipt.txt");
          BufferedWriter bw = new BufferedWriter(fileWriter);
          bw.write("————————————————————欢迎光临  **有点LOW**  KFC————————————————"+"\r\n");
          bw.write("\n\n");
          bw.write("订单时间："+currentTime+"\r\n\n");
          bw.write("您本次消费清单如下"+"\r\n");
          for (Food food:list){
              bw.write("ID："+food.id+"\r\n");
              bw.write("食物："+food.name+"\r\n");
              bw.write("金额："+food.price+"\r\n");
          }
          bw.write("折扣"+disCount*10 +"折"+"\r\n");
          bw.write("优惠"+tickets+"元"+"\r\n");
          bw.write("总金额"+((getMoneyCount(list)*disCount)-tickets)+ "\u5143");
          bw.flush();
          bw.close();

    }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
package kfc.order.control;

import java.io.IOException;
import java.util.Scanner;

public class MainApp {
    public static  Double tickets=0.0 ;
    public static Double disCount=1.0;
    MoneyAnalyze moneyAnalyze = new MoneyAnalyze();
    static FoodControler foodControler = new FoodControler();


    public void interFace()throws IOException{
        System.out.println("============================================================");
        System.out.println("************************************************************\n");
        System.out.println("--------------------欢迎光临KFC------------------------------");
        System.out.println("**************     1.点餐                                    \n");
        System.out.println("**************     2.领取优惠卷 (请在购买商品之后查看领取哦)   \n");
        System.out.println("**************     3.结算                                    \n");
        System.out.println("*************************************************************\n");
        System.out.println("=============================================================");
        System.out.println("请选择服务类型：");
        chooseServe();
    }
    public void chooseServe() throws IOException {
        Scanner sc = new Scanner(System.in);
        String inter =sc.nextLine();
        while (true){
        if(inter.equals("1")){
            orderMeal();

            break;
        }
        else if(inter.equals("2")){
            System.out.println("满50减3.6元");
            System.out.println("满80减5.0元");
            System.out.println("请选择服务类型：");
            chooseServe();
            break;
        }
        else if(inter.equals("3")){
            if(foodControler.foodList!=null){
            settlement();
            break;}
            else {
                System.out.println("您当前还未点餐，结算系统锁定，请点餐后选择");
                chooseServe();
            }
        }else {
            System.out.println("服务类型不存在，我们正在完善中,请您重新选择 ");
            chooseServe();
            break;
        }}
    }
    public void orderMeal() throws IOException {
        System.out.println("\n");
        System.out.println("----------------  本店推出以下菜品：--------------------------");
        System.out.println("①  自选单品");
        System.out.println("1. 香辣鸡翅：48元/份             2. 香辣大虾堡：22元/个");
        System.out.println("3. 波纹霸王薯条： 12元/份        4. 美式咖啡：17元/杯  ");
        System.out.println("5. 可口可乐：11元/杯             6. 百威啤酒：15元/杯    " );
        System.out.println("②  人气套餐——有优惠哦");
        System.out.println("7. 套餐一：啤酒+炸鸡：60元/份");
        System.out.println("8. 套餐二：汉堡+咖啡：37.5元/份");
        System.out.println("9. 套餐三：可乐+薯条：21.5元/份");
        System.out.println("--------------------------------------------------------------");
        System.out.println("请选择餐品序号");

//调用FoodControler 函数Server（）
// FoodControler foodControler =new FoodControler();
        while(true){

            foodControler.service();

            System.out.println("您所点的商品如下 ：");
            System.out.println(foodControler.foodList);
            System.out.println("您当前订单金额为："+moneyAnalyze.getMoneyCount(foodControler.foodList)+"元");
//            System.out.println(foodControler.foodList.isEmpty());//测试列表空否
            chooseQuit();
            break;


        }

    }
    public void chooseQuit() throws IOException {//点餐界面离开选项
        System.out.println("继续:【Y】  结算:【S】  返回【A】");
        System.out.println("请输入服务类型：");
        Scanner sc = new Scanner(System.in);
        String item =sc.nextLine();
        while (true) {
            if (item.equals("A") || item.equals("a")) {
                interFace();
                break;
            } else if (item.equals("Y") || item.equals("y")) {

                System.out.println(foodControler.foodList);
//                System.out.println("您当前订单金额为："+moneyAnalyze.getMoneyCount(foodControler.foodList));

                orderMeal();
                break;
            } else if (item.equals("S") || item.equals("s")) {
                settlement();
                break;


            } else {
                System.out.println("您所选择的服务不存在，请重新输入：");
                chooseQuit();
                break;
            }
        }
    }
    public void getTickets(){

        if(moneyAnalyze.getMoneyCount(foodControler.foodList)<50){
            System.out.println("您的订单无法领取优惠券");
        }
        if(moneyAnalyze.getMoneyCount(foodControler.foodList)>50&&moneyAnalyze.getMoneyCount(foodControler.foodList)<80){
            tickets=3.6;
            System.out.println("您的订单可以领取3.6元优惠券");
        }else if(moneyAnalyze.getMoneyCount(foodControler.foodList)>80){
            tickets=5.0;
            System.out.println("您的订单可以领取5元优惠券");
        }

    }

    /**
     * 通过消费判定折扣
     */
    public void settlement() throws IOException {

        System.out.println("您的付款金额：");
        Scanner sc = new Scanner(System.in);
        Double inMoney = sc.nextDouble();

        if(moneyAnalyze.getMoneyCount(foodControler.foodList)>50){
            //tickets= 3.6;
            disCount=0.86;
        }else if(moneyAnalyze.getMoneyCount(foodControler.foodList)>80){
            //tickets=5;
            disCount=0.75;
        }

        System.out.println("您本次消费如下：");
        getTickets();
        System.out.println("您本次消费："+moneyAnalyze.getMoneyCount(foodControler.foodList));

        System.out.println("优惠："+tickets+" 元");
        System.out.println("折扣："+disCount*10+" 折");
        System.out.println("折后消费:"+(moneyAnalyze.getMoneyCount(foodControler.foodList)*disCount));
        System.out.println("收您："+inMoney+" 元");

        System.out.println("找零："+(moneyAnalyze.getChange(inMoney,moneyAnalyze.getMoneyCount(foodControler.foodList)*disCount-tickets))+" 元");

        moneyAnalyze.receipt(foodControler.foodList,disCount,tickets);//调用函数打印小票

    }



}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package kfc.order.control;
import java.io.IOException;



public class StartKFC  {

    public static void main(String[] args) throws IOException {
        MainApp mainApp = new MainApp();

        mainApp.interFace();




    }
}
//工厂模式算法源自CSDN 博客

java实现24点

java 基础

一．题目分析

从扑克中每次取出4张牌。使用加减乘除，第一个能得出24者为赢。（其中，J代表11，Q代表12，K代表13，A代表1），按照要求编程解决24点游戏。

1.基本要求：

随机生成4个代表扑克牌牌面的数字字母，程序自动列出所有可能算出24的表达式，用擅长的语言（C/C++/Java或其他均可）实现程序解决问题。
1.程序风格良好(使用自定义注释模板)
2.列出表达式无重复。

2. 提高要求：

用户初始生命值为一给定值（比如3），初始分数为0。随机生成4个代表扑克牌牌面的数字或字母，由用户输入包含这4个数字或字母的运算表达式（可包含括号），如果表达式计算结果为24则代表用户赢了此局。
1. 程序风格良好(使用自定义注释模板)
2.使用计时器要求用户在规定时间内输入表达式，如果规定时间内运算正确则加分，超时或运算错误则进入下一题并减少生命值（不扣分）。
3.所有成绩均可记录在TopList.txt文件中。

二. 关键算法构造

  1. 基本要求
    一般24点均采用降维的方法来实现，所谓降维就是将原本四个数的计算通过递归的方式变成两两计算，即将前两个数的运算结果当做下一步计算的数据，以达到求表达式结果的目的。而表达式的去重则涉及到Java 中集合的应用即通过HashSet踢除重复元素。生成（calculateSet）来存放所有表达式，使用calculateSet.add(filterCalculate(t.getCul_str()))来实现集合元素的去重。
    此代码即集合去重的基本思想

  2. 提高要求
    为实现表达式24点的判断，采用双栈操作将操作符及运算数据分别入栈，无视左括号，当遇到右括号时，根据表达式从操作符栈中取出操作符，并从操作数栈中取出相应的操作数进行计算，并将计算结果压入操作数栈。在压栈操作完成后，取出栈顶元素，即表达式的运算结果。
    如(1 + ( ( 2 + 3 ) * ( 4 * 5 ) ) )的双栈算法演示
    在这里插入图片描述
    为了实现在输入的同时倒计时的目的，程序必须采用多线程，上周刚接触到 Java多线程，想到自己写一个线程可能会出现问题，于是想有没有现成的Java类来实现倒计时功能，而Java中Timer 和 Timertask 就可以实现这样的功能。

    三. 程序实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
import java.util.Date;//统计用时
import java.util.Random;

import java.util.ArrayList;
import java.util.Arrays;

import java.util.HashSet;
 
import java.util.List;
import java.util.Set;
 
public class pointGame {
    static List<Node> result = new ArrayList<Node>();    //实例化集合对象，用来存放结果
    static Set<String> calculateSet = new HashSet<String>();//表达式放入集合并去重
    public static void main(String[] args) {
        Date now = new Date();
        int[] values = new int[4];//存放随机数
        Random random = new Random();
        for(int i=0;i<4;i++)//生成随机数
        {
        	int x=random.nextInt(13)+1;
        	values[i]=x;
        }
        System.out.println(Arrays.toString(values)); //打印随机数组
        traverse(values); 
        System.out.println("共耗时: "+(System.currentTimeMillis()-now.getTime())+" 毫秒");//当前时间减去程序开始运行时间
    }
    
    public static void traverse(int[] a){
        if(a.length!=4){
            System.out.println("不得多于或少于4个数");
            return;
        }
        Double[] dArrays = new Double[4];
        dArrays[0] = a[0]+0D;
        dArrays[1] = a[1]+0D;
        dArrays[2] = a[2]+0D;
        dArrays[3] = a[3]+0D;
        List<Node> headerList = null;//初始化集合
        for(int i=0;i<4;i++){
            for(int j=0;j<4;j++){
                if(j==i){
                    continue;
                }
                for(int k=0;k<4;k++){
                    if(k==i || k==j){
                        continue;
                    }
                    headerList = createHeaderList(dArrays[i],dArrays[j]);
                    List<Node> chooseThreeNum = null;
                    for(Node t:headerList){
                        chooseThreeNum = chooseThreeOrFourNum(t, dArrays[k]);
                        List<Node> chooseFourNum = null;
                        for(Node temp:chooseThreeNum ){
                            chooseFourNum = chooseThreeOrFourNum(temp,dArrays[6-(i+j+k)]);
                            pickNode(chooseFourNum);
                        }
                    }
                }
            }
        }
        getAllCalculate();
        if(calculateSet.size()>0){
            display();
        }      
    }
    
    private static void display(){
        System.out.println("共有解:"+calculateSet.size()+"个,具体如下:");
        for(String s:calculateSet){
            System.out.println(s+" = 24");
        }
    }
    
    private static void getAllCalculate(){
        if(result.size()<1){
            System.out.println("抱歉，没有解");
        }
        Node second = null;
        Node first = null;
        for(Node t:result){
            second = t.getPre_node();
            first = second.getPre_node();
            if(second.get_a().doubleValue()==first.getValue().doubleValue()){
                second.setA_cul_str(first.getCul_str());              
            }else{
                second.setB_cul_str(first.getCul_str());    
            }
            second.doCalculate();
            
            if(t.get_a().doubleValue()==second.getValue().doubleValue()){
                t.setA_cul_str(second.getCul_str());              
            }else{
                t.setB_cul_str(second.getCul_str());    
            }
            t.doCalculate();
            calculateSet.add(filterCalculate(t.getCul_str()));
            
        }
    }
    
    private static String filterCalculate(String str){
        str = str.substring(1, str.length()-1);
        str = str.replace(".0", "");
        str = str.replace("*", "×");
        str = str.replace("/", "÷");
        return str;
    }
    
    private static void pickNode(List<Node> list){
        for(Node t : list){
            if(judge24(t.getValue())){
                result.add(t);//result 集合添加符合24点的表达式
            }
        }
    }
    
    private static boolean judge24(Double d){//判断表达式结果
        if(Math.abs(d.doubleValue()-24)<=0.000001){
            return true;
        }
        return false;
        
    }
    private static List<Node> chooseThreeOrFourNum(Node t,Double b){
        List<Node> result = new ArrayList<Node>();
        Double a = t.getValue();
        Node n1 = new Node(a,b,'+');
        Node n2 = new Node(a,b,'-');
        Node n3 = new Node(a,b,'-',true);//a-b 或 a*b 结果与顺序相关
        Node n4 = new Node(a,b,'*');
        Node n5 = new Node(a,b,'/');
        Node n6 = new Node(a,b,'/',true);
        n1.doCalculate();
        n2.doCalculate();
        n3.doCalculate();
        n4.doCalculate();
        n5.doCalculate();
        n6.doCalculate();
        insertNode(n1,result);
        insertNode(n2,result);
        insertNode(n3,result);
        insertNode(n4,result);
        insertNode(n5,result);
        insertNode(n6,result);
        n1.setPre_node(t);
        n2.setPre_node(t);
        n3.setPre_node(t);
        n4.setPre_node(t);
        n5.setPre_node(t);
        n6.setPre_node(t);    
        return result;
    }
    
    private static List<Node> createHeaderList(Double a,Double b){
        List<Node> result = new ArrayList<Node>();
        Node n1 = new Node(a,b,'+');
        Node n2 = new Node(a,b,'-');
        Node n3 = new Node(a,b,'-',true);
        Node n4 = new Node(a,b,'*');
        Node n5 = new Node(a,b,'/');
        Node n6 = new Node(a,b,'/',true);
        n1.doCalculate();
        n2.doCalculate();
        n3.doCalculate();
        n4.doCalculate();
        n5.doCalculate();
        n6.doCalculate();
        insertNode(n1,result);
        insertNode(n2,result);
        insertNode(n3,result);
        insertNode(n4,result);
        insertNode(n5,result);
        insertNode(n6,result);
        return result;
    }
    
    
    private static void insertNode(Node p,List<Node> list){
        if(p.getValue()!=null){
            list.add(p);
        }
    }
    
}
 
class Node {
    Double _a;
    Double _b;
    char opr;
    Double value;
    boolean is_rev_order;
    String a_cul_str;//_a的算式
    String b_cul_str;//_b的算式
    String cul_str;//自身的算式
    /**
     * 实例化Node 对象
     */
    Node pre_node;
    Node next_branch1;
    Node next_branch2;
    Node next_branch3;
    Node next_branch4;
    Node next_branch5;
    Node next_branch6;
 
    public Node(Double a, Double b, char opr) {
        this._a = a;
        this._b = b;
        this.opr = opr;
        this.a_cul_str = Double.toString(_a);
        this.b_cul_str = Double.toString(_b);
    }
 
    public Node(Double a, Double b, char opr, boolean is_rev_order) {
        this._a = a;
        this._b = b;
        this.opr = opr;
        this.is_rev_order = is_rev_order;
        this.a_cul_str = Double.toString(_a);
        this.b_cul_str = Double.toString(_b);
    }
 
    public Double getValue(){//获得随机数
        return value;
    }
    
    
    /**
         *计算数学表达式
         *对操作符进行数据间插入
         *递归实现将两个数的运算继续参与运算   
         * */
    public void doCalculate(){
        switch(opr){
        case '+':
            cul_str = "("+a_cul_str+"+"+b_cul_str+")";
            value = _a+_b;
            break;
        case '-':
            if(is_rev_order){//是生成数据顺序
                cul_str = "("+b_cul_str+"-"+a_cul_str+")";
                value = _b-_a;
            }else{
                cul_str = "("+a_cul_str+"-"+b_cul_str+")";
                value = _a-_b;
            }
            break;
        case '*':
            cul_str = "("+a_cul_str+"*"+b_cul_str+")";
            value = _a*_b;
            break;
        case '/':
            if(is_rev_order){
                if(_a!=0){
                    cul_str = "("+b_cul_str+"/"+a_cul_str+")";
                    value = _b/_a;
                }
               
            }else{
                if(_b!=0){
                    cul_str = "("+a_cul_str+"/"+b_cul_str+")";
                    value = _a/_b;
                }
            }
            break;
        }
    }
    
    public Double get_a() {
        return _a;
    }
 
    public void set_a(Double _a) {
        this._a = _a;
    }
 
    public Double get_b() {
        return _b;
    }
 
    public void set_b(Double _b) {
        this._b = _b;
    }
 
    public String getA_cul_str() {
        return a_cul_str;
    }
 
    public void setA_cul_str(String a_cul_str) {
        this.a_cul_str = a_cul_str;
    }
 
    public String getB_cul_str() {
        return b_cul_str;
    }
 
    public void setB_cul_str(String b_cul_str) {
        this.b_cul_str = b_cul_str;
    }
 
    public String getCul_str() {//获得计算后的值
        return cul_str;
    }
 
    public void setCul_str(String cul_str) {
        this.cul_str = cul_str;
    }
 
    public Node getPre_node() {
        return pre_node;
    }
 
    public void setPre_node(Node pre_node) {
        this.pre_node = pre_node;
    }
 
    public Node getNext_branch1() {
        return next_branch1;
    }
 
    public void setNext_branch1(Node next_branch1) {
        this.next_branch1 = next_branch1;
    }
 
    public Node getNext_branch2() {
        return next_branch2;
    }
 
    public void setNext_branch2(Node next_branch2) {
        this.next_branch2 = next_branch2;
    }
 
    public Node getNext_branch3() {
        return next_branch3;
    }
 
    public void setNext_branch3(Node next_branch3) {
        this.next_branch3 = next_branch3;
    }
 
    public Node getNext_branch4() {
        return next_branch4;
    }
 
    public void setNext_branch4(Node next_branch4) {
        this.next_branch4 = next_branch4;
    }
 
    public Node getNext_branch5() {
        return next_branch5;
    }
 
    public void setNext_branch5(Node next_branch5) {
        this.next_branch5 = next_branch5;
    }
 
    public Node getNext_branch6() {
        return next_branch6;
    }
 
    public void setNext_branch6(Node next_branch6) {
        this.next_branch6 = next_branch6;
    }
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Date;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Random;
import java.util.Scanner;
import java.util.Stack;
import java.util.Timer;
import java.util.TimerTask;

public class User_point {
	static boolean flag = true;//该变量标识是否超时
	static int life = 3;//初始化生命值
	static int score=0;//初始化分数
	
	    public static void main(String[] args)  throws IOException{
	    	start();//start 函数作函数入口
	    }

	    public static Double calculate (String str) {

	        //创建操作符栈
	        Stack<Character> ops = new Stack<>();
	        //创建操作数栈
	        Stack<Double> nums = new Stack<>();
	        for (int i = 0 ; i < str.length(); i++) {
	            char s = str.charAt(i);
	            switch (s) {
	                //无视左括号
	                case '(':
	                    break;
	                // +.-.*./ 这些操作符都压入栈
	                case '+':
	                    ops.push(s);
	                    break;
	                case '-':
	                    ops.push(s);
	                    break;
	                case '*':
	                    ops.push(s);
	                    break;
	                case '/':
	                    ops.push(s);
	                    break;
	                case ')':
	                    //遇到右括号时，根据从操作符栈中取出操作符，并从操作数栈中取出相应都操作数进行计算，并将计算结果压入操作数栈
	                    char op = ops.pop();
	                    Double num = nums.pop();
	                    switch (op) {
	                        case '+':
	                            num = num + nums.pop();
	                            break;
	                        case '-':
	                            num = num - nums.pop();
	                            break;
	                        case '*':
	                            num = num * nums.pop();
	                            break;
	                        case '/':
	                            num = num / nums.pop();
	                            break;
	                    }
	                    nums.push(num);
	                    break;
	                default:
	                    nums.push(Double.parseDouble(Character.toString(s)));
	                    break;
	            }
	        }
	        return nums.pop();//栈顶元素
	    }
	    
    
	
	
	public  static int[] set_num()
	{   
		int number[] = new int[4];
		Random random = new Random();
		
		for(int i=0;i<4;i++)
		{int x=random.nextInt(13)+1;
    	number[i]=x;
    	}
		
		return number;
	}
	//考虑异常处理
	public  static void start() throws IOException {
		Calendar date = Calendar.getInstance();//实例化Calendar对象，工厂方法
		while(life>0) {//当生命值大于0才会进行
			flag=true;//初始化分数标记
			/**
			 * 在60秒内输入表达式，超时将 flag 的值 变为 false ，在answer 中分支进入‘2’, 
			 */
			date.setTime(new Date()); // 重置 Calendar 显示当前时间

			date.add(Calendar.SECOND,60);//设置限定时间
			
			Timer timer = new Timer();
			//当达到限定时间将会执行run()方法,即把全局变量flag变为false
			timer.schedule(new RemindTask(), date.getTime());
			int answer = answer();
			switch(answer) {
			case -1:
				System.out.println("表达式错误！！    当前生命值为"+life+" 分数为："+score);
				break;
			case -2:
				System.out.println("输入超时！！    当前生命值为"+life+" 分数为："+score);
				break;
			case -3:
				System.out.println("结果错误！！    当前生命值为"+life+" 分数为："+score);
				break;
			case 1:	
				System.out.println("正确,得到1分奖励！！    当前生命值为"+life+" 分数为："+score);
				break;
			}
			System.out.println("-------------------------------------------------------------");
		}
		System.out.println("游戏结束……分数为: "+score);//循环结束也就是生命值为0,打印游戏结束
		saveScore(score);//将玩家当前分数存入文件
		return;
	} 
	/**
	 * 文件操作,将玩家最后得分存入e:/TopList.txt
	 */
	public static void saveScore(int score) throws IOException {
		FileOutputStream fos = new FileOutputStream("e:/TopList.txt");
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		bos.write((score+"").getBytes());//把分数写入文件
		bos.close();
		
	}
	/**
	 * 表达式正确性及时间处理函数
	 */
	public static int answer() {
		int[] number = set_num();
		System.out.println("                           "+Arrays.toString(number)+"                       "); //打印随机数组	
		System.out.println("------------------------------开始作答-----------------------------------");
		System.out.println("-------请在一分钟内输入您的24点表达式并将其括号化，（否则凉凉了呀）---------");
		Scanner sc= new Scanner(System.in);
	    String s = sc.nextLine();
	   
		
		try {
			for (int i = 0; i < number.length; i++)
				if (!s.contains(number[i] + "")) {//输入的表达式不含给定的值
					life--;
					return -1;
				}
			if(!flag) {//判断超时
				life--;
				return -2;
			}
			if (calculate(s)==24.0){//玩家表达式调用双栈运算
				score++;//分数加一
				return 1;
			}
			else life--;
			
		} catch (Exception e) {
			
			System.out.println("表达式输入不合法");
		}
		
		return -3;

	}

	
	}
class RemindTask extends TimerTask {  //TimerTask 类多线程计算从开始输入表达式倒计时

	@Override
	public void run() {//重写父类run方法
		User_point.flag = false;//当超时会把全局变量flag变为false
	}

}

四. 测试截图

基础要求

在这里插入图片描述

提高要求

在这里插入图片描述

五．个人总结

刚拿到题目时无从下手，由于对递归掌握的不是很好，所以也就没能想到利用降维的方法来解决问题，在网上看了很多很多算法后，才对这种递归降维的方法有了一定的认识，解决了问题。因为之前学习Java过程中关于集合的部分还未涉及，表达式去重也就变得相对困难，看了Java的集合部分后，才找到解决问题的办法——hashset。在提高要求的完成部分，解决表达式求值成了关键问题，这让我意识到学好数据结构的重要性，虽然有些算法的使用频率相对较低，但当使用的时候确实可以发挥奇效。还有一个问题是双栈算法尽管可以求值但需要将用户输入的表达式完全括号化，否则就会出现结果偏差，相较于这种算法，中缀表达式转后缀表达式的算法就更人性化一些，这也是本次程序设计还需完善的地方。

java三种设计模式实例实现

java 基础

一． 题目分析

1) 熟悉建模工具。
2) 掌握简单工厂模式、工厂方法模式、抽象工厂模式，并进行设计应用。

①．简单工厂模式

使用简单工厂模式模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，请实现该场景。现需要增加一个新的Robot类，如果传入参数 R，则返回一个Robot对象，对代码进行修改并注意女娲的变化。
※分析：简单工厂模式属于类创建型模式，在简单工厂模式中，可以根据参数的不同返回不同类的实例。被创建的实例通常都具有共同的父类，也可用接口实现。

② . 工厂方法模式

海尔工厂(Haier)生产海尔空调(HaierAirCondition)，美的工厂(Midea)生产美的空调(MideaAirCondition) 。使用工厂方法模式描述该场景，绘制类图并编程实现。
※分析：工厂方法模式也叫多态工厂模式，属于类创建型模式。在工厂方法模式中，空调父类工厂负责定义创建产品对象的公共接口，而工厂子类（如HaierAirConditionFactory）则负责生成具体的产品对象（HaierAirCondition），这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。
即使有新产品添加进来，也只需要新建具体的新建产品工厂，不会违反ocp原则。
※分析：

③．抽象工厂模式

电脑配件生产工厂生产内存、CPU等硬件设备，这些内存、CPU的品牌、型号并不一定相同，根据下面的“产品等级结构-产品族”示意图，使用抽象工厂模式实现电脑配件生产过程并绘制相应的类图，绘制类图并编程实现。
※分析：抽象工厂模式属于对象创建型模式。它提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。此模式适用于产品族（且产品的个数较少）的生产。如添加新建产品子项，就需要在接口中添加新产品实例，违反开闭原则

二． 类图设计

1. 简单工厂模式

在这里插入图片描述

2. 工厂模式在这里插入图片描述
3.抽象工厂模式

在这里插入图片描述

三． 程序实现

①．man类,women类,robot类 分别实现People接口，重写接口play（）方法，实现子类对象的特性。而产生三种人的任务均由PeopleFactory（）类承担，其中带参函数producePeople(S)
通过用户键盘输入传入s,根据不同传入参数生成不同人种。
②．HaierAirCondition（），MideaAirCondition（）分别实现接口AirCondition（），并重写其活动方法。HaierAirConditionFactory（），MideaAirConditionFactory（）分别实现AirConditionFactory（）接口。在各自的工厂内重写接口方法，实现产品的制造，返回实例化对象。通过改写xml文件中类名来生产不同的空调。XML配置采用Java 反射机制来完成。
③．interface<CPU ,RAM>分别是PC_CPU,Mac_CPU 的父类，子类通过重写discriber() 方法来对产品进行描述。Interface< ComputerPartsFactory>是MacFactory，和PCFactory 的父类，子类重写接口方法返回相应的子类对象，达到生产产品族的目的。

四． 调试测试截图

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

五． 经验总结

通过具体的代码了解掌握了三种设计模式的思想及实现方法，并在编程中学到了参数传递的新方法XML。
XML文件通过修改自身关于类名映射来实现不同对象的改变。
两种设计模式总结如下
工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

附：
具体代码 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
package AirConditionMade;

public interface airCondition {
	public void display();
	
package AirConditionMade;

public interface airConditionFcatory {
	public airCondition produce();

}}
package AirConditionMade;
import AirConditionMade.XMLUtil;
import AirConditionMade.airConditionFcatory;
import AirConditionMade.airCondition;

public class Client {
	public static void main(String[] args)
	  {
		try {
			airCondition AC;
			airConditionFcatory factory;
			factory=(airConditionFcatory)XMLUtil.getBean();
			AC=factory.produce();
			AC.display();
			
		}
		catch(Exception e)
		{
			System.out.println(e.getMessage());
		}

	}

}
package AirConditionMade;

public class HaierAirCondition implements airCondition{
	public void display() {
		System.out.println("HaierAirCondition hava made!");
		System.out.println("海尔空调下线销售中");
		
	}

}
package AirConditionMade;

public class HaierAirConditionFacctory implements airConditionFcatory{
     public airCondition produce() {
    	 System.out.println("海尔集团生产海尔空调");
    	 return  new HaierAirCondition();
     }
}
package AirConditionMade;

public class MideaAirCondition implements airCondition {
    public void display() {
    	System.out.println("MideaAirCondition have made!");
    	System.out.println("美的空调下线销售中");
    }
}
package AirConditionMade;

public class MideaAirConditionFactory implements airConditionFcatory{
public airCondition produce() {
	 System.out.println("美的集团生产美的空调");
	 return  new MideaAirCondition();
}

}
package AirConditionMade;
import org.w3c.dom.*;
import org.xml.sax.SAXException;
import java.io.*;
import javax.xml.parsers.*;


public class XMLUtil {
	public static Object getBean() {
	try {
		/**
		 * 
		 * 创建文档对象
		 */
	
	
		DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
		DocumentBuilder builder = dFactory.newDocumentBuilder();
		Document doc;
		doc = builder.parse(new File("XMLUtil.xml"));
		//获取包含类名的文本节点
		NodeList nl =doc.getElementsByTagName("className");
		Node classNode = nl.item(0).getFirstChild();
		String className = classNode.getNodeValue();
		
		//通过类名生成实例化对象将其返回
		Class<?> c = Class.forName(className);
		Object  obj = c.newInstance();
		return obj;
	}
	catch(Exception e)
	{
		e.printStackTrace();
		return null;
	}

}
}

具体代码 2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
package NvWamade;
import NvWamade.PeopleFactory;

import java.util.Scanner;

import NvWamade.People;
//import NvWamade.XMLUtilPeople;

public class Client {
	public static void main(String[] args) {
		try

        {
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入想造的人种");
			String input = sc.nextLine();
			System.out.println("女娲娘娘造人中，请稍后···");
			Thread.sleep(3000);
			
			
			
			
			
			

         People pe;

       //  String createName=XMLUtilPeople.getCreateName();
         

         pe=PeopleFactory.producePeople(input);

         pe.play();
         sc.close();

        }

        catch(Exception e)

        {

         System.out.println(e.getMessage());

        }
	}
	

}
package NvWamade;

public class Man implements People{
public void play(){
		System.out.println("男人");
}
}
package NvWamade;

public interface People {
	public void play();

}

package NvWamade;
import NvWamade.People;
import NvWamade.Man;
import NvWamade.Women;
import NvWamade.Robot;

public class PeopleFactory {
	public static People producePeople(String creat) throws Exception{
		if(creat.equalsIgnoreCase("M")) {
			System.out.println("Have made MAN");
			return  new Man();
		}
		else if(creat.equalsIgnoreCase("W")) {
			System.out.println("Have made WOMEN");
			return new Women();
		}
		else if(creat.equalsIgnoreCase("R")) {
			System.out.println("Have made ROBOT");
			return new Robot();			
		}
		else
		{
			throw new Exception("对不起，女娲的技术还不能满足您的造人需求");
		}
		
	} 

}
package NvWamade;

public class Robot implements People {
	public void play(){
		System.out.println("机器人");
		}
}
package NvWamade;

public class Women implements People {
	public void play(){
		System.out.println("女人");
		}
}
package NvWamade;
import java.io.File;

import javax.xml.parsers.*;


import org.w3c.dom.NodeList;
import org.w3c.dom.Document;
import org.w3c.dom.Node;


public class XMLUtilPeople {
	public static String getCreateName() {
		try {
			/**
			 * 创建文档对象
			 */
			DocumentBuilderFactory dFactory =DocumentBuilderFactory.newInstance();
			DocumentBuilder builder =dFactory.newDocumentBuilder();
			Document doc;
			doc = (Document) builder.parse(new File("congflgPeople.xml"));
			/**
			 * 获取包含名称的文本节点
			 */
			NodeList nl = doc.getElementsByTagName("createName");
			Node classNode=nl.item(0).getFirstChild();
			String creatName = classNode.getNodeValue().trim();
			return creatName;
		}
		catch(Exception e)
		{
			e.printStackTrace();
			return null;
		}
	}

}

具体代码 3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
package PCpartMade;

public class ComputerPartsClient {
public static void main(String[] args) {
	CPU cpu;
	RAM ram;
	ComputerPartsFactory pcFactory;
	ComputerPartsFactory macFactory;
	
	System.out.println("THIS IS THE PC_PARTS  @_@  ");
	pcFactory = new PCFactory();
	cpu = pcFactory.produceCPU();
	ram = pcFactory.produceRAM();
	cpu.discribe();
	ram.discribe();
	System.out.println("***************************");
	System.out.println("THIS IS THE MAC_PARTS   @_@ ");
	macFactory = new MacFactory();
	cpu = macFactory.produceCPU();
	ram = macFactory.produceRAM();
	cpu.discribe();
	ram.discribe();


}
}
package PCpartMade;

public interface ComputerPartsFactory {
	CPU produceCPU();
	RAM produceRAM();

}
package PCpartMade;

public interface CPU {
void discribe();
}
package PCpartMade;

public class MacCPU implements CPU {
	public void discribe() {
		System.out.println("This production is the Mac_CPU");
	}

}																				
package PCpartMade;

public class MacFactory implements ComputerPartsFactory{
	public MacCPU produceCPU() {
		System.out.println("MAC_CPU produced!");
		return new MacCPU();
		
	}
	public MacRam produceRAM() {
		System.out.println("Mac_RAM produced!");
		return new MacRam();
	}

}
package PCpartMade;

	public class MacRam implements RAM {
		public void discribe() {
			System.out.println("This production is the Mac_RAM");
		}

	}
package PCpartMade;

public class PcCPU implements CPU {
	public void discribe() {
		System.out.println("This production is the PC_CPU");
	}

}
package PCpartMade;

public class PCFactory implements ComputerPartsFactory{
	public PcCPU produceCPU() {
		System.out.println("PC_CPU produced!");
		return new PcCPU();
		
	}
	public PcRam produceRAM() {
		System.out.println("PC_RAM produced!");
		return new PcRam();
	}

}
package PCpartMade;

public class PcRam implements RAM {
	public void discribe() {
		System.out.println("This production is the PC_RAM");
	}

}
package PCpartMade;

public interface RAM {
	void discribe();

}

Hexo 添加分类及标签不能显示解决方法

github blog

问题：使用Ayer 主题配置Hexo个人博客，添加分类和标签无法显示

1.添加博客分类

  1. 开启主题配置文件下_config.yml menu来设置侧边栏菜单
1
2
3
4
5
6
menu:
  主页: /
  归档: /archives
  分类: /categories  # 开启此项
  标签: /tags  
  CSDN: https://blog.csdn.net/qq_41753944
  1. 在站点文件夹下打开Git bash,输入以下代码
1
hexo n page categories
  1. 修改source\categories文件夹下index.md文件为下面的代码
1
2
3
4
5
6
---
title: 分类
date: 2020-03-04 17:18:32
type: categories
layout: categories   #注意此行不添加则点击不会显示分类结果
---
- layout: categories 使用该主题时，如果不添加此行虽然在文章中有分类，但是点击左侧菜单栏时并不会跟上你所添加的分类，也就不会显示分类

2.添加博客分类

  1. 开启主题配置文件下_config.yml menu来设置侧边栏菜单
1
2
3
4
5
6
menu:
  主页: /
  归档: /archives
  分类: /categories  
  标签: /tags  # 开启此项
  CSDN: https://blog.csdn.net/qq_41753944
  1. 在站点文件夹下打开Git bash,输入以下代码
1
hexo n page tags
  1. 修改source\categories文件夹下index.md文件为下面的代码
1
2
3
4
5
6
---
title: 标签
date: 2020-03-04 17:18:32
type: tags
layout: tags   #注意此行不添加则点击不会显示标签
---
- layout: tags 使用该主题时，如果不添加此行虽然在文章中有标签，但是点击左侧菜单栏时并不会跟上你所添加的标签，也就不会显示标签

附：Ayer hexo 主题作者开源项目网址

  • © 2019-2020 卻水
  • PV: UV:

请我喝杯咖啡吧~

支付宝
微信