模具技师证怎么考？

一、模具技师证怎么考？

模具技师证是一种专业技能证书，考试通常由权威认证机构如中国模具工业协会或相关学术机构组织。要考取模具技师证，首先需要具备相关的模具专业知识，包括模具设计、制造、维修等方面的技能。

通常，考取证书需要完成一定的学习课程，掌握相关的基础知识和技能，并参加考试。

在考试过程中，需要展示对模具设计、制造、维修等技能的理解和应用能力。通过考试后，就可以获得相应的模具技师证书。需要注意的是，考试内容和难度会因不同的认证机构而有所差异，因此需要了解相关认证机构的具体要求和考试内容，进行充分准备。

二、冲压模具设计面试题

冲压模具设计面试题是在冲压行业中常见的一种面试形式。对于模具设计师来说，掌握面试题的解答是非常重要的，这不仅可以展示自己的专业知识和技能，还能增加面试成功的机会。

作为一名冲压模具设计师，在面试前充分准备各类面试题是必不可少的。下面，我将分享一些常见的冲压模具设计面试题，并给出相应的答案供大家参考。

1. 请简要介绍一下冲压模具设计的基本流程。

冲压模具设计的基本流程包括以下几个步骤：

• 需求分析：了解客户的需求，包括产品的形状、尺寸、材料等要求。
• 产品设计：将产品的形状、尺寸等要求转化为设计图纸。
• 模具设计：根据产品设计图纸设计模具的结构和尺寸。
• 加工制造：将模具设计图纸转化为实际的冲压模具。
• 调试优化：对模具进行调试和优化，确保其正常运行。

2. 冲压模具设计中常用的软件有哪些？

冲压模具设计中常用的软件主要有以下几种：

• AutoCAD：用于进行模具的二维图设计。
• Pro/ENGINEER：一款三维实体建模软件，可以进行复杂模具的设计。
• UG/NX：也是一款三维实体建模软件，适用于大型模具的设计。
• CATIA：用于进行高级曲面模具的设计。
• SolidWorks：一款常用的三维建模软件，适用于各类模具的设计。

3. 请介绍一下常见的冲压模具的分类。

常见的冲压模具可以根据不同的分类标准进行划分：

• 按照加工方式分类：包括冲裁模、拉伸模、弯曲模、冲切模等。
• 按照结构分类：包括单工位模具、连续模具、复合模具等。
• 按照材料分类：包括金属模具、非金属模具等。
• 按照用途分类：包括汽车模具、家电模具、电子产品模具等。

4. 请谈谈您对冲压模具设计的经验和技巧。

在我多年的冲压模具设计经验中，我积累了一些经验和技巧，包括：

• 充分了解产品特点：在设计模具之前，要充分了解产品的特点和要求，包括材料、尺寸、形状等。
• 注重模具结构设计：模具的结构设计对冲压工艺和产品质量具有重要影响，要注重合理的结构设计。
• 考虑模具的可制造性：在设计模具时要考虑到模具的可制造性，避免设计上的不合理和过于复杂。
• 运用先进的软件和技术：运用先进的软件和技术可以提高冲压模具设计的效率和精度。
• 不断学习和创新：冲压模具设计是一个不断学习和创新的领域，要保持持续的学习和研究。

5. 请谈谈您在冲压模具设计中的成功案例。

在我从事冲压模具设计的职业生涯中，我参与了多个成功的冲压模具设计项目，其中一个典型案例是：

我所在的团队负责设计某汽车零部件的冲压模具，这个零部件形状复杂，要求尺寸精度高。在该项目中，我采用了先进的三维建模软件和模拟分析技术，经过多次的方案比选和优化，最终设计出了一个结构合理、性能稳定的冲压模具。该模具经过实际生产验证，零件的质量和生产效率得到了显著提升，获得了客户的高度赞誉。

6. 冲压模具设计中常见面临的问题及解决方法有哪些？

在冲压模具设计过程中，常见的问题包括：

