原文作者：deors 

  原文地址：https://deors.wordpress.com/2011/09/26/annotation-types/ 

  译文作者：Jianan - qinxiandiqi@foxmail.com 

  版本信息：本文基于2015-10-09版本进行翻译 

  版权声明：经原作者许可进行翻译，保留所有权利，未经允许不得复制和转载。




从本文开始，我将开始写一系列关于Java语言使用注解处理器生成代码的文章，包括这种方法的强大之处。最后还会描述如何确保在编译的时候使用这种方法生成源代码。

在这系列文章中，我们将会：

介绍Java语言的注解。
了解注解的常用方式以及使用范围。
了解注解处理器以及它们所代表的角色。
学习如何创建注解处理器。
学习如何在终端命令行、Eclipse和Maven中运行注解处理器。
学习如何使用注解处理器生成源代码。
学习如何使用像Apache Velocity这样的外部模板引擎来使用注解处理器生成源代码。  



序

Java的注解从第三版的Java语言规范(1)中开始引入，并在Java 5中开始支持。

通过注解，我们可以为源代码添加元数据信息，包括编译或部署信息、配置属性、编译行为或者代码质量检查。

与Javadoc不同，注解属于强类型，用到的注解在类路径下都能找到对应的注解类型定义。因此，定义的注解可以在运行时访问到，而Javadoc是不可能的。




注解语法

注解通常出现在被注解的代码段前面，通常情况下都是独立成行并且与代码段同样缩进。

注解可以添加到package（包）、types（类型，包括类、接口、枚举和其它注解类型）、variable（变量、包括class、类实例、局部变量——包括定义在for或者while循环里面的局部变量）、constructions（构造方法）、methods（方法）和parameters（参数）。

最简单的注解结构就是内部什么元素都没有，例如：

@Override()
public void theMethod() {…}

在这个例子中，括号可以省略（因为没有参数）：



@Override
public void theMethod() {…}

注解也可以包含元素，这些元素是通过逗号分隔的键值对。允许使用的值类型包括java原生数据类型、String类型、枚举类型，以及这些类型的数组形式：



@Author(name = "Albert",
        created = "17/09/2010",
        revision = 3,
        reviewers = {"George", "Fred"})
public class SimpleAnnotationsTest {…}

当注解内部只有一个元素，并且这个元素名为value的时候，元素名可以省略：



@WorkProduct("WP00000182")
@Complexity(ComplexityLevel.VERY_SIMPLE)
public class SimpleAnnotationsTest {…}

注解可以为内部一些元素或者全部元素都设置默认值。在使用这类注解的时候，具备默认值的元素可以省略。

例如，假设有个注解为Author，它为内部元素revision（默认为1）以及reviewers（默认为空String数组）设置了默认值，下面使用这个注解的两种方式是等效的：



@Author(name = "Albert",
        created = "17/09/2010",
        revision = 1,
        reviewers = {})
public class SimpleAnnotationsTest() {…}
@Author(name = "Albert",        // defaults are revision 1
        created = "17/09/2010") // and no reviewers
public class SimpleAnnotationsTest() {…}




注解的典型使用

Java语言规范中定义了三种注解类型——它们都用于Java编译器：

@Deprecated： 用来声明被注解的元素不应该再使用。每当这个注解被使用的时候，编译器就会生成一个警告。它应该与Javadoc的@deprecated一起使用，在Javadoc中解释舍弃被注解元素的原因。
@Override： 用来声明被注解的元素重写了父类中声明的元素。如果被注解的元素没有在父类中找到对应的被重写的元素，编译器就会生成一个警告。尽管这个注解没有要求一定要使用，但是它对于错误判断非常有用——例如，如果在创建父类之后，有人又修改了父类方法的签名，那么我们在重新编译源代码的时候就能马上得到提醒。
@SuppressWarnings： 让编译器抑制指定的警告类型，否则被注解的元素就会触发这类警告——例如，为了避免使用了被舍弃的API或者与旧代码（例如Java 5之前的版本）进行了未检查的交互而产生过多的编译器“干扰”。
自从引入这些注解后，很多库和框架都将注解集成到它们新的发行版本中。通过在源代码中使用注解，这些库和框架都简化甚至移除了所需要的配置文件。

