《java基础》- 胖菜鸟说类

先扯两句

  懒人的最怕就是他还是个完美主义者，真想要做什么事的时候，总发现缺点什么，然后就总想要补上缺少的部分。而每次补充上一个缺憾的时候，又会发现新的缺憾，然后。。。我也就经历了写《工厂模式》–>《泛型》–>《接口》–>《类》这样一个看似没有什么关联，却又好像千丝万缕剪不断理还乱的折磨中。

  因为这部分主要是我自己的学习笔记，如果大家想要看一些官方点的入门知识点介绍，也可以去菜鸟教程-Java 对象和类看看。

  希望这次写的时。候不会再有其他拓展了吧，不扯废话了，再不开始不知道一会会不会又想到什么东西了。

正文

  首先大家都知道的java是面向对象的语言，对于什么是面向对象，什么是面向过程，为了防止一拓展又不知拓展到哪里去了，这里就多说了，大家如果想要了解的话，这里也找到了一篇面向过程 VS 面向对象，大家可以去看看。

  我们这里只是来说说什么是对象？很简单，一个被玩坏的梗就是“女朋友”。但是从java的角度上来说，放眼望去，你的所见、所知、所感都可以成为我们代码中的对象。

  为了方便说明，这里还是使用“想得却不可得，你奈人生何”的女朋友作为例子吧：

类

/**
 * 女朋友
 */
public class GirlFriend{
    
}

@Test
public void create() {
    // 创建一个女朋友
    GirlFriend girlFriend = new GirlFriend();
}

  上面的GirlFriend就是将女朋友这个对象，通过java类的形式具象到代码中。也就是《Java对象和类》所说的：

  类可以看成是创建Java对象的模板。

  当然，上面的只是一个最最简单的类，就好像我现在的状态，我的女朋友啊，是现阶段我最熟悉的陌生人，她的一切我都一无所知，所以只能含着泪创建这么一个空的类了。

属性

  可是每当午夜时分睡不着觉的时候，难免会去想，她叫什么名字？哪天生日？性格如何？家住何方？喜欢吃甜的还是辣的…而当我们逐渐去幻想这种种的时候，我的女朋友自然就变得具象起来，她也就不再是一个空的类了，而是变得丰满了起来（咳咳，不是体型啊）。而这关于她的种种信息，就是这个类的属性。

/**
 * 女朋友
 */
public class GirlFriend{
    /**
     * 姓名
     */
    private String name;
    /**
     * 生日
     */
    private long birthday;
    /**
     * 性格
     */
    private String character;
    /**
     * 地址
     */
    private String address;
    /**
     * 口味
     */
    private String flavor;
}

方法

  别问我为什么用private不用public，那是我女朋友，我都不知道，会告诉你！！！可转念一想，我这未来女朋友将所有的个人信息都私有，确实很安全，但是我什么时候能找到她、了解她、爱护她啊？这可不行，于是做出了如下调整。

/**
 * 女朋友
 */
public class GirlFriend {
    /**
     * 口味：甜
     */
    public static final String FLAVOR_SWEET = "爱吃甜食";
    /**
     * 口味，辣
     */
    public static final String FLAVOR_HOT = "爱吃辣食";

    /**
     * 口味约束，只能爱吃这两种口味
     */
    @Retention(RetentionPolicy.SOURCE)
    @StringDef({FLAVOR_SWEET, FLAVOR_HOT})
    @interface FlaverType {
    }

    /**
     * 日期格式化工具类
     */
    private SimpleDateFormat dateFormat;
    /**
     * 日期类
     */
    private Date date;


    /**
     * 姓名
     */
    private final String name;
    /**
     * 生日
     */
    private final long birthday;
    /**
     * 性格
     */
    private String character;
    /**
     * 地址
     */
    private String address;
    /**
     * 口味
     */
    private String flavor;

    /**
     * 构造方法，女朋友出生了
     *
     * @param name 我未来岳父岳母给取的名字
     * {@link GirlFriend#birthday 出生的时候就是她的生日了}
     */
    public GirlFriend(String name) {
        this.name = name;
        this.birthday = System.currentTimeMillis();
    }

