贝叶斯java

1. java大数据培训

智游大数据的课程讲这些：
第一阶段：Java基础
 Java基础介绍及常用开发术语操作，Java跨平台原理，JDK的安装与卸载
 Java开发基本语法和编程规范，Eclipse的安装与使用
 Java面向对象、封装、继承、抽象类
 String、StringBuffer、StringBuilder等开发文档的使用，
 NIO的设计思想和常用组件使用方法
 IP/端口/URL等网络基础
 多线程的创建与启动
 完成聊天工具（线程+IO+网络编程）
 反射的意义和概念，通过内省机制处理JavaBean
 XML格式与XML解析
第二阶段:Java Web
 MySQL基本概念及使用
 使用JDBC完成CRUD操作，JDBC重构/封装/解耦合代码思想，JDBC多条件过滤和分页的代码封装
 HTML5网页技术，HTML常用标签使用，JavaWeb发展历程和规范，Tomcat安装、配置、插件使用、部署
 Servlet基础知识，Cookie和Session原理和技术
 JSP原理、JSP九大内置对和四大作用于,EL和JSTL原理和重用操作
 Struts2和Spring MVC，过滤器、监听器、国际化，文件上传和文件下载
 Hibernate的基础知识及使用，Hibernate查询的方式和结果集的包装，Hibernate的HQL常用语法，Hibernate的事务管理及缓存机制和性能优化
 JPA2.0规范和常见JPA标签的使用
 Spring原理，Spring IoC容器，bean生命周期、bean作用域，Spring测试
 Spring针对不同持久化方式的操作模板以及DAO支持
 Spring集成JDBC、Hibernate、MyBatis操作
 spring struts hibernate 大型企业级项目实践开发
第三阶段 大数据基础：Hadoop
 linux系统概述及系统安装相关配置
 Linux的常用命令，Linux系统进程管理基本原理及相关管理工具
 Linux启动流程，用户和组账户管理，磁盘管理，系统文件权限管理，RPM软件包管理
 Linux网络基础，Shell编程，yum命令，yum源搭建
 Linux上常见软件的安装：安装JDK、安装Tomcat、安装mysql,web项目部署
 Hadoop生态环境概览、功能和作用、Hadoop 核心组成介绍及hdfs、maprece 体系结构、hadoop集群搭建
 Hdfs shell编写、Hdfs java api操作、Hadoop基本命令操作，Hadoop优化
 日志及常见故障处理，名称节点管理
 Maprece数据去重，数据类型，数据排序，倒排索引，输入输出格式，MR串联，MR模型核心解析
 Lucene入门实例及概述，Lucene 中文分词器，Lucene 复杂检索，Lucene 和hadoop的整合
 Yarn基础及Yarn框架核心原理解析
 Hive入门及集群安装，Hive CRUD操作，hive UDF
第四阶段 大数据进阶
 Zookeeper概论及集群安装，Zookeeper java 操作
 Hbase总体概述及基本原理及架构，Hbase 分布式安装操作，Hbase java操作
 Hbase的复杂操作、二级索引、协处理器、分页实例、存储及检索原理、行键设计原则、预分区及优化
 Phoenix的安装及常用操作，Phoenix java操作，Phoenix spring整合
 Flume概述及核心讲解，Flume-ng的安装及测试、核心流程讲解、串联、多路、插件开发、正则表达式
 Kafka概述及集群安装，kafka sink，Flume-ng自定义 interceptor
 大型日志分析和用户行为分析项目
学完成为Spark实时数据分析开发工程师，一线城市薪资12000~15000
第五阶段：Spark内存数据处理
 Scala的语言开发环境、基本语法、集合之数组、集合之List、集合之MAP、集合之元组、集合操作
 Scala的伴生对象及apply、模式匹配、并发编程、并发编程actor、并发编程akka，Scala IO编程
 Scala 与java互操作，Spark概论及与其他几个平台的对比，Spark搭建过程
 spark yarn模式部署，spark 实例开发，spark的核心进程及资源调度，spark API，spark MapRece，spark java应用实例
 spark SQL实例语法，Spark stream入门
 Spark stream整合kafka，Spark stream整合spark SQL，Spark stream整合flume-ng
 spark MLLib算法，Spark MLlib之协同过滤，Spark MLlib之K-Means聚类算法，Spark实现贝叶斯算法
 spark大型机房主机实时监控系统项目

2. Java软件工程师主要学习哪些课程

