Search

This chapter will discuss the difference between objects in Kotlin and instance of a class. This is important as many other object-oriented languages use these terms interchangeably. However, in Kotlin they are significantly different concepts, defined with different language constructs and used in different ways.

Many object-oriented languages have the explicit concept of encapsulation; that is the ability to hide data within an object and only to provide specific gateways into that data. These gateways are functions defined to get or set the value of an attribute (often referred to as getters and setters). This allows more control over access to the data; for example, it is possible to check that only a positive integer above zero, but below 120, is used for a person’s age etc.

Kotlin provides five functions whose sole purpose is to execute a block of code within the context of an instance or an object. When you call such a function on an instance with a lambda expression, it forms a temporary scope (hence the term scope function). In this scope, you can access the instance directly typically using the this reference or in two cases using the it implicit parameter.

In this chapter we are going to bring everything we have learned so far together to create a simple number guessing game.

In this chapter we are going to look at the flow of control statements in Kotlin. These statement are used to control the flow of execution within a program based on some condition. These conditions represent some choice point that will be evaluated too true or false. To perform this evaluation it is common to use a comparison operator (for example to check to see if a temperature is greater than some threshold or while some boolean flag is true then repeat a set of instructions). In many cases these comparisons need to take into account several values and in these situations logical operators can be used to combine two or more comparison expressions together. This chapter first introduces comparison and logical operators before discussing the null and condition operators. It then considers if statements, when expressions, while and do-while loops, for loops and repeat loops. It concludes by introducing a simple application that uses both a while loop and an if statement.

In this chapter we will look at the Android Studio and a simple Hello World style Android application.

This chapter considers exception and error handling and how it is implemented in Python. You are introduced to the object model of exception handling, to the throwing and catching of exceptions, and how to define new exceptions and exception-specific constructs.

In this chapter we will look at a simple Kotlin program and understand what it is doing. We will also modify it to become more interactive and will explore the concept of Kotlin variables (specifically vals and vars).

When you build an application of any size you will want to break it down into more manageable units; these units can then be worked on separately, tested and maintained separately. One way in which these units can be defined is as Kotlin functions.

There are two further types of classes in Kotlin specifically Sealed Classes and inline Classes. This chapter will explore each of these. The chapter will conclude by introducing type aliases.

The Kotlin type system is comprised of more than just classes and objects; it includes interfaces and enumerated types. In this chapter we will explore the concept of an interface and what components can be defined within an interface. We will also consider a Kotlin language facility that allows an interface to be implemented via delegation. The chapter concludes by looking at enumerated types. An enumerated type is a type consisting of a set of named values also called elements or members of the enumeration. These values have a specific name and an ordering.

In this chapter we will explore the creation of a simple TicTacToe (or Noughts and Crosses) Android game.

Sexually antagonistic coevolution is predicted to lead to the divergence of male and female genotypes related to the effects of substances transferred by males at mating on female physiology. The outcome of mating should thus depend on the specific combination of mating genotypes. Although mating has been shown to influence female immunity in diverse insect taxa, a male-female genotype-by-genotype effect on female immunity post mating remains largely unexplored. Here, we investigate the effects of mating on female decorated cricket baseline immunity and the potential for a male-genotype-by-female-genotype interaction affecting this response. Females from three distinct genotypic backgrounds were left unmated or singly mated in a fully reciprocal design to males from the same three genotypic backgrounds. Hemocytes and hemocyte microaggregations were quantified for female cellular immunity, and phenoloxidase, involved in melanization, and antibacterial activity for humoral immunity. In this system, female cellular immunity was more reactive to mating, and mating effects were genotype-dependent. Specifically, for hemocytes, a genotype-by-mating status interaction mediated the effect of mating per se, and a significant male-female genotype-by-genotype interaction determined hemocyte depletion post mating. Microaggregations were influenced by the female's genotype or that of her mate. Female humoral immune measures were unaffected, indicating that the propensity for post-mating effects on females is dependent on the component of baseline immunity. The genotype-by-genotype effect on hemocytes supports a role of sexual conflict in post-mating immune suppression, suggesting divergence of male genotypes with respect to modification of female post-mating immunity, and divergence of female genotypes in resistance to these effects.

In this chapter we will explore the idea of an implicit contract between an object and the code that uses that object. As part of this discussion we will explore what is meant by Duck Typing. Following this we will introduce the Python concept called a protocol. We will explore its role within Python programming and look at two commonly occurring protocols; the Context Manager Protocol and the Descriptor Protocol.

Regular Expression are a very powerful way of processing text while looking for recurring patterns; they are often used with data held in plain text files (such as log files), CSV files as well as Excel files. This chapter introduces regular expressions, discusses the syntax used to define a regular expression pattern and presents the Python re module and its use.

Python classes can hold data and behaviour that is not part of an instance or object; instead they are part of the class.

Testing software systems is not an easy thing to do; the functions, objects, methods etc. That are involved in any program can be complex things in their own right. In many cases they depend on and interact with other functions, methods and objects; very few functions and methods operate in isolation. Thus the success of failure of a function or method or the overall state of an object is dependent on other program elements.

In this chapter we will introduce the concepts of concurrency and parallelism. We will also briefly consider the related topic of distribution. After this we will consider process synchronisation, why object oriented approaches are well suited to concurrency and parallelism before finishing with a short discussion of threads versus processes.

Many programming languages have common logging libraries including Java and C# and of course Python also has a logging module. Indeed the Python logging module has been part of the builtin modules since Python 2.3. This chapter introduces logging, what to log, and what not to log.

The pervious four chapters have introduced the basic concepts behind object orientation, the terminology and explored some of the motivation. This chapter looks at how object orientation addresses some of the issues that have been raised with procedural languages. To do this it looks at how a small extract of a program might be written in a language such as C, considers the problems faced by the C developer and then looks at how the same functionality might be achieved in an object-oriented language such as Python. Do not worry too much about the syntax you will be presented with; it is mostly a form of pseudo code and it should not detract from the legibility of the examples.

This chapter builds on the GUI library presented in the last two chapters to illustrate how a larger application can be built. It presents a case study of a drawing tool akin to a tool such as Visio etc.

The previous chapter illustrated the basic structure of a very simple web service application. We are now in a position to explore the creation of a set of web services for something a little more realistic; the bookshop web service application.

In this chapter we will step through the development of another Python program; this time the program will be to provide a simple calculator which can be used to add, subtract, multiple and divide numbers. The implementation of the calculator is base on the Function Decomposition performed earlier in the book in the Introduction to Structured Analysis chapter.

There are several testing frameworks available for Python, although only one, unittest comes as part of the typical Python installation. Typical libraries include unittest (which is available within the Python distribution by default) and PyTest. This chapter introduces the PyTest testing framework.

Computer Graphics are everywhere; they are on your TV, in cinema adverts, the core of many films, on your tablet or mobile phone and certainly on your PC or Mac as well as on the dashboard of your car, on your smart watch and in childrens electronic toys. This chapter introduces this topic.