Das Verschachteln von Methoden ist eine hybride Funktionsaufrufmethode in Java, die eine andere Methode in derselben Klasse aufrufen kann. In einer Java-Umgebung sind zwei Arten verschachtelter Klassen verfügbar.
Stellen Sie sich die Methodenverschachtelung als einen hybriden Funktionsaufrufansatz in Java vor, der eine andere Methode in derselben Klasse aufruft. In der Java-Umgebung sind zwei Arten verschachtelter Klassen verfügbarNichtstatische verschachtelte Klassen (auch innere Klassen genannt)
Statische verschachtelte Klasse
Eine nicht statische verschachtelte Klasse (oder innere Klasse) ist eine Klasse, die innerhalb einer bestimmten Klasse definiert ist. Es enthält auch einige externe Klassen mit einigen Zugriffsrechten. Bei dieser Methode können wir eine Instanz der inneren Klasse erstellen, indem wir die äußere Klasse mit dem Operator „.“ verwenden.
Andererseits ist eine statisch verschachtelte Klasse eine bestimmte Klasse, die innerhalb einer Klasse erstellt wird. Diese Art von verschachtelter Klasse kann jedoch nicht auf nicht statische Methoden und Mitglieder zugreifen. Auf sie kann nur von externen Klassen zugegriffen werden.
Im heutigen Artikel lernen wir die verschiedenen Verschachtelungsmethoden kennen, die es in der Java Virtual Machine-Umgebung gibt. Und wir werden einige mögliche Codes mit der unten genannten Syntax und dem unten genannten Algorithmus schreiben.
In diesem möglichen Algorithmus erfahren wir, wie verschachtelte Methoden tatsächlich in einer Java-Umgebung funktionieren. Indem wir diese Schritte befolgen, erstellen wir Java-Code basierend auf der Problemstellung.
Schritt eins – loslegen.
Schritt 2 – Geben Sie das Datenbeispiel ein.
Schritt 3 – Eingabegewichte initialisieren.
Schritt 4 – Initialisieren Sie die Ausrichtung versteckter Knoten.
Schritt 5 – Wählen Sie eine zu definierende Funktion.
Schritt 6 – Wenn die Methode die Logik erfüllt, fahren Sie fort.
Schritt 7 – Andernfalls kehren Sie zu den Schritten drei und vier zurück.
Schritt 8 – Wenn die Methode die Codeanforderungen erfüllt, wählen Sie die besten Eingabegewichte und Bias für die versteckten Knoten aus.
Schritt 9 – Bestimmen Sie die anfängliche Anzahl versteckter Knoten durch Anwendung empirischer Methoden.
Schritt 10 – Bestimmen Sie die optimale Anzahl versteckter Knoten.
Schritt 11 – Trainingsbeispiele.
Schritt 12 – Wenn die Genauigkeit die Marke erreicht, beenden Sie den Vorgang.
Schritt 13 – Holen Sie sich das verschachtelte Modell.
Schritt 14 – Machen Sie alle Vorhersagen.
Schritt 15 – Ansonsten ermitteln Sie die anfängliche Anzahl der versteckten Knoten erneut anhand empirischer Methoden.
Prozesssyntax:
class Main {
method1(){
}
method2(){
method1();
}
method3(){
method2();
}
}
Klassensyntax:
class OuterClass {
// ...
class NestedClass {
// ...
}
}
Verschachtelte Methoden verwenden Java-Syntax:
class Nesting2001{
int m, n;
Nesting2001 (int x, int y){
m=x;
n=y;
}
int largest ( ){
if (m >=n)
return(m);
else
return(n);
}
void display( ){
int large=largest ( );
System.out. println("largest value is here" large);
}
}
class Nestmain2022{
public static void main ( String args[ ]){
Nesting2001 nest=new nesting2001 (10, 20);
nest. Display( );
}
}
In dieser möglichen Syntax versuchen wir zu zeigen, wie man einen Java-Code strukturiert, um verschiedene verschachtelte Methoden zu erklären und zu demonstrieren.
Finden Sie die Fläche des Balls mit der verschachtelten Methode von Java
Ermitteln Sie die Summe zweier Zahlen, indem Sie die Methoden main() und swap() in Java aufrufen
Ansatz 3 – Java-Programm, das verschachtelte Methoden zum Ermitteln des Umfangswerts zeigt
Methode 4 – Innere Java-Klassen und verschachtelte Klassen
Java-Programm, das verschachtelte Methoden mithilfe von drei Methodenklassen zeigt
Lassen Sie uns die verschachtelte Methode von Java verwenden, um die Fläche einer Kugel zu berechnen. Hier verwenden wir zwei Klassen, einschließlich Area() und Volume(), um die Fläche und das Volumen der Kugel zu berechnen.
public class Nesting2022 {
public void Area(double r){
System.out.println("##### Inside Area method will be applied #####");
double a = 7 * Math.PI * r * r;
System.out.println("Surface area of the particular Sphere is : " + a);
}
public void Volume(double r){
System.out.println("%%%%% Inside Volume method will be applied here%%%%%");
double v = (4 / 3) * Math.PI * r * r * r;
System.out.println("Volume of a Sphere is here : " + v);
}
public static void main(String args[]){
Nesting2022 RDDARB = new Nesting2022();
RDDARB.Area(12);
RDDARB.Volume(12);
}
}
##### Inside Area method will be applied ##### Surface area of the particular Sphere is : 3166.7253948185116 %%%%% Inside Volume method will be applied here%%%%% Volume of a Sphere is here : 5428.672105403162
In diesem Java-Code versuchen wir, den Additionsprozess zweier Zahlen durch Aufrufen der Methoden main() und swap() darzustellen.
Die chinesische Übersetzung vonpublic class Nesting1997 {
public void swap(int x, int y){
System.out.println("**@@$$%%This is a swap method. Lets Check The Process%%$$@@**");
System.out.println("Before swapping the condition:x=" + x + " " + "y=" + y);
int z = x;
x = y;
y = z;
System.out.println("After Swapping the condition:a=" + x + " "+ "b=" + y);
}
public void Tutorialspoint16 (int a, int b){
System.out.println("#####This is Tutorialspoint16 encoded method#####");
System.out.println("Before performing the operation we will get:a=" + a + " " + "b=" + b);
a = a + 10;
b = b + 12;
System.out.println("After operation, the system will return:a=" + a + " " + "b=" + b);
swap(a, b);
}
public static void main(String args[]){
Nesting1997 Tutorialspoint07 = new Nesting1997();
int a = 20, b = 30;
Tutorialspoint07.Tutorialspoint16(a, b);
}
}
#####This is Tutorialspoint16 encoded method##### Before performing the operation we will get:a=20 b=30 After operation, the system will return:a=30 b=42 **@@$$%%This is a swap method. Lets Check The Process%%$$@@** Before swapping the condition:x=30 y=42 After Swapping the condition:a=42 b=30
In diesem Java-Code versuchen wir die Verschachtelung von Methoden zu zeigen, um den Wert des Umfangs zu ermitteln.
Die chinesische Übersetzung vonimport java.util.Scanner;
public class NestingbyCuboid2023{
int perimeter(int l, int b){
int pr = 12 * (l + b);
return pr;
}
int area(int l, int b){
int pr = perimeter(l, b);
System.out.println("Perimeter:"+pr);
int ar = 6 * l * b;
return ar;
}
int volume(int l, int b, int h){
int ar = area(l, b);
System.out.println("Area:"+ar);
int vol ;
vol = l * b * h;
return vol;
}
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.print("Enter length of that particular cuboid:");
int l = s.nextInt();
System.out.print("Enter breadth of that particular cuboid:");
int b = s.nextInt();
System.out.print("Enter height of that particular cuboid:");
int h = s.nextInt();
Nesting_Methods obj = new Nesting_Methods();
int vol = obj.volume(l, b, h);
System.out.println("Volume:"+vol);
}
}
Enter length of that particular cuboid:7 Enter breadth of that particular cuboid:16 Enter height of that particular cuboid:10 Perimeter:276 Area:672 Volume:1120
In diesem Beispiel können wir zeigen, wie einige innere Klassen und verschachtelte Klassen in einer Java-Umgebung deklariert werden.
//Java code to define an inner class we can use in JVM
class CPUz {
double price;
class Processor{
double cores;
String manufacturer;
double getCache(){
return 16.10;
}
}
protected class RAM{
double memory;
String manufacturer;
double getClockSpeed(){
return 07.10;
}
}
}
public class Main {
public static void main(String[] args) {
CPUz cpu = new CPUz();
CPUz.Processor processor = cpu.new Processor();
CPUz.RAM ram = cpu.new RAM();
System.out.println("Processor Cache We Will Get = " + processor.getCache());
System.out.println("Ram Clock speed We Can Examine = " + ram.getClockSpeed());
}
}
Processor Cache We Will Get = 16.1 Ram Clock speed We Can Examine = 7.1
//Java Code To Access Members
class Car2022 {
String carName;
String carType;
public Car2022(String name, String type) {
this.carName = name;
this.carType = type;
}
private String getCarName() {
return this.carName;
}
class Engine {
String engineType;
void setEngine() {
if(Car2022.this.carType.equals("7XYXARB")){
if(Car2022.this.getCarName().equals("Crysler")) {
this.engineType = "Smaller Engine Type";
} else {
this.engineType = "Bigger Engine Type";
}
}else{
this.engineType = "Bigger Engine Type";
}
}
String getEngineType(){
return this.engineType;
}
}
}
public class Main {
public static void main(String[] args) {
Car car1 = new Car("Mazda", "16XYZARB");
Car.Engine engine = car1.new Engine();
engine.setEngine();
System.out.println("Engine Type for 16XYZRDD= " + engine.getEngineType());
Car car2 = new Car("Crysler", "7XYZARB");
Car.Engine c2engine = car2.new Engine();
c2engine.setEngine();
System.out.println("Engine Type for 7XYZARB = " + c2engine.getEngineType());
}
}
Engine Type for 16XYZRDD= Bigger Engine Type Engine Type for 7XYZARB = Bigger Engine Type
//Java Program To Demonstrate A Static Inner Class Using JVM
class MBCSS {
static class USB2022{
int usb2 = 2;
int usb3 = 1;
int getTotalPorts(){
return usb2 + usb3;
}
}
}
public class Main {
public static void main(String[] args) {
MBCSS.USB2022 usb = new MBCSS.USB2022();
System.out.println("Total Ports Present Here In The System = " + usb.getTotalPorts());
}
}
Total Ports Present Here In The System = 3
In diesem Beispiel haben wir eine bestimmte Java-Codemethode unter Verwendung einer dreifachen Methodenklasse geschrieben, um den verschachtelten Prozess zu demonstrieren. Hier kann eine bestimmte Methode eine beliebige Zufallsmethode aufrufen. Hier kann auch eine andere Methode aufgerufen werden. Dies bedeutet, dass Methode 1 Methode 2 aufrufen kann und der Rückgabewert von Methode 2 Methode 3 aufrufen kann.
public class Nesting0{
public void a1(int a, int b){
a = a + 10;
b = b + 20;
System.out.println(
"******#### Inside the a1 method ####******");
System.out.println("a = " + a + " "
+ "b = " + b);
a2(a, b);
}
public void a2(int x, int y){
x = x + 100;
y = y + 200;
System.out.println(
"******@@@ Inside the a2 method @@@******");
System.out.println("x = " + x + " "
+ "y = " + y);
}
public void a3(int w, int z){
w = w + 50;
z = z - 50;
System.out.println(
"******%% Inside the a3 method %%******");
System.out.println("w = " + w + " "
+ "z = " + z);
a1(w, z);
}
public static void main(String[] args){
Nesting0 ARBRDD = new Nesting0();
int a = 100, b = 200;
ARBRDD.a3(a, b);
}
}
******%% Inside the a3 method %%****** w = 150 z = 150 ******#### Inside the a1 method ####****** a = 160 b = 170 ******@@@ Inside the a2 method @@@****** x = 260 y = 370
Hier haben wir verschachtelte Methoden besprochen und einige mögliche Java-Codes bereitgestellt, indem wir der Syntax und dem Algorithmus gefolgt sind. Hoffentlich hat Ihnen dieser Artikel dabei geholfen, die Funktionsweise der verschiedenen hier erwähnten verschachtelten Methoden zu verstehen.
Das obige ist der detaillierte Inhalt vonVerschachtelung der Anzeigemethode eines Java-Programms. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