很多新手在学习java的时候都比较迷茫，不知道从哪里开始学起，这里就给大家整理了一份java开发学习路线，比较系统全面，可参考这份大纲来安排学习计划，希望可以帮到你~
最新java学习路线：第一阶段：java业基础课程
阶段目标：
1、熟练掌握java的开发环境与编程核心知识；
2、熟练运用java面向对象知识进行程序开发；
3、对java的核心对象和组件有深入理解；
4、熟练运用javaAPI相关知识；
5、熟练应用java多线程技术；
6、能综合运用所学知识完成一个项目。
知识点：
1、基本数据类型，运算符，数组，掌握基本数据类型转换，运算符，流程控制；
2、数组，排序算法，java常用API，类和对象，了解类与对象，熟悉常用API；
3、面向对象特征，集合框架，熟悉面向对象三大特征，熟练使用集合框架；
4、IO流，多线程；
5、网络协议，线程运用。
第二阶段：javaWEB核心课程
阶段目标：
1、熟练掌握数据库和MySQL核心技术；
2、深入理解JDBC与DAO数据库操作；
3、熟练运用JSP及Servlet技术完成网站后台开发；
4、深入理解缓存、连继池、注解、反射、泛型等知识；
5、能够运用所学知识完成自定义框架。
知识点：
1、数据库知识，范式，MySQL配置，命令，建库建表，数据的增删改查，约束，视图，存储过程，函数，触发器，事务，游标，建模工具。
2、深入理解数据库管理系统通用知识及MySQL数据库的使用与管理。为Java后台开发打下坚实基础。Web页面元素，布局，CSS样式，盒模型，JavaScript，jQuery。
3、掌握前端开发技术，掌握jQuery。
4、Servlet，EL表达式，会话跟踪技术，过滤器，FreeMarker。
5、掌握Servlet相关技术，利用Servlet，JSP相关应用技术和DAO完成B/S架构下的应用开发。
6、泛型，反射，注解。
7、掌握JAVA高级应用，利用泛型，注解，枚举完成自己的CRUD框架开发为后续框架学习做铺垫。
8、单点登录，支付功能，项目整合，分页封装熟练运用JSP及Servlet核心知识完成项目实战。
第三阶段：JavaEE框架课程
阶段目标：
1. 熟练运用Linux操作系统常见命令及完成环境部署和Nginx服务器的配置
2. 熟练运用JavaEE三大核心框架：Spring,SpringMVC,MyBatis
3. 熟练运用Maven,并使用SpringBoot进行快速框架搭建
4. 深入理解框架的实现原理，Java底层技术，企业级应用等
5. 使用Shiro,Ztree和Spring,SpringMVC,Myts完成企业项目
知识点：
1、Linux安装配置，文件目录操作，VI命令，管理，用户与权限，环境部署，Struts2概述，hiberante概述。
2、Linux作为一个主流的服务器操作系统，是每一个开发工程师必须掌握的重点技术，并且能够熟练运用。
3、SSH的整合,MyBatis,SpringMVC,Maven的使用。
4、了解AOP原理，了解中央控制器原理，掌握MyBatis框架，掌握SSM框架的整合。
5、Shiro,Ztree，项目文档，项目规范，需求分析，原型图设计，数据库设计，工程构建，需求评审，配置管理，BUG修复，项目管理等。
6、独立自主完成一个中小型的企业级综合项目的设计和整体架构的原型和建模。独立自主完成一个大型的企业级综合项目，并具备商业价值。
第四阶段：分布式与微服务课程
阶段目标：
1.掌握前端框架VUE及Bootstrap的应用开发
2.基于SpringCloud完成微服务架构项目的开发
3.掌握NoSQL数据库Redis的使用
4.掌握消息队列RabbitMQ的使用
5.掌握Mycat数据库中间件的使用
知识点：
1、Bootstrap前端框架、VUE前端框架、RabbitMQ消息队列。
2、掌握Bootstrap前端框架开发、掌握VUE前端框架开发、掌握RabbitMQ消息队列的应用、掌握SpringBoot集成RabbitMQ。
3、Redis缓存数据库的应用、Java基于Redis的应用开发、基于SpringCloud微服务架构开发实战。
4、掌握NOSQL数据库Redis的安装、使用，Redis客户端的安装使用，Java访问操作Redis数据库，Redis的持久化方案、主从复制、高可用。
5、掌握SpringCloud微服务架构的开发，注册中心，网关配置，配置中心，微服务间通信及容器化部署。
6、项目文档，项目规范，需求分析，数据库设计，工程构建，需求评审，配置管理，BUG修复，项目管理等。
7、掌握数据库中间件Mycat的应用，基于Mycat实现数据读写分离，高可用集群。
8、掌握项目开发的流程，按照项目开发流程完成基于微服务架构项目的需求分析，编码开发。
PS：温馨提示，光看不练假把式，跟着视频教程练项目也是必不可少的！相关教程指路B站尚学堂官方号！都是免费滴！

