• Множества и отображения
  
• Объекты и действия
  
• Данные-члены и функции-члены класса
  
• Масса и гравитация
  
• Материя и взаимодействия
  
• Подлежащее и сказуемое (аналогия между членами предложения и ООП продолжается и дальше)

class Ellipse
{
  virtual Vector BigAxis {get {return (Focus1 - Focus2).Normalize();}}
}

class Circle:
  Ellipse
{
  override Vector BigAxis {get {return new Vector(0, 1);}}
}

class Ellipse
{
  public Ellipse(Point focus1, Point focus2, double excentriset){..}
}

class Circle:
  Ellipse
{
  public Circle(Point center, double radius):
   base(center, center, CalcExcentriset(center, radius)){}
}

G>Применение stretch ("сжать в n раз к большей оси") в твоем примере выведет экземпляр Circle из класса Circle, и он станет эллипсом (так как ты все-таки согласился ввести ось для круга). Если не согласен, то просто попробуй написать метод stretch.

class Ellipse
{
  Ellipse Stretch(double Factor)
    {
      return new Ellipse(Focus1, Focus2, Excentricitet/Factor);
    }
}

G>>Применение stretch ("сжать в n раз к большей оси") в твоем примере выведет экземпляр Circle из класса Circle, и он станет эллипсом (так как ты все-таки согласился ввести ось для круга). Если не согласен, то просто попробуй написать метод stretch.

Circle circle = new Circle(new Point(0, 0), 10);
Circle circle2 = circle.Stretch(0.5).Stretch(2);
Assert.IsEqual (circle, circle2);

DG>Circle circle = new Circle(new Point(0, 0), 10);
DG>Circle circle2 = circle.Stretch(0.5).Stretch(2);
DG>Assert.IsEqual (circle, circle2);
DG>

Circle circle = new Circle(new Point(0, 0), 10);
Ellipse circle2 = circle.Stretch(0.5).Stretch(2); //ok
Assert.IsEqual (circle, circle2); // no problem - equality will work properly if defined on Ellipse class.

G>Любопытно. Я очень прошу Вас привести все-таки хоть один пример для JavaScript. Чертовски интересно. Потому что есть проблема. "По честному" это сделать все равно не выйдет, так как вообще говоря такая операция требует пересоздания экземпляра класса (и у вас опять "уплывут" указатели, если они не устроены как-то страшно внутри). В противном случае, пример не будет иметь отношения к ООП. Вот мне и любопытно, что-же такого может быть хитрого в казалось-бы простом языке JavaScript?

function CreateEllipse(focus1, focus2, diameter)
{
  var ellipse = new object();
  ellipse.UpdateFigure = UpdateFigure;
  ellipse.Stretch = Stretch;
  ellipse.focus1 = focus1;
  ellipse.focus2 = focus2;
  ellipse.diameter = diameter;
  return ellipse;
}

function CreateCircle(center, radius)
{
  var circle = CreateEllipse(center, center, radius * 2);
  circle.UpdateFigure();
  return circle;
}

function Stretch(int k)
{
  this.ChangeFocusesAndDiameter(k);

  this.UpdateFigure();
}


function SetCenter(center)
{
  this.focus1 = center;
  this.focus2 = center;
}
function GetCenter()
{
  return this.focus1;
}


function UpdateFigure()
{
  if (this.IsCircle())
    Ellipse2Circle(this);
  else
    Circle2Ellipse(this);
}

function IsCircle()
{
  return this.focus1 == this.focus2;
}

function Ellipse2Circle(ellipse)
{
  ellipse.SetCenter = SetCenter;
  ellipse.GetCenter = GetCenter;
}

function Circle2Ellipse(ellipse)
{
  ellipse.SetCenter = null;
  ellipse.GetCenter = null;
}

G>Ага. Все правильно, я ждал что кто-то это придумает . Но иногда такой трюк будет выглядеть нескольно странно. Как насчет метода Ellipse::SetRadiuses( double i_x, double i_y ) из примера уважаемого SG?

using System;
using System.Drawing;

namespace ConsoleApplication1
{
    public interface IEllipse
    {
        void SetFocuses(PointF focus1, PointF focus2);
        PointF Focus1{get;set;}
        PointF Focus2{get;set;}
        void StretchByBigAxis(double k);
    }

    public interface ICircle:
        IEllipse
    {
        PointF Center {get;set;}
    }

    public abstract class EllipseWrapper:
        IEllipse
    {
        protected abstract IEllipse InnerEllipse {get;}
    
        #region IEllipse Members

        public void SetFocuses(PointF focus1, PointF focus2)
        {
            InnerEllipse.SetFocuses(focus1, focus2);
        }

        public void StretchByBigAxis(double k)
        {
            InnerEllipse.Stretch(k);
        }

        public PointF Focus1
        {
            get {return InnerEllipse.Focus1;}
            set {InnerEllipse.Focus1 = value;}
        }

        public PointF Focus2
        {
            get {return InnerEllipse.Focus2;}
            set {InnerEllipse.Focus2 = value;}
        }

        #endregion
    }
    public abstract class CircleWrapper:
        EllipseWrapper,
        ICircle
    {
        protected abstract ICircle InnerCircle {get;}

        protected override IEllipse InnerEllipse
        {
            get
            {
                return InnerCircle;
            }
        }


    
        #region ICircle Members

        public PointF Center
        {
            get
            {
                return InnerCircle.Center;
            }
            set
            {
                InnerCircle.Center = value;
            }
        }

        #endregion
    }

