Both answers given will solve your technical issue, but neither answers your final question, so here goes, with some additional info which will help you understand this a bit more.
Also why would they be conflicting? Even though I am overwriting the
same class I am changing different functions?
When you rewrite, you replace the class with your custom class. The entire class file is replaced. It is not merged with the rewritten (original) class.
If your custom class extends the original class (not a requirement, but this usually is what gets done), it naturally becomes the parent class, and you can inherit any functionality.
You can only rewrite a class once. That is a limitation on using rewrites. The last loaded module will then logically be the class that replaces the original class.
Module load order is alphabetical (I think, someone correct me if I am wrong, please), but there is also a dependency load order that precedes alphabetical.
If, for example, you know that the other class that is performing the rewrite is no longer adding any functionality to the system, you can simply make your module depend on it. The module load order will then ensure your module load after it, and thus affect the rewrite. Yes, you will get warnings with some tools that there is a conflict, but it is then a false positive, and can be ignored. It helps to document this for other developers (please)
The normal way to solve conflicts is to chain the class files together, and in only one effect the rewrite. You have to remove the rewrite directive form the other modules config.xml. As mentioned this makes upgrading a pain. Again such actions should be well documented. It WILL cause you lots of pain down the road if forgotten, after you update extensions, thus loosing the changes.
As mentioned in one of the other answers, you should try and use events. Most of rewrites done can actually be done with events. Not all. But most.
Usually it does require a lot more effort, and more clever code, but that's the fun part :)
Also, when making changes to the display layer, you don't always even need rewrites, or events.
By using layouts, you can change the block of a template, and from you new template block simply extend the original template block. Now you have your custom code in action, and can derive all teh core functionality for that blocks output.
Too many times I have seen rewrites for blocks, that is simply not needed. Unnecessary complication.
Anyways, that's my 2c to this answer :)