3. 怎么用java实现贝叶斯公式

。。。估计没人懂
叶斯公式。。。。 大多数程序员 数学渣渣

4. 贝叶斯网络算法Java实现

public static void main(String[] args){
int n=10;//定义n
int[] π={};//定义存放π的数组
for(int i=0;i++;i<n){
π[i]=Ф;
int Pold=g(i,π[i]);//调用g方法
boolean OkToProceed=true;//定义布尔值
while(OkToProceed &&Math.abs(π[i])<u){
//写不下去了。。。好多都不知道是什么方法
}

}
}

5. 贝叶斯网络主流工具软件

目前国际上存在许多种 BN 处理工具，一般均同时支持多种图模型处理。下面介绍几种比较常见的 BN 工具软件。

( 1) Hugin Expert: 该软件包括一系列产品，自称是基于 BN 的人工智能领域的领航者，既可作为单个工具使用，也可集成到其他产品中使用。目前在软件、医学、工业、军事、警容、信息处理以及农业等多个领域得到了广泛应用。如用应用于 NOKIA 公司的移动网络故障诊断、医学决策支持、隧道施工设计阶段的决策支持、数据挖掘及风险评估等。

( 2) 微软的 BBN( Microsoft Belief Networks) : 该软件采用视窗界面，界面友好且操作简单，并且提供了 API 接口，以供 VB 调用。缺点是用户不能自主选择概率推理算法，且不提供结构学习功能，即不能从数据中学习建立 BN 模型。

( 3) Netica: 该软件是加拿大 Norsys 软件公司开发研制的图模型处理工具。其主要特点是提供了图形化的建模界面及概率参数展示界面，方便直观且易于操作，并且提供了 API接口，供 Java 调用。缺点是用户不能自主选择概率推理算法。

( 4) Ergo: 该软件是由 Noetic 公司开发研制的可视化建模分析软件，它功能单一且应用范围较窄，主要用于专家系统的建立，对节点的个数和状态空间的范围都有一定程度上的限制。

( 5) BNJ: 是由肯尼索州立大学开发的开放源码软件，采用视窗界面，兼容其他 BN 建模软件的文件格式，包括 Netica、Ergo、Hugin Expert、GeNie 等。支持精确推理和近似推理、结构学习和参数学习，并且提供了 API 接口供调用。该软件最大的缺点是可操作性差，且帮助功能相对较弱。

( 6) GeNie 2. 0: 该软件是匹兹堡大学决策系统实验室( Decision Systems Laboratory，U-niversity of Pittsburgh) 开发研制的图模型处理软件。采用了图形化建模界面，界面直观，操作简单，提供多种推理算法，且支持结构学习和参数学习。该实验室还用 VC + + 开发了API 接口 SmileX 和 Smile. net ，以供 VB、VC + + 、Java、C Sharp 等多种语言调用。

上述工具各有特点，本文选用了 GeNie 软件及其提供的 Smile. net 软件包，进行 BN 模型构建、BN 学习及推理等工作。图 2. 1 为 GeNie 2. 0 软件的主界面。

图 2. 1 Genie2. 0 主界面

6. JAVA培训课程有什么内容具体有哪些模块框架

智游大数据的课程大纲如下：
第一阶段：Java基础
l Java基础介绍及常用开发术语操作，Java跨平台原理，JDK的安装与卸载
l Java开发基本语法和编程规范，Eclipse的安装与使用
l Java面向对象、封装、继承、抽象类
l String、StringBuffer、StringBuilder等开发文档的使用，
l NIO的设计思想和常用组件使用方法
l IP/端口/URL等网络基础
l 多线程的创建与启动
l 完成聊天工具（线程+IO+网络编程）
l 反射的意义和概念，通过内省机制处理JavaBean
l XML格式与XML解析

第二阶段:Java Web