• 尺寸精度难以控制：冲压模具制造过程中，尺寸精度是一个关键问题。可以通过合理的模具结构设计、优化加工工艺等方式来解决。
• 裂纹、变形等问题：冲压过程中，材料容易出现裂纹、变形等问题。可以通过优化冲压工艺、选择合适的材料等方式来解决。
• 模具磨损和寿命问题：模具在使用过程中可能会出现磨损和寿命不够长的问题。可以通过选择高耐磨材料、优化润滑方式等方式来解决。
• 成本控制问题：冲压模具制造成本较高，如何控制成本是一个挑战。可以通过合理的设计、优化加工工艺等方式来降低成本。

这些问题在实际冲压模具设计中是常见的，解决方法需要根据具体情况进行分析和判断。

结语

冲压模具设计是一个复杂而关键的工作，对设计师的专业知识和技能有较高要求。通过对冲压模具设计面试题的准备和理解，可以提高自己在面试中的竞争力，展示出自己的实力和潜力。希望以上的面试题及答案对正在准备冲压模具设计面试的人士有所帮助，祝大家面试顺利！

三、模具技师个人总结报告

模具技师个人总结报告

引言

作为一名经验丰富的模具技师，我认为对自己的工作进行总结和反思是非常必要的。通过这篇个人总结报告，我将回顾过去的工作经历，总结所取得的成绩和经验教训，以及未来的发展规划和目标。希望通过这样的总结能够不断提升自我，更好地适应行业发展的需要。

工作成绩与经验

在过去的工作中，我主要负责模具的设计、制造和维护工作。在设计方面，我注重与工程师团队的紧密合作，根据产品需求进行设计方案的制定，确保模具的质量和效率。在制造过程中，我严格把控每一个工序，确保模具的精准度和稳定性。在维护方面，我建立了完善的维护记录和计划，定期检查和保养模具，延长了模具的使用寿命，降低了生产成本。

在工作中，我积累了丰富的经验，能够独立解决各种复杂的技术问题，反映了我的专业能力和工作态度。同时，我善于与同事合作，团队协作能力较强，能够高效地完成工作任务。在工作中，我始终保持学习的态度，不断学习新知识和新技术，不断提升自己的专业水平。

经验教训

在工作中，我也遇到过一些困难和挑战。比如在某个项目中，由于沟通不畅，导致了设计方案的误解，影响了模具的制造进度。通过这样的教训，我意识到沟通的重要性，学会了更加有效地与团队沟通，避免类似的问题再次发生。

此外，我也意识到在工作中要保持耐心和细心，不能因为工作的繁忙而忽略细节。细节决定成败，只有将每一个细节做到位，才能保证工作的质量和效率。因此，我在工作中更加注重细节，保持高度的专注和耐心，确保工作的完美完成。

未来规划与发展目标

在未来的工作中，我将继续努力提升自己的专业能力和技术水平，不断学习行业最新的发展动态和技术知识，保持与行业前沿的接轨。同时，我也希望能够挑战更高级别的工作岗位，拓展自己的职业发展空间，为企业的发展贡献自己的力量。

此外，我还计划参加相关的培训和认证考试，提升自己的专业认证水平，增强个人在求职市场上的竞争力。通过不断学习和提升，我相信自己能够在模具行业中取得更加出色的成绩，实现个人职业目标和企业发展目标。

结语

总的来说，通过这次模具技师个人总结报告，我对自己的工作进行了深入的反思和总结，发现了自身的优势和不足，明确了未来的发展方向和目标。我会继续努力工作，不断提升自己，为行业的发展和企业的成功贡献自己的力量。

四、模具钳工技师毕业论文

模具钳工技师毕业论文

模具钳工技师是机械制造行业中非常重要的角色，他们负责制造和维修各种模具，并确保其质量和准确度。而在模具钳工技师毕业论文中，我们将探讨模具钳工技师的职责、技能要求以及未来发展前景。

1. 模具钳工技师的职责

作为模具钳工技师，他们的主要职责是制造和维修各种模具。模具是用于制造各种产品的工具或零件，它们的准确性和质量直接影响到最终产品的质量。因此，模具钳工技师需要拥有精密加工的技能，能够操作各种机械设备和工具，以及能够解读和理解技术图纸。