下面是一些成功使用注解的例子：

Java企业版和它的主要模块——企业级JavaBeans、Java持久化API或者Web Service API。
Spring框架——用于核心模块中的配置、依赖注解和控制反转中，以及其它一些Spring项目。
Sean、Weld、Guice.
Apache Struts 2.  



注解类型

在Java语言中注解类型是一种特殊的接口，用来自定义注解。

注解的定义要使用@interface关键字来代替interface：

public @interface Author {
    String name();
    String created();
    int revision() default 1;
    String[] reviewers() default {};
}
public @interface Complexity {
    ComplexityLevel value() default ComplexityLevel.MEDIUM;
}
public enum ComplexityLevel {
    VERY_SIMPLE, SIMPLE, MEDIUM, COMPLEX, VERY_COMPLEX;
}

注解类型与普通的接口有一些区别：

只允许原生数据类型、String、枚举、class，以及这些类型的数组。注意注解类型中不允许常用的对象，也不允许数组的数组（因为每一个数组都是一个对象）。
注解元素的定义与定义方法的语法很类似，但是不允许有修饰符和参数。
注解元素的默认值定义需要使用default关键字，后面连接字面量、初始化数组或者枚举值。
正如其它的类或者接口，枚举类型也可以嵌套在注解类型的内部：



public @interface Complexity {
    public enum Level {
        VERY_SIMPLE, SIMPLE, MEDIUM, COMPLEX, VERY_COMPLEX;
    }
    …
}




用于定义注解的注解

JDK自带了一些注解，用于修改我们自定义的注解的默认行为。

@Documented： 声明被@Documented注解后的注解类型，一旦使用，被注解的元素就应该连同注解都记录到Javadoc中。
@Inherited： 声明被注解的注解类型能够继承到它的子类上。通过这种方法，如果当前子类没有受@Inherited注解的注解类型注解过，但是它的父类有，那么当前子类也能通过继承得到这个注解类型。不过它只适用于类继承，不适用于接口实现。
@Retention： 声明被注解的注解类型生命周期。可选的值都包含在RetentionPolicy枚举中：CLASS（默认值——能被包含到class文件中，但是在运行时访问不到），SOURCE（创建class文件的时候会被编译器丢弃），RUNTIME（能够在运行过程中访问到）。
@Target： 声明注解类型能够注解的元素类型。可选的值包含在ElementType枚举中：ANNOTATION_TYPE（用于注解类型），CONSTRUCTOR（用于构造方法），FIELE（用于成员变量），LOCAL_VARIABLE（用于局部变量），METHOD（用于方法），PACKAGE（用于包），PARAMETER（用于方法参数），TYPE（用于类、接口、枚举）。
本系列将会在第二部分中继续讲解：注解处理器。请阅读这里.

项目代码优化：
每页显示商品记录数在代码中原来是定义的一个类常量，因为在代码中多次使用到，因此在这个实现类中定义了一个类常量。

使用

和

这样的代码运行是没有任何问题的，但是对于以后的代码维护和程序的灵活扩展都是不好的，就算是定义了类常量，也是属于硬编码问题。这里我们可以使用Java推荐使用的枚举。
那么Java枚举是怎么使用的呢？
学习C++的时候使用过，但是Java没有怎么使用过，有些遗忘，C++和Java中的枚举还是比较相似的，先来看看Java枚举的基本使用
Java 语言中定义枚举也是使用关键字enum

上述定义了一个枚举类型 Color（可以说是类，因为代码编译之后是Color.class字节码文件，这个和接口还是蛮相似的）.
上面的定义，还可以改成下面的这种形式

其实，枚举的成员就是枚举对象，只不过他们是静态常量而已。
使用javap命令（javap 文件名<没有后缀.class>）可以反编译 class 文件使用CMD先编译这个Java源文件Color.java，再使用javap Color命令反编译：

我们可以使用普通类或者接口来模拟枚举，下面定义一个Color类。

对比一下，就明白了，如果按照这个逻辑，是否还可以为其添加另外的构造方法？答案是肯定的！