l MySQL基本概念及使用
l 使用JDBC完成CRUD操作，JDBC重构/封装/解耦合代码思想，JDBC多条件过滤和分页的代码封装
l HTML5网页技术，HTML常用标签使用，JavaWeb发展历程和规范，Tomcat安装、配置、插件使用、部署
l Servlet基础知识，Cookie和Session原理和技术
l JSP原理、JSP九大内置对和四大作用于,EL和JSTL原理和重用操作
l Struts2和Spring MVC，过滤器、监听器、国际化，文件上传和文件下载
l Hibernate的基础知识及使用，Hibernate查询的方式和结果集的包装，Hibernate的HQL常用语法，Hibernate的事务管理及缓存机制和性能优化
l JPA2.0规范和常见JPA标签的使用
l Spring原理，Spring IoC容器，bean生命周期、bean作用域，Spring测试
l Spring针对不同持久化方式的操作模板以及DAO支持
l Spring集成JDBC、Hibernate、MyBatis操作
l spring struts hibernate 大型企业级项目实践开发
第三阶段 大数据基础：Hadoop
l Linux系统概述及系统安装相关配置
l Linux的常用命令，Linux系统进程管理基本原理及相关管理工具
l Linux启动流程，用户和组账户管理，磁盘管理，系统文件权限管理，RPM软件包管理
l Linux网络基础，Shell编程，yum命令，yum源搭建
l Linux上常见软件的安装：安装JDK、安装Tomcat、安装mysql,web项目部署
l Hadoop生态环境概览、功能和作用、Hadoop 核心组成介绍及hdfs、maprece 体系结构、hadoop集群搭建
l Hdfs shell编写、Hdfs java api操作、Hadoop基本命令操作，Hadoop优化
l 日志及常见故障处理，名称节点管理
l Maprece数据去重，数据类型，数据排序，倒排索引，输入输出格式，MR串联，MR模型核心解析
l Lucene入门实例及概述，Lucene 中文分词器，Lucene 复杂检索，Lucene 和hadoop的整合
l Yarn基础及Yarn框架核心原理解析
l Hive入门及集群安装，Hive CRUD操作，hive UDF

第四阶段 大数据进阶
l Zookeeper概论及集群安装，Zookeeperjava 操作
l Hbase总体概述及基本原理及架构，Hbase 分布式安装操作，Hbase java操作
l Hbase的复杂操作、二级索引、协处理器、分页实例、存储及检索原理、行键设计原则、预分区及优化
l Phoenix的安装及常用操作，Phoenixjava操作，Phoenix spring整合
l Flume概述及核心讲解，Flume-ng的安装及测试、核心流程讲解、串联、多路、插件开发、正则表达式
l Kafka概述及集群安装，kafka sink，Flume-ng自定义 interceptor
l 大型日志分析和用户行为分析项目

第五阶段：Spark内存数据处理
l Scala的语言开发环境、基本语法、集合之数组、集合之List、集合之MAP、集合之元组、集合操作
l Scala的伴生对象及apply、模式匹配、并发编程、并发编程actor、并发编程akka，Scala IO编程
l Scala 与java互操作，Spark概论及与其他几个平台的对比，Spark搭建过程
l spark yarn模式部署，spark 实例开发，spark的核心进程及资源调度，spark API，spark MapRece，spark java应用实例
l spark SQL实例语法，Sparkstream入门
l Spark stream整合kafka，Spark stream整合spark SQL，Spark stream整合flume-ng
l spark MLLib算法，Spark MLlib之协同过滤，Spark MLlib之K-Means聚类算法，Spark实现贝叶斯算法
l spark大型机房主机实时监控系统项目

7. 如何用java编写naivebayes

1.关于贝叶斯分类

bayes 是一种统计学分类方法，它基于贝叶斯定理，它假定一个属性值对给定类的影响独立于其它属性点的值。该假定称作类条件独立。做次假定是为了简化所需计算，并在此意义下称为“朴素的”。

bayes分类的算法大致如下：

（1）对于属性值是离散的，并且目标label值也是离散的情况下。分别计算label不同取值的概率，以及样本在label情况下的概率值，然后将这些概率值相乘最后得到一个概率的乘积，选择概率乘积最大的那个值对应的label值就为预测的结果。

例如以下：是预测苹果在给定属性的情况是甜还是不甜的情况：

color={0,1,2,3} weight={2,3,4};是属性序列，为离散型。sweet={yes,no}是目标值，也为离散型；

这时我们要预测在color=3,weight=3的情况下的目标值，计算过程如下：

P{y=yes}=2/5=0.4; P{color=3|yes}=1/2=0.5;P{weight=3|yes}=1/2=0.5; 故F{color=3,weight=3}取yesd的概率为 0.4*0.5*0.5=0.1;

