hibernate02：session对象、hql查询、在线查询也叫对象查询、离线查询

第一:概念

深入查询：
1.当我们要保存两张表的时候，就需要两个session来开启事务，两个session开启的两个事务互不影响，当第一个事务完成后关闭session之后再打开第二个session。因此session不能再dao层产生和关闭。这样不对。
因此我们应该把事务控制放到业务层。业务层的一个方法调用数据访问层的多个方法，而且保证用同一个session的这个事务来控制这几个dao中的方法，。
2.hql：是hibernate query languange：hibernate查询语言。hql语句不用考虑数据库之间的差异，因为我们在hibernate主配置文件中设置了数据库的方言。hql查询要用query对象
3.本地查询：session.careteSQLQuery是本地查询，只能针对此项目的数据库，因为没有方言。
4.单条查询：
--1.hql=from Emp where name=? ;query=session.createQuery(),query.set(1,"张三")
--2.hql=from Emp where name=:name ;query=session.createQuery(),query.set("name","张三")
5.在hibernate中hql查询，后面跟的字符串可以是from语句也可以是select语句。from语句查询结果是个实体类对象的集合(list)。select查询语句查询出来的结果是一个object[](数组)类型的集合（list）,此list集合中的每个object数组就是一个实体类对象，数组中的每个下标就是对象的各个属性。
6.对象查询criteria，也叫在线查询。这个criteria是关联的意思，因为把where条件都封装到对象的方法里了，因此叫对象查询
7.where 1=1的意思是说先保证where语句随时能用
8.离线查询，是脱离session对象的查询（其他查询都需要由session对象创建）。他封装的是查询条件（where），然后在用criteria把条件封装成对象

 

----------------------------------------------------------------------

笔记二：

持久化：就是把实体类对象放在session的map结构中
hibernate框架：封装了jdbc的查询过程。
1.主键生成策略：
         （1）identity：主键自动增长，适用于mysql（auto_increment）、SQLServer(identity)
          (2)uuid.hex:是个算法。产生一个十六进制32位的字符串，这样保证了在互联网上可以唯一的标识数据库中的每一个记录，避免了主键的重复
         （3)native（内迪）：自动增长，但更具有兼容性。（oracle使用于sequence，mysql（auto_increment）、SQLServer(identity)）
         （4）increnment：只适用于单线程，在多线程情况下线程不安全。所以不建议使用
         （5）assigned（饿散的）:由程序员来设置主键字段。（程序员来设置可能造成主键的重复）。是分配的意思
2.session接口API：
  hibernate提供了session接口的实现类，并提供了session对象。利用session对象来操作javabean（增删改查），
 第一：javabean的持久化：由一个实体类对象（瞬时态）通过session的save方法变成持久化对象（持久化就是永久保存了，例如保存到了数据库）。
  注意：当我们执行session.save的时候实体类对象就会进入session对象的map结构中了，然后session对象把实体类对象通过sql语句插入到oracle数据库中
3.session对象的方法：
 --1.flush（福辣湿）方法：session对象和数据库同步的机制。（session对象的同步机制，session对象在客户端，数据库在服务器端，因此需要同步）
   第一种情况： 持久化对象的属性变更：第一步创建对象并给属性赋值，第二步是执行session的save方法，第三步是修改当中的一个属性值。
      最后的结果是修改了这个属性值（也就表明hibernate框架不但执行了一个insert语句，还执行了一个update语句）。
      为什么会改变？答：由于session的map结构中的属性发送变更，为了session对象和数据库保持同步，session对象向数据库发送了一个update语句。
      什么时候发送的update语句？答：默认情况下，在执行commit的时候，也就是在提交事务的时候发送update语句。有一定的延时
   第二种情况：第一步创建对象并给属性赋值，第二步是执行session的save方法，第三步是修改当中的一个属性值，第四步是执行flush方法，第五步在修改一个属性值。
         产生的结果就是：产生了两条update语句。
      为什么会产生两条update语句？答：flush方法会使session主动跟数据库同步，此时产生一个update语句。同步之后又修改了一个属性值之后在提交时候，提交事务的时候又产生一个update语句
 --2.get方法：如何查询唯一的持久化对象？用get方法，session.get(Class,id)。注意查询的时候可以不用事务
     get方法是hibernate框架向数据库发送一个select语句。
     get方法的执行流程：首先查询session对象的map结构，如果没有在查数据库，查数据库中的会发送select语句。如果session中有（也就是缓存中有这个数据），就不会再发送select语句去数据库查了。
 --3.delete方法：如何删除一个持久化对象？ 
     session.delete方法：先删掉sesion对象的map结构中的该数据，在删掉数据库中的该对象。
     传入的参数是个对象，其实hibernate框架只需要id，因此只要这个对象有id属性就能够成功删除。
