Explore
For Enterprise
Join for Free
Log In

artes y humanidades
Negocios
Ciencias de la Computación
Ciencia de Datos
Tecnología de información
salud
Matemáticas y Lógica
Desarrollo Personal
Ciencias Físicas e Ingeniería
Ciencias sociales
Aprendizaje de un idioma
Grados
Certificados

Explorar todo lo que Coursera tiene para ofrecer

Explorar
Buscar
For Enterprise
Inicia Sesión
Únete de forma gratuita

Testing and Debugging

Loading...

Java Programming: Principles of Software Design

Universidad Duke

4.6 (774 calificaciones) | 52K estudiantes inscritos

Curso 4 de 5 en Java Programming and Software Engineering Fundamentals Programa Especializado

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.

Destrezas que aprenderás

Programming Principles, Interfaces, Software Design, Java Programming

Revisiones

4.6 (774 calificaciones)

5 stars
582 ratings
4 stars
142 ratings
3 stars
30 ratings
2 stars
7 ratings
1 star
13 ratings

SB

Aug 13, 2016

This course was another of many well-taught courses of Duke University. The GPS library use to find locations of earthquakes particularly of very interesting. Thank you Duke University

LY

Sep 28, 2016

devoted professors, appropriate topics which can lead to the correct understanding of each Java object, so we can realize OO programming ideas, not only how to type codes.

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

Impartido por:

Robert Duvall
Lecturer
Owen Astrachan
Professor of the Practice
Andrew D. Hilton
Associate Professor of the Practice
Susan H. Rodger
Professor of the Practice

Transcripción

Wait a minute.

I don't think his output is right.

It's kind of hard to tell when it's random like that, but when he did Markov

three and it still looked like gibberish, I don't think that's right.

But if you think about it, we're using Markov three.

We've got three characters that should be together and

we're looking at a character that follows it.

So we should have in our output every group of four characters,

every substring of four characters, should be four characters from the actual

training text, but that still looked a lot like gibberish.

So I'm going to try and see if I can debug his program and

see if there's a bug in it.

So here's is his get random text message.

We're going to look at Markov Two, which is where he was,

and it's doing one thing or at least I'm looking at my code and

I think it's going to do one thing, but it actually doing something else.

So how do I figure that out?

I'm going to have to print out some information.

Now I don't want to work with a big file, so

I'm going to come back to Markov Runner and the first thing I'm going to do

is just put in a small string, so I'll just set st equal to.

This is a test, yes a test.

So something really small.

And that will just block the file even though we're going to load a file,

we're just going to replace it immediately with a small stream for testing.

And then in my markov two class, what we're going to do

Is we need to print out the key and

the follows that we're getting back to see if those are correct.

So I'm going to add a print statement here.

Let's see, key

And then we'll just put the, so we're printing the key, and

we're going to print also beside it the follows array.

If we can spell it right.

Okay, so again, we have a small amount of data we're working with now.

So let me go back over here to Markov Runner and

let's see, We'll make this smaller too.

And let's compile it.

And let's see what happens now.

This is always helpful to figure out what your program's doing,

because you think it's doing one thing, but it might be doing something else.

Now we're going to load a data file, but then we're going to ignore it,

because we have that strings so I have to load Romeo.

Here we go.

So I would did this so we could look at the follow set, but I'm looking at this

and oh my gosh, we're supposed to have a key that's two characters long and

you can see that our key is only one character long.

The first key is two characters, but all the rest are just one character.

That is a problem.

Our characters should be, our key should always be two characters.

So that the way Markov works is you take your old key and

then with Markov two we want to start with, we want to shift a little bit and

use, could take off the first character and

add the new follow character we use and use that to predict the next character.

So let's look at our code.

We just get random text, so you can see here we set the key in this

line here up here we set the key, and it is two characters, that's the first key.

And where do we change the key?

We change it down here, and we're just setting it to that next character, so

that's wrong.

What we want to do is we want it to be the old key minus the first character so

we'll just start it at sub string one.

And then we'll tack on at the end, the new character that we just found.

We'll just shift it a little bit each time.

So let's try running that.

We'll compile it.

Okay, so we're going to run it,

now again we're running it on our test data to see if that works.

Here, now, oh yes and that looks much better.

And you can see we have, all our keys are two digits,

some of them have a space in there so they look funny, and then we have text.

So now let's run it on a file.

Let's run it on Romeo now.

So we need to comment out what we just put in markov two.

We're going to comment out the print statement here.

That's the extra print statement.

We don't need that now.

Okay, that's good.

And then we'll come back over to Markov Runner and we'll

ignore this extra small string to put in there, so we can now run it on Romeo.

And we'll also change this back to 500.

We can look at a big thing now.

And let's compile it and run it.

So we're going to select Romeo to run it on.

And there, that looks a little bit better, more like Romeo.

But let's run it on Markov Three now, so this is what he had done before.

If we come back over here at Markov Two,

he said there was three changes we'd need to make.

And now we can make those same three changes.

Here we go.

We're going to change the key length to three.

Let's see.

Everywhere we see a two, we change it to a three, and

this should give us even better, when we run it,

even a better random text generation that looks more like Romeo.

So those are the three things he changed before.

Our key down here will still be the same, it'll be of link three every time.

Let's try that.

Compile, markov runner.

And so it says markov two, but we're really running markov three.

And we're going to run it on Romeo.

Now let's see what we get.

Oh yeah there we go.

Nurse, good hite me, my go all!

Those look like words, so that looks pretty good.

Now, love, ear, eyes, for the, so

we're getting almost real words now for most of these.

That looks much better, so, sometimes when your program doesn't look quite right,

you're going to have to think small, test cases, and

add some print statements to print out to figure out what's going on,

because you may think one thing and something else is going on.

Anyway this looks a lot better, thank you.

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

Coursera
Acerca de
Liderazgo
Empleo
Catálogo
Certificados
Certificados MasterTrack™
Grados
For Enterprise
For Government

Comunidad
Learners
Partners
Developers
Beta Testers
Translators

Conectar
Blog
Facebook
LinkedIn
Twitter
Instagram
Youtube
Blog de Tecnología

Más
Términos
Privacidad
Ayuda
Accesibilidad
Prensa
Contacto
Directorio
Afiliados