P{y=no}=3/5=0.6; P{color=3|no}=1/3 P{weight=3|no}=1/3; 故P{color=3,weight=3}取no为 0.6*1/3*1/3=1/15;

0.1>1/15 所以认为 F{color=3,weight=3}=yes;

(2)对于属性值是连续的情况，思想和离散是相同的，只是这时候我们计算属性的概率用的是高斯密度：

这里的Xk就是样本的取值，u是样本所在列的均值，kesi是标准差；

最后代码如下：

/*

* To change this template, choose Tools | Templates

* and open the template in the editor.

*/

package auxiliary;

import java.util.ArrayList;

/**

*

* @author Michael Kong

*/

public class NaiveBayes extends Classifier {

boolean isClassfication[];

ArrayList <Double>lblClass=new ArrayList<Double>(); //存储目标值的种类

ArrayList<Integer>lblCount=new ArrayList<Integer>();//存储目标值的个数

ArrayList<Float>lblProba=new ArrayList<Float>();//存储对应的label的概率

CountProbility countlblPro;

/*@ClassListBasedLabel是将训练数组按照 label的顺序来分类存储*/

ArrayList<ArrayList<ArrayList<Double>>> ClassListBasedLabel=new ArrayList<ArrayList<ArrayList<Double>>> ();

public NaiveBayes() {

}

@Override

/**

* @train主要完成求一些概率

* 1.labels中的不同取值的概率f(Yi); 对应28,29行两段代码

* 2.将训练数组按目标值分类存储 第37行代码

* */

public void train(boolean[] isCategory, double[][] features, double[] labels){

isClassfication=isCategory;

countlblPro=new CountProbility(isCategory,features,labels);

countlblPro.getlblClass(lblClass, lblCount, lblProba);

ArrayList<ArrayList<Double>> trainingList=countlblPro.UnionFeaLbl(features, labels); //union the features[][] and labels[]

ClassListBasedLabel=countlblPro.getClassListBasedLabel(lblClass, trainingList);

}

@Override

/**3.在Y的条件下，计算Xi的概率 f(Xi/Y)；

* 4.返回使得Yi*Xi*...概率最大的那个label的取值

* */

public double predict(double[] features) {

int max_index; //用于记录使概率取得最大的那个索引

int index=0; //这个索引是 标识不同的labels 所对应的概率

ArrayList<Double> pro_=new ArrayList<Double>(); //这个概率数组是存储features[] 在不同labels下对应的概率

for(ArrayList<ArrayList<Double>> elements: ClassListBasedLabel) //依次取不同的label值对应的元祖集合

{

ArrayList<Double> pro=new ArrayList<Double>();//存同一个label对应的所有概率，之后其中的元素自乘

double probility=1.0; //计算概率的乘积

for(int i=0;i<features.length;i++)

{

if(isClassfication[i]) //用于对属性的离散还是连续做判断

{

int count=0;

for(ArrayList<Double> element:elements) //依次取labels中的所有元祖

{

if(element.get(i).equals(features[i])) //如果这个元祖的第index数据和b相等，那么就count就加1

count++;

}

if(count==0)

{

pro.add(1/(double)(elements.size()+1));

}

else

pro.add(count/(double)elements.size()); //统计完所有之后 计算概率值 并加入

}

else

{

double Sdev;

double Mean;

double probi=1.0;

Mean=countlblPro.getMean(elements, i);

Sdev=countlblPro.getSdev(elements, i);

if(Sdev!=0)

{

probi*=((1/(Math.sqrt(2*Math.PI)*Sdev))*(Math.exp(-(features[i]-Mean)*(features[i]-Mean)/(2*Sdev*Sdev))));

pro.add(probi);

}

else

pro.add(1.5);

}

}

for(double pi:pro)

probility*=pi; //将所有概率相乘

probility*=lblProba.get(index);//最后再乘以一个 Yi

pro_.add(probility);// 放入pro_ 至此 一个循环结束，

index++;

}

double max_pro=pro_.get(0);

max_index=0;

for(int i=1;i<pro_.size();i++)

{

if(pro_.get(i)>=max_pro)

{

max_pro=pro_.get(i);

max_index=i;

}

}

return lblClass.get(max_index);

}

public class CountProbility

{

boolean []isCatory;

double[][]features;

private double[]labels;

public CountProbility(boolean[] isCategory, double[][] features, double[] labels)

{

this.isCatory=isCategory;

this.features=features;

this.labels=labels;

}

//获取label中取值情况

public void getlblClass( ArrayList <Double>lblClass,ArrayList<Integer>lblCount,ArrayList<Float>lblProba)

{

int j=0;

for(double i:labels)

{

//如果当前的label不存在于lblClass则加入

if(!lblClass.contains(i))

{

lblClass.add(j,i);

lblCount.add(j++,1);

}

else //如果label中已经存在，就将其计数加1

{

int index=lblClass.indexOf(i);

int count=lblCount.get(index);

lblCount.set(index,++count);

}

}

for(int i=0;i<lblClass.size();i++)

{

// System.out.println("值为"+lblClass.get(i)+"的个数有"+lblCount.get(i)+"概率是"+lblCount.get(i)/(float)labels.length);

lblProba.add(i,lblCount.get(i)/(float)labels.length);

}

}

//将label[]和features[][]合并

public ArrayList<ArrayList<Double>> UnionFeaLbl(double[][] features, double[] labels)

{

ArrayList<ArrayList<Double>>traingList=new ArrayList<ArrayList<Double>>();

for(int i=0;i<features.length;i++)

{

ArrayList<Double>elements=new ArrayList<Double>();

for(int j=0;j<features[i].length;j++)

{

elements.add(j,features[i][j]);

}

elements.add(features[i].length,labels[i]);

traingList.add(i,elements);

}

return traingList;

}

/*将测试数组按label的值分类存储*/

public ArrayList<ArrayList<ArrayList<Double>>> getClassListBasedLabel (ArrayList <Double>lblClass,ArrayList<ArrayList<Double>>trainingList)

{

ArrayList<ArrayList<ArrayList<Double>>> ClassListBasedLabel=new ArrayList<ArrayList<ArrayList<Double>>> () ;

for(double num:lblClass)

{

ArrayList<ArrayList<Double>> elements=new ArrayList<ArrayList<Double>>();

for(ArrayList<Double>element:trainingList)

{

if(element.get(element.size()-1).equals(num))

elements.add(element);

}

ClassListBasedLabel.add(elements);

}

return ClassListBasedLabel;

}

public double getMean(ArrayList<ArrayList<Double>> elements,int index)

{

double sum=0.0;

double Mean;

for(ArrayList<Double> element:elements)

{

sum+=element.get(index);

}

Mean=sum/(double)elements.size();

return Mean;

}

public double getSdev(ArrayList<ArrayList<Double>> elements,int index)

{

double dev=0.0;

double Mean;

Mean=getMean(elements,index);

for(ArrayList<Double> element:elements)

{

dev+=Math.pow((element.get(index)-Mean),2);

}

dev=Math.sqrt(dev/elements.size());

return dev;

}

}

}

