16216

РЕАЛИЗАЦИЯ ПРИНЦИПОВ ПОЛИМОРФИЗМА

Лабораторная работа

Информатика, кибернетика и программирование

Лабораторная работа №4 Реализация принципов полиморфизма Цель лабораторной работы: изучить правила создания дочерних классов. Постановка задачи: Разработать дочерний класс вычисления определенного интеграла с различными подынтегральными функциями. Реализоват...

Русский

2013-06-20

109 KB

7 чел.

Лабораторная работа №4

Реализация принципов полиморфизма

Цель лабораторной работы: изучить правила создания дочерних классов.

Постановка задачи:

Разработать дочерний класс вычисления определенного интеграла с различными подынтегральными функциями. Реализовать возможность арифметических операций над интегралами с выбранными функциями.

Краткие теоретические сведения:

В основе классов лежат три фундаментальных принципа, которые называются инкапсуляция, наследование и полиморфизм.

Полиморфизм - это свойство классов решать схожие по смыслу проблемы разными способами (возможность использовать одинаковые имена для методов, входящих в различные классы).

В рамках Object Pascal поведенческие свойства класса определяются набором входящих в него методов. Изменяя алгоритм того или иного метода в потомках класса, программист может придавать этим потомкам отсутствующие у родителя специфические свойства. Для изменения метода необходимо перекрыть его в потомке, т. е. объявить в потомке одноименный метод и реализовать в нем нужные действия. В результате в объекте-родителе и объекте-потомке будут действовать два одноименных метода, имеющих разную алгоритмическую основу и, следовательно, придающих объектам разные свойства. Это и называется полиморфизмом объектов.

В Object Pascal полиморфизм достигается не только описанным выше механизмом наследования и перекрытия методов родителя, но и их виртуализацией, позволяющей родительским методам обращаться к методам своих потомков.

Метод, замещаемый в родительском классе, должен объявляться как динамический (с директивой dynamic) или виртуальный (virtual). Встретив такое объявление, компилятор создаст две таблицы -DMT (Dynamic Method Table) и VMT (Virtual Method Table) и поместит в них адреса точек входа соответственно динамических и виртуальных методов. При каждом обращении к замещаемому методу компилятор вставляет код, позволяющий извлечь адрес точки входа в подпрограмму из той или иной таблицы. В классе-потомке замещающий метод объявляется с директивой override (перекрыть). Получив это указание, компилятор создаст код, который на этапе прогона программы поместит в родительскую таблицу точку входа метода класса-потомка, что позволит родителю выполнить нужное действие с помощью нового метода.

Текст программы:

// основная программа

// модуль, содержащий класс

unit UDisplayForm;

interface

uses

 Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

 Dialogs, Series, ExtCtrls, StdCtrls, TeEngine, TeeProcs, Chart, Buttons, UCalc, UTwoIntegrals;

type

 TForm1 = class(TForm)

   Edit2: TEdit;

   Edit1: TEdit;

   MethodSelector: TRadioGroup;

   DisplayChart: TChart;

   SeriesFunction1: TLineSeries;

   Label1: TLabel;

   Label2: TLabel;

   Label4: TLabel;

   SeriesPatterned1: TAreaSeries;

   Label3: TLabel;

   Edit3: TEdit;

   SpeedButton1: TSpeedButton;

   Edit4: TEdit;

   Panel1: TPanel;

   Label5: TLabel;

   Panel2: TPanel;

   CheckBox1: TCheckBox;

   SeriesPatterned2: TAreaSeries;

   SeriesFunction2: TLineSeries;

   SeriesCommon: TAreaSeries;

   Label6: TLabel;

   Edit5: TEdit;

   Label7: TLabel;

   Edit6: TEdit;

   Label8: TLabel;

   Edit7: TEdit;

   Panel3: TPanel;

   Label9: TLabel;

   Edit8: TEdit;

   Panel4: TPanel;

   Label10: TLabel;

   Edit9: TEdit;

   Panel5: TPanel;

   Label11: TLabel;

   Edit10: TEdit;

   Bevel1: TBevel;

   Panel6: TPanel;

   Label12: TLabel;

   Edit11: TEdit;

   RadioGroup1: TRadioGroup;

   RadioGroup2: TRadioGroup;

   procedure FormCreate(Sender: TObject);

   procedure SomeEditKeyPress(Sender: TObject; var Key: Char);

   procedure SpeedButton1Click(Sender: TObject);

   procedure SomeEditChange1(Sender: TObject);

   procedure SomeEditChange2(Sender: TObject);

   procedure MethodSelectorClick(Sender: TObject);

   procedure CheckBox1Click(Sender: TObject);

   procedure FormShow(Sender: TObject);

   procedure SmthChanged;

   function f2(x: Extended): Extended;

   procedure RadioGroup1Click(Sender: TObject);

   procedure RadioGroup2Click(Sender: TObject);

 private

   { Private declarations }

 public

   { Public declarations }

 end;