    public class CircleImpl:
        EllipseWrapper,
        ICircle
    {
        public CircleImpl(IEllipse ellipse)
        {
            this._InnerEllipse = ellipse;
        }
        IEllipse _InnerEllipse;
        protected override IEllipse InnerEllipse
        {
            get
            {
                return _InnerEllipse;
            }
        }

    
            #region ICircle Members

            public PointF Center
            {
                get
                {
                    return InnerEllipse.Focus1;
                }
                set
                {
                    InnerEllipse.Focus1 = InnerEllipse.Focus2 = value;
                }
            }

            #endregion
        }

    public class Ellipse:
        IEllipse
    {
        public Ellipse(PointF focus1, PointF focus2)
        {
            this._Focus1 = focus1;
            this._Focus2 = focus2;
        }
    
        #region IEllipse Members

        PointF _Focus1, _Focus2;
        public void SetFocuses(PointF focus1, PointF focus2)
        {
            this.Focus1 = focus1;
            this.Focus2 = focus2;
        }

        public PointF Focus1
        {
            get
            {
                return _Focus1;
            }
            set
            {
                _Focus1 = value;
            }
        }

        public PointF Focus2
        {
            get
            {
                return _Focus2;
            }
            set
            {
                _Focus2 = value;
            }
        }

        public void StretchByBigAxis(double k)
        {
        }

        #endregion
    }

    public class Circle:
        CircleWrapper
    {
        public Circle(IEllipse ellipse)
        {
            _InnerCircle = new CircleImpl(ellipse);            
        }
        ICircle _InnerCircle;
        protected override ICircle InnerCircle
        {
            get
            {
                if (!IsCircle(_InnerCircle))
                    throw new Exception("Данная фигура не круг");
                return _InnerCircle;
            }
        }


        public static ICircle AsCircle(IEllipse ellipse)
        {
            if (!IsCircle(ellipse))
                throw new Exception("Данная фигура не круг");
            if (ellipse is ICircle)
                return (ICircle)ellipse;
            return new Circle(ellipse);
        }
        public static bool IsCircle(IEllipse ellipse)
        {
            return ellipse.Focus1 == ellipse.Focus2;
        }
    }


    /// <summary>
    /// Summary description for Class1.
    /// </summary>
    class Class1
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {
            IEllipse ellipse = new Ellipse(new PointF(0, 1), new PointF(0, -1));
            ellipse.SetFocuses(new PointF(0, 0), new PointF(0, 0));
            ICircle circle = Circle.AsCircle(ellipse);
            circle.StretchByBigAxis(1.5);
        }
    }
}

OFFTOPIC

/OFFTOPIC

An OLE component can implement an interface without implementing all the semantics of every method in the interface, instead returning E_NOTIMPL or S_OK as appropriate. The following table describes those methods that an ActiveX Control container is not required to implement (i.e. the control container can return E_NOTIMPL).

The table below describes optional methods; note that the method must still exist, but can simply return E_NOTIMPL instead of implementing real semantics. Note that any method from a mandatory interface that is not listed below must be considered mandatory and may not return E_NOTIMPL.

class Figure
{
  object GetService(Type type)
  {
    if (type == typeof(Circle) && IsCircle)
      return new Circle(this);
    if (type == typeof(Ellipse) && IsEllipse)
      return new Ellipse(this);
    throw new Exception ("Данный тип не поддерживается данной фигурой"); 
  }
}

Figure f;
((Ellipse)f.GetService(typeof(Ellipse))).Resize(2);
((Ellipse)f.GetService(typeof(Ellipse))).Rotate(Pi/2);
((Ellipse)f.GetService(typeof(Ellipse))).Resize(2);

void Func()
{
  context<int>
  {
    Out(2/5);
  }
}

class Number
{
   SqrtResult Sqrt()
   {
     return new SqrtResult(this);
   }
}
class SqrtResult
{
  Number source;
  operator Number()
  {
    return SimpleSqrt(source);
  }
  operator Complex()
  {
    return ComplexSqrt(source);
  }
}

DG>class Figure
DG>{
DG>  object GetService(Type type)
DG>  {
DG>    if (type == typeof(Circle) && IsCircle)
DG>      return new Circle(this);
DG>    if (type == typeof(Ellipse) && IsEllipse)
DG>      return new Ellipse(this);
DG>    throw new Exception ("Данный тип не поддерживается данной фигурой"); 
DG>  }
DG>}
DG>

