Had fun solving this one.

The trick to this that I found is actually a new thing, [SerializeReference], which does a few things, one of which lets you do polymorphic serialization, which this question requires.

The major steps to solving this:

• Add [SerializeReference] to the data field.
• Add a static method that creates a new instance depending on the desired type
• Add a custom editor that checks the type field for changes, and if it changes, create a new instance with the above method and assign it to the data field

Altogether, this gives you this kind of result:

[CreateAssetMenu(fileName = "Data", menuName = "Inventory/Item", order = 1)]
public class ItemObject : ScriptableObject
{
    [CustomEditor(typeof(ItemObject))]
    public class ItemObjectInspector : Editor
    {
        SerializedProperty m_type;
        SerializedProperty m_data;

        private void OnEnable()
        {
            m_type = serializedObject.FindProperty("type");
            m_data = serializedObject.FindProperty("data");
        }

        public override void OnInspectorGUI()
        {
            serializedObject.Update();

            EditorGUI.BeginChangeCheck();
            EditorGUILayout.PropertyField(m_type);
            if (EditorGUI.EndChangeCheck())
            {
                m_data.managedReferenceValue = 
                        ItemObject.CreateBlankData((ItemType)m_type.intValue);
            }

            // avoid drawing type a second time
            // avoid drawing annoying Script field
            DrawPropertiesExcluding(serializedObject, new string[] { "type", "m_Script" });
            serializedObject.ApplyModifiedProperties();
        }
    }

    [System.Serializable]
    public enum ItemType
    {
        Physical,
        Magical
    }

    // Determines how to create an Item from each ItemType
    public static Item CreateBlankData(ItemType type)
    {
        switch (type)
        {
            default:
            case ItemType.Physical:
                return new PhysicalItem();

            case ItemType.Magical:
                return new MagicalItem();
        }
    }

    [System.Serializable]
    public class Item
    {
        [SerializeField] public string typeDescription;
    }

    [System.Serializable]
    public class MagicalItem : Item
    {
        [SerializeField] string elementName;

        public MagicalItem() { typeDescription = "Magical"; elementName = "fire"; }
    }

    [System.Serializable]
    public class PhysicalItem : Item
    {
        [SerializeField] float materialHardness;
        public PhysicalItem() { typeDescription = "Physical"; materialHardness = 1f; }

    }

    public ItemType type;
    [SerializeReference] public Item data;
}

Note: all the above classes are only inner classes for the sake of brevity. They can be separate classes or inner classes with no issues.

Just as an addition to Ruzihm's good answer.

For this kind of stuff you could actually skip the overhead of implementing a custom editor and simply use OnValidate

This function is called when the script is loaded or a value is changed in the Inspector (Called in the editor only).

So simply e.g.

private void OnValidate()
{
    switch(type)
    {
        case ItemType.Magical:
            // To avoid losing already filled in data
            // simply check if the current data already has the correct type
            if(data != null && data.GetType != typeof(MagicalItem))
            {
                data = new MagicalItem();
            }
            break;

        case ItemType.Physical:
        default:
            if(data != null && data.GetType != typeof(PhysicalItem))
            {
                data = new PhysicalItem();
            }
            break;
    }
}