Note that each instruction has several different Addressing Modes. The instruction opcode (the first byte) indicates the instruction AND the addressing mode.
LDA $aabb would be an example of "Absolute Addressing".
That's AD bb aa in Hex. It means to LoaD (read) the A (accumulator) with the value from address $aabb. That's the CPU address. $0000-07FF is RAM, $6000-7FFF is SRAM, $8000-FFFF is a ROM bank.
STA $aabb (hex 8D bb aa) is the reverse, it STores A. Note that you can only actually store to a RAM address. Trying to write to a ROM address is typically what activates the Mapper's functionality (since you can't actually write to ROM). You'd need to read a document on whatever mapper DW2 uses (MMC1?) to know what mapper writes do, but typically documents will denote things like "write to $8000-9FFF". That means that writing to any address between $8000 and $9FFF will have the same stated effect.
LDA $aa (with only one byte) is an example of "Zero Page" Absolute Addressing. It's like the above except that (like its name implies) the high byte is 0, so it's limited to an address between $0000 and $00FF.
That's A5 aa in Hex.
STA $aa (hex 85 aa) is again the reverse.
LDA #$aa (with the # in front) is an example of "Immediate". It means to load A with the specified value.
JSR $aabb (hex 20 bb aa). Jump to Subroutine. Makes the CPU run a function at $aabb. The CPU will automatically store the address to a part of RAM known as the "Stack". The called function will end with an "RTS" instruction ("Return from Subroutine") (hex 60).
Note that games can and will JSR to functions that will call another JSR. Those will nest, meaning that successive RTS instructions will close functions in the order of most recent first.
(the "Stack" is called that because it should be visualized as a stack of plates. When you make a stack of plates, you typically when adding a plate to the stack add it to the top (people don't usually insert a new one five plates down), and when you remove one you remove the top one.
Imagine if those plates had numbers written on them and maybe that is you can imagine the RAM Stack.)
Two other very common instructions to watch for are PHA and PLA.
("Push Accumulator" and "Pull Accumulator") They will insert and remove, respectively, from the "Stack" (the same area mentioned in JSR).
Generally PHA will be used to "save" a value (since the Accumulator can only hold one value at a time, PHA is used when something is important enough to remember but not important enough to give it a more permanent storage) and PLA will be used to "restore" it. (as with JSR address, they can be only restored in the order of most-recent saved value first)
I you technically could (you could be that guy that lifts the stack of plates to get the fifth one down), but for simplicity of understanding the concept of a Stack let's say you can't. (You're a typical human who grabs from the top.
As to using PHA/PLA to save/load values, compared to using LDA/STA to read/store to RAM, is kind of like how with emulators that give you the option to Save and Load savestates with specific filenames. But you use the Quick Save and Load for small progress when you don't care about the file location. PHA and PLA is like that "don't care" savestate slots vs. LDA/STA to a RAM address that has a definable purpose is like the "do care" savestates)