var

 Form1: TForm1;

 e1, e2, e3, e5, e6, e7: string;

 p1, p2, p3, p5, p6, p7: integer;

 integ: TIntegral;

 twoIntegrals: TTwoIntegrals;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);

begin

 integ:=TIntegral1.Create(0);

 twoIntegrals:=TTwoIntegrals.Create();

 twoIntegrals.Chart:=DisplayChart;

 twoIntegrals.OnSomethingChanged:=SmthChanged;

 //integ.Chart:=DisplayChart;

end;

//Edited

procedure TForm1.SomeEditKeyPress(Sender: TObject; var Key: Char);

begin

 if Sender=Edit3 then

   p3:=Edit3.SelStart;

 

 if (Sender=Edit2) then

   p2:=Edit2.SelStart;

 if (Sender=Edit1) then

   p1:=Edit1.SelStart;

 if Sender=Edit7 then

   p7:=Edit7.SelStart;

 if (Sender=Edit6) then

   p6:=Edit6.SelStart;

 if (Sender=Edit5) then

   p5:=Edit5.SelStart;

end;

procedure TForm1.SpeedButton1Click(Sender: TObject);

begin

 Application.Terminate;

end;

procedure TForm1.SomeEditChange1(Sender: TObject);

var r: real;

begin

 if Sender=Edit3 then

 begin

   try

    twoIntegrals.Integral1.N:=StrToInt((Sender as TEdit).Text);

     e3:=Edit3.Text;

   except

     on EConvertError do begin

                               Edit3.Text:=e3;

                               Edit3.SelStart:=p3;

                             end;

   end;

 end

 else if ((Sender=Edit1) or (Sender=Edit2)) then

 begin

   if true then

   begin

       try

         r:=StrToFloat((Sender as TEdit).Text);

         e1:=Edit1.Text;

         e2:=Edit2.Text;

       except

         on EConvertError do begin

                               if Sender=Edit1 then

                               begin

                                 (Sender as TEdit).Text:=e1;

                                 (Sender as TEdit).SelStart:=p1;

                               end

                               else if Sender=Edit2 then

                               begin

                                 (Sender as TEdit).Text:=e2;

                                 (Sender as TEdit).SelStart:=p2;

                               end;

                               exit;

                             end;

       end;

       if Sender=Edit2 then

       begin

         twoIntegrals.Integral1.B:=r;

       end

       else

       begin

         twoIntegrals.Integral1.A:=r;

       end;

   end;

 end;

end;

procedure TForm1.SomeEditChange2(Sender: TObject);

var r: real;

begin

 if Sender=Edit7 then

 begin

   try

    twoIntegrals.Integral2.N:=StrToInt((Sender as TEdit).Text);

     e7:=Edit7.Text;

   except

     on EConvertError do begin

                               Edit7.Text:=e7;

                               Edit7.SelStart:=p7;

                             end;

   end;

 end

 else if ((Sender=Edit5) or (Sender=Edit6)) then

 begin

   if true then

   begin

       try

         r:=StrToFloat((Sender as TEdit).Text);

         e5:=Edit5.Text;

         e6:=Edit6.Text;

       except

         on EConvertError do begin

                               if Sender=Edit5 then

                               begin

                                 (Sender as TEdit).Text:=e5;

                                 (Sender as TEdit).SelStart:=p5;

                               end

                               else if Sender=Edit6 then

                               begin

                                 (Sender as TEdit).Text:=e6;

                                 (Sender as TEdit).SelStart:=p6;

                               end;

                               exit;

                             end;

       end;

       if Sender=Edit6 then

       begin

         twoIntegrals.Integral2.B:=r;

       end

       else

       begin

         twoIntegrals.Integral2.A:=r;

       end;

   end;

 end;

end;

procedure TForm1.MethodSelectorClick(Sender: TObject);

