Interfaces and Abstract Classes

Loading...

Del curso dictado por Duke University

Java Programming: Principles of Software Design

699 calificaciones

Duke University

Java Programming: Principles of Software Design

699 calificaciones

Curso 4 de 5 en SpecializationJava Programming and Software Engineering Fundamentals

Solve real world problems with Java using multiple classes. Learn how to create programming solutions that scale using Java interfaces. Recognize that software engineering is more than writing code - it also involves logical thinking and design. By the end of this course you will have written a program that analyzes and sorts earthquake data, and developed a predictive text generator. After completing this course, you will be able to: 1. Use sorting appropriately in solving problems; 2. Develop classes that implement the Comparable interface; 3. Use timing data to analyze empirical performance; 4. Break problems into multiple classes, each with their own methods; 5. Determine if a class from the Java API can be used in solving a particular problem; 6. Implement programming solutions using multiple approaches and recognize tradeoffs; 7. Use object-oriented concepts including interfaces and abstract classes when developing programs; 8. Appropriately hide implementation decisions so they are not visible in public methods; and 9. Recognize the limitations of algorithms and Java programs in solving problems. 10. Recognize standard Java classes and idioms including exception-handling, static methods, java.net, and java.io packages.

De la lección

N-Grams: Predictive Text

In this module, you will explore some of the underlying concepts of predictive text. The first lesson will introduce random character generation and then how to train the character selection based on an input text. The second lesson will extend this concept to complete words. By the end of this module, you will be able to: (1) base random text generation on the frequency of characters in a training text, (2) collect a set of characters that occur in a text after randomly chosen initial character(s) to create a semi-random text, (3) extend the predictive text generation to use whole words, and (4) implement your own .equals method to compare complex data types.

Introduction5:45

Order-Zero, Order-One6:40

Finding Follow Set7:25

Implementing Order-Two9:23

Testing and Debugging7:36

Interfaces and Abstract Classes9:14

Conoce a los instructores

Robert Duvall
Lecturer
Computer Science
Owen Astrachan
Professor of the Practice
Computer Science
Andrew D. Hilton
Associate Professor of the Practice
Electrical and Computer Engineering
Susan H. Rodger
Professor of the Practice
Computer Science

Hello.

We're going to look at using interfaces and abstract classes to capture

common features shared among many classes in the Markov programs.

We developed code in the method runMarkov of the MarkovRunner class to create

random text we first used MarkovZero to generate random text.

Then, we changed the variable Markov from the MarkovZero

class to the MarkovOne class and the code in runMarkov still worked.

This happened because we used the same method names in MarkovZero and MarkovOne.

This means Markov.setTraining worked in both classes and

Markov.getRandomText worked in both classes.

We'd like to capture these commonalities with a Java interface so

that we can use the classes in many ways.

You may remember the interfaces Comparable and Comparator when sorting and

the filter interface we developed to search for earthquake data.

We'll design and implement a new interface to capture the commonalities here.

Let's look at developing the interface.

We capture the common methods in the Markov classes

by including their signatures in the interface.

Here you see setTraining and getRandomText.

The interface name here starts with an I.

That's a common practice.

So we've created IMarkovModel.

Each class that implements the interface indicates that with the Java keyword

implements.

As we see here with MarkovOne and again here with MarkovTwo.

We already have the required methods with the required names in each class.

Using an interface will provide both utility and flexibility.

Let's look at these.

We can write a method that has a parameter with an IMarkovModel

interface as seen here with the method runModel.

The first parameter markov has type IMarkovModel.

This means we can call runModel and pass a MarkovZero object as the first parameter,

or a MarkovTwo object as the first parameter.

The object named mz can be passed because it has type,

MarkovZero, which implements the IMarkovModel interface.

And we can pass the object named m2,

because MarkovTwo also implements the IMarkovModel interface.

This call to markov.setTraining will call the appropriate method in MarkovZero or

MarkovTwo, or any other class that implements the IMarkovModel interface.

This call to markov.getRandomText also calls code that

is specific to the object and class passed as the first parameter.

This example illustrates what's called the open-closed software design principle.

The idea is that classes are open to be extended, but closed for modification.

