Android developer nanodegree program

Udacity Android Developer Nanodegree — Java Style Guide

Introduction

This style guide acts as the official guide to follow in your projects. Udacity reviewers will use this guide to grade your projects. For a more detailed set of rules with examples refer to this link. These are very strict rules followed in the Android Developers world.

Before you look into the Language and Style rules listed below, remember to BE CONSISTENT. Style guidelines are used to have a common vocabulary of coding.

Java Language Rules

Don’t Ignore Exceptions

You must handle every Exception in your code in some principled way. The specific handling varies depending on the case.

Not Recommended:

Recommended:

Throw the exception up to the caller of your method.

Throw a new exception that is appropriate to your level of abstraction.

Handle the error gracefully and substitute an appropriate value in the catch <> block.

Don’t Catch Generic Exception

It is inappropriate to catch generic Exception or Throwable, preferably not Throwable, because it includes Error exceptions as well. It is very dangerous. It means that Exceptions you never expected (including RuntimeExceptions like ClassCastException) end up getting caught in application-level error handling. It obscures the failure handling properties of your code.

Not Recommended:

Recommended:

• There might be certain test code and top-level code where you want to catch all kinds of errors (to prevent them from showing up in a UI, or to keep a batch job running). In that case you may catch generic Exception (or Throwable) and handle the error appropriately.
• Catch each exception separately as separate catch blocks after a single try. Beware repeating too much code in the catch blocks.
• Refactor your code to have more fine-grained error handling, with multiple try blocks. Split up the IO from the parsing, handle errors separately in each case.
• Rethrow the exception. Many times you don’t need to catch the exception at this level anyway, just let the method throw it.

Fully Qualify Imports

Not Recommended:

Recommended:

This makes it obvious what classes are actually used. Makes Android code more readable for maintainers.

Don’t Use Finalizers

Finalizers are a way to have a chunk of code executed when an object is garbage collected.

In most cases, you can do what you need from a finalizer with good exception handling. If you absolutely need it, define a close() method (or the like), print a short log message from the finalizer and document exactly when that method needs to be called.

Java Style Rules

Javadoc Standard Comments

Recommended:

Every file should have a copyright statement at the top. Then a package statement and import statements should follow. Each block separated by a blank line. Finally, there is the class or interface declaration. In the Javadoc comments, describe what the class or interface does.

Every class and nontrivial public method you write must contain a Javadoc comment with at least one sentence describing what the class or method does. Make sure you start with a third person descriptive verb.

You do not need to write Javadoc for trivial get and set methods.

Android does not currently enforce a specific style for writing Javadoc comments, but you should follow the instructions on How to Write Doc Comments for the Javadoc Tool.

Limit Variable Scope

The scope of local variables should be kept to a minimum. This increases the readability and maintainability of the code and reduce the likelihood of error.

Each variable should be declared in the innermost block that encloses all uses of the variable.

Every local variable declaration should contain an initializer (if you don’t have enough information to initialize, you can postpone this).

Loop variables should be declared in the for statement itself unless there is a compelling reason to do otherwise:

Order Import Statements

The order of importing statements is:

1. Android Imports
2. Imports from third parties( com , junit , net , org )
3. java and javax imports

To exactly match the IDE settings, the imports should be:

• Alphabetical within each grouping, with capital letters before lower case letters (e.g. Z before a).
• There should be a blank line between each major grouping ( android , com , junit , net , org , java , javax ).

Static imports can be a little tricky. It can either be interspersed with the remaining imports or below all other imports. We leave it to your judgement. Please be consistent.

Use Spaces for Indentation

We use 4 space indents for blocks. We never use tabs. When in doubt, be consistent with code around you.

We use 8 space indents for line wraps, including function calls and assignments.

Not Recommended:

Recommended:

Follow Field Naming Conventions

• Non-public, non-static field names start with m.
• Static field names start with s.
• Other fields start with a lower case letter.
• Public static final fields (constants) are ALL_CAPS_WITH_UNDERSCORES.

Recommended:

Use Standard Brace Style

Braces do not go on their own line; they go on the same line as the code before them.

We require braces around the statements for a conditional. Except, if the entire conditional (the condition and the body) fit on one line, you may (although not obligated to) put it all on one line.

Not Recommended:

Recommended:

Use TODO Comments

Use TODO comments for code that is temporary, a short-term solution, or good-enough but not perfect.

TODOs should include the string TODO in all caps, followed by a colon:

If your TODO is of the form «At a future date do something» make sure that you either include a very specific date («Fix by November 2005») or a very specific event («Remove this code after all production mixers understand protocol V7.»).

Treat Acronyms as Words

Treat acronyms and abbreviations as words in naming variables, methods, and classes. This way, the names are much more readable.

Not Recommended:

Recommended:

Avoid using Magic Numbers

A Magic Number is a hard-coded value that may change at a later stage, but that can be therefore hard to update.

Not Recommended:

Make sure you refactor the above code by defining a numeric constant to store the pin size value. NOTE: Define numeric constants as final

Recommended:

Use Standard Java Annotations

Annotations should precede other modifiers for the same language element. Simple marker annotations (e.g. @Override ) can be listed on the same line with the language element. If there are multiple annotations, or parameterized annotations, they should each be listed one-per-line in alphabetical order.

Android standard practices for the three predefined annotations in Java are:

• @Deprecated : The @Deprecated annotation must be used whenever the use of the annotated element is discouraged. If you use the @Deprecated annotation, you must also have a @deprecated Javadoc tag (and vice versa) and it should name an alternate implementation.
• @Override : The @Override annotation must be used whenever a method overrides the declaration or implementation from a super-class.
• @SuppressWarnings : The @SuppressWarnings annotation should only be used under circumstances where it is impossible to eliminate a warning.When a @SuppressWarnings annotation is necessary, it must be prefixed with a TODO comment that explains the «impossible to eliminate» condition. For example:

Log Sparingly

While logging is necessary, it has a significantly negative impact on performance and quickly loses its usefulness if it’s not kept reasonably terse.

Define Fields in Standard Places

Fields should be defined either at the top of the file, or immediately before the methods that use them.

Write Short Methods

Methods should be kept small and focused. Although there is no hard limit on method length, think about whether method definitions that go above 40 lines can be broken up without harming the structure of the program.

Limit Line Length

Each line of text in your code should be at most 100 characters long.

Exception:

If a comment line contains an example command or a literal URL longer than 100 characters, that line may be longer than 100 characters for ease of cut and paste.

Import lines can go over the limit because humans rarely see them. This also simplifies tool writing.

Источник

Android developer nanodegree program

Real-world projects from industry experts

Technical mentor support

Flexible learning program

School of Data Science

Data Scientist is the hottest job in America, and Udacity data science courses teach you the most in demand data skills. Learn data science and what it takes to get data science jobs, while earning a Data Science Certificate.

School of Artificial Intelligence

AI is changing how entire industries operate—retail, education, healthcare, and almost every other field out there. Enroll in one of Udacity’s many AI programs and learn AI skills in robotics, python, computer vision, and NLP.

School of Programming

Learning to code is the first step in starting a career as a Front End Web Developer, a Full Stack Web Developer, or even a Machine Learning Engineer. Enroll in one of Udacity’s many programming nanodegrees and get started today!

School of Autonomous Systems

Udacity is the leading place to learn autonomous systems! Enroll in cutting edge programs that train you from scratch to become a self driving car engineer, autonomous aerial robotics engineer, even how to build a flying car.

School of Cloud Computing

All companies are adopting cloud computing to enable their digital transformation. The growth of this technology has created incredible demand for Cloud computing jobs, from Cloud developers and Cloud DevOps roles to more specialized roles such as solutions architects and Cloud security engineers. You can join this growing field – get started today.

School of Business

Learn digital marketing fundamentals to build your business and engage your customers. Udacity offers training in everything from Google AdWords, social media marketing, SEO, Content Marketing, to customer lifecycle management.

School of Cybersecurity

There are a lot of different cyber programs and certificates, but most focus on theory over practical skill sets. Our programs range from beginner to expert levels and deliver the hands-on skills for real-world expertise.

School of Product Management

There’s a good reason Product Management roles in the U.S. have grown an astounding 32% over just a two year period. A good product manager with the right skills can transform any business. Udacity’s School of Product Management can equip you with these skills, helping you develop experience across the business, design, and tech domains through hands-on, industry-relevant projects and mentor feedback.

Need help selecting the right program for you? Need help selecting the right program for you?

Get in touch to receive more information on our available programs and updates on new programs to come.

© 2011–2021 Udacity, Inc.

«Nanodegree» is a registered trademark of Udacity. В© 2011–2021 Udacity, Inc.

Udacity is not an accredited university and we don’t confer traditional degrees. Udacity Nanodegree programs represent collaborations with our industry partners who help us develop our content and who hire many of our program graduates.

