[JAVA] Écriture de base de divers langages de programmation (auto-mémo)

Si je faisais plusieurs sites d'apprentissage de langage de programmation à une vitesse extrême, je voudrais résumer comment écrire chaque langage. Pour le moment, seulement super basique. .. ..

Ce qui est écrit ici est une compilation des recherches de l'auteur qui est un super débutant en programmation.

Je vous serais reconnaissant de bien vouloir signaler toute erreur.

Liste des langages de programmation traités ici

Il est difficile de décrire clairement la différence de spécifications pour chaque langue, c'est donc à titre indicatif seulement.

production

hello_world.c


printf("Hello World");
printf("%d",num);  //Sortie entière
printf("%f",data);  //Sortie de nombre réel
printf("%c",mozi);  //Sortie de caractères
printf("%s",str);  //Sortie de chaîne

hello_world.py


print("Hello World")
print(num)
print(str)

#Devis unique "', Et la double citation ""L'un ou l'autre est acceptable(Parce que c'est gênant, j'ai dit ""」)

hello_world.java


System.out.println("Hello World"); //Le deuxième caractère à l'arrière de println est l(Elle)

hello_world.js


console.log("Hello World");
console.log(num);
console.log(str);

hello_world.rb


puts "Hello World"
puts "#{str}"  #「#{variable}Peut remplacer la valeur par

hello_world.cs


Console.WriteLine("Hello World");  //Avec saut de ligne
Console.Write("Hello World");  //Aucun saut de ligne
Console.WriteLine("{0}",num);

commentaire

comment.c_&_comment.java_&_comment.js_&_comment.cs


//C'est un commentaire

comment.py_&_comment.rb


#C'est un commentaire

Déclaration de variable (initialisation)

box.c


int num = 0;
char mozi = 'a'; //Une seule lettre
char str[] = "abc";  //Chaîne

box.py_&_box.rb


num = 0  #Valeur numérique
str = "abc"  #Chaîne

box.java


int num = 0;  //entier
double num = 3.14;  //Nombre réel
String str = "abc";  //Chaîne
boolean bool = true; //Valeur booléenne

box.js


var num = 0;
var str = "abc";

box.cs


int num = 0;
string str = "abc";
bool a = true;
var x = 10;
var y = "abc";

##Concaténation de chaînes

