ООП или что же все-таки это такое - объекто-ориентированное программирование

/** Файл main.cpp **************************/
#include <stdio.h>
#include "NewClass.h"

int main()
{
    NewClass newClass;
    newClass.message();
    newClass.message();
    
    return 0;
}

/** Файл NewClass.h **************************/
class NewClass {
private:
    int index;
    
public:
     /** Конструктор */
     NewClass();
     void message();
};

/** Файл NewClass.cpp **************************/
#include <stdio.h>
#include "NewClass.h"

/** Конструктор */
NewClass::NewClass() {
    index = 0;
}

void NewClass::message() {
    index ++;
    printf("Hello World %d\n", index);
}

public class Main {
    public static void main(String[] args) {
        NewClass newClass = new NewClass();
        newClass.message();
        newClass.message();
    }
}

class NewClass {
    private int index;
    
    /** Конструктор */
    public NewClass() {
        index = 0;
    }
    
    public void message() {
        index ++;
        System.out.println("Hello World " + index);
    }
}

class NewClass:
    def __init__(self):
        """ Конструктор """
        self._index = 0

    def message(self):
        self._index += 1
        print("Hello World {}".format(self._index))


def main():
        new_class = NewClass()
        new_class.message()
        new_class.message()


if __name__ == '__main__':
    main()

/** Файл main.cpp **************************/
#include <stdio.h>
#include "NewClass.h"

int main()
{
    NewClass newClass;
    newClass.setPositiveProperty(-10);
    printf("Положительное свойство %d\n", newClass.getPositiveProperty());
    
    newClass.setPositiveProperty(20);
    printf("Положительное свойство %d\n", newClass.getPositiveProperty());
    
    return 0;
}
/** Файл NewClass.h **************************/
class NewClass {
private:
    /** Закрытая переменная */
    int positiveProperty;
    
public:
    /** Конструктор класса */
     NewClass();
    /** Сеттер */
     void setPositiveProperty(int val);
    /** Геттер */
     int getPositiveProperty();
};

/** Файл NewClass.cpp **************************/
#include <stdio.h>
#include "NewClass.h"

/** Конструктор класса */
NewClass::NewClass() {
    positiveProperty = 0;
}

/** Сеттер */
void NewClass::setPositiveProperty(int value) {
    if (value < 0)
        value = value * -1;
   positiveProperty = value;
}

/** Геттер */
int NewClass::getPositiveProperty() {
    return positiveProperty;
}

using System;
public class MainClass {
    public static void Main() {
        NewClass newClass = new NewClass();
        newClass.PositiveProperty = -10;
        Console.WriteLine("Положительное свойство {0}", newClass.PositiveProperty);
        
        newClass.PositiveProperty = 20;
        Console.WriteLine("Положительное свойство {0}", newClass.PositiveProperty);
    }
}

class NewClass {
    // Закрытая переменная
    private int positiveProperty;
    
    /** Конструктор класса */
    public NewClass() {
        positiveProperty = 0;
    }
    /** Свойство */
    public int PositiveProperty {
        // Сеттер
        set {
            if (value < 0)
                value = value * -1;
            positiveProperty = value;
        }
        // Геттер        
        get {
            return positiveProperty;
            
        }
    }
}

class NewClass:
    def __init__(self):
        """ Конструктор класса """
        # Закрытая переменная
        self._positive_property = 0
    
    @property
    def positive_property(self) -> str:
        """ Свойство. Геттер. """
        return self._positive_property
    
    @positive_property.setter
    def positive_property(self, value: int):
        """ Свойство. Сеттер. """
        if value < 0:
            value = value * -1
        self._positive_property = value


def main():
        new_class = NewClass()
        new_class.positive_property = -10
        print("Положительное свойство", new_class.positive_property)
        
        new_class.positive_property = 20
        print("Положительное свойство", new_class.positive_property)


if __name__ == '__main__':
    main()

/** Файл main.cpp **************************/
#include <stdio.h>
#include "MyClasses.h"

int main()
{
    // Использование класса Прямоугольник.
    Rectangle rectangle(2, 3, RED);
    printf("Прямоугольник:\n");
    rectangle.ShowArea();
    rectangle.ShowLength();
    rectangle.ShowColor();
    printf("----------------------------\n");

    return 0;
}


/** Файл MyClasses.h **************************/
const int WHITE = 0xFFFFFF;
const int BLACK = 0x000000;
const int RED =   0xFF0000;
const int GREEN = 0x00FF00;
const int BLUE =  0x0000FF;

/** Класс прямоугольника */
class Rectangle {
private:
    int height,
        width,
        color;
    int Area();
    int Length();
    
public:
     Rectangle();
     Rectangle(int height, int width, int color);
     void ShowArea();
     void ShowLength();
     void SetColor(int color);
     void ShowColor();
};

/** Файл MyClasses.cpp **************************/
#include <stdio.h>
#include "MyClasses.h"

Rectangle::Rectangle(): Rectangle(1, 1, BLACK) {}

Rectangle::Rectangle(int height, int width, int color) {
    this->height = height;
    this->width = width;
    this->color = color;
}

/** 
* Возвращает площадь фигуры 
*/
int Rectangle::Area() {
    return height * width;
}

/** 
* Возвращает длину периметра фигуры 
*/
int Rectangle::Length() {
    return (height + width) * 2;
}

/**
* Отображает площадь
*/
void Rectangle::ShowArea() {
    printf("Площадь: %d\n", Area());
}
        
/**
* Отображает длину периметра
*/
void Rectangle::ShowLength() {
    printf("Длина: %d\n", Length());
}

/**
* Отображает цвет
*/
 void Rectangle::ShowColor() {
    printf("Цвет: #%06X\n", color);
}

public class Main {
    static final int WHITE = 0xFFFFFF;
    static final int BLACK = 0x000000;
    static final int RED =   0xFF0000;
    static final int GREEN = 0x00FF00;
    static final int BLUE =  0x0000FF;
    
    public static void main(String[] args) {
        Main main = new Main();
        main.Start();
    }
    
    public void Start() {
        Rectangle rectangle = new Rectangle(2, 3, RED);
        System.out.println("Прямоугольник:");
        rectangle.ShowArea();
        rectangle.ShowLength();
        rectangle.ShowColor();
        System.out.println("----------------------------\n");
    }

    /** Класс прямоугольника */
    class Rectangle {
        private int height;
        private int width;
        private int color;
        
        public Rectangle() {
            this(1, 1, BLACK);
        }
        
        public Rectangle(int height, int width, int color) {
           this.height = height;
           this.width = width;
           this.color = color;
        }
        
        /** 
        * Возвращает площадь фигуры 
        */
        private int Area() {
            return height * width;
        }
        
        /** 
        * Возвращает длину периметра фигуры 
        */        
        private int Length() {
            return (height + width) * 2;
        }
        
        /**
        * Отображает площадь
        */        
        public void ShowArea() {
            System.out.printf("Площадь: %d\n", Area());
        }
        
        /**
        * Отображает длину периметра
        */        
        public void ShowLength() {
            System.out.printf("Длина: %d\n", Length());
        }

        /**
        * Устанавливает цвет
        */        
        public void SetColor(int color) {
            this.color = color;
        }
        
        /**
        * Отображает цвет
        */        
        public void ShowColor() {
            System.out.printf("Цвет: #%06X\n", color);
        }
    }
}

WHITE = 0xFFFFFF
BLACK = 0x000000
RED = 0xFF0000
GREEN = 0x00FF00
BLUE = 0x0000FF


class Rectangle:
    """  Класс прямоугольник """
    def __init__(self, height: int=1, width: int=1, color: int=BLACK):
        self._height = height
        self._width = width
        self._color = color

    def _area(self) ->int:
        """ Возвращает площадь фигуры """
        return self._height * self._width

    def _length(self) -> int:
        """ Возвращает длину периметра фигуры """
        return (self._height + self._width) * 2

    def show_area(self):
        print("Площадь {0}". format(self._area()))

    def show_length(self):
        print("Длинна {0}". format(self._length()))

    def set_color(self, color: int):
        self._color = color

    def show_color(self):
        print("Цвет #{0:06X}".format(self._color))


def main():
    # Использование класса Прямоугольник
    rectangle = Rectangle(2, 3, RED)
    print("Прямоугольник:")
    rectangle.show_area()
    rectangle.show_length()
    rectangle.show_color()
    print("----------------------------\n")


if __name__ == '__main__':
    main()

/** Файл Square.h **************************/
#include "Rectangle.h"

/** Класс Квадрат */
class Square : public Rectangle {
public:
    Square();
    Square(int height, int color);
};

/** Файл Square.cpp **************************/
#include "Rectangle.h"
Square::Square(): Rectangle() {}
Square::Square(int height, int color): Rectangle(height, height, color) {}

/** Класс Квадрат */
class Square extends Rectangle {
    public Square() {
        super();
    }
        
    public Square(int height, int color) {
        super(height, height, color);
    }
}

class Square(Rectangle):
    """ Класс Квадрат """
    def __init__(self, height: int=1, color: int=BLACK):
        super().__init__(height, height, color)

/** main.cpp **************************/
#include <stdio.h>
#include "MyClasses.h"