8. 做了这么多年Java开发，如何快速转行大数据

一、学习大数据是需要学习java和linux的

二、你有多年的java开发经验，那么可以直接跳过java课程部分，学习大数据技术！

三、分享一份大数据技术课程大纲供你了解参考

9. 用weka贝叶斯公式决策分类的步骤是什么求赐教。。。。 最好给出详细的步骤，谢谢！

你可以用程序debug跟踪一下，以前是weka中NaiveBayesSimple类的主要函数和作用。
(1) globalInfo()
返回该分类器的描述字符串．
(2) getTechnicalInformation()
返回一个TechnicalInformation类型的对象实例，包含该类的技术背景等信息．
(3) getCapabilities()
返回默认参数．
(4) BuildClassifier(Instances instances)
BuildClassifier()方法从一个训练数据集合instances构造一个分类器．求出所有名称型属性的后验概率，类属性的先验概率，数值属性的均值和方差，为后来的分类工作做准备．
(5) distributionForInstance (Instance instance)
该方法计算待分类实例instance属于各个类标的百分比，并且将各个百分比数值存于一个数组中，最后返回该数组．
(6)toString()
把分类器的参数（均值，方差，各先验概率，各后验概率）以字符串的形式返回．
(7)normalDens(double x, double mean, double stdDev)
该方法用于根据正态分布（均值为mean，方差为stdDev）计算数值型属性当属性值为x时的概率密度．
(8) getRevision()
返回程序的版本号．
(9) Main()
当类从命令行被执行时，就会调用main()方法．他只是用所给的命令行选项告诉Weka的Evaluation类来评估朴素贝叶斯，并且打印所得到的数组．完成这个功能的一行表达式包括在try-catch声明中．try-catch声明用于发现Weka例程或其他Java方法中抛出的各种异常．