4.创建一个实体类对象，并赋属性值的过程是个瞬时态，因为当我们关闭电脑这个值就没了，没能永久的保存。
  save方法的返回值是个serializable序列化类型的(其实就是返回的是主键，这个主键就是序列化类型的)，也就是返回the generated identifier，也就是执行save方法后服务器会返回一个序列化的标识
5.关于游离态的操作
  ---1.对象离开了session对象的map结构
  ---2.session对象断开了数据库的连接：此时session对象中map结构中的对象都是游离状态。例如：session.ecict(bean)将某个对象断开,session.clear()清除sesion对象,session.close()关闭session
  ---3,如何把游离态对象重新变成持久态？
    答：实体类对象只有放入session对象中才能跟数据库进行交互。
      session的update方法的作用就是把游离态对象变成持久化对象（在dao层中的修改的方法不用session.update进行修改表数据,因为当我们执行对象.set方法的时候session对象就会向数据库发送update方法），而不是修改数据。
     update方法的参数是个游离态的对象。session的update方法将会数据库发送一个update语句。此时由游离态变成了持久态（因为执行update语句后会重新同步数据库与session对象）。这个update语句的作用不一定非得是改变数据库的内容，但是肯定会把游离态对象重新变成持久化对象。
  ---4.为什么参数必须是游离态的，不能是瞬时态的吗？
     答：不能，因为瞬时态的对象还没有id属性的值呢，也就是说这个瞬时对象还不完整呢，此时不能进行修改。因此只有游离态对象才会用到update方法
  ---5,游离态对象的属性变更。
6.javabean对象的三种状态：
    --瞬时态：刚刚创建的javabean对象，id属性为null
    ---持久态：在session对象的map里，并且此时的id属性有值
    --游离态：session对象中没有，数据库中有
7.如何区分瞬时对象和游离对象？
  答：通过id属性来区分，瞬时态为null。这就需要我们的实体类中的id属性设置成为Integer，因为integer的默认值是null，int类型的默认值是0；
8.merge(墨这)方法：融合：利用游离态对象修改持久化对象，session.merge(游离对象)
   做法1：在通过get方法获得对象之后就关闭session（保证此时已经是游离态了），然后修改这个对象u1的属性值，然后在重新开启一个事务并创建相同id的u2对象进行查询，此时发现查询结果是修改之前的结果。(因为第一次关闭session之后变成游离态，就没有session的map结构跟数据库之间的同步机制了)
   做法2：在通过get方法获得对象之后就关闭session（保证此时已经是游离态了），然后修改这个对象u1的属性值，然后在重新开启一个事务并创建相同id的u2对象进行查询，并把游离态对象变成持久化对象（使用update方法），执行结果是报错了。
   做法3：在通过get方法获得对象之后就关闭session（保证此时已经是游离态了），然后修改这个对象u1的属性值，然后在重新开启一个事务并创建相同id的u2对象进行查询，并用merge方法将游离态对象变成持久化对象u3=session.merge(u1)，
        此方法的返回值不是u1对象，而是u2对象，u2与u3对象是同一个对象。u1对象还是瞬时态的对象，u1一直没进入数据库，因为数据库中有这个主键对应着对象了。
   综合三种：我想用游离对象修改数据表中的记录，使用update方法就报错，因此要使用merge方法。
9.hql查询：基于hibernate框架的查询，Query q=session.createQuery("from User u where u.id=44")：这是hql的查询语句
 把hql语句封装成了query类型的对象，如果结果唯一的话，就User user=q.uniqueRequest()，得到这个对象。
 问题：为什么不要get查询呢？
