Polymorphism question for my custom class

Hi all,
I have used polymorphism in the past, but not with anything too complicated. This time, I have a class which stores a bunch of info about the object I pass into it, and I wrote a very similar class for a different type of object in another script, which seems like a waste of time and typing since I could probably make a master class, and use copies of it instead of writing it over and over again, but I'm not 100% it's a good idea for this specific class. Here is the first class I wrote:

public class HUDElement
	{
		// Store object information for the passed GameObject
		private HUDSettings.HUDType _hudType;
		private HUDSettings.NGUIType _nguiType;
		private GameObject _hudObject;
		private GUITexture _gTexture;
		private bool _hudState;
		private bool _isControl;
		public HUDElement( HUDSettings.HUDType type )
		{
			this._hudType = type;
		}
		public void Init( GameObject go, bool state, bool isControl, HUDSettings.NGUIType nguiType )
		{
			_hudObject		= go;
			_gTexture		= go.GetComponent();
			_hudState		= state;
			_nguiType		= nguiType;
			_isControl		= isControl;
			// Toggle HUD Element to its default starting state,
			// this prevents HUD elements that are turned off by default from being activated on Initialization
			Toggle( state, true );
		}
		public void Toggle( bool isActive, bool isInit = false )
		{
			if( _hudType == HUDSettings.HUDType.BOOST && isInit == false )
			{
				if( _hudObject ) _hudObject.SetActiveRecursively( isActive );
			}
			else
			{
				if( _nguiType != HUDSettings.NGUIType.NONE && _hudObject )
				{
					switch( _nguiType )
					{	
						case HUDSettings.NGUIType.UISlicedSprite:
							var uiSliceSprites = _hudObject.GetComponentsInChildren();
							foreach( UISlicedSprite s in uiSliceSprites ) s.enabled = isActive;
							break;
						case HUDSettings.NGUIType.UISprite:
							var uiSprites = _hudObject.GetComponentsInChildren();
							foreach( UISprite s in uiSprites ) s.enabled = isActive;
							break;
					}
					// No need to toggle the gameObject itself nor check for a GUITexture, so let's stop here.
					return;
				}
				if( _gTexture != null ) _gTexture.enabled = isActive;
				else if( _hudObject ) _hudObject.active = isActive;
			}
		}
		public HUDSettings.HUDType HudType{ get{ return _hudType; }}
		public HUDSettings.NGUIType NGuiType{ get{ return _nguiType; }}
		public GameObject HudObject{ get{ return _hudObject; }}
		public GUITexture GTexture{ get{ return _gTexture; }}
		public bool HudState{ get{ return _hudState; } set{ _hudState = value; Toggle( _hudState ); }}
		public bool IsControl{ get{ return _isControl; } set{ _isControl = value; Toggle( _isControl ); }}
	}
	private HUDElement[] HUDElements = new HUDElement[(int)HUDSettings.NumOfHUDTypes];


	private HUDElement _mainHUD = null;
	public HUDElement MainHUD
	{
		get
		{
			if( _mainHUD == null ) _mainHUD = HUDElements[(int)HUDSettings.HUDType.MAIN];
			return _mainHUD;
		}
	}
	
	private HUDElement _menuHUD = null;
	public HUDElement MenuHUD
	{
		get
		{
			if( _menuHUD == null ) _menuHUD = HUDElements[(int)HUDSettings.HUDType.MENU];
			return _menuHUD;
		}
	}
	
	// more properties.......
}

Next, here's the second - similar - class I wrote for another type of object:

public class ControlElement
	{
		private ControlSettings.ControlType _controlType;
		private GameObject _controlObject;
		private bool _controlState;
		public ControlElement( ControlSettings.ControlType type )
		{
			_controlType = type;
		}
		public void Init( GameObject go, bool state )
		{
			_controlObject	= go;
			_controlState	= state;
			// Toggle this Control Element to its default starting state,
			// this prevents Control elements that are turned off by default from being activated on Initialization
			Toggle( state );
		}
		public void Toggle( bool isActive )
		{
			_controlObject.active = isActive;
		}
		public ControlSettings.ControlType ControlType{ get{ return _controlType; }}
		public GameObject ControlObject{ get{ return _controlObject; }}
		public bool ControlState{ get{ return _controlState; } set{ _controlState = value; }}
	}
	private ControlElement[] ControlElements = new ControlElement[(int)ControlSettings.NumOfControlTypes];


        private ControlElement _accelControl = null;
	public ControlElement AccelControl
	{
		get
		{
			if( _accelControl == null ) _accelControl = ControlElements[(int)ControlSettings.ControlType.ACCEL_BTN];
			return _accelControl;
		}
	}

	private ControlElement _brakeControl = null;
	public ControlElement BrakeControl
	{
		get
		{
			if( _brakeControl == null ) _brakeControl = ControlElements[(int)ControlSettings.ControlType.BRAKE_BTN];
			return _brakeControl;
		}
	}
	
	// more properties...
}

So my question is, given the differences between those 2 classes, is it still a good idea to use polymorphism with copies of 1 master class?
Thanks for your time guys!
Stephane