为Color声明了两个成员变量，并为其构造带参数的构造器。
如果你这样创建一个枚举是错误的。

对于类来讲，最好将其成员变量私有化，然后，为成员变量提供 get、set 方法。
按照这个原则，可以进一步写好枚举Color.

但是，java设计enum的目的是提供一组常量，方便用户设计。
如果我们冒然的提供set方法（外界可以改变其成员属性），好像是有点违背了设计的初衷。那么，我们应该舍弃set方法，保留get方法。

普通类，我们可以将其实例化，那么，能否实例化枚举呢？在回答这个问题之前，先来看看，编译之后的Color.class 文件

可以看出，编译器为其构造方法加上了private，那么也就是说，我们无法实例化枚举。
所有枚举类都继承了Enum类的方法，这点可以从反编译出来的源码看到，包括toString 、equals、hashcode 等方法。
因为equals、hashcode方法是被final修饰的，所以不可以被枚举重写（只可以继承）。
但是，可以重写toString方法。

我们可以看一下Enum源码

对于枚举的使用可以看考博客：
Java 枚举(enum) 详解7种常见的用法 
地址：http://blog.csdn.net/qq_27093465/article/details/52180865
对于定义的枚举Color，简单测试一下：

结果：

具体应用：
定义枚举

使用枚举

和

java1.5发行版本中增加了泛型。在没有泛型之前，从集合中读取到的每一个对象都必须进行装换。如果有人不小心插入了类型错误的对象，在运行时的装换处理器就会出错。有了泛型之后，可以告诉编译器每个集合中接受那些对象类型。编译器自动为你的插入进行转化，并在编译器告知是否插入了类型错误对象。这样可以使程序更加安全，也更加清楚，但是要享有这些优势有一点的难度。

定义 

具有一个或者多个类型参数的类或者接口。

泛型类或者接口统称为泛型。

在java1.5版发行之前，没有泛型时，集合声明：



// Now a raw collection type - don't do this!

/**
 * My stamp collection, Contains only Stamp instance.
 */

private final Collection stamps = ...;


如果不小心将一个coin放进了stamp集合中，这一错误的插入照样得以编译和运行并且不会出现任何错误提示：



// Erroneous insertion of coin into stamp collection
stamps.add(new Coin( ... ));


直到从stamp集合中获取coin时才会收到错误提示。



//Now a raw interator type - don't do this !
for (Iterator i = stamps.iterator(); i.hasNext();) {
    Stamp s = (Stamp) i.next(); // Throws ClassCastException
    ... // Do something with the stamp
}


出错之后应该尽快发现，最好是编译时就发现。上述例子，直到运行时才发现错误，已经错误了很久。

有了泛型，就可以改进后的类型声明来代替集合中的这种注释，告诉编译器之前的注释中所隐含的信息：




// Parameterized collection type - typesafe
private final Collection<Stamp> stamps = ...;

通过这条声明，编译器直到stamps应该只包括Stamp实例，并给予保证，假设整个代码是利用java 1.5机器之后的编译器进行编译的，所有代码在编译国企成都没有发出任何警告。当stamps利用一个参数化的类型进行声明时，错误的插入会产生一条编译时的错误消息，准确地告诉你那里出错了。

还有一个好处是：从集合中取元素时不需要再进行手动的转换了，编译器会替你插入隐士的转换，并确保他们不会失败，无论你是否使用for-each循环，上述功能都适用。



// for-each loop over a parameterized collection - typesafe
for(Stamp s:stamps){//No cast
  // Do something with the stamp
}


或者无论是否使用传统的for循环也一样