除了制造和维修模具外，模具钳工技师还需要进行模具测试和调整，以确保其符合产品规格。他们还负责解决模具生产过程中的问题，并进行必要的改进和调整。同时，他们需要与其他部门合作，如设计师和工程师，以确保模具的质量和功能。

2. 模具钳工技师的技能要求

要成为一名优秀的模具钳工技师，以下是一些必备的技能要求：

• 机械加工技能：模具钳工技师需要熟练掌握各种机械加工技能，如钳工、铣工、磨工等。他们需要能够操作各种机械设备和工具，如车床、铣床、磨床等。
• 技术图纸解读：模具钳工技师需要能够解读和理解复杂的技术图纸，以便准确制造和修复模具。
• 质量控制：模具钳工技师需要具备严格的质量控制意识，确保制造和修复的模具符合产品规格和质量要求。
• 沟通与合作能力：模具钳工技师需要与其他团队成员进行合作，如设计师、工程师和生产人员，以确保模具的质量和功能。

3. 模具钳工技师的未来发展前景

随着制造业的发展和技术的进步，模具钳工技师的需求将继续增长。他们在汽车制造、航空航天、电子设备等行业中扮演着重要的角色。

当前，制造业正经历着工业4.0的时代，即数字化、智能化生产。模具钳工技师需要跟上这一潮流，学习和掌握与技术相关的知识和技能，如计算机辅助设计、数控加工等。

此外，随着制造业对高精度、高质量模具的需求不断增加，模具钳工技师需要不断提升自己的技能，学习新的加工技术和工具。他们可以通过持续的学习和培训来提高自己的专业水平，并通过参加技能竞赛和获得相关证书来展示自己的能力。

总而言之，模具钳工技师是制造行业中不可或缺的一部分。他们的技能和贡献直接影响着产品的质量和效率。通过不断学习和提升自己的技能，模具钳工技师将在未来的发展中获得更多的机会和挑战。

五、如何办理模具钳工技师证？

国企的话大专毕业只能先从中级钳工考起，每个单位体系不一样，私企的话可以在社会上考去技师证。

六、模具技师、模具师傅、模具补师的区别是什么?主要做些什么？

技师可以说是另外两个会的他都会。 成熟的技师在拿到零件时候到装配然后调试做成成品，最后给客户交模以及交产品时候按客户要求要求做的临时改动中的做法和技术都要精通。 模具师傅工作是装配以及调试为主。 模具补师就是在产品生产过程中碰到加工损坏、装配不完整、调试需要修补，或者存在设计方面的漏洞处理。 模具技师有：冲压模具技师、五金模具技师、塑胶模具技师、精密模具零件测量技师、模具钳工技师。

1、维护模具的日常运行，定时对模具维护及保养。

2、负责生产所需工装模具设计。

3、处理工装模具制作和维修过程中出现的技术问题。 模具补师就是在产品生产过程中碰到加工损坏、装配不完整、调试需要修补，或者存在设计方面的漏洞处理，对产品进行修补工作。 通常先从模具补师坐起，会做装配和调试成为模具师傅，然后一步一步进阶到模具技师。

七、注塑技师未修理模具检讨书怎么写？

首先本职工作内容，然后分析产生原因，然后 本人未预料后果，耽误了后续生产以及其它同事的效率，本人检讨，并作好预防措施，再有修理事件，会在笔记或黑板标识，同时给予第一时间处理，提高工作效率与积极性

八、有谁是做铝型材挤压拉伸模具技师呀?工资如何？

我没做过，不过以厂在铝材厂待过，我去两家厂工资都不错。听说有5到6千一个月。因为那些厂就靠那些模具生产。如果模具不行，就要停工。

九、无锡技师学院，那个专业女生多，模具女生数量怎么样？

该学院以机械方面专业居多，总体女生相对要少一些，在学校里，一般数控、电子之类的专业女生稍多，模具要钳工基础的，一般不太招女生。

十、mahout面试题？

之前看了Mahout官方示例 20news 的调用实现；于是想根据示例的流程实现其他例子。网上看到了一个关于天气适不适合打羽毛球的例子。

训练数据：

Day Outlook Temperature Humidity Wind PlayTennis

