Java: что конкретно скрывается & rdquo; внутреннее состояние объекта. И почему скрывает внутреннее состояние объекта? [Дубликат]
Я сделал решение, которое работает очень хорошо для меня:
function shadeColor(color, percent) {
var R = parseInt(color.substring(1,3),16);
var G = parseInt(color.substring(3,5),16);
var B = parseInt(color.substring(5,7),16);
R = parseInt(R * (100 + percent) / 100);
G = parseInt(G * (100 + percent) / 100);
B = parseInt(B * (100 + percent) / 100);
R = (R<255)?R:255;
G = (G<255)?G:255;
B = (B<255)?B:255;
var RR = ((R.toString(16).length==1)?"0"+R.toString(16):R.toString(16));
var GG = ((G.toString(16).length==1)?"0"+G.toString(16):G.toString(16));
var BB = ((B.toString(16).length==1)?"0"+B.toString(16):B.toString(16));
return "#"+RR+GG+BB;
}
Пример Lighten:
shadeColor("#63C6FF",40);
Пример Darken:
shadeColor("#63C6FF",-40);
2 ответа
Это о сложности. Возьмите двигатель вашего автомобиля, например. Это очень сложный объект. Вы можете, если вы знаете, что добратесь туда и закрутите вещи и управляйте автомобилем. Однако это было бы очень опасно. Возможно, вы можете делать то, чего не думал дизайнер движка.
В этом сумасшедшем сценарии вам предоставляется интерфейс. Это положение водителя с рулевым колесом, шестернями, педалями и т. Д. В этом положении все, что вы можете сделать, ограничено, и безопасно, и управлять автомобилем легко. Например, вы не можете переключить передачу из парка без первого нажатия на педаль тормоза. Если я обойду интерфейс и перейду непосредственно к движку, я, вероятно, смогу сделать что угодно, даже если это приведет к разрушению двигателя.
Чтобы применить это к программному обеспечению, подумайте, есть ли у вас класс фракций, состоит из двух целых значений: числителя и знаменателя. Существует инвариант класса (правило), который гласит: знаменатель не может быть 0. Если знаменатель действительно равен 0, то объект фракции не имеет смысла и будет бесполезным. В следующем коде я не скрываю переменные:
public class Fraction{
int numerator;
int denominator;
public Fraction add(Fraction f){
//add this Fraction to f
}
....
}
В этом случае код клиента может сделать это:
Fraction f1 = new Fraction();
f1.numerator = 2;
f1.denominator = 0;
Fraction f2 = new Fraction();
f2.numerator = 3;
f2.denominator = 4;
Fraction f3 = f1.add(f2);
Что делает ваш метод добавления здесь? Что делает этот код, он несет ответственность за обеспечение того, чтобы такие проблемы избегали клиента. При правильной инкапсуляции ответственность за обеспечение целостности всех объектов принадлежит самому классу.
public class Fraction{
private int numerator;
private int denominator;
public void setDenominator(int d) throws IllegalArgumentException{
if(d == 0){
throw new IllegalArgumentExcepton("Denominator cannot be 0");
}
this.denominator = d;
}
...
}
Если клиент пытается это сделать:
Fraction f1 = new Fraction();
f1.setDenominator(0); ///exception
И все безопасен.
Итак, чтобы подвести итог:
- Делает ваши объекты безопасными - клиент не может делать то, что вы не намеревались
- Делает ваши объекты проще use - клиенту не нужно знать все внутренние действия этого класса, чтобы использовать его
- способствует повторному использованию вашего кода - если вы решите изменить реализацию класса, если вы не измените интерфейс, тогда клиенты не будут затронуты.
Это похоже на довольно широкий вопрос, охватывающий широкий круг вопросов, но я попытаюсь обратиться к парам пунктов:
Уверен, что ваш клиент может не увидеть или изменить ваш код (если вы предоставите полное скомпилированное приложение), но вы и любые другие сопровождающие могут. Целью скрытия данных является минимизация точек взаимодействия между данными и каждым уровнем интерфейса. Это помогает вам писать и поддерживать правильный код.
По той же причине, что глобальные переменные могут быть чрезвычайно трудными в использовании и правильном использовании, чем больше вы локализуете использование данных, тем проще, код и быть уверенным в правильности.
Когда вы предоставляете абстрактный интерфейс классу, который вы позволяете классу работать с внутренними данными / состоянием без внешнего мира, которому нужно что-то знать о базовой структуре данных, типов или алгоритмов. Это делает ваш код намного проще для эффективного использования клиентами.