package com.imooc.reflect.homework;

/**
 * 2-6练习，反射，goods实体类
 */
public class Goods {
    private  Integer id;
    private String name;
    private  Float price;
    private  String desc;

    //无参
    public  Goods(){

    }
    //有参

    public Goods(Integer id, String name, Float price, String desc) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.desc = desc;
    }
    //get/set

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Float getPrice() {
        return price;
    }

    public void setPrice(Float price) {
        this.price = price;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }
    //toString

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

    /**
     * 更改商品描述
     * @param desc
     */
    public Goods display(String desc){
        this.setDesc(desc);
        System.out.println(this.getName()+"更改后的商品描述："+this.getDesc());
        return  this;
    }
}

package com.imooc.reflect.homework;

import java.lang.reflect.Constructor;
package com.imooc.reflect.homework;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

/**
 * 通过反射调取对象信息，2-6练习
 */
public class GoodsTest {
    public static void main(String[] args) {
        //加载类,获取Goods类
        try {
           Class goodsClass= Class.forName("com.imooc.reflect.homework.Goods");
           //获取带参构造对象
           Constructor constructor = goodsClass.getConstructor(new Class[]{
                    Integer.class,String.class,Float.class,String.class});
           //通过带参构造对象，获取goods类实例化带参对象
            Goods goods=(Goods)constructor.newInstance(new Object[]{
                    001,"mooc手机",3999f,"6.58英寸大屏,超长待机"
            });
            System.out.println("原始商品信息：");
            System.out.println(goods);

            //通过反射，类对象获取对应方法对象
            Method goodsMethodDisplay = goodsClass.getMethod("display", new Class[]{String.class});
             //执行对应方法，invoke() 参数1，要执行方法的对应对象，参数2，传值；
            goodsMethodDisplay.invoke(goods,new Object[]{"6.58英寸大屏,超长待机,超级快充，6400万高清四摄"});
            System.out.println(goods);


        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

之前method有点问题：

Employee employee=(Employee)constructor.newInstance(new Object[]{
100,"李磊",3000f,"研发部"
});

已经通过反射创建了对象，为什么还要再次反射去创建method对象呢，为什么不直接通过反射创建到的对象调用方法呢？ 

老师这边是为了讲解吧，其实都可以是把。 

问题2：到方法内只有一个参数的时候，能这样写吗

employeeClass.getMethod("updateSalary", Float.class);

3/

 goodsMethodDisplay.invoke(goods,new Object[]{"6.58英寸大屏,超长待机,超级快充，6400万高清四摄"});
            System.out.println(goods);

好奇怪，这样写也可以得到结果，是为什么呢？是因为最后return this吗？ 返回的是当前对象，set覆盖了吧。 那就不用转型了阿。 直接输出就好了吧。省代码了。 

Employee employee1=(Employee) updateSalaryMethod.invoke(employee,new Object[]{1000f});
System.out.println(employee1);