begin

 twoIntegrals.CalcMethod:=MethodSelector.ItemIndex;

end;

procedure TForm1.CheckBox1Click(Sender: TObject);

begin

 SeriesPatterned1.AreaLinesPen.Visible:=(Sender as TCheckBox).Checked;

 SeriesPatterned2.AreaLinesPen.Visible:=(Sender as TCheckBox).Checked;

end;

procedure TForm1.FormShow(Sender: TObject);

begin

 SomeEditChange1(Edit1);

 SomeEditChange1(Edit2);

 SomeEditChange2(Edit5);

 SomeEditChange2(Edit6);

end;

procedure TForm1.SmthChanged;

begin

 if not twoIntegrals.Integral1.IsError then

   Edit4.Text:=FloatToStr(twoIntegrals.Integral1.Res)

 else

   Edit4.Text:='Îøèáêà â äàííûõ!';

 if not twoIntegrals.Integral2.IsError then

   Edit9.Text:=FloatToStr(twoIntegrals.Integral2.Res)

 else

   Edit9.Text:='Îøèáêà â äàííûõ!';

 if not twoIntegrals.IsError then

 begin

   Edit8.Text:=FloatToStr(twoIntegrals.Sum);

   Edit10.Text:=FloatToStr(twoIntegrals.Difference12);

   Edit11.Text:=FloatToStr(twoIntegrals.Difference21);

 end

 else

 begin

   Edit8.Text:='Îøèáêà â äàííûõ!';

   Edit10.Text:='Îøèáêà â äàííûõ!';

   Edit11.Text:='Îøèáêà â äàííûõ!';

 end;

end;

function TForm1.f2(x: Extended): Extended;

begin

 Result:=x*x*3;

end;

procedure TForm1.RadioGroup1Click(Sender: TObject);

begin

 twoIntegrals.Integral1.Free;

//  case (Sender as TRadioGroup).ItemIndex of

 case RadioGroup1.ItemIndex of

 0: twoIntegrals.Integral1:=TIntegral1.Create(0);

 1: twoIntegrals.Integral1:=TIntegral2.Create(0);

 2: twoIntegrals.Integral1:=TIntegral3.Create(0);

 3: twoIntegrals.Integral1:=TIntegral4.Create(0);

 4: twoIntegrals.Integral1:=TIntegral5.Create(0);

 else

   twoIntegrals.Integral1:=TIntegral1.Create(0);

 end;

 //twoIntegrals.Integral1.CalcMethod:=twoIntegrals.CalcMethod;

 //twoIntegrals.Integral1.Chart:=twoIntegrals.Chart;

 //twoIntegrals.Integral1.OnRecalc:=twoIntegrals.ParametersChanged;

end;

procedure TForm1.RadioGroup2Click(Sender: TObject);

begin

 twoIntegrals.Integral2.Free;

 case (Sender as TRadioGroup).ItemIndex of

   0: twoIntegrals.Integral2:=TIntegral1.Create(1);

   1: twoIntegrals.Integral2:=TIntegral2.Create(1);

   2: twoIntegrals.Integral2:=TIntegral3.Create(1);

   3: twoIntegrals.Integral2:=TIntegral4.Create(1);

   4: twoIntegrals.Integral2:=TIntegral5.Create(1);

 else

   twoIntegrals.Integral2:=TIntegral2.Create(1);

 end;

 //twoIntegrals.Integral2.CalcMethod:=twoIntegrals.CalcMethod;

 //twoIntegrals.Integral2.Chart:=twoIntegrals.Chart;

 //twoIntegrals.Integral2.OnRecalc:=twoIntegrals.ParametersChanged;

end;

end.

unit UCalc;

unit UCalc;

interface

uses Chart;

const funcCount=4;

