Byte Size Chunks : Java Reflection, Annotations and Lambdas
3.8 (11 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
849 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Byte Size Chunks : Java Reflection, Annotations and Lambdas to your Wishlist.

Add to Wishlist

Byte Size Chunks : Java Reflection, Annotations and Lambdas

A little treat with all you need to know about reflection, annotations and lambda functions in Java
3.8 (11 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
849 students enrolled
Created by Loony Corn
Last updated 11/2015
Current price: $10 Original price: $20 Discount: 50% off
5 hours left at this price!
30-Day Money-Back Guarantee
  • 2 hours on-demand video
  • 7 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Use Reflection, Annotations and Lambda functions - modern Java language features
  • Use reflection when its appropriate (and avoid it when its not!)
  • Understand how annotations - both custom and built-in - are powerful tools in specific situations
  • Write crisp event handling code using lambda functions (and reduce the code bloat of UI applications!)
  • Chain together aggregate operations and lambda functions to benefit from the best features of functional programming now available in Java
View Curriculum
  • This course calls for a basic working knowledge of Java
  • Prerequisites: Basic understanding of Java
  • Taught by a Stanford-educated, ex-Googler, husband-wife team
  • Please don't take this class if you have already signed up for our From 0 to 1: Learn Java Programming course (that includes a far longer and more in-depth version of this material)

This is a quick and handy course with exactly what you need to know (nothing more, nothing less!) about reflection, annotations and lambda functions in Java

Let’s parse that.

  • The course is quick and handy: It explains reflection, annotations and lambda functions in just the right level of detail for you to put these to work today.
  • The course has exactly what you need - nothing more, nothing less. It starts from zero, builds up the design, then gives plenty of real-world examples, but crisply and quickly.
  • The course is also quirky. The examples are irreverent. Lots of little touches: repetition, zooming out so we remember the big picture, active learning with plenty of quizzes. There’s also a peppy soundtrack, and art - all shown by studies to improve cognition and recall.

What's Covered:

  • Reflection: The how, what and why - also the good and bad
  • Annotations: Custom and built-in annotations, and how they save effort and prevent bugs
  • Lambda Functions: Functional constructs that have made the crossover into the mainstream of Java - lambda functions, aggregate operators.

Using discussion forums

Please use the discussion forums on this course to engage with other students and to help each other out. Unfortunately, much as we would like to, it is not possible for us at Loonycorn to respond to individual questions from students:-(

We're super small and self-funded with only 2 people developing technical video content. Our mission is to make high-quality courses available at super low prices.

The only way to keep our prices this low is to *NOT offer additional technical support over email or in-person*. The truth is, direct support is hugely expensive and just does not scale.

We understand that this is not ideal and that a lot of students might benefit from this additional support. Hiring resources for additional support would make our offering much more expensive, thus defeating our original purpose.

It is a hard trade-off.

Thank you for your patience and understanding!

Who is the target audience?
  • Yep! Basic or intermediate level Java programmers
Students Who Viewed This Course Also Viewed
Curriculum For This Course
9 Lectures
1 Lecture 02:23

We'll start with an introduction - what this course covers and what you should be able to do at the end of the course.

Preview 02:23
Functional Programming: Crossover Hits
4 Lectures 44:34
Functional, Imperative or Object-Oriented? Our choice of programming paradigm profoundly shapes how we design and write our code. We quickly explore how these three programming paradigms differ. This is a nice lead-in to lambda functions, which are a crossover hit from functional programming into object-oriented Java.
Preview 04:10

Introducing lambda functions, which are a functional programming concept that became so popular that Java added support for them. Very handy at reducing code bloat, particularly in UI programming.

Preview 12:06

More on Lambdas, and a look at aggregation operations - stream, map, filter, foreach - all of which are newly added to Java.

Lambda Functions: No more boiler-plate code

A coding drill that illustrates the appeal of lambda functions and aggregate operators. We will sort a list of names in the drill using two approaches - imperative and functional. We will use .stream() and aggregate functions

Lambda functions for real - in code

Lambda Functions
2 questions
Recursion, Reflection and Annotation
4 Lectures 01:00:02

Recursive functions are functions that call themselves. This can be a little abstract to wrap your head around, but once you do, the idea is - beautiful.


Reflection and Type Introspection are ways to do things 'on-the-fly' with classes and objects: create objects directly from their classes, check out what methods these classes have, invoke those methods and so on. This lecture covers the pros, cons and complexities of reflection. We will also cover old school approach to unit testing and how reflection solves the problems of old school approach.
Reflection: Not a Dark Art

Reflection can be really useful in specific use-cases, unit testing is an excellent example

Reflection: A real use case

Type Introspection
1 question

This lecture is about annotations. Annotations in Java are notes added to the code. The lectures explains how annotations are different from comments, how are they processed by compiler and how programmers can take advantage of annotations. We will also cover some built-in annotations.

Annotations: Notes to Self can be Super-Useful

1 question
About the Instructor
Loony Corn
4.3 Average rating
4,676 Reviews
37,405 Students
76 Courses
An ex-Google, Stanford and Flipkart team

Loonycorn is us, Janani Ravi and Vitthal Srinivasan. Between us, we have studied at Stanford, been admitted to IIM Ahmedabad and have spent years  working in tech, in the Bay Area, New York, Singapore and Bangalore.

Janani: 7 years at Google (New York, Singapore); Studied at Stanford; also worked at Flipkart and Microsoft

Vitthal: Also Google (Singapore) and studied at Stanford; Flipkart, Credit Suisse and INSEAD too

We think we might have hit upon a neat way of teaching complicated tech courses in a funny, practical, engaging way, which is why we are so excited to be here on Udemy!

We hope you will try our offerings, and think you'll like them :-)