Как принудительно использовать метод setter без использования private ? (общедоступный для чтения, закрытый для записи)

В Java нет понятия свойств, доступных только для чтения.

Если вы позволите r быть читаемым, кто-то может и изменит его случайным образом. Кроме того, это вредная привычка. Просто не надо. Длинный пример: что, если вам нужно, чтобы это функционировало в каком-то странном неевклидовом пространстве? Теперь вам нужно развернуть беспорядок, чтобы исправить это.

Реалистичные варианты:

Вы можете отклониться от нормы и назвать геттер r(). Почти такой же короткий.

Или вы можете поместить такую ​​математику в класс Circle, где она может напрямую обращаться к своим членам. Вы получаете лучшую часть инкапсуляции с более короткими именами.

class Circle() {
   static double alpha(Circle c1, Circle c2) {
      return c1.r + c2.r -2*c1.r*c2.r
   }
   ...
}

а). Не пропускайте использование геттеров и сеттеров, чтобы обеспечить инкапсуляцию вашего кода.

б). Если удобочитаемость является вашей проблемой, я предлагаю получить радиус с помощью метода getR() и сохранить в локальных переменных. например - int firstCircleRadius = first.getR() и аналогично для других кругов, и сделайте формулу легко читаемой, используя ваши локальные переменные.

в). Не используйте r в качестве имени свойства. Вместо этого используйте радиус, который сам по себе увеличивает читаемость.

Лично я бы использовал геттеры и сеттеры. Однако вы можете сохранить реальный радиус в частном члене, а затем использовать метод setR() для обновления фиктивного радиуса r. Это не решает проблему возможности изменить r вручную.

private int radius;
public int r;
public void setR(int r) {
    radius = r;
    square(); //do you squaring and other math
    this.r = r;
}

Недавно я был обожжен этой проблемой, и, рискуя получить кучу отрицательных голосов и гнев сообщества Java, я бы посоветовал НЕ полагаться на доступ к Java - в переменной класса или методе (или то, что я раньше думал, что "private" для инкапсуляции в объектно-ориентированном языке программирования. Просто используйте public для всего и спокойно спать по ночам. Вот объяснение. Рассмотрим следующий класс:

package hiddenscope;

public class Privacy {
    private int privateInt = 12;
    private double oneBy2pi = 0.5 / Math.PI;
    private String myClassName;

    public Privacy () { 
        privateInt = 12;
        myClassName = this.getClass().getName();
        print ("Constructor");
    }

    // Given the circumference of a circle, get its radius
    public double c2r (double c) {
        return c * oneBy2pi;
    }

    // Do not let any other class call this method
    private void print (String caller) {
        System.out.println ("["+caller+"] Current value of privateInt in class " + 
                                                myClassName + " is " + privateInt);
    }
}

Вот класс, который изменяет приватную переменную privateInt вышеприведенного класса и вызывает ее приватным методом «печати» даже из-за пределов пакета (защищено, кто-нибудь?):

package userpackage;
import hiddenscope.Privacy;

import java.lang.reflect.*;


public class EditPrivate {

    private int i2set;
    private String fieldNameToModify, myClassName;
    private Object p;
    private Method printer;

    public EditPrivate (Object object, String fName, int value) {
        fieldNameToModify = fName;
        i2set = value;
        p = object;
        myClassName = this.getClass().getName();
        Method[] methods = p.getClass().getDeclaredMethods();
        for (Method m : methods) {
            if (m.getName().equals("print")) {
                printer = m;
                printer.setAccessible(true);
                break;
        }}

        if (printer == null)
            return;

        try {
            printer.invoke (p, myClassName);
        } catch (IllegalAccessException ex1)        {   ex1.printStackTrace();
        } catch (InvocationTargetException ex2)     {   ex2.printStackTrace();
    }}

    public void invadePrivacy () throws Exception {
        Field[] fields = p.getClass().getDeclaredFields();
        for (Field field : fields) {
            String fieldName = field.getName();
            if (fieldName.equals(fieldNameToModify)) {
                field.setAccessible(true);
                if ("int".equals(field.getType().toString())) {
                    try {
                        field.setInt(p, i2set);
                        if (printer != null)
                            printer.invoke (p, myClassName);
                        return;
                    } catch (IllegalAccessException ex) {
                        ex.printStackTrace();
        }}}}
        throw new Exception ("No such int field: " + fieldNameToModify);
    }

    public static void main(String[] args) {
        try {
            Privacy p = new Privacy();
            new EditPrivate(p, "privateInt", 15).invadePrivacy();
        } catch (Exception ex) {
            ex.printStackTrace();
}}}

Чтобы усугубить эту травму, вот что происходит, когда несколько потоков искажают внутренние и частные переменные класса (предполагается, что oneBy2pi является закрытым!)

package userpackage;
import java.lang.reflect.Field;
import java.util.concurrent.*;
import java.util.*;

import hiddenscope.*;

public class ThreadedPi implements Runnable {

    Privacy p = new Privacy();
    private int nSample = 2000, bins[] = new int[4]; // 94814117 999065 0003379, 2028859
    private Field c2dField;
    private boolean mutate;

    public ThreadedPi () {
        Field[] fields = p.getClass().getDeclaredFields();
        for (Field field : fields) {
            String fieldName = field.getName();
            if (fieldName.equals("oneBy2pi")) {
                field.setAccessible(true);
                c2dField = field;
    }}}

    synchronized private boolean setMutationOfField (boolean master, boolean value) {
        if (master)
            mutate = value;
        return mutate;
    }

    public void run () {
        Random rng = new Random();
        for ( ; ; ) {
            if (setMutationOfField (false, true)) {
                int nDigit = 2 + rng.nextInt(4);
                double doublePi = 4.0 * Math.atan(1.0),
                        decimal = Math.pow(10, nDigit),
                        apprxPi = Math.round(decimal * doublePi) / decimal;
                try {
                    c2dField.setDouble (p, 0.5/apprxPi);
                } catch (IllegalAccessException ex) {
                    ex.printStackTrace();
            }} else {
                return;
    }}}

    public void execute () {
        setMutationOfField (true, true);
        new Thread (this).start();
        Executed[] class2x = new Executed[nSample];
        ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0 ; i < 4 ; i++)
            bins[i] = 0;
        for (int i = 0 ; i < nSample ; i++) {
            class2x[i] = new Executed();
            executor.execute(class2x[i]);
            double d = class2x[i].getDiameter(-1);
            if (d < 399.99)         bins[0]++;
            else if (d < 400)       bins[1]++;
            else if (d < 400.01)    bins[2]++;
            else                    bins[3]++;
            //System.out.println ("d: " + d);
        }
        setMutationOfField (true, false);
        for (int i = 0 ; i < 4 ; i++)
            System.out.print("\t\t[" + (i+1) + "] " + bins[i]);
        System.out.println ();
    }

    public static void main(String[] args) {
        ThreadedPi tp = new ThreadedPi();
        for (int k = 0 ; k < 5 ; k++)
            tp.execute();
    }

    private class Executed implements Runnable {
        private double d=-1, c = 2513.274123;

        synchronized double getDiameter (double setter) {
            if (setter < 0) {
                while (d < 0) {
                    try {
                        wait();
                    } catch (InterruptedException ex) {
            }}} else {
                d = setter;
                notify();
            }
            return d;
        }

        public void run () {
            getDiameter (p.c2d(c));
}}}

Все вышеперечисленные классы прекрасно компилируются и работают, что объясняет, почему «приватный» может не иметь никакого значения в java. Подними щиты, Скотти!