答：因为uniqueRequest()是绕过session对象的查询。如果使用Hql查询，将会立刻实施同步。hql语句也会向数据库发送hql语句
10.查询全部：使用Query对象的list方法：Query q=session.createQuery;q.list()
11.saveorupdate方法：当程序员不知道该对象是瞬时态的还是持久态的时候，就用这个方法。如果这个对象是瞬时态的就调用save方法，如果这个对象是持久态的就调用update方法。
  这个判断的依据是我传入的对象的id在数据库中能不能找到。其他字段不管，只管id字段
12.hql查询和sql查询的区别：hql语句会立即执行
总结：hibernate生命周期（状态）：
1.瞬态：存在于内存中，数据库中没有，一级缓存中没有。（所谓的内存就是指数据进入堆内存或者栈内存）
2.持久态：一级缓存也有，同步一级缓存和数据库的数据。（所谓的一级缓存就是指session对象的map结构）
3.游离态：数据库当中有，一级缓存中没有（所谓的游离态对象就是指该对象跟session的map结构断开了）
4.瞬时态变成持久态：是通过save方法，游离态变成持久态是通过update方法
5.当缓存中有的时候就不会去数据库中去查，而是直接访问缓存。
添加的时候会产生缓存。查询的时候会先看有没有缓存，有缓存的话就不进入数据库了。删除的时候是先删掉缓存在删数据库

注意：Query接口是用来封装hql的查询语句的，是把hql的查询语句转化成sql的查询语句.并不执行hql语句，执行是调用query里面的方法的时候才会执行。

 笔记三：最原始的比较

（一）Session接口
通过配置文件，Hibernate框架会为我们建立一个Sesssion对象，
通过Session对象，可以调用Session接口中所提供的方法。
（二）Session对象的持久化机制
（1）持久化JavaBean对象
    Session对象内部包含一个Map结构，
        当调用Session对象save方法时，向数据库发送insert语句，将
    JavaBean对象存入表中并返回id属性；Hibernate框架以id属性作键，
        将JavaBean对象存入Session对象的map中！    
（2）持久化对象的属性变更
 持久化对象的属性变更时，如何实施数据库的同步？
 同步是通过向数据库发送update语句实现的，目的是使JavaBean对象的变更数据体现
 在数据库表中。
 ①执行session.flush()方法时；//程序员控制
 ②实施HQL查询时(案例：TestSession#testQuery()方法)；//自动同步
 ③事务提交时；//自动同步
（3）Session对象通过get方法，获取指定id属性的持久化对象:
        ①方式：
     session.get(Student.class, "1001");
          立刻产生和发送SelectSQL语句
       ②get方法的执行过程：
     (a)session对象首先从map中查找，如果没有，再去数据库查询(会产生select语句)，
     (b)查询后的数据结果封装成实体bean对象，并存入map中。
 ---------------------------------------------------
（三）在Hibernate框架下，JavaBean对象有三种状态：
          瞬时状态、持久化状态、游离状态
（1）刚诞生时，是瞬时状态；
        特点：id属性为null;
（2）进入session后，是持久化状态：
 ①对持久化对象的属性变更，会产生update语句
 ②持久化对象的删除:
   (a)首先获得持久化对象；
   (b)然后删除该对象：
      session.delete(bean);
（3）游离状态
 ①持久化对象转变为游离对象：
   (a)session.evict(bean);
   (b)session.clear();
   (c)session.close();
 ②游离对象重新持久化：
   (a)方式：
      session.update(bean);
    
   (b)条件：
      Session对象的map结构中，不能含有和游离对象id属性相同的持久化对象，
           否则会报异常；
   (c)注意：
          ⅠSession对象的update方法总是产生update语句，无论游离对象的属性是否变更；
          Ⅱupdate方法只能操作游离对象，如果操作瞬时对象将产生异常；
 ③Hibernate框架如何区分瞬时状态的对象和游离状态的对象？
    通过考察对象的id属性是否为null。
    瞬时对象的id属性是空(null)，游离对象的id属性不为空(null);
    【建议】：
   (a)id属性的类型最好使用引用类型，此时id属性的默认值是null;
          （如果id属性的类型使用了基本数据类型，比如int，id属性的默认值是0，此时要求在映射配置
             文件中的id标签使用unsaved属性，并设置为0。即<id name="id" unsaved=0 type="int">）
   (b)如果程序员不能断定当前对象是瞬时状态还是游离状态，可以采用：
      session.saveOrUpdate(bean)，此时由Hibernate框架决定使用save方法还是update方法；
    ④使用游离对象修改持久化对象：
   (a)方式:
      session.merge(bean);
   (b)适用的场合：
            在Session对象的map结构中，含有和游离对象id属性相同的持久化对象
   (c)merge之后，游离对象还是游离对象；merge方法返回的持久化对象与游离对象不是同一个对象；  

（四）HQL查询：
（1）HQL语句（Hibernate Query Language)：
       ①举例:from User u;  //User u=new User();
          特点:从面相对象的角度解释HQL语句，比SQL简单。
       ②对比SQL语句:select *　from t_user(表名) tu;
     (Structured Query Language)
