Scala Applied, Part 2

Scala Applied, Part 2, available at $64.99, has an average rating of 4.45, with 226 lectures, 5 quizzes, based on 1191 reviews, and has 6383 subscribers.

You will learn about Understand Scalas composition and inheritance features Create abstract classes and pure abstract members (methods and fields) Override and overload methods Create primary and auxiliary constructors Call superclass constructors and methods Understand and use parametric fields Create factory methods in companion objects Construct simple DSLs (Domain Specific Languages) Understand top and bottom types and how Scala uses them Write correct equals and hashCode methods Use traits to mix behavior into classes Know the different styles of packages and visibility modifiers Be able to import anything from anywhere Write pre-conditions and post-conditions Test your code with unit testing This course is ideal for individuals who are Anyone wanting to learn the Scala programming language or This is part 2 of a 3 part course, please check you have skills equivalent to part 1 before taking this course or We do assume the student has some programming knowledge in a modern programming language It is particularly useful for Anyone wanting to learn the Scala programming language or This is part 2 of a 3 part course, please check you have skills equivalent to part 1 before taking this course or We do assume the student has some programming knowledge in a modern programming language.

Enroll now: Scala Applied, Part 2

Summary

Title: Scala Applied, Part 2

Price: $64.99

Average Rating: 4.45

Number of Lectures: 226

Number of Quizzes: 5

Number of Published Lectures: 118

Number of Published Quizzes: 5

Number of Curriculum Items: 231

Number of Published Curriculum Objects: 123

Original Price: $19.99

Quality Status: approved

Status: Live

What You Will Learn

Understand Scalas composition and inheritance features

Create abstract classes and pure abstract members (methods and fields)

Override and overload methods

Create primary and auxiliary constructors

Call superclass constructors and methods

Understand and use parametric fields

Create factory methods in companion objects

Construct simple DSLs (Domain Specific Languages)

Understand top and bottom types and how Scala uses them

Write correct equals and hashCode methods

Use traits to mix behavior into classes

Know the different styles of packages and visibility modifiers

Be able to import anything from anywhere

Write pre-conditions and post-conditions

Test your code with unit testing

Who Should Attend

Anyone wanting to learn the Scala programming language

This is part 2 of a 3 part course, please check you have skills equivalent to part 1 before taking this course

We do assume the student has some programming knowledge in a modern programming language

Target Audiences

Anyone wanting to learn the Scala programming language

This is part 2 of a 3 part course, please check you have skills equivalent to part 1 before taking this course

We do assume the student has some programming knowledge in a modern programming language

Scala Applied, Part 2 covers Scala features that are different from other languages or maybe unique to Scala. It is intended to follow on from Part 1, and dovetails nicely into that flow.

While part 1 covered common concepts from other languages in Scala, part 2 concentrates on the parts of the language that are more specific to Scala and may be unfamiliar when coming from other programming languages, either the features themselves or the syntax for using them, taught by an instructor with over 15 years experience programming in Scala, and more than a dozen years teaching it.

As part of the larger Scala Applied 3 part course, this will prepare you with everything you need for day-to-day development in the Scala language.

In particular, by following this course you will:

Understand Scala’s composition and inheritance features

Create abstract classes and pure abstract members (methods and fields)

Override and overload class methods

Create primary and auxiliary constructors

Call superclass constructors and methods

Understand and use parametric fields

Create factory methods in companion objects

Construct simple DSLs (Domain Specific Languages)

Understand top and bottom types and how Scala uses them

Write correct equals and hashCode methods

Use traits to mix behavior into classes

Know the different styles of packages and visibility modifiers

Be able to import anything from anywhere

Write pre-conditions and post-conditions

Test your code with unit testing

Course Curriculum

Chapter 1: Course Introduction and Exercises

Lecture 1: Download the exercises for this course

Lecture 2: Download Slides and Exercises

Chapter 2: Module 7 – Composition and Inheritance

Lecture 1: 01 – Introduction

Lecture 2: 02 – Agenda

Lecture 3: 03 – Classes and Abstract Classes

Lecture 4: 04 – Abstract Classes

Lecture 5: 05 – Anonymous Classes and Overrides

Lecture 6: 06 – Uniform Access

Lecture 7: 07 – val, def and lazy val

Lecture 8: 08 – Inheriting and Extends

Lecture 9: 09 – Invoking Superclasses