Using an interface and other concepts we'll see soon, you can create a new

class and use it in place of an already tested and proven class.

You shouldn't modify code that works to extend the functionality of that code.

The IMarkovModel interface provides flexibility.

As you've seen, we can develop a new general MarkovModel class

that takes the place of Markov1, Markov2, and so on If this class

implements the IMarkovModel interface we can use it with existing code.

That means we don't have to modify runModel for example to use the new class.

We could develop a more efficient implementation using a HashMap and

use this in place of MarkovModel.

For example, in the code you wrote the helper function getFollows that

might be called hundreds of times to find the characters that follow th.

Each time the entire text is re-scanned to find the characters that follow th.

By storing and

reusing the follow characters, your code might be more efficient.

And you could use it with runModel and other code because of the interface.

The IMarkovModel interface provides great flexibility, but there is some sum

shared code that can avoid by developing what's called an abstract class.

Each Markov class we developed shares state and

code, sometimes that's duplicated in each class.

For example, each class has a random object, and the text used to model random

texts, stored in its variables myRandom and myText, respectively.

Many of the classes share the exact same getFollows helper method that

was copy-pasted into each .java file.

We'd like to avoid this duplication by capturing the common state

in code in what's called an Abstract Base Class.

This will rely on inheritance,

an extremely important object oriented concept we'll touch on briefly here.

You can learn more about this and

other object-oriented concepts in the UCST specialization in Coursera.

Abstract base classes are used extensively in the java.util package with

classes like AbstractList and AbstractMap, classes like ArrayList and HashMap.

Or sub-classes of these abstract classes, sub-classes can inherit state and

code or behavior.

Let's take a look at the abstract base class.

The abstract base class, AbstractMorkovModel is

marked as abstract with the abstract keyword.

We'll see what this means soon.

The state shared across all classes like Markov1, Markov2, and MarkovModel,

the subclasses of this class, is marked as protected rather than private.

These instance variables would be accessible in each subclass that extends

this abstract base class.

We'll discuss the word extends next.

Let's take a closer look at Abstract and Shared Methods.

The class is abstract because there is one method in the AbstractMarkovModel class,

labelled as abstract.

That method is the getRandomText method

which is implemented differently in each class that extends AbstractMarkovModel.

These are called sub-classes.

The helper function getFollows is labelled as protected.

It can be called in each sub-class just as the protected instant variables

can be accessed.

Let's look at extending the base class.

You can see the class MarkovModel that inherits state and

behavior from the class AbstractMarkovModel we've been looking at.

The keyword extends means that this class gets instance variables and

getFollows code from this super or parent class.

Because the super or base class implements the IMarkovModel interface.

This MarkovModel class implements the same interface

that's inherited from the super class.

This class has its own instance variable, myOrder,

marked as private, as you've done in previous coding examples.

Classes that extend an abstract class must implement the abstract methods.

The AbstractMarkovModel class has one abstract method, getRandomText.

This means the class, MarkovModel, must implement this method as you see here.

The MarkovModel subclass inherits protected state and

behavior from the superclass.

This includes the protected instant variables, myRandom and

myText, the training text.

Subclasses can call inherited methods too like getFollows.

We'll summarize the interface and the inheritance example.

The key idea of an abstract based class is to implement the interface and

to supply default functionality when that’s possible

to avoid duplicating state or behavior in each subclass.

Sub classes like MarkovZero or MarkovOne will extend the base class.

Extending the class means that the subclasses inherit the interfaces

of the parent or super class so that subclasses implement IMarkovModel too.

This means client code won't change.

The code that relied on the interface will still work.

Some methods in the abstract base class are labeled as abstract,

subclasses must provide implementations.

We saw different implementations of getRandomText in MarkovOne and

MarkovTwo for example.

Happy programming.

Explora nuestro catálogo

Inscríbete de manera gratuita y obtén recomendaciones personalizadas, actualizaciones y ofertas.

Coursera brinda acceso universal a la mejor educación del mundo, al asociarse con las mejores universidades y organizaciones, para ofrecer cursos en línea.

© 2019 Coursera Inc. Todos los derechos reservados.

Descargar en la App Store

Consíguelo en Google Play