Was ist ein einzelnes Programm in Java, in dem alle OOP-Konzepte behandelt werden können?

Vererbung, Polymorphismus, Abstraktion, Verkapselung, Überfahren, Überladen

Der Dateiname muss MainClass.java sein

Programm:

Klasse Eins {

public void display () {

System.out.println (“One”);

}

}

//Erbe

klasse zwei verlängert eins {

@Override

public void display () {

System.out.println (“Two”);

}

public int add (int x, int y) {

return x + y;

}

//Überlast

public double add (double x, double y) {

return x + y;

}

}

// Kapselungsbeispiel

Klasse EncapTest {

private String name;

public String getName () {

return name;

}

public void setName (String newName) {

name = newName;

}

}

//Abstraktion

abstrakte Klasse TwoWheeler {

public abstract void run ();

}

Klasse Honda erweitert Zweirad {

public void run () {

System.out.println (“\ nbike läuft ..”);

}

}

Klasse MainClass {

public static void main (String [] args) {

Eins a = Neues ();

ein Bildschirm();

Zwei b = neue zwei ();

b.display ();

System.out.println (b.add (4,2));

System.out.println (b.add (5., 2.)); // Polymorphismus

EncapTest encap = new EncapTest ();

encap.setName (“Sandeep’s”);

System.out.print (“Name:” + encap.getName ());

Zweiradtest = neuer Honda ();

Testlauf();

}

}

Ausgabe:

Eins

Zwei

6

7.0

Name: Sandeeps

Fahrrad läuft ..

Was ist ein einzelnes Programm in Java, in dem alle OOP-Konzepte behandelt werden können?

Es ist wirklich beeindruckend, wie einfach RPG-Spiele mit OOP-Konzepten modelliert werden können.

Es ist nicht schwer zu überlegen, was unser Unterricht sein soll. Wir müssen uns nur überlegen, welche Elemente wir in unser Spiel aufnehmen möchten. Helden, Feinde, Moves, Gegenstände, Ausrüstungen … Alle von ihnen könnten Klassen in unserem Programm sein, aber lassen Sie uns die grundlegendste behalten: Der Held.

Klasse Held {
String name;
int hp;
int atk;
int def;
}

Nun, es ist üblich, mehr als einen spielbaren Charakter zu haben. Dazu müssen wir den Konstruktor der Hero Klasse implementieren.

Klasse Held {
String name;
int hp;
int atk;
int def;

public Hero (Stringname, int hp, int atk, int def) {
this.name = name;
this.hp = hp;
this.atk = atk;
this.def = def;
}
}

Klasse Controller {
public static void main (String [] argv) {
Hero rick = neuer Held (“Rick”, 30, 20, 40);
Hero Daryl = neuer Held (“Daryl”, 20, 25, 45);
}
}

Wie bei jedem guten Spiel müssen wir einige Feinde haben. Lass sie uns machen!

Klasse Tier {
int hp;
int atk;
int def;
boolean is_aggressive = false;

öffentliches Tier (int hp, int atk, int def) {
this.hp = hp;
this.atk = atk;
this.def = def;
}
}

Klasse Zombie {
int hp;
int atk;
int def;
boolean is_aggressive = true;

öffentlicher Zombie (int hp, int atk, int def) {
this.hp = hp;
this.atk = atk;
this.def = def;
}
}

Das Attribut is_aggressive ist falsch, wenn der Feind nur angreift, wenn er vom Helden getroffen wird, und es ist wahr, wenn der Feind angreift, sobald er den Helden sieht.

Beachten Sie, dass hier einige redundante Informationen vorhanden sind. Sowohl Tiere als auch Zombies sind Feinde und sowohl Tiere als auch Zombies haben einige Attribute gemeinsam. Das ist ein gutes Indiz dafür, dass wir Vererbung brauchen.

abstrakte Klasse Enemy {
int hp;
int atk;
int def;
boolean is_aggressive;

öffentlicher Feind (int hp, int atk, int def, boolean is_aggressive) {
this.hp = hp;
this.atk = atk;
this.def = def;
this.is_aggressive = is_aggressive;
}
}

Klasse Animal erweitert Enemy {
öffentliches Tier (int hp, int atk, int def) {
super (hp, atk, def, false);
}
}

Klasse Zombie erweitert Enemy {
öffentlicher Zombie (int hp, int atk, int def) {
super (hp, atk, def, true);
}
}

Beachten Sie, dass die Enemy Klasse eine abstrakte Klasse ist, da in unserem Rollenspiel alle Feinde einer Kategorie wie Orks, Menschen, Tiere, Zombies, Professoren für Softwaretechnik usw. angehören.

Wenn wir Helden und Feinde haben, lassen wir sie zu Tode kämpfen! Eine Möglichkeit besteht darin, für jeden möglichen Feind eine Methode zu erstellen.

