Java构造方法的作用

构造方法的作用

构造方法的作用之一就是实例化对象，之前对此一直都不是很了解，为什么要实例化对象呢？我们知道对象具有一定的属性，例如姓名，年龄，身高等，我们在定义类的时候就得要定义这些属性，但是实例化的意思是什么呢？就是通过这些属性，把这些人实际的表达出来，通过属性或方法来实例一个人。

[java] view plain copy

1. public Person{//定义了一个人的属性，具备一些特征和功能  
2.     String name;  
3.     int age;  
4.     float  height;  
5.     void talk(){};  
6. //我们可以将定义的属性和方法组合起来，就可以组合成一个人了  
7.     Person(String name,int age,float height){  
8.     This.name=name;  
9.     This.age=age;  
10.     This.height=height;   
11. }  
12. }  
13. //组合完成之后，便可以定义不同的人了  
14. Public class Gouzao{  
15.     Public static void main(String[] args){  
16.     Person    ren1=new Person(“张三”，20,180)；  
17.     ren1.talk();  
18.     Person    ren2=new Person(“李四”，25,170)；  
19.     ren2.talk();  
20.     Person    ren3=new Person(“王二”，30,185)；  
21.     ren3.talk();  
22. <span style="white-space:pre">    </span>}  
23. }  

如果没有构造方法，我们得要这样写：Person   ren1=new Person();

Ren1.name=(“张三”);   ren1.age=20; ren1.height=180;  多麻烦……所以用构造方法，相当于建立了一个代码块，直接填充进去就可以……

----------------------------------------------------------分割线-------------------------

封装的高复用泛型类，运用了构造方法，以及创建成功的返回方法，和错误的放回方法

 

package com.mmall.common;

import com.sun.org.apache.regexp.internal.RE;
import org.codehaus.jackson.annotate.JsonIgnore;
import org.codehaus.jackson.map.annotate.JsonSerialize;

import java.io.Serializable;

/**
 * Created by qxl on
 * 2018/4/6
 *
 * 1. 高封装类
 * 2. 序列化的结果返回给前端
 * 3.有的时候需要返回data （对象），有的时候不需要，
 * 4.不要null
 * 5. 如果只需要status，可以直接返回status。没有msg 没有data
 * /**
 *
 * 在我们使用泛型类的时候，虽然传入了不通的泛型实参，但并没有真正意义上生成不通的类型
 * 传入不通泛型实参的泛型类在内存上只有一个，即还是原来的最基本的类型，本实例中为ox,
 * 当然，在逻辑上我们可以理解成多个不通的泛型类型
 *
 * 究其原因，在余java泛型的这一概念提出的母的，导致其只是作用与代码编译阶段，在编译过程中，
 * 对于检验法宁结果后，会将法宁的相关信息擦出，也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段
 *
 * 对此总结成一句话： 泛型类型在逻辑上看以看成是多个不通的类型，实际上都是相同的基本类型。
 *
 */

@JsonSerialize( include = JsonSerialize.Inclusion.NON_NULL)
// 不要null  报纸序列化json时候，如果是null的对象，key也会消息
// 返回json中去除null字段
public class ServerResponse<T> implements Serializable {

    //status   跟ajax返回的一致
    private int status;
    //info
    private String msg;
    //对象
    private T data;
    //构造方法
    private ServerResponse(int status){
        this.status =status;
    }
    private ServerResponse(int status,T data){
        this.status =status;
        this.data = data;
    }
    private  ServerResponse(int status,String msg){
        this.status =status;
        this.msg = msg;
    }

    private ServerResponse(String msg){
        this.msg = msg;
    }
    private ServerResponse(int status,String msg,T data){
        this.status =status;
        this.msg = msg;
        this.data = data;
    }
    /**
     * 疑点 ：T任意对象  用String到底是哪一个
     */
   /* public static void main(String[] args) {
        ServerResponse sr1 =new ServerResponse(1,new Object());
        ServerResponse hello = new ServerResponse(1, "hello");
        System.out.println("console");
    }*/

    /**
     * 是否成功 0成功  1失败
     * @return
     */
    /**
     * boolean 显示在json中
     * 1、加注解 @JsonIgnore 就不会显示在json里面
     * @return
     */
   @JsonIgnore
   //不在json序列化结果之中
   public  boolean isSuccess(){
        //是0状态成功  1状态是失败
        return this.status == ResponseCode.SUCCESS.getCode();
   }
    //这三个就在
   public  int getStatus(){
       return status;
   }
   public   String getMsg(){
       return msg;
   }
   public T getData(){
       return data;
   }

    /**
     * 創建成功 返回一個status状态
     * @param <T>
     * @return
     */
   public static <T> ServerResponse<T> createBySuccess (){
       return new ServerResponse<T>(ResponseCode.SUCCESS.getCode());
   }

    /**
     * 成功返回 和 消息
     * @param msg
     * @param <T>
     * @return
     */
   public  static <T> ServerResponse<T> createBySuccessMessage(String msg){
        return new ServerResponse<T>(ResponseCode.SUCCESS.getCode(),msg);
   }

    /**
     * 成功状态   和 对象
     * @param data
     * @param <T>
     * @return
     */
   public  static <T> ServerResponse<T> createBySuccessData(T data){
        return new ServerResponse<T>(ResponseCode.SUCCESS.getCode(),data);
   }

    /**
     *  成功状态  和 消息  对象
     * @param msg
     * @param data
     * @param <T>
     * @return
     */
   public  static <T> ServerResponse<T> createBySuccessData(String msg,T data){
        return new ServerResponse<T>(ResponseCode.SUCCESS.getCode(),msg,data);
   }

    /**
     * 错误
     * @param <T>
     * @return
     */
   public  static <T> ServerResponse<T> createByError(){
       return new ServerResponse<T>(ResponseCode.ERROR.getCode());
   }

    /**
     * 错误的状态  和 消息
     * @param errormsg
     * @param <T>
     * @return
     *  类上的泛型是对象的
        静态的只能自己定义泛型
     */
   public  static <T> ServerResponse<T> createByErrorMessage(String errormsg){
       //返回值是ServerResponse  实例化的每個返回值都是構造方法。 所以可以
        return new ServerResponse<T>(ResponseCode.ERROR.getCode(),errormsg);
   }

    /***
     *  参数错误   需要登录，code做成变量，
     *  参数错误的话，需要暴露出来
     * @param errormsg
     * @param <T>
     * @return
     */
    public  static <T> ServerResponse<T> createByErrorCodeMessage(int errorcode,String errormsg){
        return new ServerResponse<T>(errorcode,errormsg);
    }

    }