#### **`strlink.c`**
```c

include <string.h>
char str1[80] = "DRAGON";
char str2[] = "QUEST";
strcat(str1,str2);
printf("%s",str1);

Post-scriptum: Il est nécessaire de créer des éléments supplémentaires du tableau pour que le montant soit concaténé.(ex:str1[80]) Merci d'avoir signalé, shiracamus!

strlink.py


str1 = "DRAGON"
str2 = "QUEST"
print(str1 + str2)

strlink.java


String str1 = "DRAGON";
String str2 = "QUEST";
System.out.println(str1 + str2);

strlink.js


var str1 = "DRAGON";
var str2 = "QUEST";
console.log(str1 + str2);

strlink.rb


str1 = "DRAGON"
str2 = "QUEST"
puts str1 + str2

##Conversion de type(jeter)

convert.c


 itoa (num, str, 10); // Décimal // Valeur numérique (int num) en chaîne (str)
 atoi (str); // Valeur numérique de la chaîne de caractères

convert.py


 str (num) # Du type numérique au type chaîne
 int (str) # Du type chaîne au type numérique

Java a une conversion de type automatique et une conversion de type manuelle

convert.java


 System.out.println (month + "month" + date + "day"); // type int Les variables de mois et de date sont automatiquement converties en type String

cast.java


int num = 13;
 System.out.println ((double) num); // Le résultat de la conversion manuelle est "13.0"

convert.rb


 met 1.to_s + "month" + 1.to_s + "day" #to_s pour convertir les nombres en chaînes

 num = "13" # Ceci est un objet chaîne car il est placé entre guillemets
 met num.to_i #to_i pour convertir des chaînes en nombres

convert.cs


int num = int.Parse(str);
string str = (string)123;

##if déclaration

if.c_&_if.java_&_if.js


if(num == 100 && score > 1000){
 //処理文
}
 else if(num < 100 || score != 1000){
 //処理文
}
else{
 //処理文
}

if.py


if num == 100 and score > 1000:
 # Instruction de traitement
elif num > 100 or score != 1000:
 # Instruction de traitement
else:
 # Instruction de traitement

if.rb


if num == 100 && score > 1000
 # Instruction de traitement
 elsif num > 100 || score != 1000
 # Instruction de traitement
else
 # Instruction de traitement
end
# (Traitement de l'instruction si expression conditionnelle) est également possible

##instruction switch

switch.c_&_switch.java


switch(num){
 case 0:
 //処理文
   break;
 case 1:
 //処理文
   break;
 default:
 //処理文
   break;
}

#déclaration de cas

case.rb


case x
 when 1
 # Instruction de traitement
 when 2
 # Instruction de traitement
 else
 # Instruction de traitement
end

##contribution

input.c


 scanf ("% d", & num); // Entrez un entier
 scanf ("% lf", & data); // Entrez un nombre réel
 scanf ("% c", mozi); // Saisir des caractères
 scanf ("% s", str); // Entrer la chaîne de caractères

input.py


 count = input () #variable type non pertinent

input.java


 import java.util.Scanner; // Appel de la bibliothèque externe

class Main{
 public static void main(String[] args){
 Scanner scanner = new Scanner (System.in); // Initialiser le scanner
 String name = scanner.next (); // En attente d'une entrée de la console
 }
}

input.rb


 L'entrée reçue par count = gets #gets est une chaîne

##Liste des tableaux

array.c


int a[] = {1, 2, 3, 4};
int a[3][4];

image

L'image est http://www.cc.kyoto-su.ac.jp/~yamada/programming/array.Depuis html

array.java


String names[] = {"apple","banana"};

array.js


var names = ["apple","banana"];
 console.log (names.length); // Récupère le nombre d'éléments dans le tableau

array.rb


names = ["apple","banana"]
 met names.size # Récupère le nombre d'éléments dans le tableau
 names.push ("grape") # Ajouter un élément à la fin du tableau

list.py


lists = ["apple","banana",200,300]
 lists.append ("pizza") #Ajouter un élément à la fin de la liste

##dictionnaire(dict) (Tableau associatif) (hacher)

dict.py_&_dict.js


 fruits = {"pomme": 200, "banane": 300} // Variable = {"clé": valeur, "clé": valeur}

hash.rb


 fruits = {"apple" => "200", "banana" => "300"} #variable = "key" => "value"}
 met des fruits ["apple"] # Récupération des valeurs
 fruits ["grape"] = "400" #Ajouter des données

##symbole Une fonctionnalité de Ruby. Bien qu'il ressemble à une chaîne dans le code, il est plus rapide qu'un objet chaîne pour la comparaison, la recherche et la référence. Souvent utilisé pour les clés de hachage.

symbol.rb


fruits = {:apple => "200", :banana => "300"}
puts fruits[:apple]

#chaque déclaration Une méthode qui itère sur un tableau ou un hachage dans l'ordre à partir des premières données

each.rb


 fruits.each do |key,value|  #Tableau.each do |variable|
 puts "#{key}:#{value}"
end

##pour déclaration

for.c_&_for.js


for(int i = 0; i < 10; i++){
 //処理文
}

for.java


for(int i = 0; i < 10; i++){
 System.out.println(i);
}

String names = {"apple","banana"};
 for (int i = 0; i <names.length; i ++) {// Compter le nombre d'éléments dans le tableau avec la méthode length
 System.out.println("eat" + names[i]);
}

exfor.java


String names = {"apple","banana"};
 for (String name: names) {// L'élément lui-même des noms de tableau est affecté au nom de la variable
 System.out.println(name);
}

for.py


for i in range(0,10):
 print(i)

for.rb


 for i in 0..9 do # (do peut être omis)
 puts i
end

##déclaration while

while.c_&_while.java_&_while.js


int x = 1;
while(x <= 100){
 //処理文
 x++;
}

while.py


x = 1
while x <= 100:
 # Instruction de traitement
 x += 1

while.rb


i = 1
 tandis que i <= 100 do #do peut être omis
 # Instruction de traitement
 i += 1
end

##Méthode(une fonction)

func.c


include <stdio.h>
int number(int num){
 printf ("Le nombre est% d \ n", num);
  num += 1;
  return num;
}

int main()
{
  int data = number(1);
  printf("%d\n",data);
  return 0;
}

func.py


# Portée du nom de la variable À partir d'ici (plage où les variables peuvent être utilisées)
def hello(name): 
  print("hello" + name)
  name = "hello"
  return name  
# Portée jusqu'à ici

hi = hello("world")
print(hi)

func.java


class Main{
 public static void main(String[] args){
  String hi; 
  hi = hello("world");
  System.out.println(hi);
 }

 public static String hello(String name){
  System.out.println("Hello" + name);
  name = "hello";
  return name;
 }
}

func.js


function number(num){
  console.log(num);
  num += 1;
  return num;
}

var data = number(1);
console.log(data);

func.rb


def number(num)
 puts num
 num += 1
 return num
end

data = number(1)
puts(data)

Ruby a des méthodes uniques en fonction du type d'objet(↓ est un exemple)

func1.rb


 met "Hello" .length # Affiche le nombre de caractères dans l'objet chaîne
 met 3.14.round # Sortir les nombres arrondis
 met "Hello" .reverse #Inverser les caractères et la sortie

##Bibliothèque(module)(En tête de fichier)

module.c


include <~.h>

module.py_&_module.java


import ~

##Ce que j'ai remarqué / note -Il semble que les spécifications soient assez différentes entre Python 2 et Python 3. -En Python, vous pouvez utiliser des guillemets simples ou doubles(je pense)

Quand vous pouvez surcharger: Lorsque le nombre d'arguments est différent, lorsque le type d'argument est différent, lorsque l'ordre des arguments est différent

Lorsque la surcharge n'est pas possible: Lorsque seul le nom de l'argument est différent, lorsque seule la valeur de retour est différente

J'ajouterai de plus en plus!

Recommended Posts

Écriture de base de divers langages de programmation (auto-mémo)
Évaluation des performances de base du langage de programmation
Caractéristiques du langage de programmation [Memo]
La popularité des langages de programmation
Écrire des classes (ou de type classe) dans divers langages de programmation
Programmation réseau (basique)
Animation de transition du langage de programmation le plus populaire (#programming language #popular)
Écriture de base Python
Représentation numérique des jours dans différentes langues
[Note] Début de la programmation
Recrutement de maîtres de programmation
Fonctionnement de base des pandas
Utilisation de base de Jinja2
Fonctionnement de base des Pandas
Utilisation de base de SQL Alchemy
HMAC en plusieurs langues
Connaissance de base de Python
Divers traitements de Python
Un mémo que j'ai écrit une fonction de base en Python en utilisant la récurrence
[Pour les débutants] Un résumé en mots des langages de programmation populaires (version 2018)