int main()
{
    Rectangle rectangle(2, 3, RED);
    printf("Прямоугольник:\n");
    rectangle.ShowArea();
    rectangle.ShowLength();
    rectangle.ShowColor();
    printf("----------------------------\n\n");
    
    Square square(5, GREEN);
    printf("Квадрат:\n");
    square.ShowArea();
    square.ShowLength();
    square.ShowColor();
    printf("----------------------------\n");
        
    return 0;
}

/** Файл MyClasses.h **************************/
const int WHITE = 0xFFFFFF;
const int BLACK = 0x000000;
const int RED =   0xFF0000;
const int GREEN = 0x00FF00;
const int BLUE =  0x0000FF;


class Rectangle {
private:
    int height,
        width,
        color;
    int Area();
    int Length();
    
public:
     Rectangle();
     Rectangle(int height, int width, int color);
     void ShowArea();
     void ShowLength();
     void SetColor(int color);
     void ShowColor();
};

class Square : public Rectangle {
public:
    Square();
    Square(int height, int color);
};

/** Файл MyClasses.cpp **************************/
#include <stdio.h>
#include "MyClasses.h"

Rectangle::Rectangle(): Rectangle(1, 1, BLACK) {}

Rectangle::Rectangle(int height, int width, int color) {
    this->height = height;
    this->width = width;
    this->color = color;
}

/** 
* Возвращает площадь фигуры 
*/
int Rectangle::Area() {
    return height * width;
}

/** 
* Возвращает длину периметра фигуры 
*/
int Rectangle::Length() {
    return (height + width) * 2;
}

/**
* Отображает площадь
*/
void Rectangle::ShowArea() {
    printf("Площадь: %d\n", Area());
}
        
/**
* Отображает длину периметра
*/
void Rectangle::ShowLength() {
    printf("Длина: %d\n", Length());
}

/**
* Отображает цвет
*/
 void Rectangle::ShowColor() {
    printf("Цвет: #%06X\n", color);
}

Square::Square(): Rectangle() {}

Square::Square(int height, int color): Rectangle(height, height, color) {}

using System;

public class MainClass {
    const int WHITE = 0xFFFFFF;
    const int BLACK = 0x000000;
    const int RED =   0xFF0000;
    const int GREEN = 0x00FF00;
    const int BLUE =  0x0000FF;
    
    public static void Main() {
        Rectangle rectangle = new Rectangle(2, 3, RED);
        Console.WriteLine("Прямоугольник:");
        rectangle.ShowArea();
        rectangle.ShowLength();
        rectangle.ShowColor();
        Console.WriteLine("----------------------------\n");
        
        Square square = new Square(5, GREEN);
        Console.WriteLine("Квадрат:");
        square.ShowArea();
        square.ShowLength();
        square.ShowColor();
        Console.WriteLine("----------------------------\n");
        
    }
    
    class Rectangle {
        private int height;
        private int width;
        private int color;
        
        public Rectangle() : this(1, 1, BLACK) {}
        
        public Rectangle(int height, int width, int color) {
           this.height = height;
           this.width = width;
           this.color = color;
        }
        
        /** 
        * Возвращает площадь фигуры 
        */
        private int Area() {
            return height * width;
        }
        
        /** 
        * Возвращает длину периметра фигуры 
        */
        private int Length() {
            return (height + width) * 2;
        }
        
        /**
        * Отображает площадь
        */
        public void ShowArea() {
            Console.WriteLine("Площадь: {0}", Area());
        }
        
        /**
        * Отображает длину периметра
        */
        public void ShowLength() {
            Console.WriteLine("Длина: {0}", Length());
        }
        
        /**
        * Устанавливает цвет
        */
        public void SetColor(int color) {
            this.color = color;
        }
        
        /**
        * Отображает цвет
        */
        public void ShowColor() {
            Console.WriteLine("Цвет: #{0:X6}", color);
        }
    }

    class Square : Rectangle {
        public Square() : base() {}
        
        public Square(int height, int color) : base(height, height, color) {
        }
    }
}

WHITE = 0xFFFFFF
BLACK = 0x000000
RED = 0xFF0000
GREEN = 0x00FF00
BLUE = 0x0000FF


class Rectangle:
    def __init__(self, height: int=1, width: int=1, color: int=BLACK):
        self._height = height
        self._width = width
        self._color = color

    def _area(self) ->int:
        """ Возвращает площадь фигуры """
        return self._height * self._width

    def _length(self) -> int:
        """ Возвращает длину периметра фигуры """
        return (self._height + self._width) * 2

    def show_area(self):
        print("Площадь {}".format(self._area()))

    def show_length(self):
        print("Длинна {}".format(self._length()))

    def set_color(self, color: int):
        self._color = color

    def show_color(self):
        print("Цвет #{0:06X}".format(self._color))


class Square(Rectangle):
    def __init__(self, height: int=1, color: int=BLACK):
        super().__init__(height, height, color)


def main():
    rectangle = Rectangle(2, 3, RED)
    print("Прямоугольник:")
    rectangle.show_area()
    rectangle.show_length()
    rectangle.show_color()
    print("----------------------------\n")

    square = Square(5, GREEN)
    print("Квадрат:")
    square.show_area()
    square.show_length()
    square.show_color()
    print("----------------------------\n")


if __name__ == '__main__':
    main()

/** Файл Circle.h **************************/
const int WHITE = 0xFFFFFF;
const int BLACK = 0x000000;
const int RED =   0xFF0000;
const int GREEN = 0x00FF00;
const int BLUE =  0x0000FF;

class Circle {
private:
    int radius,
        color;
    double Area();
    double Length();
    
public:
    const double pi = 3.14;
    Circle();
    Circle(int radius, int color);
    void ShowArea();
    void ShowLength();
    void SetColor(int color);
    void ShowColor();
};

/** Файл Circle.cpp **************************/
#include <stdio.h>

Circle::Circle(): Circle(1, BLACK) {}

Circle::Circle(int radius, int color) {
    this->radius = radius;
    this->color = color;
}

/** 
* Возвращает площадь фигуры 
*/
double Circle::Area() {
    return pi * (radius * radius);
}

/** 
* Возвращает длину периметра фигуры 
*/
double Circle::Length() {
    return 2 * pi * radius;
}

/**
* Отображает площадь
*/
void Circle::ShowArea() {
    printf("Площадь: %.2f\n", Area());
}
        
/**
* Отображает длину периметра
*/
void Circle::ShowLength() {
    printf("Длина: %.2f\n", Length());
}

/**
* Устанавливает цвет
*/
void Circle::SetColor(int color) {
    this->color = color;
}

/**
* Отображает цвет
*/
 void Circle::ShowColor() {
    printf("Цвет: #%06X\n", color);
}

    static final int WHITE = 0xFFFFFF;
    static final int BLACK = 0x000000;
    static final int RED =   0xFF0000;
    static final int GREEN = 0x00FF00;
    static final int BLUE =  0x0000FF;

    class Circle {
        final double pi = 3.14;
        private int radius;
        private int color;
        
        public Circle() {
            this(1, BLACK);
        }
        
        public Circle(int radius, int color) {
            this.radius = radius;
            this.color = color;
        }
        
        private double Area() {
            return pi * (radius * radius);
        }
        
        private double Length() {
            return 2 * pi * radius;
        }
        
        public void ShowArea() {
            System.out.println("Площадь: " + Area());
        }
        
        public void ShowLength() {
            System.out.println("Длина: " + Length());
        }
        
        public void SetColor(int color) {
            this.color = color;
        }
        
        public void ShowColor() {
            System.out.printf("Цвет: #%06X\n", color);
        }
    }

class Circle:
    def __init__(self, radius: int=1, color: int=BLACK):
        self._pi = 3.14
        self._radius = radius
        self._color = color

    def _area(self) -> float:
        """ Возвращает площадь фигуры """
        return self._pi * (self._radius * self._radius)

    def _length(self) -> float:
        """ Возвращает длину периметра фигуры """
        return 2 * self._pi * self._radius

    def show_area(self):
        print("Площадь {0:.2f}".format(self._area()))

    def show_length(self):
        print("Длинна {0:.2f}".format(self._length()))

    def set_color(self, color: int):
        self.__color = color

    def show_color(self):
        print("Цвет #{0:06X}".format(self._color))

/** Файл main.cpp **************************/
#include <stdio.h>
#include "MyClasses.h"

/**
* Отображает информацию о переданном массиве фигур
*/
void ShowFigures(Figure *figures[], int size) {
    for(int i = 0; i < size; i++ ) {
        printf("Отображение %sа:\n", figures[i]->getName().c_str());
        figures[i]->ShowArea();
        figures[i]->ShowLength();
        figures[i]->ShowColor();
        printf("----------------------------\n\n");
    }
}

int main()
{
    Rectangle rectangle("прямоугольник", 2, 3, RED);
    Square square("квадрат", 5, GREEN);
    Circle circle("круг", 3, BLUE);
    
    int size = 3;
    Figure *figures[] = {&rectangle, &square, &circle};
    ShowFigures(figures, size);
        
    return 0;
}

/** Файл MyClasses.h **************************/
#include <map>
#include <string>
const int WHITE = 0xFFFFFF;
const int BLACK = 0x000000;
const int RED =   0xFF0000;
const int GREEN = 0x00FF00;
const int BLUE =  0x0000FF;


