Scala Applied Part 2

Scala Applied Part 2

What you’ll learn

Understand Scala’s 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

Requirements

Students should follow and complete the Stairway to Scala Setup instructions, available for free on Udemy, before starting this course
Students should have also completed Stairway to Scala Applied Part 1 or have equivalent skills before starting this course
Students will need a laptop or desktop computer with sufficient performance and resources to compile and run the coding exercises

Description

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 featuresCreate abstract classes and pure abstract members (methods and fields)Override and overload class methodsCreate primary and auxiliary constructorsCall superclass constructors and methodsUnderstand and use parametric fieldsCreate factory methods in companion objectsConstruct simple DSLs (Domain Specific Languages)Understand top and bottom types and how Scala uses themWrite correct equals and hashCode methodsUse traits to mix behavior into classesKnow the different styles of packages and visibility modifiersBe able to import anything from anywhereWrite pre-conditions and post-conditionsTest your code with unit testing

Overview

Section 1: Course Introduction and Exercises

Lecture 1 Download the exercises for this course

Lecture 2 Download Slides and Exercises

Section 2: Module 7 – Composition and Inheritance

Lecture 3 01 – Introduction

Lecture 4 02 – Agenda

Lecture 5 03 – Classes and Abstract Classes

Lecture 6 04 – Abstract Classes

Lecture 7 05 – Anonymous Classes and Overrides

Lecture 8 06 – Uniform Access

Lecture 9 07 – val, def and lazy val

Lecture 10 08 – Inheriting and Extends

Lecture 11 09 – Invoking Superclasses

Lecture 12 10 – Alternative Car Definition

Lecture 13 11 – override keyword

Lecture 14 12 – override keyword continued

Lecture 15 13 – final keyword

Lecture 16 14 – final keyword continued

Lecture 17 15 – final classes

Lecture 18 16 – case classes

Lecture 19 17 – Domain Models

Lecture 20 18 – Cars and Vehicles

Lecture 21 19 – Parking Structure

Lecture 22 20 – Module 07 Exercises

Section 3: Module 8 – Hierarchy, Types and Options

Lecture 23 01 – Module 08 Introduction

Lecture 24 02 – Agenda

Lecture 25 03 – Top Classes

Lecture 26 04 – Top Types Example

Lecture 27 05 – Organization From the Top

Lecture 28 06 – Bottom Classes

Lecture 29 07 – Null and Nothing

Lecture 30 08 – Even More Nothing

Lecture 31 09 – Scala Type Calculus

Lecture 32 10 – Scala Type Inference Tricks

Lecture 33 11 – Primitives and Implicit Conversions

Lecture 34 12 – Rich Wrappers

Lecture 35 13 – @specialized

Lecture 36 14 – @specialized generation

Lecture 37 15 – Extension Methods and Implicit Classes

Lecture 38 16 – Value Class

Lecture 39 17 – Nil, Null, Nothing, None

Lecture 40 18 – Option

Lecture 41 19 – Working with Option

Lecture 42 20 – Option continued

Lecture 43 21 – equals and hashCode

Lecture 44 22 – Generate with IDEA

Lecture 45 23 – Follow this formula

Lecture 46 24 – Sub classes

Lecture 47 25 – Just use case classes

Lecture 48 26 – Product Types

Lecture 49 27 – Product Type Features

Lecture 50 28 – Module 8 Exercises

Lecture 51 29 – Module 8 Puzzlers explanations

Section 4: Module 9 – Traits

Lecture 52 01 – Module 09 Introduction

Lecture 53 02 – Agenda

Lecture 54 03 – Multiple Inheritance

Lecture 55 04 – Traits Compared to Interfaces

Lecture 56 05 – Creating a Trait

Lecture 57 06 – Using a Trait in a Class

Lecture 58 07 – Polymorphism and Rich Interfaces

Lecture 59 08 – Multiple Traits

Lecture 60 09 – How’d it do that?

Lecture 61 10 – Stacking Traits

Lecture 62 11 – Stacking Traits – Quiz

Lecture 63 12 – Stacking Traits 1

Lecture 64 13 – Stacking Traits 2

Lecture 65 14 – Stacking Traits 3

Lecture 66 15 – Construction Composition

Lecture 67 16 – Traits vs Classes

Lecture 68 17 – Trait Initialization

Lecture 69 18 – Trait Initialization Fixes

Lecture 70 19 – abstract override

Lecture 71 20 – Implementing the Abstract

Lecture 72 21 – Traits with Type Parameters

Lecture 73 22 – Another CompareAge class

Lecture 74 23 – Selfless Traits

Lecture 75 24 – Exercises for Module 9

Section 5: Module 10 – Packages, Imports and Scope

Lecture 76 01 – Module 10 Introduction

Lecture 77 02 – Agenda

Lecture 78 03 – Public, Protected and Private

Lecture 79 04 – Packages

Lecture 80 05 – Package Structure Alternatives

Lecture 81 06 – Namespace Notation

Lecture 82 07 – More Parts of the Model

Lecture 83 08 – Package Visibility

Lecture 84 09 – At the top level

Lecture 85 10 – wine package

Lecture 86 11 – The PairWine object

Lecture 87 12 – Package Objects

Lecture 88 13 – Importing from an object

Lecture 89 14 – Importing from an instance

Lecture 90 15 – Importing Fu: Renaming

Lecture 91 16 – Selective Importing

Lecture 92 17 – Companion Objects

Lecture 93 18 – Module 10 Exercises

Section 6: Module 11 – Testing in Scala

Lecture 94 01 – Module 11 Introduction

Lecture 95 02 – Agenda

Lecture 96 03 – Pre and Post Conditions

Lecture 97 04 – Eliding

Lecture 98 05 – Requirements

Lecture 99 06 – Testing

Lecture 100 07 – Scalatest

Lecture 101 08 – FunSuite

Lecture 102 09 – FunSpec

Lecture 103 10 – Matchers

Lecture 104 11 – Matchers 2

Lecture 105 12 – Matchers 3

Lecture 106 13 – Unit vs Integration Testing

Lecture 107 14 – Scalamock

Lecture 108 15 – Unit Testing with Mocks

Lecture 109 16 – Advantages of Mocks

Lecture 110 17 – Mocks vs Stubs

Lecture 111 18 – Fakes

Lecture 112 19 – Property Driven Testing

Lecture 113 20 – Custom Property Generators

Lecture 114 21 – Testing with Futures

Lecture 115 22 – Waiting for the Future

Lecture 116 23 – whenready

Lecture 117 24 – Full Async Suites

Lecture 118 25 – Module 11 Exercises

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

Course Information:

Udemy | English | 4h 49m | 1.99 GB
Created by: Dick Wall

You Can See More Courses in the Developer >> Greetings from CourseDown.com