type

    TValueChangedFunc=procedure (newValue: Extended) of object;

    TIntegral=class

     private

       FValueMin: Extended;//Íèæíÿÿ ãðàíèöà

       FValueMax: Extended;//Âåðõíÿÿ ãðàíèöà

       FValueH: Extended; //Øèðèíà øàãà

       FRes: Extended;    //Ðåçóëüòàò

       FValueN: Integer;  //Êîëè÷åñòâî øàãîâ

       FCalcMethod: Byte; //Íîìåð âûáðàííîãî ñïîñîáà ïîäñ÷¸òà (0-òðàï.; 1-ëåâ.ïðÿìîóã.; 2-ïðàâ.ïðÿìîóã.; 3-ñðåäí.ïðÿìîóã)

       FAutoRedraw: Boolean; //Ïåðåðèñîâûâàòü ïðè èçìåíåíèè õîòÿ áû îäíîãî ïàðàìåòðà

       FChart: TChart;

       FMaxY: extended;

       FOnMinChanged: TValueChangedFunc;

       FOnMaxChanged: TValueChangedFunc;

       FOnNChanged: TValueChangedFunc;

       FOnHChanged: TValueChangedFunc;

       FOnRecalc: TValueChangedFunc;

       FIsError: boolean;

       FSeries: byte;

     protected

       procedure SetN(newN: integer); virtual;

       procedure SetH(newH: Extended); virtual;

       procedure SetMin(newMin: Extended); virtual;

       procedure SetMax(newMax: Extended); virtual;

       procedure SetCalcMethod(newMethod: byte); virtual;

       procedure SetChart(newChart: TChart); virtual;

     public

       constructor Create(newSeries: byte=0);

       destructor Destroy; override;

       property A: Extended read FValueMin write SetMin;//Íèæíÿÿ ãðàíèöà

       property B: Extended read FValueMax write SetMax;//Âåðõíÿÿ ãðàíèöà

       property N: integer read FValueN write SetN default 10;//Êîëè÷åñòâî øàãîâ

       property H: Extended read FValueH write SetH;//Øèðèíà îäíîãî øàãà

       property CalcMethod: byte read FCalcMethod write SetCalcMethod default 0;   //Íîìåð âûáðàííîãî ñïîñîáà ïîäñ÷¸òà (0-òðàï.; 1-ëåâ.ïðÿìîóã.; 2-ïðàâ.ïðÿìîóã.; 3-ñðåäí.ïðÿìîóã)

       property Chart: TChart read FChart write SetChart;

       property AutoRedraw: boolean read FAutoRedraw write FAutoRedraw default true;//Ïåðåðèñîâûâàòü ïðè èçìåíåíèè õîòÿ áû îäíîãî ïàðàìåòðà

       property Res: Extended read FRes;

       property IsError: boolean read FIsError;

       property MaxY: Extended read FMaxY;

       //Ñîáûòèÿ (íà èçìåíåíèå êàæäîãî èç ïàðàìåòðîâ)

       property OnMinChanged: TValueChangedFunc read FOnMinChanged write FOnMinChanged default nil;

       property OnMaxChanged: TValueChangedFunc read FOnMaxChanged write FOnMaxChanged default nil;

       property OnNChanged: TValueChangedFunc read FOnNChanged write FOnNChanged default nil;

       property OnHChanged: TValueChangedFunc read FOnHChanged write FOnHChanged default nil;

       property OnRecalc: TValueChangedFunc read FOnRecalc write FOnRecalc default nil;

       //Ïîäûíòåãðàëüíàÿ ôóíêöèÿ

       function f(x: Extended): Extended; virtual; abstract;

       //Ôóíêöèè ïîäñ÷¸òà ðåçóëüòàòà

       procedure ReCalc(); virtual;

       function calc_trapezium: Extended; virtual;

       function calc_rectangle_left: Extended; virtual;

       function calc_rectangle_right: Extended; virtual;

       function calc_rectangle_media: Extended; virtual;

       //Ôóíêöèè âûâîäà èíôîðìàöèè â êîìïîíåíò TChart

       procedure Redraw(); virtual;

       procedure draw_f; virtual;

       procedure draw_trapezium; virtual;

       procedure draw_rectangle_left; virtual;

       procedure draw_rectangle_right; virtual;

       procedure draw_rectangle_media; virtual;

    end;

    TIntegral1=class(TIntegral)

     public

       function f(x: Extended): Extended; override;

    end;

    TIntegral2=class(TIntegral)

     public

       function f(x: Extended): Extended; override;

    end;

    TIntegral3=class(TIntegral)

     public

       function f(x: Extended): Extended; override;

    end;

    TIntegral4=class(TIntegral)

     public

       function f(x: Extended): Extended; override;

    end;

    TIntegral5=class(TIntegral)

     public

       function f(x: Extended): Extended; override;

    end;

implementation

constructor TIntegral.Create(newSeries: byte = 0);