（2）封装Query对象
    Session对象通过createQuery方法，将HQL语句封装为Query对象
（3）Query对象的唯一性查询:
    Query#uniqueResult();
（4）Query对象的多值查询:
    Query#list()；
（5）HQL查询与get方法的区别:
        ①get方法首先查询Session对象的map结构；
        ②HQL查询绕过Session对象，直接查询数据库；

 

 

 

第二：代码实现

1.实体类

package com.model.pojo;

public class chu_hibernate01 {
 //模拟员工表
 private String empId;//员工编号
 private String empName;//员工姓名
 private int empAge;//员工年龄
 private String empWh;//员工工资
 public chu_hibernate01() {
  super();
  // TODO Auto-generated constructor stub
 }
 public String getEmpId() {
  return empId;
 }
 public void setEmpId(String empId) {
  this.empId = empId;
 }
 public String getEmpName() {
  return empName;
 }
 public void setEmpName(String empName) {
  this.empName = empName;
 }
 public int getEmpAge() {
  return empAge;
 }
 public void setEmpAge(int empAge) {
  this.empAge = empAge;
 }
 public String getEmpWh() {
  return empWh;
 }
 public void setEmpWh(String empWh) {
  this.empWh = empWh;
 }
 public chu_hibernate01(String empId, String empName, int empAge,
   String empWh) {
  super();
  this.empId = empId;
  this.empName = empName;
  this.empAge = empAge;
  this.empWh = empWh;
 }
 

}

 

2.对象关系映射

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <hibernate-mapping package="com.model.pojo">
       <class name="chu_hibernate01" table="chu_table01">
          <id name="empId" column="empId" type="java.lang.String">
               <generator class="native"></generator>
          </id>
          <property name="empName" column="empName" type="java.lang.String"></property>
          <property name="empAge" column="empAge" type="int"></property>
          <property name="empWh" column="empWh" type="java.lang.String"></property>
       </class>
   
    </hibernate-mapping>

 

3.hibernate主配置文件

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<!-- Generated by MyEclipse Hibernate Tools.                   -->
<hibernate-configuration>

    <session-factory>
        <property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>
        <property name="connection.url">jdbc:oracle:thin:@localhost:1521:ORCL</property>
        <property name="connection.username">chu1</property>
        <property name="connection.password">1234</property>
        <property name="connection.driver_class">oracle.jdbc.OracleDriver</property>
        <property name="myeclipse.connection.profile">chu</property>
       
       <!--  <property name="hbm2ddl.auto">create</property> -->
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>
        <mapping resource="com/model/pojo/Chu_hibernate01.hbm.xml"/>
    </session-factory>

</hibernate-configuration>

 

 

 

4.公共的session工厂类

package com.comm;

