Classes - single inheritance multiple interfaces - part 4 of N [D Language - Dlang Episode 143]

追加: 2026-05-25

[00:00:02]Hey, what's going on folks? This is Mike here and welcome back to my D programming language series. In today's episode we're going to be talking about inheritance as it's related to classes.

[00:00:09]So, with that said, let's go ahead and dive on to the D programming language website here, into documentation, the language reference, and into classes.

[00:00:17]Now, again, when we were first learning about classes in one of the earlier videos, so make sure you checked out the earlier videos, uh we learned again classes are basically D's solution for object-oriented programming. So, they're again different from structs. We've again covered that in a previous video, so make sure you check out that playlist there. Uh but the basic idea is for classes, where we're defining our own type here, uh we have the ability to perform inheritance through classes. Now, again, D supports single inheritance, uh so no multiple inheritance, uh and that's basically the way to extend a type. But everything sort of lives within the same family. So, what do I mean by that?

[00:00:52]Let's just go ahead to the whiteboard here. So, if you're not familiar with this idea here, uh let's just go ahead and draw this out. And basically, what that means is we might have some base class here. Uh let's go ahead and make this a little bit different here. There we go, base class.

[00:01:07]And we'll have sort of a hierarchical relationship here, meaning I can derive a new type here. So, we'll have derived here.

[00:01:14]And as an example, the classic example is here, maybe we'll have a dog. It'll have some functionality here. So, let's just add some functionality like, uh for instance, it can uh bark.

[00:01:26]It can run, you know, some common things here. But then what what if I derive another type of dog here, uh maybe a husky, for instance, and we'll want to override how this dog runs here. Okay, so we'll override, and I'll write that out here, how it runs. And that's the basic idea. Then I can derive something else here, um from dog, another type of dog here, and pick your favorite, maybe a golden retriever here, and maybe we change how that dog uh barks, for instance. Okay? But it has the default sort of implementation of whatever the run is here. Okay?

[00:02:04]And these here that I'm defining, these are classes uh that I'm going to be using today. And we can still combine in the idea of an interface that we learned about last time. So, let's just say we have some other interface here for things that maybe animals can do.

[00:02:20]And I'll just label it as interface.

[00:02:25]Sorry, I will squeeze in that writing here. And maybe there are again things that all of them can do.

[00:02:30]Uh let's see, we have running, we have barking, and let's just add, I don't know, walking, something like that. So, we can equally have each of these uh either at the top of the hierarchy uh use or inherit to this interface, and then by default, that means everything else will have to inherit this interface. Or we can be more selective, and what if we say only uh goldens, for instance, or for whatever reason, can walk, then we can also perform uh just a uh sort of uh adherence to this interface from our golden class. Okay? So, we'll look at a few of these scenarios, so we can see how all the tools work together.

[00:03:06]Uh and I think for today, we're just going to go ahead and um dive into the code for the most part here.

[00:03:12]Um let me see if there's anything else related to inheritance uh that we can kind of queue up here.

[00:03:17]Um yeah, we'll kind of get to this idea.

[00:03:19]Again, just want to emphasize again, multiple class inheritance is not supported, but you can have again multiple interfaces. I think we touched on that in one of the previous lessons already, as well.

[00:03:29]Uh and then again, by default, uh as was also mentioned, everything is a type of object. Um so, again, that's sort of similar if you're coming from a Java world, uh D has that same sort of uh idea here.

[00:03:40]Okay? So, if you just wanted a generic collection of stuff, um objects, classed class-based objects, uh you can do that with objects. And again, D knows the runtime type information here. So, I'll actually show you so you can figure out am I looking at class A, class B, uh what exactly am I looking at? Okay? So, anyways, we'll get into this. So, let's go ahead and uh let's just dive into the uh code editor here.

[00:04:05]Um and we'll take a look at this cuz um I think we got a few neat things uh to show you here. So, let's uh start with um an example. We'll make this a little bit concrete. Let's use um Ooh, just to make it fun, let's use monster as sort of our base class here. Uh I'll give you a note here. Our base class or sometimes the superclass, okay? Uh and we're going to see this keyword super come up. I'm going to use it a little bit more in probably the next video here. Uh but again, that's the sort of the highest-level thing on the hierarchy, right? That's what we were showing here uh when I mean highest-level thing on the hierarchy, okay? And maybe we draw these arrows pointing up to show that we're deriving from uh our uh the drive class drives from the base class, okay?

