En principe, il est supposé que l'environnement peut exécuter java, eclipse (ou).
System.out.println Cette fois, j'ai pensé que j'écrirais quelque chose pour me familiariser avec java, mais j'ai pensé que ce serait amusant de simplement copier la grammaire, alors j'ai pensé que je ferais un programme capable de combattre le RPG en plusieurs fois. Je vais. Cette fois, je continuerai à expliquer la grammaire, mais je vous serais reconnaissant de bien vouloir y jeter un œil. Pour commencer, essayez ce qui suit:
Battle.java
public class Battle {
public static void main(String[] args) {
System.out.println("GameStart!");
}
}
Vous devriez voir les mots Game Start! Sur la console. Vous n'avez pas à vous soucier des autres grammaires, et maintenant vous n'avez pas encore à vous en soucier, mais la bataille après la classe et le nom de fichier Battle.java doivent correspondre à ces deux batailles.
Ensuite, augmentons un peu.
Battle.java
public class Battle {
public static void main(String[] args){
System.out.println("GameStart!");
String name="taro";
System.out.println(name);
int hp =10;
System.out.println(hp);
System.out.println(name+"HP est"+hp+"est");
}
}
Il y en a de nouveaux.
Je pense que le nombre de String name =" taro " et ʻint hp = 10a augmenté. Ici, String représente une chaîne de caractères et int représente un entier. En d'autres termes, cela signifie que "taro" est placé dans la case appelée nom de la chaîne de caractères et 10 est mis dans la case appelée hp de l'entier. Ceux-ci peuvent également être envoyés à la console en les mettant dansSystem.out.println. Les variables et les chaînes sont mélangées dans la dernière ligne, mais vous pouvez également sortir vers la console en utilisant variable +" string "`.
Faisons un peu plus de travail
Battle.java
public class Battle {
public static void main(String[] args){
System.out.println("GameStart!");
String playerName="taro";
System.out.println(playerName);
int playerHp =10;
System.out.println(playerHp);
System.out.println(playerName+"HP est"+playerHp+"est");
String monsterName = "slime";
System.out.println(monsterName);
int monsterHp = 3;
System.out.println(monsterHp);
System.out.println(monsterName+"HP est"+monsterHp+"est");
}
}
Il y a plusieurs changements, mais j'ai d'abord changé de nom et de hp en playerName et playerHp. De plus, monsterName et monsterHp ont été ajoutés. C'est un moment si vous le copiez, mais ne pensez-vous pas que c'est gênant si vous l'écrivez vous-même? Alors les vieux gens intelligents ont pensé. Mettons ensemble des choses similaires. Pouvez-vous trouver quelque chose de similaire ici à partir du code ci-dessus? En fait, il y en a des similaires.
Tout d'abord, probablement le plus simple à comprendre
System.out.println (HP de playerName +" est "+ playerHp +" ")
Quand
Il existe deux types de System.out.println (HP de monsterName +" est "+ monsterHp +") .
En outre, il est similaire que seuls le nom et HP sont affichés.
Ceux-ci peuvent être résumés comme suit.
Battle.java
public class Battle {
public static void main(String[] args){
System.out.println("GameStart!");
String playerName="taro";
int playerHp =10;
display(playerName,playerHp);
String monsterName = "slime";
int monsterHp = 3;
display(monsterName,monsterHp);
}
public static void display(String name,int hp) {
System.out.println(name);
System.out.println(hp);
System.out.println(name+"HP est"+hp+"est");
}
}
Ceux écrits sur Battle.java sont assez soignés, mais il y en a un nouveau appelé display. Cela s'appelle une méthode et sert à résumer les actions. Cette fois, je m'attends à ce qu'une boîte appelée name de type String et une boîte appelée hp de type int soient incluses, et si name et hp sont entrés, ils seront affichés. Cet affichage fait cela. Explorons un peu plus la méthode. Essayez ce qui suit:
Clac.java
public class Calc {
public static void main(String[] args) {
int number1 = 3;
int number2 = 6;
int output=plus(number1,number2);
System.out.println(output);
}
public static int plus(int plus1,int plus2) {
int result = plus1+plus2;
return result;
}
}
Il existe également une méthode plus ici. Il s'agit d'une méthode qui ajoute number1 et number2 et renvoie le résultat. Pour renvoyer le résultat, vous devez d'abord spécifier ce que la méthode renvoie. C'est l'int en face de plus. Cela spécifie le type de résultat à renvoyer, c'est-à-dire le type. Et la partie qui renvoie le résultat est la partie de return result. Il a été appelé statique plus tôt, mais c'est parce que main a static. Ce n'est pas très important, alors laissez-le dans le coin de votre tête pour le moment.
Revenons au sujet principal.
Battle.java que j'ai mentionné plus tôt, mais il y en a encore d'autres similaires.
Battle.java
public class Battle {
public static void main(String[] args){
System.out.println("GameStart!");
Player player=new Player();
player.name="taro";
player.hp=10;
display(player.name,player.hp);
String monsterName = "slime";
int monsterHp = 3;
display(monsterName,monsterHp);
}
public static void display(String name,int hp) {
System.out.println(name);
System.out.println(hp);
System.out.println(name+"HP est"+hp+"est");
}
}
class Player{
String name;
int hp;
}
Je pense qu'une nouvelle classe appelée Player a été ajoutée ci-dessus. class est une fonction pour créer vous-même de nouveaux types tels que String et int. Player player déclare une nouvelle variable appelée player, et new Player () crée une nouvelle entité de type de joueur. Si c'est le nom officiel, on l'appelle un objet. Le nombre de lignes de code lui-même n'a pas diminué, mais il est plus facile à voir. Auparavant, il était nécessaire de changer le nom de la variable afin de saisir le nom et le hp du monstre, mais si vous les assemblez de cette manière, vous n'avez pas à changer le nom de la variable. Au fait, faisons aussi un monstre.
Battle.java
public class Battle {
public static void main(String[] args){
System.out.println("GameStart!");
Player player=new Player();
player.name="taro";
player.hp=10;
display(player.name,player.hp);
Monster monster = new Monster();
monster.name = "slime";
monster.hp = 3;
display(monster.name,monster.hp);
}
public static void display(String name,int hp) {
System.out.println(name);
System.out.println(hp);
System.out.println(name+"HP est"+hp+"est");
}
}
class Player{
String name;
int hp;
}
class Monster{
String name;
int hp;
}
C'était très rafraîchissant. En fait, il y a un problème ici. Les gens qui travaillent avec Java se mettent en colère lorsqu'ils voient le code «player.name». Quant à la construction, si vous permettez de faire directement player.name, vous risquez de réécrire la valeur par erreur. Eh bien, je ne veux pas me mettre en colère, alors obtenons la valeur et attribuons la valeur avec la méthode.
Battle.java
public class Battle {
public static void main(String[] args){
System.out.println("GameStart!");
Player player=new Player();
player.setName("taro");
player.setHp(10);
display(player.getName(),player.getHp());
Monster monster = new Monster();
monster.setName("slime");
monster.setHp(3);
display(monster.getName(),monster.getHp());
}
public static void display(String name,int hp) {
System.out.println(name);
System.out.println(hp);
System.out.println(name+"HP est"+hp+"est");
}
}
class Player{
private String name;
private int hp;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHp() {
return hp;
}
public void setHp(int hp) {
this.hp = hp;
}
}
class Monster{
private String name;
private int hp;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHp() {
return hp;
}
public void setHp(int hp) {
this.hp = hp;
}
}
Privé sert à restreindre l'accès et n'est accessible qu'à partir de la même classe. De plus, le mot-clé this utilisé dans setName, setHp, etc. signifie celui de cette classe. Cela facilite la compréhension car la valeur reçue par la méthode peut être du même nom. Il y a quelque chose de plus similaire ici. C'est Player et Monster. Mettons-les ensemble.
Battle.java
public class Battle {
public static void main(String[] args){
System.out.println("GameStart!");
Player player=new Player();
player.setName("taro");
player.setHp(10);
display(player.getName(),player.getHp());
Monster monster = new Monster();
monster.setName("slime");
monster.setHp(3);
display(monster.getName(),monster.getHp());
}
public static void display(String name,int hp) {
System.out.println(name);
System.out.println(hp);
System.out.println(name+"HP est"+hp+"est");
}
}
class Animal{
private String name;
private int hp;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHp() {
return hp;
}
public void setHp(int hp) {
this.hp = hp;
}
}
class Player extends Animal{
}
class Monster extends Animal{
}
Je pense qu'il y a une nouvelle classe Animal, et Player et Monster ont «Extends Animal». Il s'agit de l'héritage, et les valeurs et méthodes sont héritées telles quelles. Par conséquent, même si la valeur ou la méthode disparaît de Player ou Monster, aucune erreur ne se produira en haut. Vous pouvez également le faire en héritant.
Battle.java
public class Battle {
public static void main(String[] args){
System.out.println("GameStart!");
Player player=new Player();
player.setName("taro");
player.setHp(10);
display(player);
Monster monster = new Monster();
monster.setName("slime");
monster.setHp(3);
display(monster);
}
public static void display(Animal animal) {
System.out.println(animal.getName());
System.out.println(animal.getHp());
System.out.println(animal.getName()+"HP est"+animal.getHp()+"est");
}
}
class Animal{
private String name;
private int hp;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHp() {
return hp;
}
public void setHp(int hp) {
this.hp = hp;
}
}
class Player extends Animal{
}
class Monster extends Animal{
}
J'ai réécrit la méthode d'affichage pour la faire «afficher (Animal animal)». Je l'ai mis directement là-bas comme «display (player)» ou «display (monster)». Il semble qu'une erreur se produit car le type est différent, mais il n'y a pas de problème car Player et Monster héritent du type appelé Animal par héritage. Vous pouvez le rendre encore plus facile en utilisant les fonctions suivantes.
Battle.java
public class Battle {
public static void main(String[] args){
System.out.println("GameStart!");
Player player=new Player("taro",10);
display(player);
Monster monster = new Monster("slime",3);
display(monster);
}
public static void display(Animal animal) {
System.out.println(animal.getName());
System.out.println(animal.getHp());
System.out.println(animal.getName()+"HP est"+animal.getHp()+"est");
}
}
class Animal{
private String name;
private int hp;
public Animal(String name,int hp){
this.name=name;
this.hp=hp;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHp() {
return hp;
}
public void setHp(int hp) {
this.hp = hp;
}
}
class Player extends Animal{
public Player(String name, int hp) {
super(name, hp);
}
}
class Monster extends Animal{
public Monster(String name, int hp) {
super(name, hp);
}
}
Un nouvel animal a été ajouté qui dit Animal. Il s'agit d'un constructeur, pas d'une méthode, et vous pouvez définir la valeur lorsque vous créez un nouvel objet avec new. Puisqu'il ne s'agit pas d'une méthode, il n'y a pas de type après public. De plus, comme le constructeur ne peut pas être hérité, le constructeur est également créé pour Player et Monster. Je ne peux pas définir la valeur avec ceci, donc j'utilise quelque chose appelé super () pour mettre la valeur.
C'est la chose la plus simple à faire, mais l'héritage lui-même est en fait gênant et il n'est pas recommandé d'en utiliser trop. La raison en est qu'il est vulnérable au changement. L'héritage Java lui-même ne peut hériter que d'une seule classe. Si vous voulez en hériter plus d'un, ce sera une classe qui hérite de B, qui hérite de A, C, qui hérite de B, mais aussi une classe qui hérite de B, qui hérite de A, et D, D qui hérite de B. Si tel est le cas, si A et B correspondent à l'implémentation d'une classe, une erreur peut se produire dans l'autre classe. Même si vous pouvez corriger l'erreur, il est probable que votre code devienne sale. Je ne recommande donc pas d'utiliser l'héritage.
D'un autre côté, il y a un désir de mettre le type Monster ou le type Player dans display (Animal animal) (soi-disant polymorphisme), alors utilisons plutôt une interface.
Battle.java
public class Battle {
public static void main(String[] args){
System.out.println("GameStart!");
Player player=new Player("taro",10);
display(player);
Monster monster = new Monster("slime",3);
display(monster);
}
public static void display(Animal animal) {
System.out.println(animal.getName());
System.out.println(animal.getHp());
System.out.println(animal.getName()+"HP est"+animal.getHp()+"est");
}
}
interface Animal{
String getName();
int getHp();
}
class Player implements Animal{
private String name;
private int hp;
public Player(String name,int hp) {
this.name=name;
this.hp=hp;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHp() {
return hp;
}
public void setHp(int hp) {
this.hp = hp;
}
}
class Monster implements Animal{
private String name;
private int hp;
public Monster(String name,int hp) {
this.name=name;
this.hp=hp;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHp() {
return hp;
}
public void setHp(int hp) {
this.hp = hp;
}
}
J'ai supprimé la relation d'héritage une fois et ajouté une nouvelle interface et des outils pour Player et Monster. Cependant, le code reste le même. C'est la même chose que extend et a également une classe appelée Animal, donc le code ci-dessus convient. Il y a String getName () et ʻint getHp () ʻ dans l'interface, mais grâce à cela, vous pouvez également utiliser getName (), getHp (), etc. dans l'affichage principal. De plus, si vous implémentez en tant que fonctionnalité d'interface, vous devez écrire ce qui est écrit dans l'interface. Cette fois, getName () et getHp () sont écrits, donc si vous ne les écrivez pas, une erreur de syntaxe se produira. Cependant, en provoquant une erreur de syntaxe au contraire, cela garantit que les implémentées fonctionneront toujours getName () et getHp ().
La différence entre héritage et interface est ambiguë pour moi. C'est ambigu, mais pour l'expliquer, je pense que l'héritage est très lié, et l'interface est vaguement liée.
C'est la fin de ce temps. Je l'ai expliqué pendant longtemps, mais comment était-ce? J'espère que cela vous aidera.
Recommended Posts