    public String getName() {
        return name;
    }

    public long getBirthday() {
        return birthday;
    }

    public String getCharacter() {
        return character;
    }

    public void setCharacter(String character) {
        this.character = character;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getFlavor() {
        return flavor;
    }

    public void setFlavor(@FlaverType String flavor) {
        this.flavor = flavor;
    }

    /**
     * 获取年龄
     *
     * @return 年龄（被询问的年份 - 出生的年份）
     */
    public int getAge() {
        return getYear(System.currentTimeMillis()) - getYear(birthday);
    }

    /**
     * 获取时间戳对应的年份
     *
     * @param time 时间戳
     * @return 年份
     */
    private int getYear(long time) {
        if (null == dateFormat) {
            // 若日期格式化工具类不存在，则构造格式化工具类
            dateFormat = new SimpleDateFormat("YYYY", Locale.getDefault());
        }
        if (null == date) {
            // 若日期类不存在，则构造日期类
            date = new Date(time);
        } else {
            // 若日期类存在，则为日期类设置新的用于转换年份的时间戳
            date.setTime(time);
        }
        return Integer.parseInt(dateFormat.format(date));
    }
}

构造方法

/**
 * 构造方法，女朋友出生了
 *
 * @param name 我未来岳父岳母给取的名字
 * {@link GirlFriend#birthday 出生的时候就是她的生日了}
 */
public GirlFriend(String name) {
    this.name = name;
    this.birthday = System.currentTimeMillis();
}

  构造方法，顾名思义，就是构造这个类的时候使用的，而构造方法除了构造类以外，还可以做的就是为类中的一些属性赋初值，比如我未来女朋友的姓名和生日。

  而赋初值的方式也有两种：

   1. 外部传入：无法明确生成信息的具体条件、需要根据构造时外界的具体情况产生（一个孩子出生之前，不可能明确知道自己的名字是什么，别说父母从有孩子一定就开始想了，毕竟这个世界上最不差的就是意外）。


   2. 自动生成：在生成的时候，不受到构造时外界的相关条件影响，可以依据自身或者系统的条件直接生成（无论中间的过程是什么样的，但是在一个人出生的那一瞬间必然是她的生日，这是无论如何都无法改变的）。

get/set方法

   与类的属性产生交互，对属性进行添加、删除、编辑的方式就是方法，而这里首先说一下直接与属性产生关联的get和set方法。其实这部分是最简单的部分。就是对类的属性进行直接的添加（也可以是编辑）或者获取。

   比如成年了要除外打拼工作，可能需要找地方租房子，而每租一次房子，地址必然会随着变化一下，所以就需要：

/**
 * 设置/更新地址
 *
 * @pparam address 最新地址
 */
public void setAddress(String address) {
    this.address = address;
}

   同样，在她需要快递买东西的时候，肯定是需要填写收货地址的，这个时候自然少不了需要使用到：

/**
 * 获取当前最新的地址
 *
 * @return 地址
 */
public String getAddress() {
    return address;
}

   可能有人会问，地址、口味可能会发生变化，但是性格为什么没有放到构造方法中，反而放到了set中赋值呢？

   这里就把庞龙的一句歌词分享给大家，算是成长的无奈吧。不过其实磨掉尖牙也没什么不好，至少可以滚的更快啊！如果正经点，那就是不用担心拥抱时，会刺伤对方，不是吗？

业务逻辑方法

   当然，现实生活中，我们谁都不可能这么直来直去的set或者get类中的属性，有很多的业务逻辑是需要额外的方法去实现的，就比如我找女朋友的时候肯定要问对方，“你今年多大了？”（虽然问女生年纪很不礼貌，但是实在生日有些大，从小喜欢装大哥哥，实在不想找个小姐姐），这个时候女生总不能说，我是XX年的，你自己算去吧。

   这个时候就需要了getAge方法，通过“被问年纪的年份”减“出生年份”的方式，来获取女朋友的年纪。