[00:04:53]Um all right. So, anyways, let's go ahead and continue on with our monsters.

[00:04:58]And let's go ahead and create some base class here like a dragon.

[00:05:03]And it's going to be a type of monster.

[00:05:06]And simple as that here, okay? Just the colon and then the type that we have here. Um And we can go ahead and compile that.

[00:05:14]That works here. Um again, if you're coming from other languages, you know, maybe you're like, "Well, what if I put public there or something?" Uh yeah, we don't really do uh that type of thing here, right? We just sort of derive uh from it here, okay? Uh let's say monsters, they all have certain attributes here like their power and their health, for instance.

[00:05:34]And then if I uh I basically uh can derive from uh monster here into my dragon, I also have these attributes here. So, I'm going to put in comments just so we see here um the public Let's see, public attributes uh are uh available. Public or protected uh attributes are available. So, we effectively have power and health here. Okay?

[00:06:05]Uh and that's the idea. And the way that we talk about dragon, if you're not familiar with inheritance, is dragon uh is a type of monster. Okay?

[00:06:17]Uh so, again, that's the the idea here.

[00:06:19]So, now what I can do is, for instance, if I have just an array of monsters here, I can do something like monster, and I can append to it a new dragon, right?

[00:06:30]Because, well, anything that is a type of monster belongs in this collection, and that includes dragons here. Okay?

[00:06:37]So, that is the idea. Let's go ahead and compile that just to make sure we're in good uh state here. Uh oh, what did I do here? Monsters.

[00:06:45]There we go.

[00:06:47]With yes. Okay, so that is compiling code and our first uh class here that we can be happy with.

[00:06:53]Now, um let's play around with this just a little bit here, cuz we've sort of talked about these public attributes here. What if I made this uh private here? Okay?

[00:07:03]Uh and let's make this private here.

[00:07:06]And okay, so that's that's good news.

[00:07:11]And let's go ahead and make a maybe a constructor here.

[00:07:15]Uh I'm just going to say int p and h.

[00:07:18]And let's assign these. Power equals p, health equals uh h.

[00:07:25]And I'm effectively just going to copy this constructor over to the dragon here. Okay? And what I want to be teaching us about is these uh attributes and how these accessories work when we're doing uh inheritance. So, let's go ahead and try this out.

[00:07:38]And uh let's see what's happening here.

[00:07:40]Okay, error. Constructor. Okay, so however we're creating our dragon, that's illegal.

[00:07:45]All right, we've defined a destructor. I mean, by default we get a implicit constructor for us. So, I need to say the power I'm calling this constructor here is five and the health is I don't know, eight here. Maybe it's a pretty weak dragon here.

[00:08:01]Okay, so now what's going on here?

[00:08:04]Error, constructor main.dragon.this no match for this implicit super call in the constructor. Okay.

[00:08:12]What does this mean here? Well, in order to derive this new class, because dragon is a type of monster, I need to also construct the monster here. So, it's saying, "Hey, there's no How do I call the, you know, sort of monster constructor?" So, implicitly it would call at the start like a this constructor if I define it. Okay, so that will satisfy our compiler here.

[00:08:36]But, I'm actually going to talk a little bit more about this in the next video here. So, I'll example.

[00:08:43]But, what I want to just focus on is this here.

[00:08:45]Now, you might be wondering, I mean, this is kind of interesting. I have, okay, these attributes here for private, I am able to access them here. I mean, that's that's sort of true that I'm able to do this. But, again, remember these sort of privacy level sort of module level.

[00:09:05]Okay? So, I have these, I mean, I can change these attributes and they definitely don't go away, right?

[00:09:11]When I sort of have these here.

[00:09:14]And let's go ahead and write out what would be monsters at index zero, the power.

[00:09:23]Let's actually see if that was actually constructed here.

[00:09:27]And the health. Let's go ahead and do that here.

