Einstieg OOP
parent
d30b596ab8
commit
1ae19d3d39
|
|
@ -0,0 +1,262 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "c37ce57d-6439-4eb0-bda5-32d33ddfbebe",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"# Objektorientierung\n",
|
||||
"\n",
|
||||
"Bei der objektorientierten Programmierung werden mehrere Attribute und Methoden zu logischen oder\n",
|
||||
"realen Objekten zusammengefasst."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "56763840-610a-4f28-abf8-6fe0473571b2",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"## Objekte\n",
|
||||
"\n",
|
||||
"Ein Objekt ist ein eindeutig identifizierbares Element. Dieses enthält gewisse Informationen und kann\n",
|
||||
"bestimmte Aktionen ausführen.\n",
|
||||
"\n",
|
||||
"Beispiele für Objekte sind:\n",
|
||||
"* **reale Dinge**, die man aus dem Alltag kennt und die sich beschreiben lassen, wie z.B. eine Person, ein Buch, ein Auto,...\n",
|
||||
"* **Rollen**, die beispielsweise eine Person annehmen kann und die mit gewissen Eigenschaften verbunden ist, wie z.B. Chef, Angestellter, Kunde, Student, Schüler,...\n",
|
||||
"* **Ereignisse/Vorgänge**, welche man sich vorstellen kann, aber nicht gegenständlich existiert, wie z.B. ein Meeting, eine Bestellung, eine Schulnote,..."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "0d7af8b2-83d3-4c99-9ae2-8d3205b14d22",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"## Objekte in TypeScript anlegen\n",
|
||||
"\n",
|
||||
"Eigenschaften bzw. sogenannte Attribute können wir in TypeScript einfach zu Objekten zusammenfassen, indem wir diese in geschweifte Klammern schreiben.\n",
|
||||
"\n",
|
||||
"Die Attribute bekommen Namen und Werte - *Besonderheit hierbei ist, dass die Werte **innerhalb eines Objektes** nicht mit dem Gleich-Zeichen sondern mit einem Doppelpunkt zugewiesen werden.*\n",
|
||||
"\n",
|
||||
"Mehrere Attribute sind mit Komma voneinander getrennt."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 1,
|
||||
"id": "2f010494-eeaa-485c-b731-54c05781fe4e",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"{\n",
|
||||
" name: \"Droste-Hülshoff-Gymnasium\",\n",
|
||||
" schueler: 600,\n",
|
||||
" schulleiter: \"Stefan Maier\"\n",
|
||||
"}\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"let schule = {\n",
|
||||
" name: 'Droste-Hülshoff-Gymnasium',\n",
|
||||
" schueler: 600,\n",
|
||||
" schulleiter: 'Stefan Maier'\n",
|
||||
"}\n",
|
||||
"\n",
|
||||
"console.log(schule)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "b0360017-7032-48e5-a41e-e86fcddd0802",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"## Methoden\n",
|
||||
"\n",
|
||||
"Neben Attributen kann ein Objekt auch Methoden beinhalten. Methoden sind Funktionen, die an ein Objekt gebunden sind."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 2,
|
||||
"id": "c7a62c16-a78f-4e2a-a863-3605556de62b",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"let auto = {\n",
|
||||
" kennzeichen: 'D-HG 1',\n",
|
||||
" hupe() {\n",
|
||||
" console.log('Törööt!')\n",
|
||||
" }\n",
|
||||
"}"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "b94d0f59-4b84-4638-9105-b9a57303e781",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"## Auf Attribute und Methoden eines Objektes zugreifen\n",
|
||||
"\n",
|
||||
"Wollen wir auf einzelne Attribute eines Objektes zugreifen bzw. Methoden eines Objektes aufrufen, so können wir das mit dem sogenannten Punkt-Operator tun:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 3,
|
||||
"id": "768d24e5-eccb-44c7-ab59-30d779d496e7",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Droste-Hülshoff-Gymnasium\n",
|
||||
"Törööt!\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"console.log( schule.name )\n",
|
||||
"\n",
|
||||
"auto.hupe()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "7fcbda33-8675-4aed-9456-20f735613e69",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"### Anmerkung:\n",
|
||||
"\n",
|
||||
"Diese Schreibweise kennen wir bereits z.B. von `console.log()`! Es gibt also bereits vorgegeben ein Objekt `console` und dieses hat die Methode `log()`."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "ff72b09b-4ba6-4ed9-a2e8-ba304d39e100",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"## Innerhalb des Objektes auf Attribute und Methoden zugreifen\n",
|
||||
"\n",
|
||||
"Genauso, wie wir mittels des Variablennamen und dem Punkt auf die Attribute eines Objektes zugreifen können, benötigt man für den Zugriff auf die Attribute innerhalb eines Objektes ebenfalls den Punkt-Operator.\n",
|
||||
"\n",
|
||||
"Da innerhalb eines Objektes aber dessen Variablenname nicht bekannt ist, verwenden wir für den Zugriff `this.`:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 5,
|
||||
"id": "00303c31-dd07-4f2f-9bc9-df7cfc416946",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Hallo, ich heiße Max Mustermann\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"let person = {\n",
|
||||
" vorname: 'Max',\n",
|
||||
" nachname: 'Mustermann',\n",
|
||||
"\n",
|
||||
" vorstellen() {\n",
|
||||
" console.log('Hallo, ich heiße ' + this.vorname + ' ' + this.nachname)\n",
|
||||
" }\n",
|
||||
"}\n",
|
||||
"\n",
|
||||
"person.vorstellen()"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Deno",
|
||||
"language": "typescript",
|
||||
"name": "deno"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": "typescript",
|
||||
"file_extension": ".ts",
|
||||
"mimetype": "text/x.typescript",
|
||||
"name": "typescript",
|
||||
"nbconvert_exporter": "script",
|
||||
"pygments_lexer": "typescript",
|
||||
"version": "5.8.3"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 5
|
||||
}
|
||||
|
|
@ -0,0 +1,234 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "636d4527-50fc-4836-ae08-00c12844da8d",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import { assertEquals } from \"jsr:@std/assert\""
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "d90b7734-c902-4300-80ef-d8bf55a64813",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"# Aufgabe 03.01.1\n",
|
||||
"Lege ein Objekt `p1` an mit den Attributen `x` und `y`. `x` soll dabei 5 sein, `y` -3."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "594735d3-e90e-443e-9eff-e4600c331bc2",
|
||||
"metadata": {
|
||||
"editable": true,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "245aec76-71a6-478e-9301-08ca4e14ff71",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"jupyter": {
|
||||
"source_hidden": true
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": [
|
||||
"Test"
|
||||
]
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"let _nr = \"03.01.1\"\n",
|
||||
"Deno.test(`${_nr}: object`, () => {\n",
|
||||
" assertEquals(typeof p1, 'object')\n",
|
||||
"})\n",
|
||||
"Deno.test(`${_nr}: x`, () => {\n",
|
||||
" assertEquals(p1.x, 5)\n",
|
||||
"})\n",
|
||||
"Deno.test(`${_nr}: y`, () => {\n",
|
||||
" assertEquals(p1.y, -3)\n",
|
||||
"})"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "9eb66210-476a-499e-8965-9c63da2de3e7",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"# Aufgabe 03.01.2\n",
|
||||
"Lege einen zweiten Punkt `p2` mit den Koordinaten $(2\\mid1)$ an."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "7daea9ea-3417-48d9-9416-3462cc38f8bc",
|
||||
"metadata": {
|
||||
"editable": true,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "4f710df6-8465-4da1-a997-4e34ea80d6ed",
|
||||
"metadata": {
|
||||
"editable": true,
|
||||
"jupyter": {
|
||||
"source_hidden": true
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": [
|
||||
"Test"
|
||||
]
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"let _nr = \"03.01.2\"\n",
|
||||
"Deno.test(`${_nr}: object`, () => {\n",
|
||||
" assertEquals(typeof p2, 'object')\n",
|
||||
"})\n",
|
||||
"Deno.test(`${_nr}: x`, () => {\n",
|
||||
" assertEquals(p2.x, 2)\n",
|
||||
"})\n",
|
||||
"Deno.test(`${_nr}: y`, () => {\n",
|
||||
" assertEquals(p2.y, -1)\n",
|
||||
"})"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "d96b8c74-089f-4ded-85ad-72fca3c93bcd",
|
||||
"metadata": {
|
||||
"editable": true,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"# Aufgabe 03.01.3\n",
|
||||
"\n",
|
||||
"Programmiere eine Funktion `abstand`, die zwei Parameter `punkt1` und `punkt2` übergeben bekommt. Es soll angenommen werden, dass diese beiden Parameter Objekte sind mit jeweils den Attributen `x` und `y`.\n",
|
||||
"\n",
|
||||
"Zurückgegeben werden soll der Abstand der beiden angegebenen Punkte.\n",
|
||||
"\n",
|
||||
"#### Tipp:\n",
|
||||
"Der Abstand wird mit dem Pythagoras berechnet, die Wurzel kann man mit `Math.sqrt(...)` berechnen lassen.\n",
|
||||
"\n",
|
||||
"#### Beispiel:\n",
|
||||
"Wird `abstand(p1, p2)` - also mit den beiden Punkten der letzten beiden Aufgaben aufgerufen, so soll `5` zurückgegeben werden."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "cccdfe03-92f4-4d0f-b3cb-56332dc31b66",
|
||||
"metadata": {
|
||||
"editable": true,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "87a2ab19-819c-43d6-9fc3-11e53dff9be7",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"jupyter": {
|
||||
"source_hidden": true
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"let _nr = \"03.01.3\"\n",
|
||||
"Deno.test(`${_nr}: function`, () => {\n",
|
||||
" assertEquals(typeof abstand, 'function')\n",
|
||||
"})\n",
|
||||
"Deno.test(`${_nr}: Parameter`, () => {\n",
|
||||
" assertEquals(abstand.length, 2)\n",
|
||||
"})\n",
|
||||
"Deno.test(`${_nr}: abstand(p1,p2)=5`, () => {\n",
|
||||
" assertEquals(abstand(p1,p2), 5)\n",
|
||||
"})\n",
|
||||
"Deno.test(`${_nr}: abstand()=0`, () => {\n",
|
||||
" assertEquals(abstand({x:0,y:0},{x:0,y:0}), 0)\n",
|
||||
"})\n",
|
||||
"Deno.test(`${_nr}: abstand()=0`, () => {\n",
|
||||
" assertEquals(abstand({x:1,y:1},{x:1,y:1}), 0)\n",
|
||||
"})\n",
|
||||
"Deno.test(`${_nr}: abstand()=2`, () => {\n",
|
||||
" assertEquals(abstand({x:5,y:0},{x:5,y:2}), 2)\n",
|
||||
"})\n",
|
||||
"Deno.test(`${_nr}: abstand()=13`, () => {\n",
|
||||
" assertEquals(abstand({x:3,y:8},{x:8,y:-4}), 13)\n",
|
||||
"})"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Deno",
|
||||
"language": "typescript",
|
||||
"name": "deno"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": "typescript",
|
||||
"file_extension": ".ts",
|
||||
"mimetype": "text/x.typescript",
|
||||
"name": "typescript",
|
||||
"nbconvert_exporter": "script",
|
||||
"pygments_lexer": "typescript",
|
||||
"version": "5.8.3"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 5
|
||||
}
|
||||
|
|
@ -0,0 +1,312 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "0aecbbea-032e-4e23-96b7-baa547ff69a3",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"# Klassen\n",
|
||||
"\n",
|
||||
"Mit der Erkenntnistheorie legten Platon und Aristoteles bereits im antiken Griechenland den Grund-\n",
|
||||
"stein zum Verständnis von Objekten und Klassen. Man spricht dabei von einer \"ist ein\"-Beziehung:\n",
|
||||
"\n",
|
||||
"* Herr Herbert Huber *ist eine* Person\n",
|
||||
"* Herr Huber *ist ein* Patient\n",
|
||||
"* Herbert *ist ein* Kunde in der örtlichen Bibliothek\n",
|
||||
"* Mein Toyota Yaris *ist ein* Auto\n",
|
||||
"* Ein Tesla S *ist ein* Auto"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "fded0977-dda1-4da4-8813-c1721d8e2921",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"## Klassen und Objekte\n",
|
||||
"\n",
|
||||
"Die konkreten \"Dinge\" (Herbert, Yaris, Tesla) sind hierbei *Objekte*. Diese werden in die *Klassen* \"Person\", \"Patient\", \"Kunde\" und \"Auto\" eingeteilt. Ein einzelnes Objekt nennt man auch **Instanz**.\n",
|
||||
"\n",
|
||||
"Diese Klassifizierung ist grundsätzlich nicht von Natur aus gegeben. Erst durch unsere Beobachtungen werden den Klassen verschiedene Attribute zugewiesen, so haben Objekte\n",
|
||||
"\n",
|
||||
"* der Klasse Patient beispielsweise die Attribute \"Name\", \"Krankenkasse\", \"Versicherungsnummer\", \"Krankenvorgeschichte\",...\n",
|
||||
"* der Klasse Kunde die Attribute \"Name\", \"Kundennummer\",...\n",
|
||||
"* der Klasse Auto die Attribute \"Farbe\", \"Leistung\", \"Sitzplätze\", \"Antriebsart\",...\n",
|
||||
"\n",
|
||||
"An den Klassen \"Patient\" und \"Kunde\" lässt sich erkennen, dass die selbe Person, je nach Kontext unterschiedliche Attribute haben kann."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "f45b9462-6f8b-46ea-a6ea-8a6fad38aed3",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"## Klassendefinition\n",
|
||||
"\n",
|
||||
"Wir können eine Klasse, d.h. eine Vorlage für Objekte, mit dem `class` Befehl definieren.\n",
|
||||
"\n",
|
||||
"**Wichtig:** Im Gegensatz zum Anlegen eines Objektes, benötigen wir hier kein Komma zur Abtrennung von mehreren Attributen/Methoden!\n",
|
||||
"\n",
|
||||
"Konkrete Objekte von dieser Klasse können wir dann mit `new Name()` erzeugen. Die Objekte erhalten automatisch alle Attribute und Methoden der Klasse:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 13,
|
||||
"id": "3259f08f-870f-4851-a9b6-4efa4c77a5e3",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Punkt { x: undefined, y: undefined }\n",
|
||||
"P(2|-3)\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"class Punkt {\n",
|
||||
" x\n",
|
||||
" y\n",
|
||||
"\n",
|
||||
" ausgabe() {\n",
|
||||
" console.log( 'P(' + this.x + '|' + this.y + ')' )\n",
|
||||
" }\n",
|
||||
"}\n",
|
||||
"\n",
|
||||
"let p1 = new Punkt()\n",
|
||||
"\n",
|
||||
"console.log(p1)\n",
|
||||
"\n",
|
||||
"p1.x = 2\n",
|
||||
"p1.y = -3\n",
|
||||
"\n",
|
||||
"p1.ausgabe()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "951f6268-9350-48c9-8999-fbcd3fd44d19",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"## Konstruktor\n",
|
||||
"\n",
|
||||
"Wie wir oben sehen können, sind die Attribute nach Erzeugung des Objektes mit `new Punkt()` noch `undefined`.\n",
|
||||
"\n",
|
||||
"In der Regel wollen wir jedoch Attribute direkt beim Anlegen eines Objektes mit Standardwerten initialisieren. Das können wir mithilfe des Konstruktors tun.\n",
|
||||
"\n",
|
||||
"Ein Konstruktor ist die Methode mit dem Namen `constructor` und beliebigen Parametern. Diese wird automatisch beim Erzeugen aufgerufen."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 16,
|
||||
"id": "0ae0a320-0283-48e4-a667-c72bd778befe",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Punkt { x: 0, y: 0 }\n",
|
||||
"P(2|-3)\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"class Punkt {\n",
|
||||
" x\n",
|
||||
" y\n",
|
||||
"\n",
|
||||
" constructor() {\n",
|
||||
" this.x = 0\n",
|
||||
" this.y = 0\n",
|
||||
" }\n",
|
||||
"\n",
|
||||
" ausgabe() {\n",
|
||||
" console.log( 'P(' + this.x + '|' + this.y + ')' )\n",
|
||||
" }\n",
|
||||
"}\n",
|
||||
"\n",
|
||||
"let p1 = new Punkt()\n",
|
||||
"\n",
|
||||
"console.log(p1)\n",
|
||||
"\n",
|
||||
"p1.x = 2\n",
|
||||
"p1.y = -3\n",
|
||||
"\n",
|
||||
"p1.ausgabe()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "8d781c0d-9996-430b-8a52-7b7f1cb3901d",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"Ein Konstruktor kann auch Parameter bekommen. Dann werden die entsprechenden Werte bei `new Punkt(...)` als Parameter mit angegeben:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 34,
|
||||
"id": "2d8cf85f-71ed-4e83-987e-5289713378b8",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"Punkt { x: 5, y: 7 }\n",
|
||||
"P(2|-3)\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"class Punkt {\n",
|
||||
" x\n",
|
||||
" y\n",
|
||||
"\n",
|
||||
" constructor(x, y) {\n",
|
||||
" if (x !== undefined) {\n",
|
||||
" this.x = x\n",
|
||||
" } else {\n",
|
||||
" this.x = 0\n",
|
||||
" }\n",
|
||||
"\n",
|
||||
" if (y !== undefined) {\n",
|
||||
" this.y = y\n",
|
||||
" } else {\n",
|
||||
" this.y = 0\n",
|
||||
" }\n",
|
||||
" }\n",
|
||||
"\n",
|
||||
" ausgabe() {\n",
|
||||
" console.log( 'P(' + this.x + '|' + this.y + ')' )\n",
|
||||
" }\n",
|
||||
"}\n",
|
||||
"\n",
|
||||
"let p1 = new Punkt(5, 7)\n",
|
||||
"\n",
|
||||
"console.log(p1)\n",
|
||||
"\n",
|
||||
"p1.x = 2\n",
|
||||
"p1.y = -3\n",
|
||||
"\n",
|
||||
"p1.ausgabe()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "29cc5ab1-7ce2-4193-a9a2-ee4b24d931b6",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"## Überprüfung auf Typen\n",
|
||||
"\n",
|
||||
"Anders als bei anderen Programmiersprachen, können wir bei TypeScript wir lediglich einen Konstruktor anlegen. Dadurch ist es manchmal nötig zu überprüfen, von welchem Datentyp die übergebenen Parameter sind.\n",
|
||||
"\n",
|
||||
"Wir können dies mit `typeof p1` machen, hier kommt jedoch nur `object` heraus, nicht der konkrete Typ.\n",
|
||||
"\n",
|
||||
"Beispielsweise in `if`-Bedingungen können wir auch mit `p1 instanceof Punkt` konkret abfragen, ob es sich bei der Variablen `p1` um ein Objekt der Klasse `Punkt` handelt."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 35,
|
||||
"id": "5f355279-c005-4c3b-a436-60f46803c05e",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"object\n",
|
||||
"true\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"console.log( typeof p1 ) // gibt \"object\" aus\n",
|
||||
"\n",
|
||||
"console.log( p1 instanceof Punkt ) // gibt \"true\" aus"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Deno",
|
||||
"language": "typescript",
|
||||
"name": "deno"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": "typescript",
|
||||
"file_extension": ".ts",
|
||||
"mimetype": "text/x.typescript",
|
||||
"name": "typescript",
|
||||
"nbconvert_exporter": "script",
|
||||
"pygments_lexer": "typescript",
|
||||
"version": "5.8.3"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 5
|
||||
}
|
||||
|
|
@ -0,0 +1,174 @@
|
|||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "636d4527-50fc-4836-ae08-00c12844da8d",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"import { assertEquals } from \"jsr:@std/assert\""
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "d90b7734-c902-4300-80ef-d8bf55a64813",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"# Aufgabe 03.01.4\n",
|
||||
"\n",
|
||||
"Programmiert werden soll ein einfaches Mathe-Tool mit den beiden Klassen `Punkt` und `Gerade`.\n",
|
||||
"\n",
|
||||
"Eine mathematische Gerade wird durch die Gleichung $y = m\\cdot x + c$ beschrieben, Punkte haben im zweidimensionalen Raum die Koordinaten $P(x\\mid y)$\n",
|
||||
"\n",
|
||||
"Es soll möglich sein:\n",
|
||||
"* einen Punkt direkt mit den Koordinaten anlegen\n",
|
||||
"* eine Gerade direkt mit Steigung und y-Achsenabschnitt anlegen\n",
|
||||
"* eine Gerade mithilfe von zwei Punkten anlegen\n",
|
||||
"* eine Gerade mit einer anderen Geraden schneiden lassen, als Ergebnis soll ein Punkt zurückgegeben werden.\n",
|
||||
"* es soll in der Klasse `Punkt` eine Methode `toString()` geben, die einen String mit der mathematischen Beschreibung des Punktes zurückgibt, z.B. $P(2\\mid3)$ (ohne Leerzeichen!)\n",
|
||||
"* es soll in der Klasse `Gerade` eine Methode `toString()` gebenm die einen String mit der mathematischen Formel zurückgibt, z.B. $y=2*x-3$ (ohne Leerzeichen!)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "789364d0-c61c-4237-b02e-ddfc04d7401f",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"Entwirf zunächst die Klassen, also welche Attribute und welche Methoden die Klassen enthalten müssen:"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "raw",
|
||||
"id": "a25cfb30-0a08-47c3-bad1-bc7712aa2c2e",
|
||||
"metadata": {
|
||||
"editable": true,
|
||||
"raw_mimetype": "",
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"Klasse \"Punkt\":\n",
|
||||
"\n",
|
||||
"Attribute:\n",
|
||||
"*\n",
|
||||
"\n",
|
||||
"Methoden:\n",
|
||||
"*"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "raw",
|
||||
"id": "a46499ec-0c9a-4ed4-815d-b680ed90803f",
|
||||
"metadata": {
|
||||
"editable": true,
|
||||
"raw_mimetype": "",
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"source": [
|
||||
"Klasse \"Gerade\":\n",
|
||||
"\n",
|
||||
"Attribute:\n",
|
||||
"*\n",
|
||||
"\n",
|
||||
"Methoden:\n",
|
||||
"*"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "594735d3-e90e-443e-9eff-e4600c331bc2",
|
||||
"metadata": {
|
||||
"editable": true,
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": []
|
||||
},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "245aec76-71a6-478e-9301-08ca4e14ff71",
|
||||
"metadata": {
|
||||
"editable": false,
|
||||
"jupyter": {
|
||||
"source_hidden": true
|
||||
},
|
||||
"slideshow": {
|
||||
"slide_type": ""
|
||||
},
|
||||
"tags": [
|
||||
"Test"
|
||||
]
|
||||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"let _nr = \"03.01.4\"\n",
|
||||
"Deno.test(`${_nr}: class Punkt`, () => {\n",
|
||||
" assertEquals(typeof Punkt, 'function')\n",
|
||||
"})\n",
|
||||
"Deno.test(`${_nr}: class Gerade`, () => {\n",
|
||||
" assertEquals(typeof Punkt, 'function')\n",
|
||||
"})\n",
|
||||
"Deno.test(`${_nr}`, () => {\n",
|
||||
" let p1 = new Punkt(1,-1)\n",
|
||||
" let p2 = new Punkt(3,3)\n",
|
||||
" assertEquals(p1.toString(), 'P(1|-1)')\n",
|
||||
" assertEquals(p2.toString(), 'P(3|3)')\n",
|
||||
"\n",
|
||||
" let g1 = new Gerade(p1,p2)\n",
|
||||
" assertEquals(g1.toString(), 'y=2*x-3')\n",
|
||||
"\n",
|
||||
" let g2 = new Gerade(-0.5, 2)\n",
|
||||
" let p = g1.schneide(g2)\n",
|
||||
" assertEquals(p1.toString(), 'P(2|1)')\n",
|
||||
"})"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Deno",
|
||||
"language": "typescript",
|
||||
"name": "deno"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": "typescript",
|
||||
"file_extension": ".ts",
|
||||
"mimetype": "text/x.typescript",
|
||||
"name": "typescript",
|
||||
"nbconvert_exporter": "script",
|
||||
"pygments_lexer": "typescript",
|
||||
"version": "5.8.3"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 5
|
||||
}
|
||||
Loading…
Reference in New Issue