Klasse Held {
//…

Leerenangriff (Tier Tier) {
int damage = Math.max (0, this.atk – animal.def);
if (animal.hp <10) damage * = 1.15;
wenn (animal.hp> 25) Schaden * = 0,8;
animal.hp – = Schaden;
}

Leerenangriff (Zombie Zombie) {
int damage = Math.max (0, this.atk – zombie.def);
wenn (zombie.hp> 5) Schaden * = 0,7;
zombie.hp – = Schaden;
}
}

Andererseits könnten wir viel besser arbeiten, wenn wir hier ein Kapselungskonzept verwenden .

Klasse Held {
//…

Leerenangriff (Tier Tier) {
int damage = Math.max (0, this.atk – animal.def);
animal.defend (Schaden);
}

Leerenangriff (Zombie Zombie) {
int damage = Math.max (0, this.atk – zombie.def);
zombie.defend (Schaden);
}
}

Klasse Tier {
//…

nichtig verteidigen (int Schaden) {
if (this.hp <10) damage * = 1.15;
if (this.hp> 25) damage * = 0.8;
this.hp – = Schaden;
}
}

Klasse Zombie {
//…

nichtig verteidigen (int Schaden) {
wenn (this.hp> 5) Schaden * = 0,7;
zombie.hp – = Schaden;
}
}

Natürlich macht es keinen Sinn, für jede feindliche Klasse eine Methode zu erstellen, wenn wir wissen, wie man Polymorphismus einsetzt .

Klasse Held {
//…

Leerenangriff (Feindlicher Feind) {
int Damage = Math.max (0, this.atk – enemy.def);
feind. verteidigen (Schaden); // Jeder Feind wird auf seine Art verteidigen.
}
}

Klasse Tier {
//…

nichtig verteidigen (int Schaden) {
if (this.hp <10) damage * = 1.15;
if (this.hp> 25) damage * = 0.8;
this.hp – = Schaden;
}
}

Klasse Zombie {
//…

nichtig verteidigen (int Schaden) {
wenn (thois.hp> 5) Schaden * = 0,7;
zombie.hp – = Schaden;
}
}

Ich könnte in dieser Antwort viel mehr über dieses RPG-Spiel schreiben. Wir können leicht feststellen, dass sowohl Feinde als auch Helden angreifen und verteidigen müssen, daher ist es eine gute Idee, sie dazu zu bringen, ein Interface-Kampfflugzeug zu implementieren. Ich denke jedoch, dass es nicht wirklich notwendig ist, weil es ziemlich klar ist, was ich dir zeigen möchte.

RPG-Spiele haben im Allgemeinen einige gemeinsame Eigenschaften, die es ihnen ermöglichen, mit OOP-Konzepten modelliert zu werden. Wenn Sie andere (oder sich selbst) zum Verständnis dieser Konzepte motivieren möchten, sind Sie derjenige, der ein einziges Programm mit allen von ihnen schreiben kann Sie. Was halten Sie von einem einfachen Pokémon-Kampfsimulator (aus den Spielen)?

Klasse a {
public void display () {
System.out.println (“Ich bin A”);
}
}
Klasse B erweitert A {// B ist eine Unterklasse von A
// Überschreiben
@Override
public void display () {
System.out.println (“Ich bin B”);
}
public int add (int x, int y) {
return x + y;
}
//Überlast
public double add (double x, double y) {
return x + y;
}
}
Klassentest {
public static void main (String [] args) {
A a = neu A ();
ein Bildschirm(); // Zeigt “Ich bin A” an
B b = neues B ();
b.display (); // Zeigt “Ich bin B” an
System.out.println (b.add (5,2)); // zeigt 7 an
System.out.println (b.add (5., 2.)); // Ad-hoc-Polymorphismus, zeigt “7.0” an
a = b; // a fungiert als Referenz auf das Objekt b
ein Bildschirm(); // Dynamic Polymorphism oder Dynamic Method Dispatch, zeigt “I am B” an
}
}

NB: Die Klasse selbst ist ein Beispiel für die Kapselung. Ich hatte in meinem 4. Semester einen Vortrag über Polymorphismus gehalten. Sie können es überprüfen, wenn Sie möchten: POLYMORPHISM.pptx

// Wenn Sie in Java möchten, können Sie dem folgenden Code folgen, einem einfachen und verständlichen Code

// 1) Dummy ist Interface, also Abstraktion. 2) Standardmäßig importiert jede Java-Klasse das Paket “java.lang. *”, Also Vererbung. 3) Ich habe die Methode equals (1) überschrieben, die bereits in “java.lang” verfügbar ist . * ”Package und equals werden zweimal mit Parametern geschrieben. Dies sind Änderungen wie equals (1) und equals (1,2). Polymorphism wird durchgeführt, 4) und die letzte Kapselung, das Binden / Umbrechen aller Variablen und Methoden in einer Klasse wird durchgeführt wird Encapsulation genannt, daher ist unter class ein Beispiel für Encapsulation.

