ВВ>Налицо неумелое проектирование. _Чайник_ должен быть представлен как отдельный объект, _Вода_ также как отдельный объект. _Чайник_с_водой_ представляет собой объект, отнаследованный от объектов _Чайник_ и _Вода_.

public abstract class Content
{
    public vitual double Weight
    {get;}
    
    public vitual double Volume
    {get;}
}

public abstract class LiquidContent : Content
{
    public vitual double BoilTemperature
    {get;}
    
    public bool IsBoiled
    {
        get
        {
            return _temperature >= DoilTemperature;
        }
    }
}

public class WaterContent
{
    public WaterContent(double count) {...}

    public override double BoilTemperature
    {
        get { return 100f; }
    }
}

public interface IContentProvider
{
    Content GetContent(double count);
}

public class Tap : IContentProvider
{
    WaterContent GetWater(double count)
    {
        try
        {
            _waterPipe.QueryWater(count);
        catch (WaterAbortedBySomebodyException)
        {
            throw new NoWaterInTapException("Воду выпили жиды");
        }
    }

    Content IContentProvider.GetContent(double count)
    {
        return GetWater(count);
    }
}

public interface IContentContainer
{
    double ContentRoom
    {get;}
    
    void PutContent(LiquidContent content);
}

public class Teapot : IContentContainer
{
    public double ContentRoom {...}
    
    public void PutContent(LiquidContent content)
    {
        if (content.Volume > (ContentRoom - _alreadyContained))
            throw new OverflowException();
        _alreadyContained += content.Volume;
    }
}

public interface IFireable
{
    bool IsFired
    {get;}

    void Fire(FireSource source);
}

public abstract class FireSourceProvider
{
    public abstract FireSource CreateFireSource();
}

public abstract class FireSource : IFireable
{
    protected abstract IsFired
    {get;}
    
    public abstract void Fire(FireSource source);
    
    public bool DoFire(IFireable what)
    {
        while (!what.IsFired)
        {
            what.Fire(this);
            if (IsFired)
                return false;
        }
        return true;
    }
}

public class Match : FireSource
{
    public override bool IsFired
    {
        get { return _isFired; }
    }
    
    public override void Fire() {...}
}

public class MatchBox : FireSourceProvider
{
    public override FireSource CreateFireSource()
    {
        if (_matchCount = 0)
            throw new NotEnoughMatchesException();
        _matchCount--;
        return new Match();
    }
}

public class Stove : IFireable
{
    public bool IsFired
    {
        get { return _isFired; }
    }
    
    public void Fire()
    {
        ...
        _isFired = true;
    }
    
    public void PutOn(object what)
    {
        ...
    }
}

const double overflowPreventVolume = 0.05f;
Teapot teapot = Home.Instance.Kitchen.PlatesAndDishesShelf.Extract("Teapot #1");
double requiredContentCount = teapot.ContentRoom - teapot.Content.Volume - overflowPreventVolume;
if (requiredContentCount > 0)
    teapot.PutContent(Home.Instance.Kitchen.Tap.GetContent(requiredContentCount));
MatchBox matchBox = Home.Instance.Kitchen.SmallShelf.Extract("MatchBox");
Stove stove = Home.Instance.Kitchen.Stove;
while (!stove.IsFired)
{
    int atemptCount = 0;
    const totalAtempts = 10;
    FireSource match = matchBox.CreateFireSource();
    while (!match.IsFired)
    {
        match.Fire(null);
        atemtpCount++;
        if (atemptCount > totalAtempts)
            throw new ArgumentException("Черт побери, какого фига спички мокрые!");
    }
    match.DoFire(stove);
}
stove.PutOn(teapot);
const int checkInterval = 30000;
while (!teapot.Content.IsBoiled)
    System.Threading.Sleep(checkInterval);

ЕК>string operator + (const string& s1,const string s2)
ЕК>{
ЕК> string res(...); // private конструктор без инициализации
ЕК> res.set_length(s1.length()+s2.length());
ЕК> strcpy(res.m_ptr,s1.m_ptr);
ЕК>// strcat(res.m_ptr,s2.m_ptr); - неправильно
ЕК> strcpy(res.m_ptr+s1.length(),s2.m_ptr);
ЕК> return res;
ЕК>}

