防止在不使用Java中的getter和setter的情况下从子类访问受保护的变量

Question

Without using getter and setter method how to prevent modification access from child class if super class has protected Hashmap variable?

This Map is mutable (So i should be able to add the values from super class)So can't use UnmodifiableMap(its only applicable immutable collection object)

    Class A
    {
      protected Map<Integer,Integer> m = new HashMap<Integer,Integer>();
      A()
       {
         m.put(10,11)
         m.put(11.12)
       }

      }

    Class B extends A
    {
      B()
      {
        super.m.put(34,90)    —— I don’t want to give access to child       class to add 

the value and child class and its only should able to get the values. } }

Answer 1

Make the map unmodifiable, and populate it in the construction of A.

class A {
    protected final Map<Integer,Integer> m;

    A() {
        Map<Integer, Integer> tempMap =  = new HashMap<>();
        tempMap.put(10,11);
        tempMap.put(11.12);
        this.m = java.util.Collections.unmodifiableMap(tempMap);
    }
}

If and when B attempts to modify the map, a ´UnsupportedOperationException´ will be thrown.

If you want A to be able to modify the map, then you'll need a different approach in which the map is private, and a protected getter returns an unmodifiable map.

class A {
    private final Map<Integer,Integer> m = new HashMap<>();

    A() {
        m.put(10,11);
        m.put(11.12);
        // m remains modifiable within the context of A
    }

    protected Map<Integer, Integer> getMap() {
        return java.util.Collections.unmodifiableMap(m);
    }
}

EDIT

If you really don't want to use a getter but still have read-only access, you can use this approach.

class A {
    private final Map<Integer,Integer> writableMap = new HashMap<>();
    protected final Map<Integer,Integer> m = Collections.unmodifiableMap(writableMap);

    A() {
        writableMap.put(10,11);
        writableMap.put(11.12);
    }
}

Using this approach, only m is visible outside A, and is read-only. Within A, you can update writableMap and these changes will be visible in m

Answer 2

Here is a variant of what Steve Chaloner presented in his answer:

public class A {

    private final Map<Integer, Integer> map = new HashMap<>();
    protected final Map<Integer,Integer> m = Collections.unmodifiableMap(map);

    public A() {
        map.put(10, 11);
        map.put(11, 12);
    }
}

The private map is modifiable in the A class and changes will be reflected in the protected m whenever changes are made in map .

---

It is being used this way in Concurrency In Practice for example.

Answer 3

This should be the best solution Composition :

Implement a new Map and keep an internal private modifiable map like this:

class A {

    private Map<Integer,Integer> m = new HashMap<>();

    protected Map<Integer, Integer> map = new Map<>() {
        //implement interface
        public Integer put(Integer key, Integer value) {
            throw new UnsupportedOperationException();
        }

        public Integer get(Object key) {
            return m.get(key);
        }

        public void clear() {
            throw new UnsupportedOperationException();
        }

        public boolean containsKey(Object key) {
            return m.containsKey(key);
        }

        public boolean containsValue(Object value) {
            return m.containsValue(value);
        }

        //
        // ... And so on
        //
        // ... with all other methods
    }

    A() {
        m.put(10,11)
        m.put(11.12)
    }


}

class B extends A {
    B() {
       super.map.put(34,90) // thorws exception
       super.m.put(34,90) // inaccesible
    }
}

All modifications are allowed in A via m but subclasses may only acces them by map that was succesfully blocked modifications.