[00:09:30]Okay, five and eight. Okay, so it is changing it here.

[00:09:33]But, you might be saying again, "Well, this is a little bit strange that I have power and health here. I've marked them private. So, again, if you're coming from other object-oriented languages, you'd say, "Well, you know, those shouldn't be things that should be derived." But, again, remember in D, the visibility level is module level. So, I can see everything uh here. So, usually what we would do is per type um is just go ahead and say, "Hey, let's just go ahead and create a monster.d file. Let's put this in here."

[00:10:02]Let's create a dragon.d file.

[00:10:06]Uh let's go ahead and put this in here.

[00:10:10]And let's go ahead and structure our code just a little bit here.

[00:10:13]Uh let me get rid of these comments here.

[00:10:16]Let me fold them.

[00:10:17]Uh let's see here.

[00:10:19]Uh I got to do the set fold method manual for now. There we go.

[00:10:27]All right. So, anyways, let's let's make sure we can see all of our code here that we have written.

[00:10:32]Um and then in order to use these uh modules here, uh oh, let's actually just uh let's actually just try to compile this and see what errors we get first.

[00:10:44]Um I think that's usually more interesting. Uh let's see. So, let's make sure we save everything. Save, save, save.

[00:10:52]Okay. So, okay, first things first, undefined identifier monster. So, again, why is that happening? Well, I need to import the monster file here.

[00:11:00]Uh so, let's save there.

[00:11:02]Uh got a little bit closer. Now, undefined identifier dragon.

[00:11:06]Let's bring in the dragon as well. And indeed, you can do these imports uh with commas. I actually like doing that. And I usually do that for things that are in the sort of same family. So, the standard libraries usually end up with one line comma separated. My libraries usually end up another one, and then maybe third-party libraries. Uh so, anyways, just a little note on that there.

[00:11:26]Uh okay.

[00:11:27]Uh so, we got basically uh a little bit closer here.

[00:11:30]Uh and then let's see in our uh, dragon file, well, we need to import monster.

[00:11:38]Okay, because that's what it's deriving from.

[00:11:40]Uh, okay, now we're getting more interesting error messages, maybe the thing that you would sort of expect here. We are getting no property uh, at line uh, eight here in our main file, where we're saying, "Hey, dot power, there's no property power here for this type." So, um, and again, the same sort of repeated error here, because these are private here. Okay? So, what if I did, let's just go ahead and practice here, protected.

[00:12:07]Okay, protected.

[00:12:09]Okay, let's try to work our way um, and make this less less encapsulated here.

[00:12:16]Uh, still same thing, right? I shouldn't be able to access these outside of the class. These are legal here, it's definitely not complaining about them there, so that's good. Uh, but if I do make these public now, okay, that will work. Okay? So, again, that's just a little bit about how the encapsulation works with the access control. Uh, and you can do the things like maybe you're used to in uh, like C++ something like that. Just make everything public, that also works here. Okay?

[00:12:44]Uh, I tend to probably go more this style. I guess it's just a little bit more explicit, although I go back and forth, but anyways, that's something you can do here.

[00:12:54]All right, so there you have it. That's how to sort of uh, separate out things here.

[00:12:59]Um, and that gives you a basic uh, look here um, of these different uh, types here.

[00:13:05]Now, let's keep playing around with this just a little bit more here.

[00:13:09]And uh, as I was alluding to in this uh, diagram here, we can also have interfaces. Okay? So, let's go ahead and take a look at how an interface affects this.

[00:13:21]Um, and what I think I'm going to do here is just apply it to the monster here. Let's have this interface. Um and let's go ahead and say there's going to be a interface for like breathe fire or something, right? We'll have some lizards, some dragons, and you know, whatever other creatures can breathe fire. And then we want it, you know, do the uh fire attack. You know, something aggressive like that here, okay?

[00:13:45]Um so, uh what do I need to do here?

[00:13:48]Well, let's say in my class uh for monster, let's say I want to have this uh breathe fire here interface.

[00:13:58]Going to compile this and it's going to say, "Okay, hey, uh monster interface function void fire attack is not implemented." So, what do we need to do here? Well, we need to implement the breathe fire attack here.