D1 Sunny Hot High Weak No

D2 Sunny Hot High Strong No

D3 Overcast Hot High Weak Yes

D4 Rain Mild High Weak Yes

D5 Rain Cool Normal Weak Yes

D6 Rain Cool Normal Strong No

D7 Overcast Cool Normal Strong Yes

D8 Sunny Mild High Weak No

D9 Sunny Cool Normal Weak Yes

D10 Rain Mild Normal Weak Yes

D11 Sunny Mild Normal Strong Yes

D12 Overcast Mild High Strong Yes

D13 Overcast Hot Normal Weak Yes

D14 Rain Mild High Strong No

检测数据：

sunny，hot，high，weak

结果：

Yes=》 0.007039

No=》 0.027418

于是使用Java代码调用Mahout的工具类实现分类。

基本思想：

1. 构造分类数据。

2. 使用Mahout工具类进行训练，得到训练模型。

3。将要检测数据转换成vector数据。

4. 分类器对vector数据进行分类。

接下来贴下我的代码实现=》

1. 构造分类数据：

在hdfs主要创建一个文件夹路径 /zhoujainfeng/playtennis/input 并将分类文件夹 no 和 yes 的数据传到hdfs上面。

数据文件格式，如D1文件内容： Sunny Hot High Weak

2. 使用Mahout工具类进行训练，得到训练模型。

3。将要检测数据转换成vector数据。

4. 分类器对vector数据进行分类。

这三步，代码我就一次全贴出来；主要是两个类 PlayTennis1 和 BayesCheckData = =》

package myTesting.bayes;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.fs.FileSystem;

import org.apache.hadoop.fs.Path;

import org.apache.hadoop.util.ToolRunner;

import org.apache.mahout.classifier.naivebayes.training.TrainNaiveBayesJob;

import org.apache.mahout.text.SequenceFilesFromDirectory;

import org.apache.mahout.vectorizer.SparseVectorsFromSequenceFiles;

public class PlayTennis1 {

private static final String WORK_DIR = "hdfs://192.168.9.72:9000/zhoujianfeng/playtennis";

/*

* 测试代码

*/

public static void main(String[] args) {

//将训练数据转换成 vector数据

makeTrainVector();

//产生训练模型

makeModel(false);

//测试检测数据

BayesCheckData.printResult();

}

public static void makeCheckVector(){

//将测试数据转换成序列化文件

try {

Configuration conf = new Configuration();

conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));

String input = WORK_DIR+Path.SEPARATOR+"testinput";

String output = WORK_DIR+Path.SEPARATOR+"tennis-test-seq";

Path in = new Path(input);

Path out = new Path(output);

FileSystem fs = FileSystem.get(conf);

if(fs.exists(in)){

if(fs.exists(out)){

//boolean参数是，是否递归删除的意思

fs.delete(out, true);

}

SequenceFilesFromDirectory sffd = new SequenceFilesFromDirectory();

String[] params = new String[]{"-i",input,"-o",output,"-ow"};

ToolRunner.run(sffd, params);

}

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.out.println("文件序列化失败！");

System.exit(1);

}

//将序列化文件转换成向量文件

try {

Configuration conf = new Configuration();

conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));

String input = WORK_DIR+Path.SEPARATOR+"tennis-test-seq";

String output = WORK_DIR+Path.SEPARATOR+"tennis-test-vectors";

Path in = new Path(input);

Path out = new Path(output);

FileSystem fs = FileSystem.get(conf);

if(fs.exists(in)){

if(fs.exists(out)){

//boolean参数是，是否递归删除的意思

fs.delete(out, true);

}

SparseVectorsFromSequenceFiles svfsf = new SparseVectorsFromSequenceFiles();

String[] params = new String[]{"-i",input,"-o",output,"-lnorm","-nv","-wt","tfidf"};

ToolRunner.run(svfsf, params);

}

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.out.println("序列化文件转换成向量失败！");

System.out.println(2);

}

}

public static void makeTrainVector(){

//将测试数据转换成序列化文件

try {

Configuration conf = new Configuration();

conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));

String input = WORK_DIR+Path.SEPARATOR+"input";

