Méthode d'affichage du programme Java imbriquée-javaDidacticiel-php.cn

Méthode daffichage du programme Java imbriquée

L'imbrication de méthodes est une méthode d'appel de fonction hybride en Java, qui peut appeler une autre méthode dans la même classe. Il existe deux types de classes imbriquées disponibles dans un environnement Java.

Considérez l'imbrication de méthodes comme une approche d'appel de fonction hybride en Java qui appelle une autre méthode de la même classe. Il existe deux types de classes imbriquées disponibles dans l'environnement Java

Classes imbriquées non statiques (également appelées classes internes)
Classe imbriquée statique

Une classe imbriquée non statique (ou classe interne) est une classe définie au sein d'une classe spécifique. Il contient également des classes externes avec certains droits d'accès. Dans cette méthode, nous pouvons créer une instance de la classe interne en utilisant la classe externe à l'aide de l'opérateur "."

D'un autre côté, une classe imbriquée statique est une classe spécifique créée à l'intérieur d'une classe. Mais ce type de classe imbriquée ne peut accéder à aucune méthode ni membre non statique. Ils ne sont accessibles que par des classes externes.

Dans l'article d'aujourd'hui, nous découvrirons les différentes méthodes d'imbrication qui existent dans l'environnement de la machine virtuelle Java. Et nous écrirons quelques codes possibles en utilisant la syntaxe et l'algorithme mentionnés ci-dessous.

Algorithme pour afficher les méthodes imbriquées en Java

Dans cet algorithme possible, nous apprendrons comment les méthodes imbriquées fonctionnent réellement dans un environnement Java. En suivant ces étapes, nous créerons du code Java basé sur l'énoncé du problème.

Première étape : commencez.
Étape 2 - Entrez l'échantillon de données.
Étape 3 - Initialisez les poids d'entrée.
Étape 4 - Initialisez le biais des nœuds cachés.
Étape 5 - Choisissez une fonction à définir.
Étape 6 - Si la méthode satisfait à la logique, continuez.
Étape 7 - Sinon, revenez aux étapes trois et quatre.
Étape 8 - Si la méthode répond aux exigences du code, sélectionnez les meilleurs poids et biais d'entrée pour les nœuds cachés.
Étape 9 - Déterminez le nombre initial de nœuds cachés en appliquant des méthodes empiriques.
Étape 10 - Déterminez le nombre optimal de nœuds cachés.
Étape 11 – Échantillons de formation.
Étape 12 - Si la précision atteint la marque, terminez le processus.
Étape 13 - Obtenez le modèle imbriqué.
Étape 14 - Faites toutes les prédictions.
Étape 15 - Sinon, déterminez à nouveau le nombre initial de nœuds cachés en vous basant sur des méthodes empiriques.

Afficher la syntaxe imbriquée de la méthode

Syntaxe du processus :

class Main {
   method1(){ 
   } 
   method2(){
      method1();
   }
   method3(){
      method2();
   }
}

Copier après la connexion

Syntaxe de classe :

class OuterClass {
   // ...
   class NestedClass {
      // ...
   }
}

Copier après la connexion

Les méthodes imbriquées utilisent la syntaxe Java :

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( );
   }
}

Copier après la connexion

Dans cette syntaxe possible, nous essayons de montrer comment structurer un code Java pour expliquer et démontrer diverses méthodes imbriquées.

Affichage de différentes méthodes d'imbrication

Trouvez la zone de la balle à l'aide de la méthode imbriquée de Java
Trouvez la somme de deux nombres en appelant les méthodes main() et swap() en Java
Approche 3 - Programme Java montrant des méthodes imbriquées pour trouver la valeur du périmètre
Méthode 4 – Classes internes Java et classes imbriquées
Programme Java affichant des méthodes imbriquées en utilisant trois classes de méthodes

Utilisez la méthode imbriquée de Java pour calculer l'aire d'une sphère

Utilisons la méthode imbriquée de Java pour calculer l'aire d'une sphère. Ici, nous utilisons deux classes, dont Area() et Volume(), pour calculer l'aire et le volume de la sphère.

Exemple 1

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);
   }
}

Copier après la connexion

Sortie

##### 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

Copier après la connexion

Ajoutez deux nombres en appelant les méthodes main() et swap() :

Dans ce code Java, nous essayons de montrer le processus d'addition de deux nombres en appelant les méthodes main() et swap().

La traduction chinoise de

Exemple 2

est :

Exemple 2

public 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);
   }
}

Copier après la connexion

Sortie

#####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

Copier après la connexion

Méthodes imbriquées pour trouver la valeur du périmètre

Dans ce code Java, nous essayons de montrer l'imbrication des méthodes pour trouver la valeur du périmètre.

La traduction chinoise de

Exemple 3

est :

Exemple 3

import 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);
   }
}

Copier après la connexion

Sortie

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

Copier après la connexion

Classes internes Java et classes imbriquées

Dans cet exemple, nous pouvons montrer comment déclarer certaines classes internes et classes imbriquées dans un environnement Java.

Exemple 4

//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());
   }
}

Copier après la connexion

Sortie

Processor Cache We Will Get = 16.1
Ram Clock speed We Can Examine = 7.1

Copier après la connexion

Exemple 4 A

se traduit par :

Exemple 4 A

//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());
   }
}

Copier après la connexion

Sortie

Engine Type for 16XYZRDD= Bigger Engine Type
Engine Type for 7XYZARB = Bigger Engine Type

Copier après la connexion

Exemple 4B

//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());
   }
}

Copier après la connexion

Sortie

Total Ports Present Here In The System = 3

Copier après la connexion

Le programme Java affiche les méthodes imbriquées en utilisant des classes de méthodes à trois couches

Dans cet exemple, nous avons écrit une méthode de code Java spécifique en utilisant une classe de méthodes triples pour démontrer le processus imbriqué. Ici, une méthode spécifique peut appeler n'importe quelle méthode aléatoire. Une autre méthode peut également être appelée ici. Cela signifie que la méthode 1 peut appeler la méthode 2 et que la valeur de retour de la méthode 2 peut appeler la méthode 3.

Exemple 5

se traduit par :

Exemple 5

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);
	}
}

Copier après la connexion

Sortie

******%% Inside the a3 method %%******
w = 150 z = 150
******#### Inside the a1 method ####******
a = 160 b = 170
******@@@ Inside the a2 method @@@******
x = 260 y = 370

Copier après la connexion

Conclusion

Ici, nous avons discuté des méthodes imbriquées et fourni quelques codes Java possibles en suivant la syntaxe et l'algorithme. J'espère que cet article vous a aidé à comprendre comment fonctionnent les différentes méthodes imbriquées mentionnées ici.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!