      - Долгая история. Все дело в том, что местные программисты пошли
по неверному пути. Этот путь называется объектно ориентированный подход
в программировании. На самом деле это мина с часовым механизмом в
красивой упаковке. В очень красивой упаковке. Как с этим бороться, я
не знаю. Упустил момент.
      - Мастер, ближе к делу.
      - Знаешь анекдот, как программист кипятит чайник. Дано: пустой
чайник, кран, спички, газовая плита. Программа действий: наполнить
чайник водой из-под крана, поставить на плиту, зажечь газ. Ждать, пока
закипит чайник. Эта программа оформляется как объект. Второй случай.
Все то же самое, но чайник с водой уже стоит на плите. Действия
программиста: вылить воду из чайника и выполнить предыдущий объект.
      - Грустно. А нырнуть внутрь объекта нельзя? Туда, где надо газ
зажечь?
      - Нельзя. Можно добавить новое свойство или действие. В нашем случае
- воду вылить. Будет новый объект. Но внутрь влезть нельзя. Объект дается
как единое целое. Никто не знает, что там внутри. Все давно забыли, откуда
ноги растут. В результате получается колоссальное дублирование кода и данных
и огромная потеря производительности компьютера. С каждым годом компьютеры
требуют все больше памяти, а работают все медленнее.

H_D>Которая лишь подтверждает мысль, что ООП везде — это вред и блед, хотя и не отрицает что в бизнес приложениях ООП — это просто круто

type
    Чайник = class()
    private
        procedure НалитьВоды();
        procedure ПоставитьНаПлиту()
        procedure ЗажечьГаз();
        function ЖдатьКогдаЗакипит(): Boolean;
    public
        procedure Кипятить();
    end;
    
procedure Чайник.Кипятить();
begin
    НалитьВоды();
    ПоставитьНаПлиту()
    ЗажечьГаз();
    repeat
    until ЖдатьКогдаЗакипит();
end;

type TMainObject = class
private
...
public
  procedure DoEverything; virtual; // override this if you need to do something else
end;

string operator + (const string& s1,const string s2)
{
  string res(...); // private конструктор без инициализации
  res.set_length(s1.length()+s2.length());
  strcpy(res.m_ptr,s1.m_ptr);
  // strcat(res.m_ptr,s2.m_ptr); - неправильно
  strcpy(res.m_ptr+s1.length(),s2.m_ptr);
  return res;
}

void Invert(int *a, int *b, int n)
{
    for(int i=0;i<n;i++)
      a[i]=-b[i];
}

int _tmain(int argc, _TCHAR* argv[])
{
    const int n=5;
    int a[n],b[]={argc, -1, 2, -2, argc};
    Invert(a, b, 5);
  for(int i=0;i<n;i++) // подавляем оптимизацию...
  std::cout << a[i];
  return 0;
}

00402790  sub         esp,14h 
    const int n=5;
    int a[n],b[]={argc, -1, 2, -2, argc};
    Invert(a, b, n);
00402793  mov         eax,dword ptr [esp+18h] 
00402797  push        esi  
00402798  neg         eax  
0040279A  push        edi  
0040279B  mov         edi,eax 
0040279D  mov         dword ptr [esp+8],eax 
004027A1  mov         dword ptr [esp+0Ch],1 
004027A9  mov         dword ptr [esp+10h],0FFFFFFFEh 
004027B1  mov         dword ptr [esp+14h],2 
004027B9  mov         dword ptr [esp+18h],edi

[...]
H_D>

H_D>Которая лишь подтверждает мысль, что ООП везде — это вред и блед, хотя и не отрицает что в бизнес приложениях ООП — это просто круто

Objects, as envisioned by the designers of languages like Smalltalk and Actors—long before C++ and Java came around— were for modeling and building complex, dynamic worlds. Programming environments for languages like Smalltalk were written in those languages and were extensible by developers. Because the philosophy of dynamic change was part of the post-Simula OO worldview, languages and environments of that era were highly dynamic.

But with C++ and Java, the dynamic thinking fostered by object-oriented languages was nearly fatally assaulted by the theology of static thinking inherited from our mathematical heritage and the assumptions built into our views of computing by Charles Babbage whose factory-building worldview was dominated by omniscience and omnipotence.

And as a result we find that object-oriented languages have succumb to static thinkers who worship perfect planning over runtime adaptability, early decisions over late ones, and the wisdom of compilers over the cleverness of failure detection and repair.

H_D>      - Долгая история. Все дело в том, что местные программисты пошли
H_D>по неверному пути. Этот путь называется объектно ориентированный подход
H_D>в программировании. На самом деле это мина с часовым механизмом в
H_D>красивой упаковке. В очень красивой упаковке. Как с этим бороться, я
H_D>не знаю. Упустил момент.
H_D>      - Мастер, ближе к делу.
H_D>      - Знаешь анекдот, как программист кипятит чайник. Дано: пустой
H_D>чайник, кран, спички, газовая плита. Программа действий: наполнить
H_D>чайник водой из-под крана, поставить на плиту, зажечь газ. Ждать, пока
H_D>закипит чайник. Эта программа оформляется как объект. Второй случай.
H_D>Все то же самое, но чайник с водой уже стоит на плите. Действия
H_D>программиста: вылить воду из чайника и выполнить предыдущий объект.
H_D>      - Грустно. А нырнуть внутрь объекта нельзя? Туда, где надо газ
H_D>зажечь?
H_D>      - Нельзя. Можно добавить новое свойство или действие. В нашем случае
H_D>- воду вылить. Будет новый объект. Но внутрь влезть нельзя. Объект дается
H_D>как единое целое. Никто не знает, что там внутри. Все давно забыли, откуда
H_D>ноги растут. В результате получается колоссальное дублирование кода и данных
H_D>и огромная потеря производительности компьютера. С каждым годом компьютеры
H_D>требуют все больше памяти, а работают все медленнее.
H_D>

функция _Главная_
{
    _Чайник_ экземпляр как _Чайник_с_водой_
    _Устройство_для_кипячения_::_Кипятить_(экземпляр) 
}


_Устройство_для_кипячения
{
    функция _Кипятить_(_Чайник_ экземпляр)
    {
        если (экземпляр есть _Чайник_с_водой_)
            кипятить
        другое
            пошел взад
    }
}

Архитекор в рамках ООП ДЛЯ ДАННОЙ ЗАДАЧИ может ъхорошо спроектировать обьект. Когда задача измениться, часто приходится делать новый класс обьектов.

Есть ли подход, который решает эту проблему ?

D>А вот "минусы" имхо аргументировать надо. Вдруг умнее стану?

Office 97 заметно тормознее офиса XP имхо.

<script language="javascript">

    function button(CtrlID)
    {
        this.CtrlID = CtrlID;
        this.Image = "";
        this.Caption = "";
        this.Height = 20;
        this.Width = 50;
        ...
        
        this.Refresh = button_Refresh;
        ...

        this._onmouseout = button_onmouseout;
        ...
        
        return;
    }
    
    function button_Refresh()
    {
        ...
        return;
    }
    
    function button_onmouseout(){
        ...
        return;
    }
</script>

<script language="javascript">
    myButton = new button('btn1');
    myButton.Caption = 'Ok';
    myButton.Height = 25;
    myButton.Width = '100';
</script>