String output = WORK_DIR+Path.SEPARATOR+"tennis-seq";

Path in = new Path(input);

Path out = new Path(output);

FileSystem fs = FileSystem.get(conf);

if(fs.exists(in)){

if(fs.exists(out)){

//boolean参数是，是否递归删除的意思

fs.delete(out, true);

}

SequenceFilesFromDirectory sffd = new SequenceFilesFromDirectory();

String[] params = new String[]{"-i",input,"-o",output,"-ow"};

ToolRunner.run(sffd, params);

}

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.out.println("文件序列化失败！");

System.exit(1);

}

//将序列化文件转换成向量文件

try {

Configuration conf = new Configuration();

conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));

String input = WORK_DIR+Path.SEPARATOR+"tennis-seq";

String output = WORK_DIR+Path.SEPARATOR+"tennis-vectors";

Path in = new Path(input);

Path out = new Path(output);

FileSystem fs = FileSystem.get(conf);

if(fs.exists(in)){

if(fs.exists(out)){

//boolean参数是，是否递归删除的意思

fs.delete(out, true);

}

SparseVectorsFromSequenceFiles svfsf = new SparseVectorsFromSequenceFiles();

String[] params = new String[]{"-i",input,"-o",output,"-lnorm","-nv","-wt","tfidf"};

ToolRunner.run(svfsf, params);

}

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.out.println("序列化文件转换成向量失败！");

System.out.println(2);

}

}

public static void makeModel(boolean completelyNB){

try {

Configuration conf = new Configuration();

conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));

String input = WORK_DIR+Path.SEPARATOR+"tennis-vectors"+Path.SEPARATOR+"tfidf-vectors";

String model = WORK_DIR+Path.SEPARATOR+"model";

String labelindex = WORK_DIR+Path.SEPARATOR+"labelindex";

Path in = new Path(input);

Path out = new Path(model);

Path label = new Path(labelindex);

FileSystem fs = FileSystem.get(conf);

if(fs.exists(in)){

if(fs.exists(out)){

//boolean参数是，是否递归删除的意思

fs.delete(out, true);

}

if(fs.exists(label)){

//boolean参数是，是否递归删除的意思

fs.delete(label, true);

}

TrainNaiveBayesJob tnbj = new TrainNaiveBayesJob();

String[] params =null;

if(completelyNB){

params = new String[]{"-i",input,"-el","-o",model,"-li",labelindex,"-ow","-c"};

}else{

params = new String[]{"-i",input,"-el","-o",model,"-li",labelindex,"-ow"};

}

ToolRunner.run(tnbj, params);

}

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.out.println("生成训练模型失败！");

System.exit(3);

}

}

}

package myTesting.bayes;

import java.io.IOException;

import java.util.HashMap;

import java.util.Map;

import org.apache.commons.lang.StringUtils;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.fs.Path;

import org.apache.hadoop.fs.PathFilter;

import org.apache.hadoop.io.IntWritable;

import org.apache.hadoop.io.LongWritable;

import org.apache.hadoop.io.Text;

import org.apache.mahout.classifier.naivebayes.BayesUtils;

import org.apache.mahout.classifier.naivebayes.NaiveBayesModel;

import org.apache.mahout.classifier.naivebayes.StandardNaiveBayesClassifier;

import org.apache.mahout.common.Pair;

import org.apache.mahout.common.iterator.sequencefile.PathType;

import org.apache.mahout.common.iterator.sequencefile.SequenceFileDirIterable;

import org.apache.mahout.math.RandomAccessSparseVector;

import org.apache.mahout.math.Vector;

import org.apache.mahout.math.Vector.Element;

import org.apache.mahout.vectorizer.TFIDF;

import com.google.common.collect.ConcurrentHashMultiset;

import com.google.common.collect.Multiset;