[00:14:09]Breathe fire.

[00:14:10]Uh and let's go ahead and do this for all of our monsters, okay?

[00:14:17]Um okay. So, again, now our monster uh has implemented fire. We didn't have to do it in dragon. Why? Because dragon is a type of monster, so it's going to inherit that behavior, right? This is by default public function that is inherited here. Now, you might say, "Well, dragons, they breathe a lot of fire. So, um let's go ahead and implement this again."

[00:14:41]Uh and what's going to happen here if we try to compile? And you might have seen this error if you're watching all my videos when we did two string. Go ahead and hit enter. Uh we need to explicitly uh override this, okay?

[00:14:53]Uh we can't have the same function twice, so we use override there.

[00:14:58]And then we'll have the, you know, specific implementation for the dragon here, okay? So, that's one way that we can uh do things here uh with these interfaces.

[00:15:08]Now, um I would say it doesn't really make sense for mons all monsters to breathe fire. Um so, let's go ahead and take this off here. And this is where interfaces can be kind of neat. So, we'll have our base sort of monster class here.

[00:15:23]Let's get rid of the fire attack.

[00:15:26]And then what I'll do here is I want my dragon to be a type of monster. And then D is smart enough that if we pass in the symbol here for the breathe fire here then our dragon will have to implement breathe fire. Let's see what kind of error we get if we leave that override there. I guess it doesn't complain too much here. Let's make sure we saved everything.

[00:15:49]That's kind of neat.

[00:15:51]Let's see here. So I guess I got to override in the interface or let's just implement it there. Perfect. And then you know, we might have other attributes for our monsters.

[00:16:02]Let's have another interface here for flying you know, ability here. Fly.

[00:16:11]And let's go ahead and Yeah, dragon should fly.

[00:16:16]And undefined identifier here. Let's see a flying, sorry.

[00:16:22]Flying, there we go.

[00:16:24]And same thing here. So we can have multiple interfaces. So remember multiple interfaces are allowed. Multiple inheritance is not allowed. Only one type here. Okay, so dragons can have as many interfaces that they want. And this is kind of a nice way to code here. So let's go ahead and do our fly.

[00:16:46]And then we can see everything here.

[00:16:48]Okay, so that's the basic idea here with inheritance and mixing in interfaces which we've just learned about here.

[00:16:56]All right, so last little thing that I want to go ahead and show you here. Let's go ahead and let's just work in this little example here towards the bottom here.

[00:17:08]And let's go ahead and figure out if I have a monster. I'm just going to call monster M1. I need to use new to create that actual monster and then I do have a constructor here for the health and the power.

[00:17:23]And basically what I want to show you how to do it here is how to get the type, okay?

[00:17:29]So let's create monster two. This one I'm going to say is a new dragon.

[00:17:36]Let's bump up the power a little bit there.

[00:17:38]And what if I want to instantiate this as a dragon for this one here?

[00:17:44]I'll just call it D1 here and let's just give it a new power or something just to be a little bit random here.

[00:17:51]First and foremost, this should work.

[00:17:53]Yes, that's good.

[00:17:54]But what I want to show you here is the types here.

[00:17:58]Type ID of M1 monster one. That's at line number 12 here. And let's just write that out there, okay? Let's repeat this here.

[00:18:07]Do the same thing for M2 and for D1 here, okay?

[00:18:12]So what I'm showing you here is the run time type information of how the object was created, okay?

[00:18:25]At run time, okay? So what are your predictions here when I run this? Okay, it's going to print five and eight from our previous print out, but we should see this M1, M2, and D1. They should take on, you know, the type that they were instantiated at, right? And I can instantiate a monster as a type of dragon here. So I should see probably monster, dragon, dragon here, okay? So let's see if that's true.

[00:18:48]I see monster.monster, dragon.dragon, and dragon.dragon here, okay? Perfect.

[00:18:54]All right, so hopefully that makes sense when I'm using type ID.

[00:18:58]I want to just show you one other thing here.