class Figure {
protected:
    int color;
    virtual double Area() = 0;
    virtual double Length() = 0;
private:
    std::map<int, std::string> colors;
    std::string name;
    void InitColorDict();
    std::string GetColorName();
    std::string GetRGBColor(); 
public:
    Figure(std::string name, int color);
    std::string getName();
    void setName(std::string name);
    void ShowArea();
    void ShowLength();
    void SetColor(int color);
    void ShowColor();
};

class Rectangle: public Figure {
protected:
    double Area() override;
    double Length() override;
private:
    int height,
        width;
public:
    Rectangle(std::string name);
    Rectangle(std::string name, int height, int width, int color);
};

class Square : public Rectangle {
public:
    Square(std::string name);
    Square(std::string name, int height, int color);
};

class Circle: public Figure {
protected:
    double Area() override;
    double Length() override;
private:
    int radius;
public:
    const double pi = 3.14;
    Circle(std::string name);
    Circle(std::string name, int radius, int color);
};

/** Файл MyClasses.cpp **************************/
#include <string>
#include <stdio.h>
#include <iostream>
#include <map>
#include "MyClasses.h"

Figure::Figure(std::string name,  int color) {
    setName(name);
    this->color = color;
    InitColorDict();
} 

std::string Figure::getName() {
    return this->name;
}

void Figure::setName(std::string name) {
    this->name = name;
}

/**
* Инициализирует список цветов
*/
void Figure::InitColorDict() {
    this->colors[WHITE] = "белый";
    this->colors[BLACK] = "чёрный";
    this->colors[RED] =   "красный";
    this->colors[GREEN] = "зелёный";
    this->colors[BLUE] =  "синий";
}

/**
* Возвращает наименование цвета фигуры
*/
std::string Figure::GetColorName() {
    return this->colors[this->color];
}

/**
* Возвращает RGBе цвета фигуры
*/        
std::string Figure::GetRGBColor() {
    char _color[8];
    sprintf(_color, "#%06X", color);

    return _color;
}

/**
* Отображает площадь
*/
void Figure::ShowArea() {
    printf("Площадь %s %s: %.2f\n", GetColorName().c_str(), getName().c_str(), Area());
}
        
/**
* Отображает длину периметра
*/
void Figure::ShowLength() {
    printf("Длина %s %s: %.2f\n", GetColorName().c_str(), getName().c_str(), Length());
}

/**
* Устанавливает цвет
*/
void Figure::SetColor(int color) {
    this->color = color;
}

/**
* Отображает цвет
*/
 void Figure::ShowColor() {
    printf("RGB цвет %s %s: %s\n", GetColorName().c_str(), getName().c_str(), GetRGBColor().c_str());
}

Rectangle::Rectangle(std::string name): Rectangle(name, 1, 1, BLACK) {}

Rectangle::Rectangle(std::string name, int height, int width, int color): Figure(name, color) {
    this->height = height;
    this->width = width;
}


double Rectangle::Area() {
    return height * width;
}

double Rectangle::Length() {
    return (height + width) * 2;
}

Square::Square(std::string name): Rectangle(name) {}

Square::Square(std::string name, int height, int color): Rectangle(name, height, height, color) {}

Circle::Circle(std::string name): Circle(name, 1, BLACK) {}

Circle::Circle(std::string name, int radius, int color): Figure(name, color) {
    this->radius = radius;
}

double Circle::Area() {
    return pi * (radius * radius);
}

double Circle::Length() {
    return 2 * pi * radius;
}

using System;
using System.Collections.Generic;

public class MainClass {
    const int WHITE = 0xFFFFFF;
    const int BLACK = 0x000000;
    const int RED =   0xFF0000;
    const int GREEN = 0x00FF00;
    const int BLUE =  0x0000FF;
    
    public static void Main() {
        Rectangle rectangle = new Rectangle("прямоугольник", 2, 3, RED);
        Square square = new Square("квадрат", 5, GREEN);
        Circle circle = new Circle("круг", 3, BLUE);
        
        Figure []figures = {rectangle, square, circle};
        ShowFigures(figures);
        
    }
    
    /**
    * Отображает информацию о переданном массиве фигур
    */
    static void ShowFigures(Figure[] figures) {
        foreach(Figure figure in figures) {
            Console.WriteLine("Отображение {0}а:", figure.Name);
            figure.ShowArea();
            figure.ShowLength();
            figure.ShowColor();
            Console.WriteLine("----------------------------\n");
        }
    }
    
    abstract class Figure {
        private Dictionary<int, string> colors;
        protected int color;
        
        /**
        * Конструктор
        */
        public Figure(string name, int color) {
            Name = name;
            this.color = color;
            InitColorDict();
        }
        
        public string Name { get; set; }
        
        /**
        * Инициализирует список цветов
        */
        private void InitColorDict() {
            colors = new Dictionary<int, string>();
            colors[WHITE] = "белый";
            colors[BLACK] = "чёрный";
            colors[RED] = "красный";
            colors[GREEN] = "зелёный";
            colors[BLUE] = "синий";
        }
        
        /** Возвращает площадь фигуры */
        abstract protected double Area();
        /** Возвращает длину периметра фигуры */
        abstract protected double Length();
        
        /**
        * Возвращает наименование цвета фигуры
        */
        private string GetColorName() {
            return colors[color];
        }
        
        /**
        * Возвращает RGBе цвета фигуры
        */        
        private string GetRGBColor() {
            return string.Format("#{0:X6}", color);
        }
        
        /**
        * Отображает площадь
        */
        public void ShowArea() {
            Console.WriteLine("Площадь {0} {1}: {2}", GetColorName(), Name, Area());
        }
        
        /**
        * Отображает длину периметра
        */
        public void ShowLength() {
            Console.WriteLine("Длина {0} {1}: {2}", GetColorName(), Name, Length());
        }
        
        /**
        * Устанавливает цвет
        */
        public void SetColor(int color) {
            this.color = color;
        }
        
        /**
        * Отображает цвет
        */
        public void ShowColor() {
            Console.WriteLine("RGB цвет {0} {1}: {2}", GetColorName(), Name, GetRGBColor());
        }
    }
    
    class Rectangle : Figure {
        private int height;
        private int width;
        
        public Rectangle(string name) : this(name, 1, 1, BLACK) {}
        
        public Rectangle(string name, int height, int width, int color) : base(name, color) {
            this.height = height;
            this.width = width;
        }
        
        override protected double Area() {
            return height * width;
        }
        
        override protected double Length() {
            return (height + width) * 2;
        }
        
    }

    class Square : Rectangle {
        public Square(string name) : base(name) {}
        
        public Square(string name, int height, int color) : base(name, height, height, color) {
        }
    }

    class Circle: Figure {
        const double pi =  3.14;
        private int radius;
        
        public Circle(string name) : this(name, 1, BLACK) {}
        
        public Circle(string name, int radius, int color): base(name, color) {
            this.radius = radius;
        }
        
        override protected double Area() {
            return pi * (radius * radius);
        }
        
        override protected double Length() {
            return 2 * pi * radius;
        }
    }
}

import java.util.HashMap;
public class Main {
    static final int WHITE = 0xFFFFFF;
    static final int BLACK = 0x000000;
    static final int RED =   0xFF0000;
    static final int GREEN = 0x00FF00;
    static final int BLUE =  0x0000FF;
    
    public static void main(String[] args) {
        Main main = new Main();
        main.Start();
    }
    
    public void Start() {
        Rectangle rectangle = new Rectangle("прямоугольник", 2, 3, RED);
        Square square = new Square("квадрат", 5, GREEN);
        Circle circle = new Circle("круг", 3, BLUE);
        
        Figure []figures = {rectangle, square, circle};
        ShowFigures(figures);
    }
    
        /**
    * Отображает информацию о переданном массиве фигур
    */
    static void ShowFigures(Figure[] figures) {
        for(Figure figure: figures) {
            System.out.printf("Отображение %sа:\n", figure.getName());
            figure.ShowArea();
            figure.ShowLength();
            figure.ShowColor();
            System.out.println("----------------------------\n");
        }
    }
    
    abstract class Figure {
        private HashMap<Integer, String> colors;
        private String name;
        protected int color;
        
        /**
        * Конструктор
        */
        public Figure(String name, int color) {
            setName(name);
            this.color = color;
            InitColorDict();
        }
        
        /**
        * Возвращает наименование фигуры
        */
        public String getName() { 
            return name;
        }
        
        /**
        * Устанавливает наименование фигуры
        */
        public void setName(String name) {
            this.name = name;
        }
        
        /**
        * Инициализирует список цветов
        */
        private void InitColorDict() {
            colors = new HashMap<Integer, String>();
            colors.put(WHITE, "белый");
            colors.put(BLACK, "чёрный");
            colors.put(RED, "красный");
            colors.put(GREEN, "зелёный");
            colors.put(BLUE, "синий");
        }
        
        /** Возвращает площадь фигуры */
        abstract protected double Area();
        /** Возвращает длину периметра фигуры */
        abstract protected double Length();
        
        /**
        * Возвращает наименование цвета фигуры
        */
        private String GetColorName() {
            return colors.get(color);
        }
        
        /**
        * Возвращает RGBе цвета фигуры
        */        
        private String GetRGBColor() {
            return String.format("#%06X", color);
        }
        