begin

 inherited Create();

 FValueMax:=1;

 FValueMin:=0;

 FValueH:=0.1;

 FAutoRedraw:=true;

 FSeries:=newSeries;

 FIsError:=true;

 N:=10;

end;

destructor TIntegral.Destroy;

begin

 inherited Destroy;

end;

procedure TIntegral.SetN(newN: integer);

begin

 FValueN:=newN;

 if FValueN<1 then

   FValueN:=1;

 FValueH:=(FValueMax-FValueMin)/FValueN;

 

 if (AutoRedraw) then

   Redraw();

 ReCalc();

 if Assigned(FOnNChanged) then

   FOnNChanged(FValueN);

 if Assigned(FOnHChanged) then

   FOnHChanged(FValueH);

end;

procedure TIntegral.SetH(newH: Extended);

begin

 FValueN:=round((FValueMax-FValueMin)/newH)+1;

 FValueH:=(FValueMax-FValueMin)/FValueN;

 

 if (AutoRedraw) then

   Redraw();

 ReCalc();

 if Assigned(FOnNChanged) then

   FOnNChanged(FValueN);

 if Assigned(FOnHChanged) then

   FOnHChanged(FValueH);

end;

procedure TIntegral.SetMin(newMin: Extended);

begin

 FValueMin:=newMin;

 FValueH:=(FValueMax-FValueMin)/FValueN;

 

 if (AutoRedraw) then

   Redraw();

 ReCalc();

 if Assigned(FOnMinChanged) then

   FOnMinChanged(newMin);

end;

procedure TIntegral.SetMax(newMax: Extended);

begin

 FValueMax:=newMax;

 FValueH:=(FValueMax-FValueMin)/FValueN;

 

 if (AutoRedraw) then

   Redraw();

 ReCalc();

 

 if Assigned(FOnMaxChanged) then

   FOnMaxChanged(newMax);

end;

procedure TIntegral.SetChart(newChart: TChart);

begin

 FChart:=newChart;

 if (AutoRedraw) then

   Redraw();

end;

procedure TIntegral.SetCalcMethod(newMethod: byte);

begin

 if (newMethod in [0..3]) then

 begin

   FCalcMethod:=newMethod;

   if (AutoRedraw) then

     Redraw();

   ReCalc();

 end;

end;

procedure TIntegral.ReCalc;

begin

   FRes:=0;

   FIsError:=true;

   if FValueMin<FValueMax then

   begin

     case FCalcMethod of

     0: FRes:=calc_trapezium();

     1: FRes:=calc_rectangle_left();

     2: FRes:=calc_rectangle_right();

     3: FRes:=calc_rectangle_media();

     end;

     FIsError:=false;

   end;

   

   if Assigned(FOnRecalc) then

     FOnRecalc(FRes);

end;

function TIntegral.calc_trapezium: Extended;

var x: extended;

   i: integer;

begin

 Result:=0;

 x:=FValueMin;

 for i:=1 to FValueN do

 begin

   Result:=Result+(f(x)+f(x+FValueH))/2*FValueH;

   x:=x+FValueH;

 end;

end;

function TIntegral.calc_rectangle_left:Extended;

var i:integer;

   x:extended;

begin

 Result:=0;

 x:=FValueMin;

 for i:=1 to n do

   begin

     Result:=Result+FValueH*f(x);

     x:=x+FValueH;

   end;

end;

function TIntegral.calc_rectangle_right:Extended;

var i:integer;

   x:extended;

begin

 Result:=0;

 x:=FValueMin;

 for i:=1 to n do

   begin

     Result:=Result+FValueH*f(x+FValueH);

     x:=x+FValueH;

   end;

end;

function TIntegral.calc_rectangle_media:Extended;

var i:integer;

   x:extended;

begin

 Result:=0;

 x:=FValueMin;

 for i:=1 to n do

   begin

     Result:=Result+FValueH*f(x+FValueH/2);

     x:=x+FValueH;

   end;

end;

procedure TIntegral.Redraw;

begin

 if (Assigned(FChart) and (FValueMin<FValueMax)) then

 begin

   draw_f;

   case FCalcMethod of

   0: draw_trapezium();

   1: draw_rectangle_left();

   2: draw_rectangle_right();

   3: draw_rectangle_media();

   end;

 end

 else if Assigned(FChart) then

 begin

   Chart.Series[FSeries].Clear;

   Chart.Series[FSeries+3].Clear;

   FMaxY:=0;

 end;