  不过在编写的过程中大家会发现，没计算一次年纪，都需要有两次将时间戳转换为年份的操作（生日的时间戳、被问时的时间戳）。所以从面相对象的思想来说，一旦有相同的流程被反复使用到的时候，就可以考虑封装了，因此这里额外添加了一个将时间戳格式化为年份的私有方法。

  同样，一个人的一生中，不可能只被一次年纪，所以没次被问年纪，都去创建一个SimpleDateFormat（日期格式化工具）、Date（时间戳的日期工具）还是很耗费资源的，万一消耗太多资源，把我素未谋面的女朋友饿瘦了，我会心疼的。所以这里就将这两个方法提取了出来做成全局变量属性，只有第一次调用时才会创建，之后只是拿来引用就好了。（培养女朋友节省，名牌包能用的时候就不用买新的了）。

/**
 * 获取年龄
 *
 * @return 年龄（被询问的年份 - 出生的年份）
 */
public int getAge() {
    return getYear(System.currentTimeMillis()) - getYear(birthday);
}
/**
 * 获取时间戳对应的年份
 *
 * @param time 时间戳
 * @return 年份
 */
private int getYear(long time) {
    if (null == dateFormat) {
        // 若日期格式化工具类不存在，则构造格式化工具类
        dateFormat = new SimpleDateFormat("YYYY", Locale.getDefault());
    }
    if (null == date) {
        // 若日期类不存在，则构造日期类
        date = new Date(time);
    } else {
        // 若日期类存在，则为日期类设置新的用于转换年份的时间戳
        date.setTime(time);
    }
    return Integer.parseInt(dateFormat.format(date));
}

方法初始化参数的约束

  在方法初始化的时候，大家应该看到一段很怪异的代码，或者说是不太常见的一段代码，那就是我们的口味约束：

/**
 * 口味：甜
 */
public static final String FLAVOR_SWEET = "爱吃甜食";
/**
 * 口味，辣
 */
public static final String FLAVOR_HOT = "爱吃辣食";
/**
 * 口味约束，只能爱吃这两种口味
 */
@Retention(RetentionPolicy.SOURCE)
@StringDef({FLAVOR_SWEET, FLAVOR_HOT})
@interface FlaverType {
}

/**
 * 获取当前当前喜欢的口味
 *
 * @return 喜欢的口味
 */
public String getFlavor() {
    return flavor;
}
/**
 * 设置口味偏好
 *
 * @param flavor 口味偏好（约束只能选择甜的和辣的）
 */
public void setFlavor(@FlaverType String flavor) {
    this.flavor = flavor;
}

  这部分就是对于方法传入参数的约束，因为在传入参数的，我们很多时候并不能让这个类的使用者随便乱传，比如：你不能说一个人有四条腿一样（别问我为什么没举例“人不能有三条腿”，自己想去）。而这里就我个人而言对口味有这么两点“刻板印象”

1. 喜欢吃甜食的妹子呆萌可爱
2. 喜欢吃辣食的妹子简单直爽

  因此给我的女朋友添加限制只能喜欢这两种口味的食物，这样在女朋友去更新自己的口味偏好的时候，就只能选择“甜食”或者是“辣食”了，一旦选择其他的口味，则会报错，提示我这不是我女朋友应该喜欢的口味：

  这里的约束使用的注解，会在后续的注解中加以说明，大家可以自行先查看一下约束的内容都是上面含义，当然，偷懒的方法也可以在封装框架的时候直接模仿着来写，只是建议还是知其然也要知其所以然。

再扯两句

  总算是在拓展的枝丫中完成了第一个部分，其实说起来，类的概念还是比较基础的，其实也没有太多可说的，但是实在单身久了，算是借着写类的机会，呼唤一下我那最熟悉的陌生女朋友吧。

  不过这么写起来，其实发现类还挺好玩的，忍不住又要在接口前面加个抽象方法。哎，泛型又要延期了，我的工厂模式啥时候才能开始啊。。。

鸣谢

• 哭得像个孩子：Pixabay的Gerd Altmann
• 劫匪要求孩子跟他姓：抖音免费播放《大赢家》（真没有广告费）
• 两位数减法好难：爱情公寓