        /**
        * Отображает площадь
        */
        public void ShowArea() {
            System.out.printf("Площадь %s %s: %.2f\n", GetColorName(), getName(), Area());
        }
        
        /**
        * Отображает длину периметра
        */
        public void ShowLength() {
           System.out.printf("Длина %s %s: %.2f\n", GetColorName(), getName(), Length());
        }
        
        /**
        * Устанавливает цвет
        */
        public void SetColor(int color) {
            this.color = color;
        }
        
        /**
        * Отображает цвет
        */
        public void ShowColor() {
            System.out.printf("RGB цвет %s %s: %s\n", GetColorName(), getName(), GetRGBColor());
        }
    }
	
class Rectangle extends Figure {
        private int height;
        private int width;
        
        public Rectangle(String name) {
            this(name, 1, 1, BLACK);
        }
        
        public Rectangle(String name, int height, int width, int color) {
            super(name, color);
            this.height = height;
            this.width = width;
        }
        
        /** 
        * Возвращает площадь фигуры 
        */
        @Override
        protected double Area() {
            return height * width;
        }
        
        /** 
        * Возвращает длину периметра фигуры 
        */
        @Override
        protected double Length() {
            return (height + width) * 2;
        }
    }
    
    class Square extends Rectangle {
        public Square(String name) {
            super(name);
        }
        
        public Square(String name, int height, int color) {
            super(name, height, height, color);
        }
    }
    
    class Circle extends Figure {
        final double pi =  3.14;
        private int radius;
        
        public Circle(String name) {
            this(name, 1, BLACK);
        }
        
        public Circle(String name, int radius, int color) {
            super(name, color);
            this.radius = radius;
        }
        
        @Override
        protected double Area() {
            return pi * (radius * radius);
        }
        
        @Override
        protected double Length() {
            return 2 * pi * radius;
        }
    }
}

/** Файл main.cpp **************************/
#include <stdio.h>
#include "MyClasses.h"

/**
* Отображает информацию о переданном массиве фигур
*/
void ShowFigures(Figure *figures[], int size) {
   /* int n = sizeof(figures)/sizeof(figures[0]); */
    for(int i = 0; i < size; i++ ) {
        printf("Отображение %sа:\n", figures[i]->getName().c_str());
        figures[i]->ShowArea();
        figures[i]->ShowLength();
        figures[i]->ShowColor();
        printf("----------------------------\n\n");
    }
}

/**
* Перекрашивает цветные объекты из массива цветных объектов
*/    
void Recolor(IColor *colorObjects[], int size) {
    /* int n = sizeof(colorObjects)/sizeof(colorObjects[0]); */
    for(int i = 0; i < size; i++) {
        colorObjects[i]->SetColor(WHITE);
    }
}

int main()
{
    Rectangle rectangle("прямоугольник", 2, 3, RED);
    Square square("квадрат", 5, GREEN);
    Circle circle("круг", 3, BLUE);
    
    Figure *figures[] = {&rectangle, &square, &circle};
    ShowFigures(figures, 3);
    
    Letter letter('Z', 11, BLACK);
    letter.ShowLetterInfo();
    printf("----------------------------\n");
    IColor *colors[] = {&rectangle, &square, &circle, &letter};
    Recolor(colors, 4);
    printf("!!! После перекраски !!!\n");
    ShowFigures(figures, 3);
    letter.ShowLetterInfo();
    printf("----------------------------\n");
        
    return 0;
}

/** Файл MyClasses.h **************************/
#include <map>
#include <string>
const int WHITE = 0xFFFFFF;
const int BLACK = 0x000000;
const int RED =   0xFF0000;
const int GREEN = 0x00FF00;
const int BLUE =  0x0000FF;

/** Интерфейс цвета */
class IColor {
public:
    virtual void SetColor(int color) = 0;
};

class Figure: public IColor {
protected:
    int color;
    virtual double Area() = 0;
    virtual double Length() = 0;
private:
    std::map<int, std::string> colors;
    std::string name;
    void InitColorDict();
    std::string GetColorName();
    std::string GetRGBColor(); 
public:
    Figure(std::string name, int color);
    std::string getName();
    void setName(std::string name);
    void ShowArea();
    void ShowLength();
    void SetColor(int color) override;
    void ShowColor();
};

class Rectangle: public Figure {
protected:
    double Area() override;
    double Length() override;
private:
    int height,
        width;
public:
    Rectangle(std::string name);
    Rectangle(std::string name, int height, int width, int color);
};

class Square : public Rectangle {
public:
    Square(std::string name);
    Square(std::string name, int height, int color);
};

class Circle: public Figure {
protected:
    double Area() override;
    double Length() override;
private:
    int radius;
public:
    const double pi = 3.14;
    Circle(std::string name);
    Circle(std::string name, int radius, int color);
};

class Letter: public IColor {
private:
    char letter;
    int  size,
         color;
    bool isBold,
         isItalic;
public:
    Letter();
    Letter(char letter, int size, int color);
    bool getIsBold();
    void setIsBold(bool isBold);
    bool getIsItalic();
    void setIsItalic(bool isItalic);
    void SetColor(int color) override;
    void ShowLetterInfo();
};

/** Файл MyClasses.cpp **************************/
#include <string>
#include <stdio.h>
#include <iostream>
#include <map>
#include "MyClasses.h"

Figure::Figure(std::string name, int color) {
    setName(name);
    this->color = color;
    InitColorDict();
} 

std::string Figure::getName() {
    return this->name;
}

void Figure::setName(std::string name) {
    this->name = name;
}

/**
* Инициализирует список цветов
*/
void Figure::InitColorDict() {
    this->colors[WHITE] = "белый";
    this->colors[BLACK] = "чёрный";
    this->colors[RED] =   "красный";
    this->colors[GREEN] = "зелёный";
    this->colors[BLUE] =  "синий";
}

/**
* Возвращает наименование цвета фигуры
*/
std::string Figure::GetColorName() {
    return this->colors[this->color];
}

/**
* Возвращает RGBе цвета фигуры
*/        
std::string Figure::GetRGBColor() {
    char _color[8];
    sprintf(_color, "#%06X", color);

    return _color;
}

/**
* Отображает площадь
*/
void Figure::ShowArea() {
    printf("Площадь %s %s: %.2f\n", GetColorName().c_str(), getName().c_str(), Area());
}
        
/**
* Отображает длину периметра
*/
void Figure::ShowLength() {
    printf("Длина %s %s: %.2f\n", GetColorName().c_str(), getName().c_str(), Length());
}

/**
* Устанавливает цвет
*/
void Figure::SetColor(int color) {
    this->color = color;
}

/**
* Отображает цвет
*/
 void Figure::ShowColor() {
    printf("RGB цвет %s %s: %s\n", GetColorName().c_str(), getName().c_str(), GetRGBColor().c_str());
}

Rectangle::Rectangle(std::string name): Rectangle(name, 1, 1, BLACK) {}

Rectangle::Rectangle(std::string name, int height, int width, int color): Figure(name, color) {
    this->height = height;
    this->width = width;
}


double Rectangle::Area() {
    return height * width;
}

double Rectangle::Length() {
    return (height + width) * 2;
}

Square::Square(std::string name): Rectangle(name) {}

Square::Square(std::string name, int height, int color): Rectangle(name, height, height, color) {}

Circle::Circle(std::string name): Circle(name, 1, BLACK) {}

Circle::Circle(std::string name, int radius, int color): Figure(name, color) {
    this->radius = radius;}

double Circle::Area() {
    return pi * (radius * radius);
}

double Circle::Length() {
    return 2 * pi * radius;
}

Letter::Letter(): Letter('A', 10, BLACK) {}

Letter::Letter(char letter, int size, int color) {
    this->letter = letter;
    this->size = size;
    SetColor(color);
}

bool Letter::getIsBold() {
    return this->isBold;
}

void Letter::setIsBold(bool isBold) {
    this->isBold = isBold;
}

bool Letter::getIsItalic() {
    return this->isItalic;
}

void Letter::setIsItalic(bool isItalic) {
    this->isItalic = isItalic;
}

void Letter::SetColor(int color) {
    this->color = color;
}

void Letter::ShowLetterInfo() {
    printf("Буква: %c, размер: %d, RGB цвет: #%06X\n", letter, size, color);
}

import java.util.HashMap;
public class Main {
    static final int WHITE = 0xFFFFFF;
    static final int BLACK = 0x000000;
    static final int RED =   0xFF0000;
    static final int GREEN = 0x00FF00;
    static final int BLUE =  0x0000FF;
    
    public static void main(String[] args) {
        Main main = new Main();
        main.Start();
    }
    
    public void Start() {
        Rectangle rectangle = new Rectangle("прямоугольник", 2, 3, RED);
        Square square = new Square("квадрат", 5, GREEN);
        Circle circle = new Circle("круг", 3, BLUE);
        
        Figure []figures = {rectangle, square, circle};
        ShowFigures(figures);
        
        Letter letter = new Letter('Z', 11, BLACK);
        letter.ShowLetterInfo();
        System.out.println("----------------------------\n");
        IColor []colorObjects = {rectangle, square, circle, letter};
        Recolor(colorObjects);
        System.out.println("!!! После перекраски !!!\n");
        ShowFigures(figures);
        letter.ShowLetterInfo();
        System.out.println("----------------------------\n");
    }
    