end;

procedure TIntegral.draw_f;

var rightRange, x, h1: extended;

begin

 if Assigned(FChart) then

 begin

   FChart.Series[FSeries+3].Clear;

   rightRange:=FValueMax+(FValueMax-FValueMin)*0.1;

   x:=FValueMin-(FValueMax-FValueMin)*0.1;

   h1:=(rightRange-x)/50;

   rightRange:=rightRange+h1;

   while x<=rightRange do

   begin

     FChart.Series[FSeries+3].AddXY(x, f(x));

     x:=x+h1;

   end;

   FMaxY:=f(x)*1.05;

 end;

end;

procedure TIntegral.draw_trapezium;

var x: extended;

   i: integer;

begin

 if Assigned(FChart) then

 begin

   draw_f;

   FChart.Series[FSeries].Clear;

   x:=FValueMin;

   for i:=0 to FValueN do

   begin

     FChart.Series[FSeries].AddXY(x, f(x));

     x:=x+FValueH;

   end;

 end;

end;

procedure TIntegral.draw_rectangle_left;

var x: extended;

   i: integer;

begin

 if Assigned(FChart) then

 begin

   draw_f;

   FChart.Series[FSeries].Clear;

   x:=FValueMin;

   for i:=1 to FValueN do

   begin

     FChart.Series[FSeries].AddXY(x, f(x));

     FChart.Series[FSeries].AddXY(x+FValueH, f(x));

     x:=x+FValueH;

   end;

 end;

end;

procedure TIntegral.draw_rectangle_right;

var x: extended;

   i: integer;

begin

 if Assigned(FChart) then

 begin

   draw_f;

   FChart.Series[FSeries].Clear;

   x:=FValueMin;

   for i:=1 to FValueN do

   begin

     FChart.Series[FSeries].AddXY(x, f(x+FValueH));

     FChart.Series[FSeries].AddXY(x+FValueH, f(x+FValueH));

     x:=x+FValueH;

   end;

 end;

end;

procedure TIntegral.draw_rectangle_media;

var x: extended;

   i: integer;

begin

 if Assigned(Chart) then

 begin

   draw_f;

   FChart.Series[FSeries].Clear;

   x:=FValueMin;

   for i:=1 to FValueN do

   begin

     Chart.Series[FSeries].AddXY(x, f(x+FValueH/2));

     Chart.Series[FSeries].AddXY(x+FValueH, f(x+FValueH/2));

     x:=x+FValueH;

   end;

 end;

end;

function TIntegral1.f(x: Extended): Extended;

begin

 Result:=sqr(x);

end;

function TIntegral2.f(x: Extended): Extended;

begin

 Result:=sqr(x)*x;

end;

function TIntegral3.f(x: Extended): Extended;

begin

 Result:=exp(x);

end;

function TIntegral4.f(x: Extended): Extended;

begin

 Result:=exp(sqr(x));

end;

function TIntegral5.f(x: Extended): Extended;

begin

 Result:=abs(x);

end;

end.

// модуль, содержащий второй класс

unit UTwoIntegrals;

unit UTwoIntegrals;

interface

uses UCalc, Chart, Windows;

type TProcedure=procedure () of object;

type TTwoIntegrals=class

 private

   FIsError: boolean;

   FSum: Extended;

   FDifference12: Extended;

   FDifference21: Extended;

   FACommon: Extended;

   FBCommon: Extended;

   FChart: TChart;

   FIntegral1: TIntegral;

   FIntegral2: TIntegral;

   FCalcMethod: byte;

   FOnSomethingChanged: TProcedure;

 protected

   procedure SetChart(newChart: TChart); virtual;

   procedure SetCalcMethod(newMethod: byte); virtual;

   procedure SetIntegral1(newIntegral1: TIntegral); virtual;

   procedure SetIntegral2(newIntegral2: TIntegral); virtual;

   procedure Recalculate; virtual;

   procedure Redraw; virtual;

 public

   procedure ParametersChanged(AA: Extended); virtual;

   constructor Create();

   destructor Destroy(); override;

   property Sum: Extended read FSum;

   property Difference12: Extended read FDifference12;

   property Difference21: Extended read FDifference21;

   property IsError: boolean read FIsError;

   property Chart: TChart read FChart write SetChart;

   property CalcMethod: byte read FCalcMethod write SetCalcMethod;

   property Integral1: TIntegral read FIntegral1 write SetIntegral1;

   property Integral2: TIntegral read FIntegral2 write SetIntegral2;

   property OnSomethingChanged: TProcedure read FOnSomethingChanged write FOnSomethingChanged;

 end;