«Nanodegree» is a registered trademark of Udacity. В© 2011–2021 Udacity, Inc.

Udacity is not an accredited university and we don’t confer traditional degrees. Udacity Nanodegree programs represent collaborations with our industry partners who help us develop our content and who hire many of our program graduates.

Источник

Developing Android Apps

Learn Android fundamentals

Start Free Course

Related Nanodegree Program

Android Kotlin Developer

Get a Nanodegree certificate that accelerates your career!

About this Course

As the first course in the Android Developer Nanodegree, Developing Android Apps is the foundation of our advanced Android curriculum. This course blends theory and practice to help you build great apps the right way. In this course, you’ll work with instructors step-by-step to build a cloud-connected Android app, and learn best practices of mobile development, and Android development in particular.

Course Cost

Timeline

Approx. 60 hours

Skill Level

intermediate

Included in Product

Rich Learning Content

Interactive Quizzes

Taught by Industry Pros

Self-Paced Learning

Join the Path to Greatness

Master Android development with Kotlin and build professional apps for the world’s most popular mobile platform using Android Studio and Kotlin.

Free Course

Developing Android Apps

Enhance your skill set and boost your hirability through innovative, independent learning.

Nanodegree Program

Android Kotlin Developer

Built in collaboration with Google, this program will prepare you to become a professional Android developer and allow you to create a diverse portfolio of projects to show employers.

Course Leads

Dan Galpin

Lyla Fujiwara

Reto Meier

Asser Samak

James Williams

Cezanne Camacho

Michael Lustig

Jocelyn Becker

What You Will Learn

lesson 1

Creating Project Sunshine

• Learn how to create and run a simple Android app
• Create simple layouts for Android
• Learn about the Android Studio IDE

lesson 2

Loading Data from the Internet

• Connect to the Internet and communicate with web APIs
• Learn about threading and how to make requests without slowing down your app
• Learn how to add menus to your app

lesson 3

RecyclerView

• Learn about the components that convert a list of data into visual UI elements

lesson 4

Intents

• Learn the difference between Explicit and Implicit Intents
• Learn how to navigate inside your apps using intents
• Learn how to create Intents that apps outside your control can respond to

lesson 5

The Application Lifecycle

• Understand the phases of the Android application lifecycle
• Learn how to persist data between orientation and other changes

lesson 6

Preferences

• Allow users to customize some aspects of your app
• Consider when to omit or add a preference

lesson 7

Content Providers

• Learn how Content Providers provide an interface to share data
• Consume data from an already existing ContentProvider

lesson 8

Android Architecture Components

• Learn how to use Room, LiveData, ViewModel and Lifecycle components
• Understand how architecture components can help you build robust and efficient apps

lesson 9

Background Tasks

• Run jobs in the background of an app
• Create notifications and schedule long-running background processes

lesson 10

Completing the UI

• Build a well-organized, accessible UI for your app
• Try different layouts, views, viewgroups, and methods of databinding
• Design your UI for users who speak different languages

lesson 11

Polishing the UI

• Add visual polish to your apps with different layouts, fonts, and colors
• Use design principles to create apps that look great across multiple form factors

Prerequisites and Requirements

This course is intended for students with at least 1 year of programming experience in Java or another object-oriented programming language (for example: C++, Objective C or Python).

If you are new to programming, we recommend taking Android for Beginners, which we created with Google for students just like you!

Also, Udacity’s Intro to Java is a helpful background if you’re looking to refresh your Java skills.

You will be expected to download Android Studio in order to follow along with the instructors throughout the course. For guidance on the install process, take our How to Install Android Studio mini-course.

In addition, you should be comfortable working with code on GitHub.

Access to an Android device is helpful — but not required — to complete the final project.

See the Technology Requirements for using Udacity.

Why Take This Course

With over 1 billion Android devices already activated, Android represents an incredible opportunity for developers.

As Android continues to grow beyond smartphones, it will become the brains behind invisible, ubiquitous cloud-connected computing. The skills you learn in this course will help you build awesome apps for smartphones and tablets today, and propel you towards exciting opportunities in Android’s future.

By the end of this course, you’ll build a cloud-connected Android app, and understand the tools, principles, and patterns that underlie all Android development. You’ll understand the challenges associated with developing for the mobile environment (and how to overcome them), learn how to build a great user experience for Android devices, and apply this knowledge to your own projects.

Источник