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 JavaClasses 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.
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.
Syntaxe du processus :
class Main {
method1(){
}
method2(){
method1();
}
method3(){
method2();
}
}
Syntaxe de classe :
class OuterClass {
// ...
class NestedClass {
// ...
}
}
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( );
}
}
Dans cette syntaxe possible, nous essayons de montrer comment structurer un code Java pour expliquer et démontrer diverses méthodes imbriquées.
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
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.
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
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 depublic 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
Dans ce code Java, nous essayons de montrer l'imbrication des méthodes pour trouver la valeur du périmètre.
La traduction chinoise deimport 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
Dans cet exemple, nous pouvons montrer comment déclarer certaines classes internes et classes imbriquées dans un environnement Java.
//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
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.
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
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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