// Also Jungs, alle OOPs-Konzepte werden in einer Klasse angerührt

Interface Dummy {

String name = “Hallo, dieser Code wurde von Kishore geschrieben”;

Boolean equals (InterfaceImpl ipl1, InterfaceImpl ipl2);

Boolean equals (InterfaceImpl ipl);

}

public class InterfaceImpl implementiert Dummy {

public static void main (String [] args) {

System.out.println (“Hallo, ich bin Hauptmethode”);

InterfaceImpl ipl1 = new InterfaceImpl ();

InterfaceImpl ipl2 = new InterfaceImpl ();

System.out.println (“Dies ist die Schnittstellenzeichenfolge:” + name);

if (ipl1.equals (ipl2)) {

System.out.println (“Beide sind gleich”);

}

sonst{

System.out.println (“Beide sind nicht gleich”);

}

System.out.println (ipl1.equals (ipl1, ipl2));

}

@Override

public Boolean equals (InterfaceImpl ipl) {

System.out.println (“Ich bin gleich (1), Wert ist wahr”);

return this == ipl;

}

@Override

public Boolean equals (InterfaceImpl ipl1, InterfaceImpl ipl2) {

if (ipl1.equals (ipl2)) {

System.out.println (“Ich bin gleich (1,2), Wert ist wahr”);

return true;

}sonst{

System.out.println (“Ich bin gleich (1,2), Wert ist falsch”);

falsch zurückgeben;

}

}

}

// Danke, Kishore, +91 8880422458

OOPS → Objektorientierte Programmierspezifikation.

Ich versuche es auf einfache Weise zu erklären, Sie können bei Bedarf eine Geschäftslogik ändern …

// prog um OOPS in einem einzelnen Programm zu erklären
// 1) Kapselung // hier wird die gesamte Klasse als Kapselung bezeichnet
// 2) Abstraktion // Eine Schnittstelle unterstützt die Abstraktion
// 3) Vererbung // Jede Klasse erbt standardmäßig die Objektklasse
// 4) Polymorphisum // equlas (..) ist das Überschreiben und Überladen von Methoden

Interface Dummy {
String str = “dies unterstützt Abstraktion”;
}

public class Demon implementiert Dummy {

@Override
public boolean equals (Object obj) {
System.out.println (“Overriding Equals Mehtod …”);
return this == obj;
}

public boolean equals (Objekt obj1, Objekt obj2) {
if (obj1.equals (obj2)) {
System.out.println (“beide Objekte sind gleich”);
return true;
}
sonst{
System.out.println (“Objekte sind nicht gleich”);
falsch zurückgeben;
}
}

public static void main (String arg []) {
Dämon d0 = neuer Dämon ();
Dämon d1 = neuer Dämon ();
System.out.println (“… ..1….” + D0.equals (d1));
System.out.println (“… ..2….” + D0.equals (d0, d1));
System.out.println (“Abstraktion ….” + str);
}
}

Ein einfaches Hello World-Programm reicht aus.

Die Vererbung wird in jedem Code angezeigt, wenn die Objektklasse automatisch vererbt wird.

Die Kapselung ist das Objekt, das Sie erstellen (erstellen Sie auch ein Objekt der von Ihnen erstellten Beispielklasse).

Abstraktion ist, wenn Sie Hallo Welt schreiben. System.out.println hat den Code, der Hello World druckt, und es ist uns egal, wie dieser Code den String.0 druckt

Polymorphismus wird als out.println () in der System-Klasse überladen angesehen.

Entwerfen Sie mithilfe einer dreistufigen Architektur eine Web-App für CRUD für ein bestimmtes DBMS-Schema.

Dies wird beinhalten

  1. Webinteraktion mit JavaScript, HTML, CSS und Ajax
  2. Datenschichtdesign mit Abstraktion, Kapselung und Skalierbarkeit
  3. Logikschicht-Design mit Architekturdesign, Implementierungsdesign, Speicherverwaltung, Skalierbarkeit, Parallelität, Interaktion mit Präsentationsschicht und Datenbank. Der Architekturentwurf sollte für jedes Datenbankschema funktionieren, für große Datenmengen skalierbar sein und gleichzeitig mit der Zugriffssteuerung erfolgen.

Wenn Sie mit der Java-Sprache vertraut sind, können Sie selbst ein einziges Programm erstellen, das alle OOPS-Konzepte für ein Beispiel enthält, es gibt jedoch kein einziges Programm.