    /**
    * Отображает информацию о переданном массиве фигур
    */
    static void ShowFigures(Figure[] figures) {
        for(Figure figure: figures) {
            System.out.printf("Отображение %sа:\n", figure.getName());
            figure.ShowArea();
            figure.ShowLength();
            figure.ShowColor();
            System.out.println("----------------------------\n");
        }
    }
    
    /**
    * Перекрашивает цветные объекты из массива цветных объектов
    */    
    static void Recolor(IColor[] colorObjects) {
        for(IColor obj: colorObjects) {
            obj.SetColor(WHITE);
        }
    }
    
    /** Интерфейс цвета */
    public interface IColor {
        void SetColor(int color);
    }
    
    abstract class Figure implements IColor {
        private HashMap<Integer, String> colors;
        private String name;
        protected int color;
        
        /**
        * Конструктор
        */
        public Figure(String name, int color) {
            setName(name);
            this.color = color;
            InitColorDict();
        }
        
        /**
        * Возвращает наименование фигуры
        */
        public String getName() { 
            return name;
        }
        
        /**
        * Устанавливает наименование фигуры
        */
        public void setName(String name) {
            this.name = name;
        }
        
        /**
        * Инициализирует список цветов
        */
        private void InitColorDict() {
            colors = new HashMap<Integer, String>();
            colors.put(WHITE, "белый");
            colors.put(BLACK, "чёрный");
            colors.put(RED, "красный");
            colors.put(GREEN, "зелёный");
            colors.put(BLUE, "синий");
        }
        
        /** Возвращает площадь фигуры */
        abstract protected double Area();
        /** Возвращает длину периметра фигуры */
        abstract protected double Length();
        
        /**
        * Возвращает наименование цвета фигуры
        */
        private String GetColorName() {
            return colors.get(color);
        }
        
        /**
        * Возвращает RGBе цвета фигуры
        */        
        private String GetRGBColor() {
            return String.format("#%06X", color);
        }
        
        /**
        * Отображает площадь
        */
        public void ShowArea() {
            System.out.printf("Площадь %s %s: %.2f\n", GetColorName(), getName(), Area());
        }
        
        /**
        * Отображает длину периметра
        */
        public void ShowLength() {
           System.out.printf("Длина %s %s: %.2f\n", GetColorName(), getName(), Length());
        }
        
        /**
        * Устанавливает цвет
        */
        public void SetColor(int color) {
            this.color = color;
        }
        
        /**
        * Отображает цвет
        */
        public void ShowColor() {
            System.out.printf("RGB цвет %s %s: %s\n", GetColorName(), getName(), GetRGBColor());
        }
    }
	
	class Rectangle extends Figure {
        private int height;
        private int width;
        
        public Rectangle(String name) {
            this(name, 1, 1, BLACK);
        }
        
        public Rectangle(String name, int height, int width, int color) {
            super(name, color);
            this.height = height;
            this.width = width;
        }
        
        /** 
        * Возвращает площадь фигуры 
        */
        @Override
        protected double Area() {
            return height * width;
        }
        
        /** 
        * Возвращает длину периметра фигуры 
        */
        @Override
        protected double Length() {
            return (height + width) * 2;
        }
    }
    
    class Square extends Rectangle {
        public Square(String name) {
            super(name);
        }
        
        public Square(String name, int height, int color) {
            super(name, height, height, color);
        }
    }
    
    class Circle extends Figure {
        final double pi =  3.14;
        private int radius;
        
        public Circle(String name) {
            this(name, 1, BLACK);
        }
        
        public Circle(String name, int radius, int color) {
            super(name, color);
            this.radius = radius;
        }
        
        @Override
        protected double Area() {
            return pi * (radius * radius);
        }
        
        @Override
        protected double Length() {
            return 2 * pi * radius;
        }
    }
    
    class Letter implements IColor {
        private boolean isBold;
        private boolean isItalic;
        private char letter;
        private int size;
        private int color;
        
        public Letter() {
            this('A', 10, BLACK);
        } 
        
        public Letter(char letter, int size, int color) {
            this.letter = letter;
            this.size = size;
            SetColor(color);
            setIsBold(false);
            setIsItalic(false);
        }
        
        public boolean getIsBold() {
            return isBold;
        }
        
        public void setIsBold(boolean isBold) {
            this.isBold = isBold;
        }
        
        public boolean getIsItalic() {
            return isItalic;
        }
        
        public void setIsItalic(boolean isItalic) {
            this.isItalic = isItalic;
        }
        
        /**
        * Устанавливает цвет
        */
        public void SetColor(int color) {
            this.color = color;
        }
        
        public void ShowLetterInfo() {
            System.out.printf("Буква: %s, размер: %d, RGB цвет: #%06X\n", letter, size, color);
        }
    }
}

from abc import ABC, abstractmethod

WHITE = 0xFFFFFF
BLACK = 0x000000
RED =   0xFF0000
GREEN = 0x00FF00
BLUE =  0x0000FF


class IColor(ABC):
    """ Интерфейс цвета """
    @abstractmethod
    def set_color(self, color: int):
        raise NotImplementedError


class Figure(IColor, ABC):
    def __init__(self, name: str, color: int):
        self._colors = dict()
        self._color = color
        self.name = name

        self._init_color_dict()

    def __str__(self):
        return self.name

    @property
    def name(self) -> str:
        return self._name

    @name.setter
    def name(self, name: str):
        self._name = name

    def _init_color_dict(self):
        """ Инициализирует список цвет """
        self._colors = {WHITE: 'белый',
                        BLACK: 'чёрный',
                        RED: 'красный',
                        GREEN: 'зелёный',
                        BLUE: 'синий'}

    @abstractmethod
    def _area(self) -> float:
        """ Возвращает площадь фигуры """
        raise NotImplementedError()

    @abstractmethod
    def _length(self) -> float:
        """ Возвращает длину периметра фигуры """
        raise NotImplementedError()

    def _get_color_name(self) -> str:
        """ Возвращает наименование цвета фигуры """
        return self._colors[self._color]

    def _get_rgb_color(self) -> str:
        """ Возвращает RGBе цвета фигуры """
        return "#{0:06X}".format(self._color)

    def show_area(self):
        """ Отображает площадь """
        print("Площадь {} {}: {}".format(self._get_color_name(), self.name, self._area()))

    def show_length(self):
        """ Отображает длину периметра """
        print("Длина {} {}: {}".format(self._get_color_name(), self.name, self._length()))

    def set_color(self, color: int):
        """ Устанавливает цвет """
        self._color = color

    def show_color(self):
        """ Отображает цвет """
        print("RGB цвет {} {}: {}".format(self._get_color_name(), self.name, self._get_rgb_color()))


class Rectangle(Figure):
    def __init__(self, name: str, height: int=1, width: int=1, color: int=BLACK):
        super().__init__(name, color)
        self._height = height
        self._width = width
        self._color = color

    def _area(self) ->int:
        """ Возвращает площадь фигуры """
        return self._height * self._width

    def _length(self) -> int:
        """ Возвращает длину периметра фигуры """
        return (self._height + self._width) * 2


class Square(Rectangle):
    def __init__(self, name: str, height: int=1, color: int=BLACK):
        super().__init__(name, height, height, color)


class Circle(Figure):
    def __init__(self, name: str, radius: int=1, color: int=BLACK):
        super().__init__(name, color)
        self._pi = 3.14
        self._radius = radius
        self._color = color

    def _area(self) -> float:
        """ Возвращает площадь фигуры """
        return self._pi * (self._radius * self._radius)

    def _length(self) -> float:
        """ Возвращает длину периметра фигуры """
        return 2 * self._pi * self._radius


class Letter(IColor):
    def __init__(self, letter='A', size=10, color=BLACK):
        self._color = None
        self._letter = letter
        self._size = size
        self.set_color(color)
        self.is_bold = False
        self.is_italic = False

    @property
    def is_bold(self):
        return self._is_bold

    @is_bold.setter
    def is_bold(self, is_bold):
        self._is_bold = is_bold

    @property
    def is_italic(self):
        return self._is_italic

    @is_italic.setter
    def is_italic(self, is_italic):
        self._is_italic = is_italic

    def set_color(self, color: int):
        """ Устанавливает цвет """
        self._color = color

    def show_letter_info(self):
        print("Буква {0}, размер {1}, RGB цвет #{2:06X}".format(self._letter, self._size, self._color))


def show_figures(figures: tuple):
    """ Отображает информацию о переданном массиве фигур """
    for figure in figures:
        if not isinstance(figure, Figure):
            raise TypeError('Переданный объект {} не является подклассом типа "Figure".'.format(figure))
        print("Отображение {}а".format(figure))
        figure.show_area()
        figure.show_length()
        figure.show_color()
        print("----------------------------\n")


def recolor(color_objects: tuple):
    """ Перекрашивает цветные объекты из массива цветных объектов """
    for obj in color_objects:
        if not isinstance(obj, IColor):
            raise TypeError('Переданный объект {} не реализует интерфес "IColor".'.format(obj))
        obj.set_color(WHITE)


def main():
    rectangle = Rectangle('прямоугольник', 2, 3, RED)
    square = Square('квадрат', 5, GREEN)
    circle = Circle('круг', 3, BLUE)
    letter = Letter('Z', 11, BLACK)    

    figures = (rectangle, square, circle)
    show_figures(figures)
    letter.show_letter_info()
    print("----------------------------\n")

    color_objects = (rectangle, square, circle, letter)
    recolor(color_objects)
    print("!!! После перекраски !!!")
    show_figures(figures)
    letter.show_letter_info()
    print("----------------------------\n")