// for loop with parameterized iterator declaration - typesafe
for(Iterator<Stamp> i=stamps.iterator();i.hasNext；{
        Stamp s=i.next();//No cast necessary
        //Do something with the stamp
}

原生态的List和参数化的类型List《Object》之间有什么区别呢？不严格的讲，前者逃避了泛型检查，后者明确告诉编译器，它能够持有任意类型的对象。虽然可以将List《String》传递给类型为List的参数，但是不能将它传给类型为List《Object》的参数。

如果使用像List这样的原生态类型，就会失掉类型安全性，但是如果使用像List《Object》 这样的参数化类型，则不会。



// Use raw type (List) - fails at runtime!
public static void main(String[] args) {
    List<String> strings = new ArrayList<String>();
    unsafeAdd(strings, new Integer(42));
    String s = strings.get(0); // Compiler - generated cast
}

private static void unsafeAdd(List list, Object o) {
    list.add(o);
}

这个程序可以运行，但是因为使用了原生态List，会收到警告。

如果在调用unsafeAdd声明中用参数化类型List代替原生态List，并试着重新编译这段程序，会发现它无法再进行编译。



//Use of raw type for unknow element type - don't do this 
static int numElementsInCommon(Set s1,Set s2){
        int result=0;
        for(Object o1:s1){
            if(s2.contains(o1)
            return result++;
        }
        return result;
}

这个倒是可以，但它使用了原生态类型，这是很危险的。从java 1.5发行版本开始，java就提供了一种安全的替代方法，称作：无限制的通配符类型。

如果要使用泛型，但不确定或者不关心实际的类型参数，就可以使用一个问号代替。例：



static int numElementsInCommon(Set<?> s1,Set<?> s2){
        int result=0;
        for(Object o1:s1){
            if(s2.contains(o1)
            return result++;
        }
        return result;
}

Set与Set《?》区别： 

后者是安全的，前者则不安全。

总之，使用原生态类型在运行时会导致异常，因此不要再新代码中使用。

作者：小傅哥

博客：https://bugstack.cn

沉淀、分享、成长，让自己和他人都能有所收获！😄

一、前言
20万行代码写完，毕业了找一份工作不是问题！
刚一毕业因为找不到工作，就得报名去参加Java培训的大有人在。并不是说参加培训就不好，只不过以你现在这个毕业的时间点参加，就会显得特别匆忙。因为你的压力既来自于培训还需要花家里一笔不小的费用，也有同班同学已经找到一份不错的工作开始赚钱的比对。
大学四年其实有足够的时间让你学会编程，也能从一个较长时间的学习中，知道自己适合不适合做程序员。就像我的同学里虽然都是计算机或者软件工程专业，但毕业后并没有都从事软件开发工作，或者从事了一段时间发现并不适合这个行业而选择到其他领域发展。
所以如果你是真的喜欢编程，那么在这个行业里工作你会很开心，如果不是那么往后路还长，你所要面对的晋升、加薪、跳槽都可能成为一道道障碍。目前可能你还是新人不了解自己是否喜欢编程开发，那么可以在以后的学习中体会，自己是否愿意为一个运行结果调来调去，辗转不寐的研究分析，只为最后那一个运行通过而激动！
当你可以在激动和开心中写完20万行代码，对于毕业后的求职找工作来说几乎可以叫你一声面霸，也可能你在实习时就被公司直接留下，这是个人才组织需要你！
20万行代码看上去很多，但放在4年的大学学习中并不会有多难。平均每天200行，一个月是6000行，一年算10个月是6万行，三年就有18万行。这20万行代码会把你从一个编程小白，带入到熟练使用Java相关API，也能给你带入到初级工程师的水平。
初学编程你可能想把一句代码完整敲下来都不容易，就更不用说运行出结果了。因此此时你的大脑和手还并不能迅速理解你眼睛里看到的这一行行代码都是啥，要干啥。这就像新买回来的钢琴手指头上去摸肯定是生硬的，敲出的声音也不连贯。这个阶段只能是照着例子大量的写，度过一个熟练期才能更好的学习。
为了可以让更多的小伙伴理解这件事，我会从我的在校、培训、外包、跳槽、阶段成长以及找什么样的工作分享给大家作为参考，最后再把我整理出资料一并分享给大家。
二、经历
12年10月25日，在CSDN发的一个帖子 拿到两个offer，一个7k，一个转正税后4.5k。求意见！ 距离现在它已经过去好久了，当时也是因为拿到了两份offer的选择纠结，所以发了个帖子求问。好气的是当时竟然不知道去面试面试互联网公司，信息太闭塞了，而且培训的地方并没有说过互联网一些公司的信息。

讲一讲我这7k的经历；

12年07月，校企合作来北京昌平一个小县城的地方参加中软培训
12年10月，培训接近尾声，开始找工作，月薪7k的中软就是最后的选择的地方，放弃了在北航院内的国家科技
12年12月，虽然拿到中软Offer但迟迟不让入职，电话联系了很多次我说可以先去实习，但都说等通知。没办法，在北京也不可能就硬待着，回家的话也麻烦行李、住宿都得折腾，所以又面了一家中科软进去实习了三个月，赚点钱养活自己
13年03月，中软的通知终于来了，但竟然是参加岗前培训，又被培训了一次，当时特别讨厌培训，每次都是讲Java基础，差点生气怼老师
13年09月，在中软正式转正，也就是说培训完又是实习，7月份毕业后9月份才入职为正式员工，心里有点不爽，埋下了一个后续跳槽的种子。哪有实习这么久的！
15年04月，第一次有跳槽准备，毕竟写了两年的C#写够了，面试了第一家互联网公司，乐视致新，不过后来没去，被公司留了下来
15年08月，之前谈的留下来涨薪，但最后少涨了1千块钱。所以继续面试，还算顺利面了两家，最后在8月25日跳槽进互联网完成。


以上整个过程就是我从学校到实习到找工作以及最后跳槽的一个阶段性经历，也有过在这条路上跌跌撞撞。就像；

虽然我面到了中软管培生，但错失没选择要北京户口，而是要了400块房补
在中软9月份从实习转正式员工，错过了第二年的入职满一年才涨薪的条件(但我觉得这个有点故意坑了)
明明是学了那么多Java，但却写了两年C#，大家还是要选择自己喜欢的语言进行工作，否则会很麻烦
提了离职，基本就不要想着再留下来，无论什么条件。哪怕钱和职位满足了，心里也有隔阂以及个人对没经历过事情的一个期许
从传统外包跳槽的互联网，并不那么容易，技术使用的不同、开发场景的不同、组织关系的不同，一切都可能是从一个较低的位置重新开始。你需要自身技术不错，也需要一个好人带
但当时在的传统也有不错的点，比如可以5:30下班，带我的经理人很不错，公司也不那么累，有时候还可以出差溜达溜达。

三、学习
一个大学生会经历在校、实习、就业几个阶段，其中在校学习属于蓄力阶段，要学习很多知识才能支撑起来将来的实习和平稳就业。
蓄力阶段的学习，主要是对编程技术的基础的夯实，以及多学习与数学相关的内容，比如；数据结构、算法逻辑，这些知识对将来在技术上的提升和造诣都是非常好的基石。下面就是整个大学过程中在编程学习过程中需要经历的阶段，如图；


熟悉工具：初学编程后你大概会接触到一系列的研发工具，包括IDEA、Eclipse、Navicat、Maven、Git、Tortoise、SourceTree、Visio、Xmind等等，工具的熟练会让编程更流畅。
编写代码：此时你需要大量写代码，写很多的代码，因为你几乎就是需要靠写代码把整个所学的编程语言熟练使用起来。总不能手生到写完 public，写不出来 class，这跟我不会弹钢琴一样，敲完了1，后面不知道要在哪找下一个音符♪了。
功能开发：小的功能开发是综合锻炼技术使用的阶段，比如做一个计算器、求一个水仙数、从一篇html中摘取你要的信息等等。此段经历会解决你之前感觉学完技术没出用的痛苦，现在你可以想象出各种场景问题，之后用代码去处理。还可以帮助英语系的小师妹，把她需要背的单词从网站中爬取下来，汇总出各类热词、语句、摘要等
项目开发：小功能练手后，接下来你就可以做做项目了。比如你常听到的图书管理系统、教师教学管理系统等等。如果觉得没有意思，你可以从哪里获取项目呢？从你用到的各类APP中，把这里用的功能简化，之后做一些项目开发。比如一个简单的商城、抽奖、全物流单号查询。另外你还可以在github中查找一些项目，去参考学习并自己动手实践。
数据结构：可能初学编程并不会对数据结构有多少思考，也想象不到这类内容是用在哪的。但其实这类技术内容早已被你天天使用，例如：LinkedList、ArrayList、HashMap，这里就包括了数组、链表、栈、队列、散列表、树、堆等各项数据结构，当你将来要开发一些较大型的互联网应用程序时，你所有的逻辑设计都会考虑到数据要如何存放，数据结构如何设计才能更合理的被程序使用。
算法逻辑：学完数据结构接下来要做的就是对算法逻辑的学习，这里不仅仅是简单的刷题，而是在数据结构的上使用算法将数据更合理的存放和读取以及做相应的操作。就像你能逐步了解的；排序、二分、旋转、洗牌等等，以及将来还会在阅读JDK源码中会看到，扰动函数、负载因子、拉链寻址、开放寻址、哈希散列、除法散列法、平方散列法、斐波那契（Fibonacci）散列法等等。
设计模式：当你开发了很多很多程序代码以后，你会逐步的思考怎么才能让这些代码有可复用性呢，怎么写才能让更多人读懂呢、怎么实现才能让再接需求时能更快的承接呢。这些都会随着你开始实习真正接触到公司级的代码开始逐步的感受到的，写代码不是一锤子买卖，也不是炫耀技术，当你有更宽的视野范围时，就会思考的更多。这里推荐阅读《重学Java设计模式》 这是一本基于互联网真实案例编写的Java设计模式实践图书。全书以解决方案为核心，从实际开发业务中抽离出交易、营销、规则引擎、中间件、框架源码等22个真实场景，对设计模式进行全面、彻底的分析。帮助读者灵活地使用各种设计模式，从容应对复杂变化的业务需求，编写出易维护、可扩展的代码结构。


以我个人经历和经验来看，想搞定这些学习范围和内容，最大的动力是来自于对编程的热爱和折腾。就像我这样做过很多土项目，如下；


串口通信、在线考试、考试抽题、彩礼管理、成绩管理、即时聊天、计算器还有后来折腾过的仿微信聊天，这些项目都可以不断的夯实个人的技术能力，每一次做新的一个项目都会把之前所遇到的问题，又考虑新的实现方式再折腾一遍。
编程的学习中重要的并不是结果，而是在这个过程中经历了什么。哪怕是犯了很多的错也没关系，因为每一次犯错都是学习的机会，都可以找到更多的资料，每一个资料里又可能教会你其他的知识。

四、就业
不只是我，可能很多在上学阶段并不知道都是做Java开发，就业的企业也分为传统行业、国企、半国企、外包、外企、互联网等这么多类型，尤其是我这样在13年毕业的时候，既没有所谓的就业指导，也没有有经验的朋友了解，就只能跟着大家走。好在现在大家可以在互联网中获取到这些信息，也就能早早的帮助毕业同学进行择业。

1. 传统行业

难度：⭐⭐
公司：金蝶、用友
发展：在传统行业方面有较强的技术积累和产品沉淀，一般其他公司也都有传统行业研发的产品。另外现在的传统行业逐步包括了互联网的领域开发以及技术使用，只不过会比纯互联网少一些高并发场景，因为大部分这类软件面对的并不是C端人群。所以个人进入此类公司会相对比较稳定，但如果后期想再跳槽比较麻烦，会出现技术断层。

2. 国企&半国企

难度：⭐⭐⭐
公司：联想、京东方、中软国际、国家电网
发展：早前应届生入职国企或者半国企一般会有解决北京户口，但现在可能名额不断的减少了。像中软有一部分自己做的东西，也有一部分是承接外包的内容。此类公司做的工作内容可能比较单一，有时候一个项目会用很多年，但同时可能不会太忙，有一些自己的时间，并且像联想、国家电网福利待遇也都不错。

3. 外包

难度：⭐⭐⭐
公司：对日外包、企业外包
发展：像是在大连会有一些专门的对日外包企业，还可能需要长期在日本出差。我的两个同学上学时候日语都学的不错，现在一直在日本工作，就他们来说挺习惯在外面的生活了。还有一部分外包是企业外包，比如你入职一个外包公司，可能会把你这个人外派给华为、腾讯、阿里等公司，开发他们外包出来的工作，此类工作一般相对来说短期、非核心。但干的好的也有转正机会，直接入职大厂，不过比较难。而且外包到企业里的人员，没有正式员工的待遇

4. 外企

难度：⭐⭐⭐⭐
公司：亚马逊、谷歌、微软
发展：外企工作还是挺香的，相对来说没有那么强的加班，福利待遇也比较不错。例如像这类的公司会明确写上不加班，以及各种假期和旅游。但可能是近几年被国内互联网挤压的，也有一些在国内的外企有裁员的动作。

5. 互联网

难度：⭐⭐⭐⭐⭐
公司：百度、阿里、腾讯、字节、京东、美团、滴滴等等
发展：这类公司在北上广就多了去了，虽然多但面试难度仍然不低，尤其是现在内卷的情况下，需要你会很多知识以及数据结构或者刷算法，才可能找到一份不错的工作。此类的公司的薪资待遇不错，每年都水涨船高，可能一个刚毕业的重点大学，大学生，入职的薪资就要倒挂各类老员工了。除了有少许的内卷，其他的还是挺不错的。

6. 出国

难度：⭐⭐⭐⭐⭐
公司：加拿大的 shopee、美国的脸书、谷歌、苹果等等
发展：如果喜欢国外的生活，又有出去的本事，那也是一个非常好的选择。像小傅哥熟悉的一个北大的伙伴，入职到了加拿大的 shopee，收入以及整个生活节奏对他来说还是非常满意的。


以上就是各类公司的一个简单介绍，每一个人就业时都会有自己的选择，比如想安稳些、想要户口、想要高工资、想不那么加班等等，只要你能对自己的选择负责，合理规划好自己的职业发展，那么就可以了。
五、资料
1. 技术内容
其实现在互联网的文档、资料、书籍、视频都已经很多了，但也可能正因为太多了，让初学编程的人找不到所处阶段，大一、大二、大三、大四以及毕业了工作了几年后，都应该找什么样的资料学习。
所以我这里把各类资料进行整合，按照不同阶段的学习范围把资料分到不同的文件夹去，方便所处不同阶段的读者可以有一个相对准确的学习范围。


资料明细：大学四年到毕业工作5年的学习路线资源汇总
网盘链接：https://pan.baidu.com/s/4mmX7sDy

2. 实战内容
如果你已经跨过了初级阶段，需要做一些实践型的项目，可以关注下我的Github，如下：


内容：本代码库是作者小傅哥多年从事一线互联网Java开发的学习历程技术汇总，旨在为大家提供一个清晰详细的学习教程，侧重点更倾向编写Java核心内容。这部分资料也是我所写博客中实践项目的源码，在这里你可以学到Netty、字节码编程、设计模式、领域驱动设计、规则引擎、面试、架构以及职场经历的分享。
地址：https://github.com/fuzhengwei/CodeGuide/wiki

六、总结

如果一个大学生不怎么关注技术博客，也不知道有哪些技术博客，那么大概率你基本不会了解到你要学什么技术，也没有渠道可以让你拓展自己的知识面。并且尤其是在现在的软件基于人群喜好推荐下，你知道的越少的东西，就越少知道这个东西。所以主动有意识的学习，几乎是你个人成长最快的方式。
做一件事，就把一件事做好！认认真真的长期坚持下来，你会在所走的路上收获很多，千万不要急于求成，否则你能获得的只是微乎其微。当你有一天真的要拿手里的这几张牌，出去闯荡的时候，会被人家炸哭。
另外在大学里进来不要去做一些不会给自身带来长久价值的兼职工作，如果你真的缺那份钱另说，否则尽可能把这些时间用在你将来要找的工作所需的知识学习上。时间不多，做有价值的事更有益个人成长。
酒香不怕巷子深，放在现在是几乎就是不可能的。因为酒不在是你一家酒了，谁能曝光的更多，宣传的更足，展示的更好，谁就更有机会可能成为佼佼者。否则站在台上那个不一定比你强的人，却可能比你过的更好。

七、系列推荐

讲道理，只要你是一个爱折腾的程序员，毕业找工作真的不需要再花钱培训！
大学四年到毕业工作5年的学习路线资源汇总
13年毕业，用两年时间从外包走进互联网大厂
刚毕业不久，接私活赚了2万块！
北漂码农的我，把在大城市过成了屯子一样舒服，哈哈哈哈哈！