public class BayesCheckData {

private static StandardNaiveBayesClassifier classifier;

private static Map<String, Integer> dictionary;

private static Map<Integer, Long> documentFrequency;

private static Map<Integer, String> labelIndex;

public void init(Configuration conf){

try {

String modelPath = "/zhoujianfeng/playtennis/model";

String dictionaryPath = "/zhoujianfeng/playtennis/tennis-vectors/dictionary.file-0";

String documentFrequencyPath = "/zhoujianfeng/playtennis/tennis-vectors/df-count";

String labelIndexPath = "/zhoujianfeng/playtennis/labelindex";

dictionary = readDictionnary(conf, new Path(dictionaryPath));

documentFrequency = readDocumentFrequency(conf, new Path(documentFrequencyPath));

labelIndex = BayesUtils.readLabelIndex(conf, new Path(labelIndexPath));

NaiveBayesModel model = NaiveBayesModel.materialize(new Path(modelPath), conf);

classifier = new StandardNaiveBayesClassifier(model);

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

System.out.println("检测数据构造成vectors初始化时报错。。。。");

System.exit(4);

}

}

/**

* 加载字典文件，Key: TermValue； Value：TermID

* @param conf

* @param dictionnaryDir

* @return

*/

private static Map<String, Integer> readDictionnary(Configuration conf, Path dictionnaryDir) {

Map<String, Integer> dictionnary = new HashMap<String, Integer>();

PathFilter filter = new PathFilter() {

@Override

public boolean accept(Path path) {

String name = path.getName();

return name.startsWith("dictionary.file");

}

};

for (Pair<Text, IntWritable> pair : new SequenceFileDirIterable<Text, IntWritable>(dictionnaryDir, PathType.LIST, filter, conf)) {

dictionnary.put(pair.getFirst().toString(), pair.getSecond().get());

}

return dictionnary;

}

/**

* 加载df-count目录下TermDoc频率文件，Key: TermID； Value：DocFreq

* @param conf

* @param dictionnaryDir

* @return

*/

private static Map<Integer, Long> readDocumentFrequency(Configuration conf, Path documentFrequencyDir) {

Map<Integer, Long> documentFrequency = new HashMap<Integer, Long>();

PathFilter filter = new PathFilter() {

@Override

public boolean accept(Path path) {

return path.getName().startsWith("part-r");

}

};

for (Pair<IntWritable, LongWritable> pair : new SequenceFileDirIterable<IntWritable, LongWritable>(documentFrequencyDir, PathType.LIST, filter, conf)) {

documentFrequency.put(pair.getFirst().get(), pair.getSecond().get());

}

return documentFrequency;

}

public static String getCheckResult(){

Configuration conf = new Configuration();

conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));

String classify = "NaN";

BayesCheckData cdv = new BayesCheckData();

cdv.init(conf);

System.out.println("init done...............");

Vector vector = new RandomAccessSparseVector(10000);

TFIDF tfidf = new TFIDF();

//sunny，hot，high，weak

Multiset<String> words = ConcurrentHashMultiset.create();

words.add("sunny",1);

words.add("hot",1);

words.add("high",1);

words.add("weak",1);

int documentCount = documentFrequency.get(-1).intValue(); // key=-1时表示总文档数

for (Multiset.Entry<String> entry : words.entrySet()) {

String word = entry.getElement();

int count = entry.getCount();

Integer wordId = dictionary.get(word); // 需要从dictionary.file-0文件（tf-vector）下得到wordID，

if (StringUtils.isEmpty(wordId.toString())){

continue;

}

if (documentFrequency.get(wordId) == null){

continue;

}

Long freq = documentFrequency.get(wordId);

double tfIdfValue = tfidf.calculate(count, freq.intValue(), 1, documentCount);

vector.setQuick(wordId, tfIdfValue);

}

// 利用贝叶斯算法开始分类,并提取得分最好的分类label

Vector resultVector = classifier.classifyFull(vector);

double bestScore = -Double.MAX_VALUE;

int bestCategoryId = -1;

for(Element element: resultVector.all()) {

int categoryId = element.index();

double score = element.get();

System.out.println("categoryId:"+categoryId+" score:"+score);

if (score > bestScore) {

bestScore = score;

bestCategoryId = categoryId;

}

}

classify = labelIndex.get(bestCategoryId)+"(categoryId="+bestCategoryId+")";

return classify;

}

public static void printResult(){

System.out.println("检测所属类别是："+getCheckResult());

}

}