import java.io.Serializable;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class BaseDao {
 
 static SessionFactory sf;
 //1.静态方法，随着类的加载而加载，因为dao中的每个方法都会用到加载配置文件这几行代码，因此写成静态的这样只用加载一次。
 //其实看看hibernate主配置文件我们也能发现，就一个主配置文件，加载一边就把所有内容都加载了，没必要每次访问数据库都加载一遍。
    static
    {
     Configuration c=new Configuration();
     Configuration cfg = c.configure("/hibernate.cfg.xml");//加载配置文件
     sf=cfg.buildSessionFactory();//创建sessionFactory，因此配置文件的跟标签就是这个session工厂。 
    }
    //2.通过session工厂获得session，对应着配置文件，因为session工厂里面的内容首先是连接数据库的内容，因此要获得session，这里的session相当于jdbc中的connection，用于与数据库进行连接
    public Session getSession(){
     return sf.openSession();
    }
   
    //3.封装增加的方法
    public Serializable save(Object obj){
     Session session=null;
     Transaction tr=null;
     Serializable ser=null;
  try {
   session = this.getSession();//获得session
   tr=session.beginTransaction();//开启事务
   ser=session.save(obj);//增加的方法，返回值是一个序列化后的id
   tr.commit();//事务提交
  } catch (Exception e) {   
   e.printStackTrace();//楚翔异常，异常处理相当于事务回滚
  }finally{
   session.close();//关闭session
  }
  return ser;
    }
  
}

 

5.dao层实现

package com.model.dao.impl;

import java.io.Serializable;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Property;
import org.hibernate.criterion.Restrictions;

import com.comm.BaseDao;
import com.model.dao.TestDao;
import com.model.pojo.chu_hibernate01;

public class TestDaoImpl extends BaseDao implements TestDao{
    //1.添加的方法，返回值是serialiazble
 @Override
 public int addEmp(chu_hibernate01 emp) {
  Serializable ser = super.save(emp);
  return Integer.parseInt(ser.toString());
 }
 //2.Query查询全部，测试from语句（用类名）。单条查询是get
 @Override
 public List<chu_hibernate01> searchEmp() {
  String hql="from chu_hibernate01 where empWh like ?";
  Session session = super.getSession();
  Query query=session.createQuery(hql);//query查询，因为是查询没有对数据库造成影响，因此可以不创建事务
  query.setString(0, "%本科%");
  return query.list();
 }
 //3.Query查询全部:测试select语句查询,用类名，因为有对象关系映射，所以都是类名 
 public List<Object[]> searchEmp2(){
  String hql="select empName,empWh from chu_hibernate01 where empWh like ?";
  Session session=super.getSession();
     Query query=session.createQuery(hql);
     query.setString(0, "%本科%");
  return query.list();
 }
 //4.测试集合函数和uniqueResult方法。
 public List searchEmp3() {
 Session session=super.getSession();
 String hql="select max(empAge),min(empAge) from chu_hibernate01";
 Query query=session.createQuery(hql);
 Object obj=query.uniqueResult();//找出唯一结果，当这个集合中就一行的时候就能用这个方法
 return query.list();
 }
 
 //5.Criteria对象查询，也叫在线查询。对象查询是把查询的where条件都封装到对象里了。
 public List<chu_hibernate01> searchEmp4() {
  Session session=super.getSession();
  Criteria c = session.createCriteria(chu_hibernate01.class);//创建对象查询语句，并指明要查的是哪个类。此时表明查询当前这个类，相当于hql=from chu_hibernate01
  c.add(Restrictions.disjunction());//相当于1=1
  c.add(Restrictions.eq("empAge", 23));//下面是设置查询条件,也就是限制结果集。Restrictions是限制的意思
  c.add(Restrictions.like("empWh", "本"));
  c.addOrder(Order.desc("empName"));
  //c.add(Criterion)//注意：Criterion是查询条件
  //上面的几行代码相当于像数据库发送hql="from chu_hibernate01 where 1=1 and empAge=23 and empWh like "%本% order by empWh desc";
  return c.list();//产生查询结果，是个集合
 }
 
 
 //注意：Restrictions是限制结果集，里面直接把查询条件写死，Property是也是限制结果集，但是具体怎么现在不少写死的，而是由dc对象给传过来的。
 