Figure f;
((Ellipse)f.GetService(typeof(Ellipse))).Resize(2);
((Ellipse)f.GetService(typeof(Ellipse))).Rotate(Pi/2);
((Ellipse)f.GetService(typeof(Ellipse))).Resize(2);

DG>>class Figure
DG>>{
DG>>  object GetService(Type type)
DG>>  {
DG>>    if (type == typeof(Circle) && IsCircle)
DG>>      return new Circle(this);
DG>>    if (type == typeof(Ellipse) && IsEllipse)
DG>>      return new Ellipse(this);
DG>>    throw new Exception ("Данный тип не поддерживается данной фигурой"); 
DG>>  }
DG>>}
DG>>

S>Ну что за подтасовки! Это та самая эмуляция поведения неоюбъеектных сущностей при помощи ООП. При помощи (конечно же!) создания нового объекта. Ты же только что критиковал меня за введение двух разных двоек. Ай-яй-яй, как нехорошо .

class Figure:
  Circle,
  Ellipse
{
  object GetService(Type type)
  {
    if (type == typeof(Circle) && IsCircle)
      return this;
    if (type == typeof(Ellipse) && IsEllipse)
      return this;
    throw new Exception ("Данный тип не поддерживается данной фигурой"); 
  }
}

class Figure
{
  public Figure()
  {
    this.circle = new Circle(this);
    this.ellipse = new Ellipse(this);
  }
  Circle circle;
  Ellipse ellipse;

  object GetService(Type type)
  {
    if (type == typeof(Circle) && IsCircle)
      return circle;
    if (type == typeof(Ellipse) && IsEllipse)
      return ellipse;
    throw new Exception ("Данный тип не поддерживается данной фигурой"); 
  }
}

S>Figure f;
S>((Ellipse)f.GetService(typeof(Ellipse))).Resize(2);
S>((Ellipse)f.GetService(typeof(Ellipse))).Rotate(Pi/2);
S>((Ellipse)f.GetService(typeof(Ellipse))).Resize(2);
S>

S>на самом деле действительно приводит к тому, что иходный f совпадает с конечным. Потому, что все операции применяются к трем совершенно разным временным объектам

DG>class Figure
DG>{
DG>  object GetService(Type type)
DG>  {
DG>    if (type == typeof(Circle) && IsCircle)
DG>      return new Circle(this);
DG>    if (type == typeof(Ellipse) && IsEllipse)
DG>      return new Ellipse(this);
DG>    throw new Exception ("Данный тип не поддерживается данной фигурой"); 
DG>  }
DG>}
DG>

DG>Figure f;
DG>((Ellipse)f.GetService(typeof(Ellipse))).Resize(2);
DG>((Ellipse)f.GetService(typeof(Ellipse))).Rotate(Pi/2);
DG>((Ellipse)f.GetService(typeof(Ellipse))).Resize(2);
DG>

void Component::DoSomething( Ellipse i_ellipse )
{
   i_ellipse.ResizeOX( 2 );
   i_ellipse.Rotate( Pi / 2 );
   i_ellipse.ResizeOX( 2 );

   DoSomethingElse( i_ellipse );
}

DG>void Func()
DG>{
DG>  context<int>
DG>  {
DG>    Out(2/5);
DG>  }
DG>}
DG>

int Int(Complex c) 
{
  InvalidTypeCastYields<0>
  {
      return (int)c;
  }
}

int Int(Complex c) 
{
  try
       return (int)c;
    catch(InvalidTypeCast)
      return 0;
}

G>void Component::DoSomething( Ellipse i_ellipse )
G>{
G>   i_ellipse.ResizeOX( 2 );
G>   i_ellipse.Rotate( Pi / 2 );
G>   i_ellipse.ResizeOX( 2 );

G>   DoSomethingElse( i_ellipse );
G>}
G>

class Figure
{
  Hashtable storage = new Hashtable();

  object GetService(Type type)
  {
    if (type == typeof(Circle) && IsCircle)
      return new Circle(this);
    if (type == typeof(Ellipse) && IsEllipse)
      return new Ellipse(this);
    throw new Exception ("Данный тип не поддерживается данной фигурой"); 
  }
  operator Ellipse()
  {
    return (Ellipse)GetService(typeof(Ellipse));
  }
  operator Circle()
  {
    return (Circle)GetService(typeof(Circle));
  }
}
class Ellipse
{
  public Ellipse(Figure figure){this.figure = figure;}
  Figure figure;
  public double Angle {get {return (double)figure.storage["Angle"];} set {figure.storage["Angle"] = value;}
  public double Width {get {return (double)figure.storage["Width"];} set {figure.storage["Width"] = value;}
  public void ResizeOX(double k)
  {
    Width = Width * k;
  }
  public void Rotate(double angle)
  {
    Angle = Angle + angle;
  }
}

//вызов уже написанного компонента:
void Main()
{
  Figure f = new Figure();
  Component c = new Component();
  c.DoSomeThing(f);
}