if __name__ == '__main__':
    main()

/** Файл main.cpp **************************/
#include <stdio.h>
#include "MyClasses.h"

/**
* Отображает информацию о переданном массиве фигур
*/
void ShowFigures(Figure *figures[], int size) {
    for(int i = 0; i < size; i++ ) {
        printf("Отображение %sа:\n", figures[i]->getName().c_str());
        figures[i]->ShowArea();
        figures[i]->ShowLength();
        figures[i]->ShowColor();
        printf("----------------------------\n\n");
    }
}

int main()
{
    Rectangle rectangle("прямоугольник", 2, 3, RED);
    Square square("квадрат", 5, GREEN);
    Circle circle("круг", 3, BLUE);
    
    int size = 3;
    Figure *figures[] = {&rectangle, &square, &circle};
    ShowFigures(figures, size);
        
    return 0;
}

/** Файл MyClasses.h **************************/
#include <map>
#include <string>
const int WHITE = 0xFFFFFF;
const int BLACK = 0x000000;
const int RED =   0xFF0000;
const int GREEN = 0x00FF00;
const int BLUE =  0x0000FF;

class Figure {
protected:
    int color;
    virtual double Area() = 0;
    virtual double Length() = 0;
private:
    std::map<int, std::string> colors;
    std::string name;
    void InitColorDict();
    std::string GetColorName();
    std::string GetRGBColor(); 
public:
    Figure(std::string name);
    std::string getName();
    void setName(std::string name);
    virtual void ShowArea();
    virtual void ShowLength();
    void SetColor(int color);
    virtual void ShowColor();
};

class Rectangle: public Figure {
protected:
    double Area() override;
    double Length() override;
private:
    int height,
        width;
public:
    Rectangle(std::string name);
    Rectangle(std::string name, int height, int width, int color);
    void ShowArea();
    void ShowLength();
};

class Square : public Rectangle {
public:
    Square(std::string name);
    Square(std::string name, int height, int color);
};

class Circle: public Figure {
protected:
    double Area() override;
    double Length() override;
private:
    int radius;
public:
    const double pi = 3.14;
    Circle(std::string name);
    Circle(std::string name, int radius, int color);
};

/** Файл MyClasses.cpp **************************/
#include <string>
#include <stdio.h>
#include <iostream>
#include <map>
#include "MyClasses.h"

Figure::Figure(std::string name) {
    setName(name);
    InitColorDict();
} 

std::string Figure::getName() {
    return this->name;
}

void Figure::setName(std::string name) {
    this->name = name;
}

/**
* Инициализирует список цветов
*/
void Figure::InitColorDict() {
    this->colors[WHITE] = "белый";
    this->colors[BLACK] = "чёрный";
    this->colors[RED] =   "красный";
    this->colors[GREEN] = "зелёный";
    this->colors[BLUE] =  "синий";
}

/**
* Возвращает наименование цвета фигуры
*/
std::string Figure::GetColorName() {
    return this->colors[this->color];
}

/**
* Возвращает RGBе цвета фигуры
*/        
std::string Figure::GetRGBColor() {
    char _color[8];
    sprintf(_color, "#%06X", color);

    return _color;
}

/**
* Отображает площадь
*/
void Figure::ShowArea() {
    printf("Площадь %s %s: %.2f\n", GetColorName().c_str(), getName().c_str(), Area());
}
        
/**
* Отображает длину периметра
*/
void Figure::ShowLength() {
    printf("Длина %s %s: %.2f\n", GetColorName().c_str(), getName().c_str(), Length());
}

/**
* Устанавливает цвет
*/
void Figure::SetColor(int color) {
    this->color = color;
}

/**
* Отображает цвет
*/
 void Figure::ShowColor() {
    printf("RGB цвет %s %s: %s\n", GetColorName().c_str(), getName().c_str(), GetRGBColor().c_str());
}

Rectangle::Rectangle(std::string name): Rectangle(name, 1, 1, BLACK) {}

Rectangle::Rectangle(std::string name, int height, int width, int color): Figure(name) {
    this->height = height;
    this->width = width;
    this->color = color;
}


double Rectangle::Area() {
    return height * width;
}

double Rectangle::Length() {
    return (height + width) * 2;
}

void Rectangle::ShowArea() {
    printf("Площадь %s: %.2f\n", getName().c_str(), Area());
}

void Rectangle::ShowLength() {
    printf("Именно длина периметра %sа. ", getName().c_str());
    Figure::ShowLength();
}

Square::Square(std::string name): Rectangle(name) {}

Square::Square(std::string name, int height, int color): Rectangle(name, height, height, color) {}

Circle::Circle(std::string name): Circle(name, 1, BLACK) {}

Circle::Circle(std::string name, int radius, int color): Figure(name) {
    this->radius = radius;
    this->color = color;
}

double Circle::Area() {
    return pi * (radius * radius);
}

double Circle::Length() {
    return 2 * pi * radius;
}

using System;
using System.Collections.Generic;

public class MainClass {
    const int WHITE = 0xFFFFFF;
    const int BLACK = 0x000000;
    const int RED =   0xFF0000;
    const int GREEN = 0x00FF00;
    const int BLUE =  0x0000FF;
    
    public static void Main() {
        Rectangle rectangle = new Rectangle("прямоугольник", 2, 3, RED);
        Square square = new Square("квадрат", 5, GREEN);
        Circle circle = new Circle("круг", 3, BLUE);
        
        Figure []figures = {rectangle, square, circle};
        ShowFigures(figures);
        
    }
    
    /**
    * Отображает информацию о переданном массиве фигур
    */
    static void ShowFigures(Figure[] figures) {
        foreach(Figure figure in figures) {
            Console.WriteLine("Отображение {0}а:", figure.Name);
            figure.ShowArea();
            figure.ShowLength();
            figure.ShowColor();
            Console.WriteLine("----------------------------\n");
        }
    }
    
    
    abstract class Figure {
        private Dictionary<int, string> colors;
        protected int color;
        
        /**
        * Конструктор
        */
        public Figure(string name) {
            Name = name;
            
            InitColorDict();
        }
        
        public string Name { get; set; }
        
        /**
        * Инициализирует список цветов
        */
        private void InitColorDict() {
            colors = new Dictionary<int, string>();
            colors[WHITE] = "белый";
            colors[BLACK] = "чёрный";
            colors[RED] = "красный";
            colors[GREEN] = "зелёный";
            colors[BLUE] = "синий";
        }
        
        /** Возвращает площадь фигуры */
        abstract protected double Area();
        /** Возвращает длину периметра фигуры */
        abstract protected double Length();
        
        /**
        * Возвращает наименование цвета фигуры
        */
        private string GetColorName() {
            return colors[color];
        }
        
        /**
        * Возвращает RGBе цвета фигуры
        */        
        private string GetRGBColor() {
            return string.Format("#{0:X6}", color);
        }
        
        /**
        * Отображает площадь
        */
        public virtual void ShowArea() {
            Console.WriteLine("Площадь {0} {1}: {2}", GetColorName(), Name, Area());
        }
        
        /**
        * Отображает длину периметра
        */
        public virtual void ShowLength() {
            Console.WriteLine("Длина {0} {1}: {2}", GetColorName(), Name, Length());
        }
        
        /**
        * Устанавливает цвет
        */
        public void SetColor(int color) {
            this.color = color;
        }
        
        /**
        * Отображает цвет
        */
        public virtual void ShowColor() {
            Console.WriteLine("RGB цвет {0} {1}: {2}", GetColorName(), Name, GetRGBColor());
        }
    }
    
    class Rectangle : Figure {
        private int height;
        private int width;
        
        public Rectangle(string name) : this(name, 1, 1, BLACK) {}
        
        public Rectangle(string name, int height, int width, int color) : base(name) {
            this.height = height;
            this.width = width;
            this.color = color;
        }
        
        override protected double Area() {
            return height * width;
        }
        
        override protected double Length() {
            return (height + width) * 2;
        }
        
        /**
        * Отображает площадь
        */
        override public void ShowArea() {
            Console.WriteLine("Площадь {0}: {1}", Name, Area());
        }
        
        /**
        * Отображает длину периметра
        */
        override public void ShowLength() {
            Console.Write("Именно длина периметра {0}а. ", Name);
            base.ShowLength();
        }
    }

    class Square : Rectangle {
        public Square(string name) : base(name) {}
        
        public Square(string name, int height, int color) : base(name, height, height, color) {
        }
    }

    class Circle: Figure {
        const double pi =  3.14;
        private int radius;
        
        public Circle(string name) : this(name, 1, BLACK) {}
        
        public Circle(string name, int radius, int color): base(name) {
            this.radius = radius;
            this.color = color;
        }
        
        override protected double Area() {
            return pi * (radius * radius);
        }
        
        override protected double Length() {
            return 2 * pi * radius;
        }
    }
}

import java.util.HashMap;
public class Main {
    static final int WHITE = 0xFFFFFF;
    static final int BLACK = 0x000000;
    static final int RED =   0xFF0000;
    static final int GREEN = 0x00FF00;
    static final int BLUE =  0x0000FF;
    