Lecture 10: 10 – Alternative Car Definition

Lecture 11: 11 – override keyword

Lecture 12: 12 – override keyword continued

Lecture 13: 13 – final keyword

Lecture 14: 14 – final keyword continued

Lecture 15: 15 – final classes

Lecture 16: 16 – case classes

Lecture 17: 17 – Domain Models

Lecture 18: 18 – Cars and Vehicles

Lecture 19: 19 – Parking Structure

Lecture 20: 20 – Module 07 Exercises

Chapter 3: Module 8 – Hierarchy, Types and Options

Lecture 1: 01 – Module 08 Introduction

Lecture 2: 02 – Agenda

Lecture 3: 03 – Top Classes

Lecture 4: 04 – Top Types Example

Lecture 5: 05 – Organization From the Top

Lecture 6: 06 – Bottom Classes

Lecture 7: 07 – Null and Nothing

Lecture 8: 08 – Even More Nothing

Lecture 9: 09 – Scala Type Calculus

Lecture 10: 10 – Scala Type Inference Tricks

Lecture 11: 11 – Primitives and Implicit Conversions

Lecture 12: 12 – Rich Wrappers

Lecture 13: 13 – @specialized

Lecture 14: 14 – @specialized generation

Lecture 15: 15 – Extension Methods and Implicit Classes

Lecture 16: 16 – Value Class

Lecture 17: 17 – Nil, Null, Nothing, None

Lecture 18: 18 – Option

Lecture 19: 19 – Working with Option

Lecture 20: 20 – Option continued

Lecture 21: 21 – equals and hashCode

Lecture 22: 22 – Generate with IDEA

Lecture 23: 23 – Follow this formula

Lecture 24: 24 – Sub classes

Lecture 25: 25 – Just use case classes

Lecture 26: 26 – Product Types

Lecture 27: 27 – Product Type Features

Lecture 28: 28 – Module 8 Exercises

Lecture 29: 29 – Module 8 Puzzlers explanations

Chapter 4: Module 9 – Traits

Lecture 1: 01 – Module 09 Introduction

Lecture 2: 02 – Agenda

Lecture 3: 03 – Multiple Inheritance

Lecture 4: 04 – Traits Compared to Interfaces

Lecture 5: 05 – Creating a Trait

Lecture 6: 06 – Using a Trait in a Class

Lecture 7: 07 – Polymorphism and Rich Interfaces

Lecture 8: 08 – Multiple Traits

Lecture 9: 09 – Howd it do that?

Lecture 10: 10 – Stacking Traits

Lecture 11: 11 – Stacking Traits – Quiz

Lecture 12: 12 – Stacking Traits 1

Lecture 13: 13 – Stacking Traits 2

Lecture 14: 14 – Stacking Traits 3

Lecture 15: 15 – Construction Composition

Lecture 16: 16 – Traits vs Classes

Lecture 17: 17 – Trait Initialization

Lecture 18: 18 – Trait Initialization Fixes

Lecture 19: 19 – abstract override

Lecture 20: 20 – Implementing the Abstract

Lecture 21: 21 – Traits with Type Parameters

Lecture 22: 22 – Another CompareAge class

Lecture 23: 23 – Selfless Traits

Lecture 24: 24 – Exercises for Module 9

Chapter 5: Module 10 – Packages, Imports and Scope

Lecture 1: 01 – Module 10 Introduction

Lecture 2: 02 – Agenda

Lecture 3: 03 – Public, Protected and Private

Lecture 4: 04 – Packages

Lecture 5: 05 – Package Structure Alternatives

Lecture 6: 06 – Namespace Notation

Lecture 7: 07 – More Parts of the Model

Lecture 8: 08 – Package Visibility

Lecture 9: 09 – At the top level

Lecture 10: 10 – wine package

Lecture 11: 11 – The PairWine object

Lecture 12: 12 – Package Objects

Lecture 13: 13 – Importing from an object

Lecture 14: 14 – Importing from an instance

Lecture 15: 15 – Importing Fu: Renaming

Lecture 16: 16 – Selective Importing

Lecture 17: 17 – Companion Objects

Instructors

Dick Wall
Scala Developer

Rating Distribution

1 stars: 5 votes

2 stars: 17 votes

3 stars: 113 votes

4 stars: 425 votes

5 stars: 631 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!