This course is the fourth course in the specialization about learning how to develop video games using the C# programming language and the Unity game engine on Windows or Mac. Why use C# and Unity instead of some other language and game engine? Well, C# is a really good language for learning how to program and then programming professionally. Also, the Unity game engine is very popular with indie game developers; Unity games were downloaded 16,000,000,000 times in 2016! Finally, C# is one of the programming languages you can use in the Unity environment. This course assumes you have the prerequisite knowledge from the previous three courses in the specialization. You should make sure you have that knowledge, either by taking those previous courses or from personal experience, before tackling this course. The required prerequisite knowledge is listed in the "Who this class is for" section below. Throughout this course you'll build on your foundational C# and Unity knowledge by developing more robust games with better object-oriented designs using various data structures and design patterns. Data structures and design patterns are both general programming and software architecture topics that span all software, not just games. Although we'll discuss these ideas in the game domain, they also apply if you're writing a web app in ASP.NET, building a tool using WinForms, or any other software you decide to build. Module 1: Explore a Dynamic Array data structure and learn the basics of algorithm analysis Module 2: Learn about and use the common Linked List and Graph data structures Module 3: Learn about and use several additional data structures: Stacks, Queues, and Trees Module 4: Learn why design patterns are so useful and discover a number of design patterns useful in game development Module 5: Complete final peer review “Unity” is a trademark or registered trademark of Unity Technologies or its affiliates in the U.S. and elsewhere. This course is an independent work and is not sponsored by, authorized by, or affiliated with Unity Technologies or its affiliates
Implementing an Interface
Loading...
来自 University of Colorado System 的课程
Data Structures and Design Patterns for Game Developers
15 个评分
University of Colorado System
15 个评分
课程 4（共 5 门，Specialization C# Programming for Unity Game Development）
从本节课中
Dynamic Arrays and Algorithm Analysis
与讲师见面
Dr. Tim "Dr. T" ChamillardAssociate Professor
Computer Science
In the previous lecture,
we saw how we can add a constraint to a generic
if we need a data type to implement a specific interface.
In this lecture, we'll learn how to implement an interface.
In this example, we want to create an ordered dynamic array of rectangles,
and then add rectangles to that array,
and then print the rectangles in the array.
So, here's our Rectangle class at this point.
We just have width and height fields,
a constructor, properties to get the width and height,
and a ToString method so we can convert
the rectangle to a string to print it out in our main method.
So, the first thing I want to do is create an ordered dynamic array of rectangle,
and I'll just call it rectangles.
And of course, I'll create a new one,
and I'll hit Enter so you can see it all on the screen.
So, when I compile, I get an error.
And the error says that the Rectangle class doesn't implement the IComparable interface.
And we know that because we didn't do anything to implement that interface.
So, over here in the Rectangle class,
the first thing we do is we say that this class will implement the IComparable interface.
And you'll notice that the syntax here is just like when we say
a particular class is a child class of another class.
But in this case, we're just saying,
we will provide whatever methods the IComparable interface requires.
And if you remember from our discussion about the ordered dynamic array,
the method that we need is the CompareTo method.
If I try to compile again,
I get another error.
And this error says that the Rectangle class doesn't implement the CompareTo method.
So, once I say,
I'm going to implement a particular interface,
I'm required to provide all the methods in that interface.
How do you know what those methods are?
Well, you read the documentation.
Here's the documentation for the IComparable interface.
And you'll notice that it says that it defines
a type-specific comparison that the class implements to order or sort its instances,
and that's exactly what we need.
And if we scroll down,
we find out there's a specific method and that's all we need.
And if we click on that method,
we can get more details about how that method is supposed to work.
Specifically, the CompareTo method
compares this object to another object of the same type,
and returns information about the relative order.
So, if the current instance is before the parameter then we return a negative number,
and if they're at the same position in terms of order then we return zero,
and if it's after the parameter then we return some number greater than zero.
If, in fact, the parameter is not
the same data-type as the class in which we're implementing this method,
we actually throw an argument exception.
And there is an example right here.
And the easiest thing to do,
is just to copy this and bring it over into our rectangle code,
and then make the appropriate adjustments.
So, first of all, I'll add a documentation comment.
And it returns relative order.
And this is the object to compare to.
I'll do some adjusting of curly braces and add some comments as well.
So, this is always greater than null.
And that by definition in the documentation,
you are allowed to omit
the curly braces for an if statement if you only have one statement,
but I always include curly braces,
so I'll do that now.
We'll also make sure that the object is actually a rectangle.
So, I'll say, check object type.
And of course, this is a rectangle.
And remember, this is like a type cast,
so if we say,
obj as Rectangle, if this is successful, if in fact,
obj is a Rectangle,
I'll rename this to be otherRectangle instead.
So, if this is successful because obj is a rectangle,
then we can now treat other rectangle as a rectangle object.
If obj is not a rectangle,
then this will be null at this point,
and that's why we have this check for null.
And if the object is not a rectangle,
so obj isn't a rectangle,
then we throw the exception because that's what the documentation tells us we should do.
If, in fact, we actually have a rectangle here,
we now need to decide how do we tell which one comes before the other in the sort order.
And I'm going to say that we're going to sort by area.
So, if width times height,
so this is the width and height of the rectangle we're inside right now,
if that is less than
the other rectangle width times the other rectangle height,
then that means that this rectangle comes before the other one in the sort order,
so I'll return negative one.
Remember, it just has to be any number less than zero,
but I typically return negative negative one, zero,
and one from my CompareTo method.
We now need to check to see if they're equal.
So, if they're equal,
I will return zero.
And the only other possibility is that
the current rectangle we're inside comes after the other one.
And I don't have to check anything at this point,
I can just return one.
So, we knew, when we implemented the IComparable interface,
that we had to provide a CompareTo method,
and we read the documentation for the CompareTo method to
see exactly how that method had to behave.
I can now compile just fine.
So, this is very exciting that we've finally been able to create the array of rectangles.
The big idea is that we actually learned how to implement the interface that we needed to
implement in order to create an ordered dynamic array of rectangle objects.
The rest of this is pretty straightforward.
So, we will add a few new rectangles.
Let's add a three by four rectangle,
a two by two rectangle,
and a one by two rectangle.
Finally, we'll print out the rectangles in the array to make sure
that they ended up in the array in sorted order,
the way we expected them to.
So, I'll just Console
Wrightline the rectangles ToString,
and if I control F5 at this point,
we see that we get the smallest area rectangle first,
and then the middle area rectangle next,
and then finally, the largest area rectangle.
So, the ordered dynamic array worked properly,
given the fact that we implemented the ComparedTo method in
the Rectangle class the way we had to do based on the IComparable interface.
To recap, in this lecture,
we learned how to implement an interface.
And we also learned that we need to read
the interface documentation to make sure we implement that interface properly.