implementation

constructor TTwoIntegrals.Create();

begin

 inherited Create();

 FIntegral1:=TIntegral1.Create(0);

 FIntegral2:=TIntegral2.Create(1);

 FIntegral1.OnRecalc:=ParametersChanged;

 FIntegral2.OnRecalc:=ParametersChanged;

 FIntegral2.A:=0.2;

 FIntegral2.B:=1.2;

 Redraw;

end;

procedure TTwoIntegrals.SetChart(newChart: TChart);

begin

 FChart:=newChart;

 if Assigned(FIntegral1) then

   FIntegral1.Chart:=FChart;

 if Assigned(FIntegral2) then

   FIntegral2.Chart:=FChart;

 Self.Redraw();

end;

procedure TTwoIntegrals.SetIntegral1(newIntegral1: TIntegral);

begin

 FIntegral1:=newIntegral1;

 FIntegral1.OnRecalc:=ParametersChanged;

 FIntegral1.CalcMethod:=FCalcMethod;

 FIntegral1.Chart:=FChart;

end;

procedure TTwoIntegrals.SetIntegral2(newIntegral2: TIntegral);

begin

 FIntegral2:=newIntegral2;

 FIntegral2.OnRecalc:=ParametersChanged;

 FIntegral2.CalcMethod:=FCalcMethod;

 FIntegral2.Chart:=FChart;

end;

procedure TTwoIntegrals.SetCalcMethod(newMethod: byte);

begin

 if newMethod<4 then

 begin

   FCalcMethod:=newMethod;

   if Assigned(FIntegral1) then

     FIntegral1.CalcMethod:=FCalcMethod;

   if Assigned(FIntegral2) then

     FIntegral2.CalcMethod:=FCalcMethod;

   ParametersChanged(0);

 end;

end;

procedure TTwoIntegrals.ParametersChanged(AA: Extended);

begin

 if (Assigned(FIntegral1) and Assigned(FIntegral2)) then

 begin

   Self.FACommon:=FIntegral1.A;

   if (FIntegral2.A>Self.FACommon) then

     Self.FACommon:=FIntegral2.A;

   Self.FBCommon:=FIntegral1.B;

   if (FIntegral2.B<Self.FBCommon) then

     Self.FBCommon:=FIntegral2.B;

   Self.FIsError:=(FIntegral1.IsError or FIntegral2.IsError);

   //MessageBox(0, '', '', 0);

   self.Redraw();

   self.Recalculate();

   if Assigned(FOnSomethingChanged) then

     FOnSomethingChanged();

 end

 else

 Self.FIsError:=true;

end;

procedure TTwoIntegrals.Recalculate;

begin

 if not (Self.FIsError) then

 begin

   FSum:=FIntegral1.Res+FIntegral2.Res;

   FDifference12:=FIntegral1.Res-FIntegral2.Res;

   FDifference21:=FIntegral2.Res-FIntegral1.Res;

 end;

end;

procedure TTwoIntegrals.Redraw;

var e, h, r1, r2: extended;

   i: integer;

begin

 {if not IsError then

 begin

   FChart.LeftAxis.Maximum:=FIntegral1.MaxY;

   if (FIntegral2.MaxY>FIntegral1.MaxY) then

     FChart.LeftAxis.Maximum:=FIntegral2.MaxY;

 end; }

 if (Assigned(FChart) and not (FIsError or (Self.FBCommon<=Self.FACommon))) then

 begin

   e:=FACommon;

   h:=(FBCommon-FACommon)/50;

   FChart.Series[2].Clear;

   for i:=0 to 50 do

   begin

     r1:=Integral1.f(e);

     r2:=Integral2.f(e);

     if r1>r2 then

       r1:=r2;

     FChart.Series[2].AddXY(e, r1);

     e:=e+h;

   end;

 end

 else if Assigned(FChart) then

 begin

   FChart.Series[2].Clear;

 end;

end;

destructor TTwoIntegrals.Destroy;

begin

 inherited Free;

end;

end.

Результаты работы программы:

Вывод: В результате выполнения данной лабораторной работы были  разработаны новые дочерние классы TIntegral1, TIntegral2, TIntegral3, TIntegral4, TIntegral5, содержащие различные подынтегральные функции. Для каждой из них организована возможность вычисления суммы и разности с графическим отображением результата. В процессе выполнения работы были рассмотрены возможности объектно-ориентированного программирования, изучены способы создания полей, методов и свойств классы и способы обращения к ним. Так же были изучены основные принципы работы с классами – полиморфизм и наследование.


 

А также другие работы, которые могут Вас заинтересовать

36794. Измерение напряженности магнитного поля соленоида 182 KB
  Магнитные поля созданные каждым витком в отдельности складываются. Напряженность магнитного поля соленоида в средней его части при прохождении по нему электрического тока определяется формулой: 1 Величина пропорциональна силе тока и зависит от числа витков приходящихся на единицу длины соленоида. Напряженность магнитного поля можно определить по воздействию этого поля на данный магнит.
36795. Измерение напряженности магнитного поля длинного соленоида с помощью датчика Холла 270 KB
  Цель работы: ознакомиться с одним из широко используемых на практике методов измерений и исследования магнитных полей с помощью датчика Холла; исследовать магнитное поле внутри длинного соленоида. Приборы и принадлежности: соленоид датчик Холла блок питания для соленоида источник питания для датчика Холла милливольтметр для измерения электродвижущей силы Холла. Эффект Холла.
36797. ЧАСТНЫЕ РЕАКЦИИ КАТИОНОВ II АНАЛИТИЧЕСКОЙ ГРУППЫ 80.5 KB
  Тема: ЧАСТНЫЕ РЕАКЦИИ КАТИОНОВ II АНАЛИТИЧЕСКОЙ ГРУППЫ. Перечень заданий: Частные реакции на катионы Аg. Частные реакции на катионы Pb2. Провести частные реакции на катион серебра g.
36798. Исследование распространения сигналов тональных частот по ЛЭП 6(10) кВ с использованием программной среды PSpice 93.83 KB
  Магистральные ЛЭП напряжением 110_кВ и выше, соединяющие между собой энергорайоны, при их использовании в качестве линий связи, как правило, обработываются с помощью заградителей, обходов и т.д
36799. ЧАСТНЫЕ РЕАКЦИИ КАТИОНОВ III АНАЛИТИЧЕСКОЙ ГРУППЫ 68 KB
  Тема: ЧАСТНЫЕ РЕАКЦИИ КАТИОНОВ III АНАЛИТИЧЕСКОЙ ГРУППЫ. Частные реакции на катионы Ва2. Частные реакции на катионы Са2. Частные реакции на катион Ва2.
36800. Графический растровый редактор GIMP 1.65 MB
  Далее возвращаемся на 1й слой в данном случае это слой Рисунок 1 и создаем над ним новый с указанными ниже параметрами: Для типа заливки слоя выбираем Цвет переднего плана при этом цвет должен быть обязательно черным: Отключаем все слои кроме двух нижним с которыми мы сейчас работаем: Переходим на наш слой залитый черным цветом: Теперь берем инструмент ластик с мягкими краями и достаточно большого размера 305: Встаем в произвольном месте нашего изображения и несколько раз щелкаем по одному и тому же месту чтобы эффект ластика...
36801. ЧАСТНЫЕ РЕАКЦИИ КАТИОНОВ IV АНАЛИТИЧЕСКОЙ ГРУППЫ 72 KB
  Реактивы: NH42S lCl3 ZnCl2 CrCl3 NOH H2O NH4OH N2S HCl NH4Cl крист K4 [Fe CN 6] K3 [Fe CN 6] CH3COOH. Групповым реагентом на катионы четвертой группы является гидроксид натрия NOH в избытке. В каждую из них добавить 1 мл группового реактива NOH. Ваши наблюдения ____________________________________________________________________________________________________________________________________________ Записать уравнения реакций в молекулярном и ионном виде: LCI3 NOH =...
36802. Структура и принцип работы полевых транзисторов, их статических характеристик и дифференциальных параметров 189.18 KB
  В данной лабораторной работе были изучены структура и принцип работы полевых транзисторов, их статические характеристики и дифференциальные параметры. Были определены пороговое напряжение, крутизна сток-затворных характеристик, внутреннее сопротивление транзисторов в режиме насыщения и в линейном режиме, вычислена удельная крутизна МОП-транзистора КП304А.