informatik i : software höhere programmiersprachen java klassen: hat methoden (funktionen) und...
Post on 06-Apr-2015
111 Views
Preview:
TRANSCRIPT
Informatik I : Software
höhere ProgrammiersprachenJava
Klassen:
• hat Methoden (Funktionen) und Daten (Variablen)• es kann mehrere Klassen geben• nur eine Klasse in einer Datei darf public sein• Variablen müssen mit new angelegt werden. Input in = new Input();• Funktionen werden Variablenname.Funktionsname aufgerufen in.readInt() oder in.readDouble()
Matrizen = zweidimensionale Felder
Matrizen = zweidimensionale Felder
• Deklaration: datentyp[][] variablenname;
Matrizen = zweidimensionale Felder
• Deklaration: datentyp[][] variablenname;
• Speicher reservieren: variablenname = new datentyp[größe_x][größe_y];
Matrizen = zweidimensionale Felder
• Deklaration: datentyp[][] variablenname;
• Speicher reservieren: variablenname = new datentyp[größe_x][größe_y];
variablenname = new datentyp[größe_x][]; variablenname[0] = new datentyp[größe_y]; variablenname[1] = new datentyp[größe_y + 1]; .........
Matrizen = zweidimensionale Felder
• Deklaration: datentyp[][] variablenname;
• Speicher reservieren: variablenname = new datentyp[größe_x][größe_y];
variablenname = new datentyp[größe_x][]; variablenname[0] = new datentyp[größe_y]; variablenname[1] = new datentyp[größe_y + 1]; .........
• Elementzugriff: variablenname[i][j];
int[][] d = new int[4][4];d[0][0] d[0][1] d[0][2] d[0][3]
d[1][0] d[1][1] d[1][2] d[1][3]
d[2][0] d[2][1] d[2][2] d[2][3]
d[3][0] d[3][1] d[3][2] d[3][3]
Reale Welt Virtuelle Welt
Reale Welt Virtuelle Welt
• Unsere Welt besteht aus Objekten!
Reale Welt Virtuelle Welt
• Unsere Welt besteht aus Objekten!
• Objekte mit gleichen Eigenschaften und gleichen Verhaltensweisen (Methoden) faßt man in Klassen zusammen.
Reale Welt Virtuelle Welt
• Unsere Welt besteht aus Objekten!
• Objekte mit gleichen Eigenschaften und gleichen Verhaltensweisen (Methoden) fasst man in Klassen zusammen. Klassen werden vereinbart.
• Ein Objekt aus einer Klasse nennt man eine Instanz der Klasse. Objekte müssen explizit erzeugt werden. Sie existieren dann mit einem persistenten lokalen Zustand. Verallgemeinerung von Prozeduren.
•Eingeschränkter Zugriff auf interne Struktur (Schnittstelle nach außen/ interne Realisierung)
Virtuelle Welt
class Person{ String vorname; String name; String adresse;
Person(String p_name, String p_vorname, String p_adresse) { name = p_name; vorname = p_vorname; adresse = p_adresse; }
void datenAusgeben() { System.out.println(“\n“); System.out.println(“Name : “ + name); System.out.println(“Vorname :“ + vorname); System.out.println(“Adresse :“ + adresse); }}
Virtuelle Welt
class Person{ String vorname; String name; String adresse;
Person(String p_name, String p_vorname, String p_adresse) { name = p_name; vorname = p_vorname; adresse = p_adresse; }
void datenAusgeben() { System.out.println(“\n“); System.out.println(“Name : “ + name); System.out.println(“Vorname :“ + vorname); System.out.println(“Adresse :“ + adresse); }}
Eigenschaften der Klasse werden in Datenfeldern gespeichert.
Virtuelle Welt
class Person{ String vorname; String name; String adresse;
Person(String p_name, String p_vorname, String p_adresse) { name = p_name; vorname = p_vorname; adresse = p_adresse; }
void datenAusgeben() { System.out.println(“\n“); System.out.println(“Name : “ + name); System.out.println(“Vorname :“ + vorname); System.out.println(“Adresse :“ + adresse); }}
Methoden der Klasse.
Virtuelle Welt
Konstruktor der Klasse.
class Person{ String vorname; String name; String adresse;
Person(String p_name, String p_vorname, String p_adresse) { name = p_name; vorname = p_vorname; adresse = p_adresse; }
void datenAusgeben() { System.out.println(“\n“); System.out.println(“Name : “ + name); System.out.println(“Vorname :“ + vorname); System.out.println(“Adresse :“ + adresse); }}
package MyPackage;class Person{ String vorname; String name; String adresse;
Person(String p_name, String p_vorname, String p_adresse) { name = p_name; vorname = p_vorname; adresse = p_adresse; }
void datenAusgeben() { System.out.println(“\n“); System.out.println(“Name : “ + name); System.out.println(“Vorname :“ + vorname); System.out.println(“Adresse :“ + adresse); }}
import MyPackage.Person;
public class BeispielAnwendungPerson{ public static void main(String[] args) { Person berti = new Person(“Vogts“, “Berti“, “Leverkusen, Trainerstr. 0“);
berti.datenAusgeben(); }}
class Person{ String vorname; String name; String adresse;
Person(String p_name, String p_vorname, String p_adresse) { name = p_name; vorname = p_vorname; adresse = p_adresse; } Person(String p_name) { name = p_name; } void datenAusgeben() { System.out.println(“\n“); System.out.println(“Name : “ + name); System.out.println(“Vorname :“ + vorname); System.out.println(“Adresse :“ + adresse); }}
import Person;
public class BeispielAnwendungPerson{ public static void main(String[] args) { Person berti = new Person(“Vogts“); berti.vorname = “Berti“; berti.adresse = „“Leverkusen, Trainerstr. 0“;
berti.datenAusgeben(); }}
class Person{ String vorname; String name; String adresse;
Person(String p_name, String p_vorname, String p_adresse) { name = p_name; vorname = p_vorname; adresse = p_adresse; } Person(String p_name) { name = p_name; } void datenAusgeben() { System.out.println(“\n“); System.out.println(“Name : “ + name); System.out.println(“Vorname :“ + vorname); System.out.println(“Adresse :“ + adresse); }}
Eine Klasse kann über viele Konstruktoren verfügen.Sie unterscheiden sich in den Eingabeparametern.
Jeder Konstruktor hat einen eindeutigen Satz vonEingabeparametern.
class Person{ String vorname; String name; String adresse;
Person(String p_name, String p_vorname, String p_adresse) { name = p_name; vorname = p_vorname; adresse = p_adresse; }
void datenAusgeben() { System.out.println(“\n“); System.out.println(“Name : “ + name); System.out.println(“Vorname :“ + vorname); System.out.println(“Adresse :“ + adresse); }}
Person
Student Mitarbeiter Professor
Vererbung
class Person{ String vorname; String name; String adresse;
Person(String p_name, String p_vorname, String p_adresse) { name = p_name; vorname = p_vorname; adresse = p_adresse; }
void datenAusgeben() { System.out.println(“\n“); System.out.println(“Name : “ + name); System.out.println(“Vorname :“ + vorname); System.out.println(“Adresse :“ + adresse); }}
Person
Student Mitarbeiter Professor
Vererbung
Basisklasse
Abgeleitete Klassen
class Person{ String vorname; String name; String adresse;
Person(String p_name, String p_vorname, String p_adresse) { name = p_name; vorname = p_vorname; adresse = p_adresse; }
void datenAusgeben() { System.out.println(“\n“); System.out.println(“Name : “ + name); System.out.println(“Vorname :“ + vorname); System.out.println(“Adresse :“ + adresse); }}
Person
Student Mitarbeiter Professor
Vererbung
Basisklasse
Abgeleitete Klassen
Abgeleitete Klassen verfügen über zusätzlicheEigenschaften und Fähigkeiten (Methoden).
class Person{ String vorname; String name; String adresse;
Person(String p_name, String p_vorname, String p_adresse) { name = p_name; vorname = p_vorname; adresse = p_adresse; }
void datenAusgeben() { System.out.println(“\n“); System.out.println(“Name : “ + name); System.out.println(“Vorname :“ + vorname); System.out.println(“Adresse :“ + adresse); }}
Vererbungclass Mitarbeiter extends Person{ float gehalt;
Mitarbeiter(String p_name, String p_vorname, String p_adresse, float p_gehalt) { // Konstruktor der Basisklasse aufrufen super(p_name, p_vorname, p_adresse);
gehalt = p_gehalt; }
void gehaltAusgeben() { System.out.println(“\n“); System.out.println(“Gehalt : “ + gehalt); } void gehaltAendern(int aenderung) { gehalt += aenderung; }}
public class AnwendungVonMitarbeiter{ public static void main(String[] args ) { Mitarbeiter billy;
billy = new Mitarbeiter(“Gates“, “Bill“, “Hollywood“, 2000); billy.gehaltAendern(-2000); billy.datenAusgeben(); billy.gehaltAusgeben(); }}
Vererbungclass Mitarbeiter extends Person{ float gehalt;
Mitarbeiter(String p_name, String p_vorname, String p_adresse, float p_gehalt) { // Konstruktor der Basisklasse aufrufen super(p_name, p_vorname, p_adresse);
gehalt = p_gehalt; }
void gehaltAusgeben() { System.out.println(“\n“); System.out.println(“Gehalt : “ + gehalt); } void gehaltAendern(int aenderung) { gehalt += aenderung; }}
Vererbung
Person
Student Mitarbeiter Professor
Wissenschaftl. Mitarbeiter Nicht-wissenschaftl. Mitarbeiter
class WissenschaftlicherMitarbeiter extends Mitarbeiter{ // Implementierung}
Polymorphismus
class Mitarbeiter extends Person{ float gehalt;
Mitarbeiter(String p_name, String p_vorname, String p_adresse, float p_gehalt) { // Konstruktor der Basisklasse aufrufen super(p_name, p_vorname, p_adresse);
gehalt = p_gehalt; }
void gehaltAusgeben() { System.out.println(“\n“); System.out.println(“Gehalt : “ + gehalt); } void gehaltAendern(int aenderung) { gehalt += aenderung; }}
public class FirstTestPolymorphism{ public static void main(String[] args ) { Person[] personen = new Person[300];
Mitarbeiter billy = new Mitarbeiter(“Gates“, “Bill“, “Hollywood“, 2000); personen[0] = billy;
((Mitarbeiter)personen[0]).gehaltAendern(-1000); ((Mitarbeiter)personen[0]).gehaltAusgeben(); }}
Cast-Operator
public class FirstTestPolymorphism{ public static void main(String[] args ) { Person[] personen = new Person[300];
Mitarbeiter billy = new Mitarbeiter(“Gates“, “Bill“, “Hollywood“, 2000); personen[0] = billy;
((Mitarbeiter)personen[0]).gehaltAendern(-1000); ((Mitarbeiter)personen[0]).gehaltAusgeben(); }}
Cast-Operator
class Person{ String vorname; String name; String adresse;
Person(String p_name, String p_vorname, String p_adresse) { name = p_name; vorname = p_vorname; adresse = p_adresse; }
void datenAusgeben() { System.out.println(“\n“); System.out.println(“Name : “ + name); System.out.println(“Vorname :“ + vorname); System.out.println(“Adresse :“ + adresse); }}
Polymorphismus
public class SecondTestPolymorphism{ public static void main(String[] args ) { Person[] personen = new Person[300];
Mitarbeiter billy = new Mitarbeiter(“Gates“, “Bill“, “Hollywood“, 2000); personen[0] = billy;
((Mitarbeiter)personen[0]).gehaltAendern(-1000); personen[0].gehaltAusgeben(); }}
class Person{ String vorname; String name; String adresse;
Person(String p_name, String p_vorname, String p_adresse) { name = p_name; vorname = p_vorname; adresse = p_adresse; }
void gehaltAusgeben() { } void datenAusgeben() { System.out.println(“\n“); System.out.println(“Name : “ + name); System.out.println(“Vorname :“ + vorname); System.out.println(“Adresse :“ + adresse); }}
Polymorphismus
import Person;import Mitarbeiter;
public class SecondTestPolymorphism{ public static void main(String[] args ) { Person[] personen = new Person[300];
Mitarbeiter billy = new Mitarbeiter(“Gates“, “Bill“, “Hollywood“, 2000); personen[0] = billy;
((Mitarbeiter)personen[0]).gehaltAendern(-1000); personen[0].gehaltAusgeben(); }}
Polymorphismus
class Mitarbeiter extends Person{ float gehalt;
Mitarbeiter(String p_name, String p_vorname, String p_adresse, float p_gehalt) { // Konstruktor der Basisklasse aufrufen super(p_name, p_vorname, p_adresse);
gehalt = p_gehalt; }
void gehaltAusgeben() { System.out.println(“\n“); System.out.println(“Gehalt : “ + gehalt); } void gehaltAendern(int aenderung) { gehalt += aenderung; }}
import Person;import Mitarbeiter;
public class SecondTestPolymorphism{ public static void main(String[] args ) { Person[] personen = new Person[300];
Mitarbeiter billy = new Mitarbeiter(“Gates“, “Bill“, “Hollywood“, 2000); personen[0] = billy;
((Mitarbeiter)personen[0]).gehaltAendern(-1000); personen[0].gehaltAusgeben(); }}
Polymorphismus
Polymorphismus erlaubt die gleichartige Behandlung verschiedener Objekte untergleichzeitiger Berücksichtigung der speziellen Eigenheiten der einzelnen Objekte
import Person;import Mitarbeiter;
public class SecondTestPolymorphism{ public static void main(String[] args ) { Person[] personen = new Person[300];
Mitarbeiter billy = new Mitarbeiter(“Gates“, “Bill“, “Hollywood“, 2000); personen[0] = billy;
((Mitarbeiter)personen[0]).gehaltAendern(-1000); personen[0].gehaltAusgeben(); }}
Polymorphismus
Beispiel: In dem Feld „personen“ können Objekte der Basisklasse „Person“ und der abgeleiteten Klassen „Mitarbeiter“ , „Student“usw. gespeichert werden. Für alle Elementeim Feld kann man die Methoden der Basis-Klasse aufrufen, wobei für Elemente abgeleiteter Klassen automatisch die über-schriebenen Versionen aufgerufen werden.
Polymorphismus erlaubt die gleichartige Behandlung verschiedener Objekte untergleichzeitiger Berücksichtigung der speziellen Eigenheiten der einzelnen Objekte
Abstrakte Klassen
abstract class Figur{ float x, y; // x und y Koordinate Figur( float px, float py) { x = px; y = py; }
abstract void zeichnen();}
Abstrakte Klassen
abstract class Figur{ float x, y; // x und y Koordinate Figur( float px, float py) { x = px; y = py; }
abstract void zeichnen();}
class Kreis extends Figur{ float radius; Kreis( float px, float py, float r) { super(px,py); radius = r; }
void zeichnen() { System.out.println(“Zeichne Kreis“); }}
Abstrakte Klassen
abstract class Figur{ float x, y; // x und y Koordinate Figur( float px, float py) { x = px; y = py; }
abstract void zeichnen();}
class Rechteck extends Figur{ float breite, laenge; Rechteck( float px, float py, float b, float l) { super(px,py); breite = b; laenge = l; }
void zeichnen() { System.out.println(“Zeichne Rechteck“); }}
Abstrakte Klassen
abstract class Figur{ float x, y; // x und y Koordinate Figur( float px, float py) { x = px; y = py; }
abstract void zeichnen();}
class Rechteck extends Figur{ float breite, laenge; Rechteck( float px, float py, float b, float l) { super(px,py); breite = b; laenge = l; }
void zeichnen() { System.out.println(“Zeichne Rechteck“); }}
Figur
Kreis Rechteck Linie
Abstrakte Klassen
public class ZeichneFiguren{ public static main(String[] args) { Figur[] zeichenobjekte = new Figur[3];
zeichenobjekte[0] = new Kreis(0.0,0.0, 3.0); zeichenobjekte[1] = new Rechteck(1.0,1.0, 5.0, 5.0); zeichenobjekte[2] = new Kreis(0.0, 0.0, 5.0);
for (int i=0; i <zeichenobjekte.length; i++) { zeichenobjekte[i].zeichnen(); } }} Figur
Kreis Rechteck Linie
Abstrakte Klassen
public class ZeichneFiguren{ public static main(String[] args) { Figur[] zeichenobjekte = new Figur[3];
zeichenobjekte[0] = new Kreis(0.0,0.0, 3.0); zeichenobjekte[1] = new Rechteck(1.0,1.0, 5.0, 5.0); zeichenobjekte[2] = new Kreis(0.0, 0.0, 5.0);
for (int i=0; i <zeichenobjekte.length; i++) { zeichenobjekte[i].zeichnen(); } }} Figur
Kreis Rechteck Linie
abstract class Figur{ float x, y; // x und y Koordinate Figur( float px, float py) { x = px; y = py; }
abstract void zeichnen();}
Abstrakte Klassen
In vielen Situationen möchte der Programmiererdas Polymorphismus-Konzept nutzen, in denendie entsprechende Funktionen für die Basis-Klassekeine sinnvolle Funktionalität besitzen.In solchen Situationen definiert man abstrakteKlassen und Funktionen.
Figur
Kreis Rechteck Linie
abstract class Figur{ float x, y; // x und y Koordinate Figur( float px, float py) { x = px; y = py; }
abstract void zeichnen();}
Wie entwirft man geeignete Klassenhierarchien?
In Java gibt es viele bereits implementierte Klassen (Pakete), die dem Nutzer sehr vielFunktionalität zur Verfügung stellen.
Wie entwirft man geeignete Klassenhierarchien?
In Java gibt es viele bereits implementierte Klassen (Pakete), die dem Nutzer sehr vielFunktionalität zur Verfügung stellen.
Alle Klassen in Java werden von der Superklasse Objekt abgeleitet.
Wie entwirft man geeignete Klassenhierarchien?
In Java gibt es viele bereits implementierte Klassen (Pakete), die dem Nutzer sehr vielFunktionalität zur Verfügung stellen.
Alle Klassen in Java werden von der Superklasse Objekt abgeleitet.
Beschreibungen der Funktionalität der wichtigsten Klassen findet man zum Beispiel im WWW unter der folgenden Adresse:
http://java.sun.com/j2se/1.3/docs/api/overview-summary.html
Wie entwirft man geeignete Klassenhierarchien?
In Java gibt es viele bereits implementierte Klassen (Pakete), die dem Nutzer sehr vielFunktionalität zur Verfügung stellen.
Alle Klassen in Java werden von der Superklasse Objekt abgeleitet.
Beschreibungen der Funktionalität der wichtigsten Klassen findet man zum Beispiel im WWW unter der folgenden Adresse:
http://java.sun.com/j2se/1.3/docs/api/overview-summary.html
Wie entwirft man geeignete Klassenhierarchien?
In Java gibt es viele bereits implementierte Klassen (Pakete), die dem Nutzer sehr vielFunktionalität zur Verfügung stellen.
Alle Klassen in Java werden von der Superklasse Objekt abgeleitet.
Beschreibungen der Funktionalität der wichtigsten Klassen findet man zum Beispiel im WWW unter der folgenden Adresse:
http://java.sun.com/j2se/1.3/docs/api/overview-summary.html
Frage: Kann man die zu entwickelnde Klasse von bereits implementierten Klassen ableiten?
Gewagte Konstruktionen?
Abgeleitete2
Basis
Abgeleitete1a Abgeleitete1b
Gewagte Konstruktionen?
Abgeleitete2
Basis
Abgeleitete1a Abgeleitete1b
Mehrfachvererbung
Gewagte Konstruktionen?
Abgeleitete2
Basis
Abgeleitete1a Abgeleitete1b
Auf Mehrfachvererbung wird in Java verzichtet. Java bietet dafür das Konzeptder sogenannten Interfaces (für Fortgeschrittene).
Datenkapselung (Information Hiding)
Das Prinzip der Datenkapselung stellt einen Grundpfeiler der objektorientierten Programmierung dar.
Datenkapselung (Information Hiding)
Das Prinzip der Datenkapselung stellt einen Grundpfeiler der objektorientierten Programmierung dar.
Möglichst wenig von der Implementierung der Klasse wirdnach außen sichtbar gemacht.
Datenkapselung (Information Hiding)
Das Prinzip der Datenkapselung stellt einen Grundpfeiler der objektorientierten Programmierung dar.
Möglichst wenig von der Implementierung der Klasse wirdnach außen sichtbar gemacht.
Man bietet dem Nutzer eine wohldefinierte Schnittstellen zur Klasse an. Diese Schnittstelle sollte sich auch bei Änderungen der Implementierung nicht ändern.
Datenkapselung (Information Hiding)
class Chamaeleon {
int wert;
BerechneResultat() {
wert = ......; }}
Datenkapselung (Information Hiding)
class Chamaeleon { int wert; int resultat;
BerechneResultat() {
resultat = ......; }}
Datenkapselung (Information Hiding)
class Chamaeleon { private int wert; private int resultat;
private BerechneResultat() { resultat = ......; }
public ResultatAusgabe() { System.out.println(resultat); }}
Zugriffsmodifizierer: public, protected, private
class Basisklasse { public int resultat;
// in jeder Methode der Basisklasse { resultat = ......; }}
Zugriffsmodifizierer: public, protected, private
class BasisKlasse { public int resultat;
// in jeder Methode der Basisklasse { resultat = ......; this.resultat = .....; }}
this ist eine spezielle Instanzvariable, die der Compiler automatisch anlegt und die immer auf die aktuelle Instanz der Klasse, in der Sie sich gerade befinden, verweist.
Zugriffsmodifizierer: public, protected, private
class BasisKlasse { public int resultat;
// in jeder Methode der Basisklasse { resultat = ......; }}
Zugriffsmodifizierer: public, protected, private
class AbgeleiteteKlasse extends BasisKlasse{
// in jeder Methode der Abgeleitete.. { resultat = ......; }}
class BasisKlasse { public int resultat;
// in jeder Methode der Basisklasse { resultat = ......; }}
import BasisKlasse.*;
class ExterneKlasse{
// in jeder Methode von ExterneKl... { Basisklasse basis = new BasisKlasse(); basis.resultat = ......; }}
Zugriffsmodifizierer: public, protected, private
class AbgeleiteteKlasse extends BasisKlasse{
// in jeder Methode der Abgeleitete.. { resultat = ......; }}
class BasisKlasse { public int resultat;
// in jeder Methode der Basisklasse { resultat = ......; }}
import BasisKlasse.*;
class ExterneKlasse{
// in jeder Methode von ExterneKl... { Basisklasse basis = new BasisKlasse(); basis.resultat = ......; }}
Auf Klassenvariablen und Methoden, die als „public“deklariert sind, kann aus jeder Methode der Klasse,aus jeder Methode der abgeleiteten Klassen undaus jeder Methode von „externen“ Klasse zugegriffen werden.
Zugriffsmodifizierer: public, protected, private
class AbgeleiteteKlasse extends BasisKlasse{
// in jeder Methode der Abgeleitete.. { resultat = ......; }}
class BasisKlasse { protected int resultat;
// in jeder Methode der Basisklasse { resultat = ......; }}
import BasisKlasse.*;
class ExterneKlasse{
// in jeder Methode von ExterneKl... { Basisklasse basis = new BasisKlasse(); basis.resultat = ......; }}
Auf Klassenvariablen und Methoden, die als „protected“deklariert sind, kann aus jeder Methode der Klasse undaus jeder Methode der abgeleiteten Klassen zugegriffenwerden.
Zugriffsmodifizierer: public, protected, private
class AbgeleiteteKlasse extends BasisKlasse{
// in jeder Methode der Abgeleitete.. { resultat = ......; }}
Zugriffsmodifizierer: public, protected, private
class BasisKlasse { private int resultat;
// in jeder Methode der Basisklasse { resultat = ......; }}
class AbgeleiteteKlasse extends BasisKlasse{
// in jeder Methode der Abgeleitete.. { resultat = ......; }}
import BasisKlasse.*;
class ExterneKlasse{
// in jeder Methode von ExterneKl... { Basisklasse basis = new BasisKlasse(); basis.resultat = ......; }}
Auf Klassenvariablen und Methoden, die als „private“deklariert sind, kann aus jeder Methode der Klasse zugegriffen werden.
Definition von n!
Durch n! wird die Zahl der Permutationen einer Menge mit n Elementen bestimmt. Eine Permutation ist dabei eine beliebige lineare Anordnung der n Elemente.
n! ist definiert durch:1 falls n = 0n*(n-1)! falls n > 0
Methoden n! zu berechnenclass Fac{
long compute (long n){ Fac f = new Fac(); if (n == 0)
return 1; else return n*f.compute(n-
1);}
long computeWhile (long n){ long a = n, b = 1; while (a != 0) { b = a*b; a--; } return b;}
long compute (long n1, long n2){ if (n1 == 0)
return n2; else return compute(n1-1,n1*n2);}
class Fac{
long compute (long n){ if (n == 0)
return 1; else return n*compute(n-1);}
long computeFor (long n){ long b = 1; for (long a = n; a != 0; a--)
b = a*b; return b;}
}
top related