    public static void main(String[] args) {
        Main main = new Main();
        main.Start();
    }
    
    public void Start() {
        Rectangle rectangle = new Rectangle("прямоугольник", 2, 3, RED);
        Square square = new Square("квадрат", 5, GREEN);
        Circle circle = new Circle("круг", 3, BLUE);
        
        Figure []figures = {rectangle, square, circle};
        ShowFigures(figures);
    }
    
        /**
    * Отображает информацию о переданном массиве фигур
    */
    static void ShowFigures(Figure[] figures) {
        for(Figure figure: figures) {
            System.out.printf("Отображение %sа:\n", figure.getName());
            figure.ShowArea();
            figure.ShowLength();
            figure.ShowColor();
            System.out.println("----------------------------\n");
        }
    }
    
    
    abstract class Figure {
        private HashMap<Integer, String> colors;
        private String name;
        protected int color;
        
        /**
        * Конструктор
        */
        public Figure(String name) {
            setName(name);
            
            InitColorDict();
        }
        
        /**
        * Возвращает наименование фигуры
        */
        public String getName() { 
            return name;
        }
        
        /**
        * Устанавливает наименование фигуры
        */
        public void setName(String name) {
            this.name = name;
        }
        
        /**
        * Инициализирует список цветов
        */
        private void InitColorDict() {
            colors = new HashMap<Integer, String>();
            colors.put(WHITE, "белый");
            colors.put(BLACK, "чёрный");
            colors.put(RED, "красный");
            colors.put(GREEN, "зелёный");
            colors.put(BLUE, "синий");
        }
        
        /** Возвращает площадь фигуры */
        abstract protected double Area();
        /** Возвращает длину периметра фигуры */
        abstract protected double Length();
        
        /**
        * Возвращает наименование цвета фигуры
        */
        private String GetColorName() {
            return colors.get(color);
        }
        
        /**
        * Возвращает RGBе цвета фигуры
        */        
        private String GetRGBColor() {
            return String.format("#%06X", color);
        }
        
        /**
        * Отображает площадь
        */
        public void ShowArea() {
            System.out.printf("Площадь %s %s: %.2f\n", GetColorName(), getName(), Area());
        }
        
        /**
        * Отображает длину периметра
        */
        public void ShowLength() {
           System.out.printf("Длина %s %s: %.2f\n", GetColorName(), getName(), Length());
        }
        
        /**
        * Устанавливает цвет
        */
        public void SetColor(int color) {
            this.color = color;
        }
        
        /**
        * Отображает цвет
        */
        public void ShowColor() {
            System.out.printf("RGB цвет %s %s: %s\n", GetColorName(), getName(), GetRGBColor());
        }
    }
	
	class Rectangle extends Figure {
        private int height;
        private int width;
        
        public Rectangle(String name) {
            this(name, 1, 1, BLACK);
        }
        
        public Rectangle(String name, int height, int width, int color) {
            super(name);
            this.height = height;
            this.width = width;
            this.color = color;
        }
        
        /** 
        * Возвращает площадь фигуры 
        */
        @Override
        protected double Area() {
            return height * width;
        }
        
        /** 
        * Возвращает длину периметра фигуры 
        */
        @Override
        protected double Length() {
            return (height + width) * 2;
        }
        
        /**
        * Отображает площадь
        */
        @Override
        public void ShowArea() {
            System.out.printf("Площадь %s: %.2f\n", getName(), Area());
        }
        
        /**
        * Отображает длину периметра
        */
        @Override
        public void ShowLength() {
            System.out.printf("Именно длина периметра %sа. ", getName());
            super.ShowLength();
        }
    }
    
    class Square extends Rectangle {
        public Square(String name) {
            super(name);
        }
        
        public Square(String name, int height, int color) {
            super(name, height, height, color);
        }
    }
    
    class Circle extends Figure {
        final double pi =  3.14;
        private int radius;
        
        public Circle(String name) {
            this(name, 1, BLACK);
        }
        
        public Circle(String name, int radius, int color) {
            super(name);
            this.radius = radius;
            this.color = color;
        }
        
        @Override
        protected double Area() {
            return pi * (radius * radius);
        }
        
        @Override
        protected double Length() {
            return 2 * pi * radius;
        }
    }
}

/** Файл main.cpp **************************/
#include <stdio.h>
#include "MyClasses.h"

/**
* Отображает информацию о переданном массиве фигур
*/
void ShowFigures(Figure *figures[], int size) {
    for(int i = 0; i < size; i++ ) {
        printf("Отображение %sа:\n", figures[i]->getName().c_str());
        figures[i]->ShowArea();
        figures[i]->ShowLength();
        figures[i]->ShowColor();
        printf("----------------------------\n\n");
    }
}

int main()
{
    Rectangle rectangle("прямоугольник", 2, 3, RED);
    Square square("квадрат", 5, GREEN);
    Circle circle("круг", 3, BLUE);
    printf("----------------------------\n");
    Circle::ShowCount();
    printf("----------------------------\n\n");
    
    Figure *figures[] = {&rectangle, &square, &circle};
    int numberFigures = sizeof(figures)/sizeof(figures[0]); 
    ShowFigures(figures, numberFigures);
    Figure::ShowCount();
        
    return 0;
}

/** Файл MyClasses.h **************************/
#include <map>
#include <string>
const int WHITE = 0xFFFFFF;
const int BLACK = 0x000000;
const int RED =   0xFF0000;
const int GREEN = 0x00FF00;
const int BLUE =  0x0000FF;

class Figure {
protected:
    int color;
    virtual double Area() = 0;
    virtual double Length() = 0;
private:
    static inline int count = 0; 
    std::map<int, std::string> colors;
    std::string name;
    void InitColorDict();
    std::string GetColorName();
    std::string GetRGBColor(); 
public:
    Figure(std::string name);
    static void ShowCount();
    static void ShowCount(std::string name);
    std::string getName();
    void setName(std::string name);
    virtual void ShowArea();
    virtual void ShowLength();
    void SetColor(int color);
    virtual void ShowColor();
};

class Rectangle: public Figure {
protected:
    double Area() override;
    double Length() override;
private:
    int height,
        width;
public:
    Rectangle(std::string name);
    Rectangle(std::string name, int height, int width, int color);
    void ShowArea();
    void ShowLength();
};

class Square : public Rectangle {
public:
    Square(std::string name);
    Square(std::string name, int height, int color);
};

class Circle: public Figure {
protected:
    double Area() override;
    double Length() override;
private:
    int radius;
public:
    const double pi = 3.14;
    Circle(std::string name);
    Circle(std::string name, int radius, int color);
};

/** Файл MyClasses.cpp **************************/
#include <string>
#include <stdio.h>
#include <iostream>
#include <map>
#include "MyClasses.h"

Figure::Figure(std::string name) {
    setName(name);
    this->count++;
    ShowCount(this->name);
    InitColorDict();
}

void Figure::ShowCount() {
    printf("Всего фигур %d.\n", count);
}

void Figure::ShowCount(std::string name) {
    printf("Создана фигура %s. Всего фигур %d.\n", name.c_str(), count);
}

std::string Figure::getName() {
    return this->name;
}

void Figure::setName(std::string name) {
    this->name = name;
}

/**
* Инициализирует список цветов
*/
void Figure::InitColorDict() {
    this->colors[WHITE] = "белый";
    this->colors[BLACK] = "чёрный";
    this->colors[RED] =   "красный";
    this->colors[GREEN] = "зелёный";
    this->colors[BLUE] =  "синий";
}

/**
* Возвращает наименование цвета фигуры
*/
std::string Figure::GetColorName() {
    return this->colors[this->color];
}

/**
* Возвращает RGBе цвета фигуры
*/        
std::string Figure::GetRGBColor() {
    char _color[8];
    sprintf(_color, "#%06X", color);

    return _color;
}

/**
* Отображает площадь
*/
void Figure::ShowArea() {
    printf("Площадь %s %s: %.2f\n", GetColorName().c_str(), getName().c_str(), Area());
}
        
/**
* Отображает длину периметра
*/
void Figure::ShowLength() {
    printf("Длина %s %s: %.2f\n", GetColorName().c_str(), getName().c_str(), Length());
}

/**
* Устанавливает цвет
*/
void Figure::SetColor(int color) {
    this->color = color;
}

/**
* Отображает цвет
*/
 void Figure::ShowColor() {
    printf("RGB цвет %s %s: %s\n", GetColorName().c_str(), getName().c_str(), GetRGBColor().c_str());
}

Rectangle::Rectangle(std::string name): Rectangle(name, 1, 1, BLACK) {}

Rectangle::Rectangle(std::string name, int height, int width, int color): Figure(name) {
    this->height = height;
    this->width = width;
    this->color = color;
}

double Rectangle::Area() {
    return height * width;
}

double Rectangle::Length() {
    return (height + width) * 2;
}

void Rectangle::ShowArea() {
    printf("Площадь %s: %.2f\n", getName().c_str(), Area());
}

void Rectangle::ShowLength() {
    printf("Именно длина периметра %sа. ", getName().c_str());
    Figure::ShowLength();
}

Square::Square(std::string name): Rectangle(name) {}

Square::Square(std::string name, int height, int color): Rectangle(name, height, height, color) {}