 //6.离线查询,查询条件封装到形参DetachedCriteria中了。离线查询的意思是脱离了session对象。可以从session之外的地方传入一个DetachedCriteria对象来当查询条件。
 //get单条查询，query查询全部，Criteria对象查询语句都必须由session创建，例如session.get,session.createquery等。离线查询与session无关。
 //因此，离线查询需要一个形参DetachedCriteria，他用来封装查询条件。
 /*public List<chu_hibernate01> searchEmp5(DetachedCriteria dc){
  Session session=super.getSession();
  Criteria c = session.createCriteria(chu_hibernate01.class);
  c.add(Property.forName("empAge").gt(dc));//这里的意思是找年龄empAge大于dc对象的，dc对象是在当前session之外获取的，dc对象里设置empAge属性的值为平均年龄
  c.add(Property.forName("empName").like(dc));
  return c.list();
 }*/
 
 //7.离线查询，dc封装的是整个sql语句。整个查询语句都由形参dc给定。并通过dc.getExecutableCriteria(session)把dc这个查询语句给当前这个session。
 public List<chu_hibernate01> searchEmp5(DetachedCriteria dc){
  Session session=super.getSession();
  Criteria c = dc.getExecutableCriteria(session);
  
  return c.list();
 }
 
 
  public static void main(String[] args) {
   TestDao tdao=new TestDaoImpl();
  
   //1.
   /* chu_hibernate01 emp=new  chu_hibernate01();
     emp.setEmpId("110");
  emp.setEmpName("小强");
  emp.setEmpAge(23);
  emp.setEmpWh("本科");
  tdao.addEmp(emp);*/
  
  
   //2.
 /*  List<chu_hibernate01> elist = tdao.searchEmp();
   for(chu_hibernate01 emp:elist){
   System.out.println("输出："+emp.getEmpName()+"\t"+emp.getEmpWh());
   }*/
  
  
  
 //  3.注意：使用select语句查询的时候，返回的list集合是个Objet[]类型的，由于list集合中的每一个元素都代表数据库中的一行（或者实体类的一个对象），
    // 所以集合中的每个元素都是一个object类型的数组，该数组表示该行，数组中的每个元素表示该行中的每一列。
   //因此，该集合的泛型必定是Object[]
  /* List<Object[]> list=tdao.searchEmp2();
   for(Object[] obj:list){//list集合中的每个对象都是一耳光object[]类型的数组，该数组表示一个对象，数组中的元素是该对象的元素。
    System.out.println(obj[0]+"\t"+obj[1]);
   }*/
  
  
   //4.
   /*List list=tdao.searchEmp3();
   Object[] obj=(Object[]) list.get(0);
   System.out.println(obj[0]+" "+obj[1]);*/
  
  
   //5对象查询
  /* List<chu_hibernate01> elist=tdao.searchEmp4();
   for(chu_hibernate01 emp:elist){
    System.out.println(emp.getEmpName()+" "+emp.getEmpAge()+" "+emp.getEmpWh());
   }*/
  
  
  
  
  //6.创建DetachedCriteria对象封装查询员工的条件。Property是对某个字段进行查询条件的设置。forName里面是属性名
   //DetachedCriteria类使你在一个session范围之外创建一个查询，并且可以使用任意的 Session来  执行它。  

 /*  DetachedCriteria dc = DetachedCriteria.forClass(chu_hibernate01.class)
   .setProjection(Property.forName("empAge").avg());
  // .add(Restrictions.like("empName", "%本科%"));
  
   List<chu_hibernate01> elist=tdao.searchEmp5(dc);
   for(chu_hibernate01 emp:elist){
    System.out.println(emp.getEmpName()+" "+emp.getEmpWh()+" "+emp.getEmpAge());
   }*/
  
   //7.这里写好一个完整sql语句
   DetachedCriteria dc = DetachedCriteria.forClass(chu_hibernate01.class)
     .add(Restrictions.like("empWh", "%本科%"));
  
   //遍历的过程
   List<chu_hibernate01> elist=tdao.searchEmp5(dc);
   System.out.println(elist.size());
   for(chu_hibernate01 emp:elist){
   
    System.out.println(emp.getEmpName()+" "+emp.getEmpWh()+" "+emp.getEmpAge());
   }
  
  }
 
}