[00:19:01]Um Can I do uh Let's see. Can I do sort of the reverse here? Dragon, let's try dragon seed equals new monster. Uh I don't know, something like that. Is this allowed? Can I go uh, sort of from the, you know, lower type and say, "Hey, create me something lesser." Sort of, you know, upcasting that direction. Yeah, we we can't really do that one, okay? So, just in case you were curious. Uh, illegal. Okay, this is going to give a, uh, error message here.

[00:19:32]I mean, we could maybe force cast it or something, um, but yeah, we, you know, we can't, uh, generally go in this, uh, direction here. Okay, so at least statically the type system's going to stop us. All right.

[00:19:44]Uh, so I showed you at run time how to figure out, okay, what is the type that we've used new with here.

[00:19:51]Okay. Uh, and let me make this a little bit bigger for you. There you are.

[00:19:56]Uh, and let's look at the type of, uh, m1 here.

[00:20:00]Uh, and I'm going to use string of, which is a property here, and then I'll use write line.

[00:20:06]Uh, and if this makes you a little bit uncomfortable, uh, the universal function call, uh, or uniform function call syntax here. Let me write out, uh, this is another way of writing this out, type of d1.stringof.

[00:20:21]Uh, you know, these are all doing the same thing here.

[00:20:24]Uh, I'll delete that just so you can see.

[00:20:27]Uh, and what is this doing here?

[00:20:29]Well, type of is telling me the left-hand side, monster, monster, and dragon. So, I do see monster, monster, and dragon here of m1, m2, and d1 respectively. Okay? And this can be, uh, handy, um, on occasion when you're using like is expressions to figure out, is something a type of, you know, uh, monster or dragon. Um, so anyway, I just wanted to show some of those tools so you can kind of have at least, um, this this at least is probably immediately more useful just remembering type ID, which we've used throughout the series.

[00:21:01]Um, so so you can see how the object was created, and then you can check, um, in your code, is this a type of dragon? Is this a troll? Is this a You know, figure out what this monster it was instantiated as, for instance, okay?

[00:21:15]All right, folks. So, I think I'll go ahead and cut it off there. So, working backwards, the things that we learned, again, we learned about a little bit about introspection here, figuring out the static type, left-hand side of the equation here.

[00:21:27]The runtime type, what we've newed the monster as. We've seen that things that are a type of monster can go into the collection here. So, uh by runtime polymorphism, it's a fancy way to say that, right? Um we can and D is doing sort of the bookkeeping for us, but it again allows us to add anything that is a type of monster into this collection. And this is one of the places where, again, inheritance is very helpful, okay? So, you learned about um how to add anything that's in this inheritance hierarchy into common collection, how to figure out the types, and then we've looked at um oops, let's uh runtime polymorphism.

[00:22:10]Uh then we looked at uh how to separate out our files into different uh well, our different types, rather, into different files, so that we can respect the public, private, and protected labels.

[00:22:24]Um in practice, I often have these in the same file anyways, cuz I don't care as much. I actually like this, but depending on what language you're coming from, you may or may not like this, right? So, you can split things into different files if that uh makes you happier, and that's probably the right thing to do. But, generally speaking, I like because I want my code to be very malleable, uh putting monster and dragon in the same file. But, again, um then you just have to think a little bit about how to enforce, perhaps, these uh public and private specifiers. So, anyways, we learned about that. Public is the default in D for both classes and structs, so just keep that in mind and that things are public to the module which are defined. So, that's why we move these into different files.

[00:23:08]Um and then we looked at last thing here, the single inheritance that we can have. So, dragon is a type of monster, but we can have as many interfaces as we want here for any of our class types, whether they're in a hierarchy or not.

[00:23:21]Okay, so just reminder on that.

[00:23:23]All right, folks. So, we covered quite a bit. I hope you enjoyed this lesson and as always, uh make sure you're following along. We're doing a lot of stuff with classes, so you can check out um courses.mshatto.io and follow along on the D programming language series here or ask questions in the community there or in the comments if you're watching this on YouTube. Um and otherwise, I hope you enjoyed this. We're going to be doing some more uh very, very soon. So, stay tuned for the next episode. Thanks for your time and attention and I'll look forward to uh seeing you in the next one.