Circle::Circle(std::string name): Circle(name, 1, BLACK) {}

Circle::Circle(std::string name, int radius, int color): Figure(name) {
    this->radius = radius;
    this->color = color;
}

double Circle::Area() {
    return pi * (radius * radius);
}

double Circle::Length() {
    return 2 * pi * radius;
}

import java.util.HashMap;
public class Main {
    static final int WHITE = 0xFFFFFF;
    static final int BLACK = 0x000000;
    static final int RED =   0xFF0000;
    static final int GREEN = 0x00FF00;
    static final int BLUE =  0x0000FF;
    
    public static void main(String[] args) {
        Main main = new Main();
        main.Start();
    }
    
    public void Start() {
        Figure.ShowCount();
        Rectangle rectangle = new Rectangle("прямоугольник", 2, 3, RED);
        Square square = new Square("квадрат", 5, GREEN);
        Circle circle = new Circle("круг", 3, BLUE);
        System.out.println("----------------------------");
        Circle.ShowCount();
        System.out.println("----------------------------\n");
        
        Figure []figures = {rectangle, square, circle};
        ShowFigures(figures);
        Figure.ShowCount();
    }
    
        /**
    * Отображает информацию о переданном массиве фигур
    */
    static void ShowFigures(Figure[] figures) {
        for(Figure figure: figures) {
            System.out.printf("Отображение %sа:\n", figure.getName());
            figure.ShowArea();
            figure.ShowLength();
            figure.ShowColor();
            System.out.println("----------------------------\n");
        }
    }
    
    abstract static class Figure {
        static private int count = 0;
        private HashMap<Integer, String> colors;
        private String name;
        protected int color;
        
        /**
        * Конструктор
        */
        public Figure(String name) {
            setName(name);
            count++;
            ShowCount(getName());
            InitColorDict();
        }
        
        static public void ShowCount() {
            System.out.printf("Всего фигур %d.\n", count);
        }
        
        static public void ShowCount(String name) {
            System.out.printf("Создана фигура %s. Всего фигур %d.\n", name, count);
        }
        
        /**
        * Возвращает наименование фигуры
        */
        public String getName() { 
            return name;
        }
        
        /**
        * Устанавливает наименование фигуры
        */
        public void setName(String name) {
            this.name = name;
        }
        
        /**
        * Инициализирует список цветов
        */
        private void InitColorDict() {
            colors = new HashMap<Integer, String>();
            colors.put(WHITE, "белый");
            colors.put(BLACK, "чёрный");
            colors.put(RED, "красный");
            colors.put(GREEN, "зелёный");
            colors.put(BLUE, "синий");
        }
        
        /** Возвращает площадь фигуры */
        abstract protected double Area();
        /** Возвращает длину периметра фигуры */
        abstract protected double Length();
        
        /**
        * Возвращает наименование цвета фигуры
        */
        private String GetColorName() {
            return colors.get(color);
        }
        
        /**
        * Возвращает RGBе цвета фигуры
        */        
        private String GetRGBColor() {
            return String.format("#%06X", color);
        }
        
        /**
        * Отображает площадь
        */
        public void ShowArea() {
            System.out.printf("Площадь %s %s: %.2f\n", GetColorName(), getName(), Area());
        }
        
        /**
        * Отображает длину периметра
        */
        public void ShowLength() {
           System.out.printf("Длина %s %s: %.2f\n", GetColorName(), getName(), Length());
        }
        
        /**
        * Устанавливает цвет
        */
        public void SetColor(int color) {
            this.color = color;
        }
        
        /**
        * Отображает цвет
        */
        public void ShowColor() {
            System.out.printf("RGB цвет %s %s: %s\n", GetColorName(), getName(), GetRGBColor());
        }
    }
	
	class Rectangle extends Figure {
        private int height;
        private int width;
        
        public Rectangle(String name) {
            this(name, 1, 1, BLACK);
        }
        
        public Rectangle(String name, int height, int width, int color) {
            super(name);
            this.height = height;
            this.width = width;
            this.color = color;
        }
        
        /** 
        * Возвращает площадь фигуры 
        */
        @Override
        protected double Area() {
            return height * width;
        }
        
        /** 
        * Возвращает длину периметра фигуры 
        */
        @Override
        protected double Length() {
            return (height + width) * 2;
        }
        
        /**
        * Отображает площадь
        */
        @Override
        public void ShowArea() {
            System.out.printf("Площадь %s: %.2f\n", getName(), Area());
        }
        
        /**
        * Отображает длину периметра
        */
        @Override
        public void ShowLength() {
            System.out.printf("Именно длина периметра %sа. ", getName());
            super.ShowLength();
        }
    }
    
    class Square extends Rectangle {
        public Square(String name) {
            super(name);
        }
        
        public Square(String name, int height, int color) {
            super(name, height, height, color);
        }
    }
    
    class Circle extends Figure {
        final double pi =  3.14;
        private int radius;
        
        public Circle(String name) {
            this(name, 1, BLACK);
        }
        
        public Circle(String name, int radius, int color) {
            super(name);
            this.radius = radius;
            this.color = color;
        }
        
        @Override
        protected double Area() {
            return pi * (radius * radius);
        }
        
        @Override
        protected double Length() {
            return 2 * pi * radius;
        }
    }
}

from abc import ABC, abstractmethod


WHITE = 0xFFFFFF
BLACK = 0x000000
RED = 0xFF0000
GREEN = 0x00FF00
BLUE = 0x0000FF


class Figure(ABC):
    count = 0

    def __init__(self, name: str):
        self._colors = dict()
        self._color = None
        self.name = name
        Figure.count += 1
        self.show_count(name)
        self._init_color_dict()

    def __str__(self):
        return self.name

    @classmethod
    def show_count(cls, name=""):
        if name == "":
            print("Всего фигур {}.".format(cls.count))
        else:
            print("Создана фигура {}. Всего фигур {}".format(name, cls.count))

    @property
    def name(self) -> str:
        return self._name

    @name.setter
    def name(self, name: str):
        self._name = name

    def _init_color_dict(self):
        """ Инициализирует список цвет """
        self._colors = {WHITE: 'белый',
                        BLACK: 'чёрный',
                        RED: 'красный',
                        GREEN: 'зелёный',
                        BLUE: 'синий'}

    @abstractmethod
    def _area(self) -> float:
        """ Возвращает площадь фигуры """
        raise NotImplementedError()

    @abstractmethod
    def _length(self) -> float:
        """ Возвращает длину периметра фигуры """
        raise NotImplementedError()

    def _get_color_name(self) -> str:
        """ Возвращает наименование цвета фигуры """
        return self._colors[self._color]

    def _get_rgb_color(self) -> str:
        """ Возвращает RGBе цвета фигуры """
        return "#{0:06X}".format(self._color)

    def show_area(self):
        """ Отображает площадь """
        print("Площадь {} {}: {}".format(self._get_color_name(), self.name, self._area()))

    def show_length(self):
        """ Отображает длину периметра """
        print("Длина {} {}: {}".format(self._get_color_name(), self.name, self._length()))

    def set_color(self, color: int):
        """ Устанавливает цвет """
        self._color = color

    def show_color(self):
        """ Отображает цвет """
        print("RGB цвет {} {}: {}".format(self._get_color_name(), self.name, self._get_rgb_color()))


class Rectangle(Figure):
    def __init__(self, name: str, height: int=1, width: int=1, color: int=BLACK):
        super().__init__(name)
        self._height = height
        self._width = width
        self._color = color

    def _area(self) ->int:
        """ Возвращает площадь фигуры """
        return self._height * self._width

    def _length(self) -> int:
        """ Возвращает длину периметра фигуры """
        return (self._height + self._width) * 2

    def show_area(self):
        """ Отображает площадь """
        print("Площадь {}: {}".format(self.name, self._area()))

    def show_length(self):
        """ Отображает длину периметра """
        print("Именно длина периметра {}а.".format(self.name), end=' ')
        super().show_length()


class Square(Rectangle):
    def __init__(self, name: str, height: int=1, color: int=BLACK):
        super().__init__(name, height, height, color)


class Circle(Figure):
    def __init__(self, name: str, radius: int=1, color: int=BLACK):
        super().__init__(name)
        self._pi = 3.14
        self._radius = radius
        self._color = color

    def _area(self) -> float:
        """ Возвращает площадь фигуры """
        return self._pi * (self._radius * self._radius)

    def _length(self) -> float:
        """ Возвращает длину периметра фигуры """
        return 2 * self._pi * self._radius


def show_figures(figures: tuple):
    """ Отображает информацию о переданном массиве фигур """
    for figure in figures:
        if not isinstance(figure, Figure):
            raise TypeError('Переданный объект {} не является подклассом типа "Figure".'.format(figure))
        print("Отображение {}а".format(figure))
        figure.show_area()
        figure.show_length()
        figure.show_color()
        print("----------------------------\n")


def main():
    Figure.show_count()
    rectangle = Rectangle('прямоугольник', 2, 3, RED)
    square = Square('квадрат', 5, GREEN)
    circle = Circle('круг', 3, BLUE)
    print("----------------------------")
    Circle.show_count()
    print("----------------------------\n")

    figures = (rectangle, square, circle)
    show_figures(figures)
    Figure.show_count()


if __name__ == '__main__':
    main()