Cela fait un an que j'ai commencé à programmer. Ce n'est pas que je n'y ai pas touché du tout parce que j'ai créé une application Android, mais je n'arrête pas de penser qu'elle est orientée objet. Si vous ne le comprenez pas, ce sera difficile à l'avenir, alors prenez note. Écrit en Java et Ruby
Je vous serais reconnaissant de bien vouloir signaler toute erreur.
J'ai fait beaucoup de méthodes dans la classe Main! !! Je ne sais plus ça!
Main.java
class Main{
public static void main(String[] args){
hello();
sorry();
goodbye();
fine();
.
.
.
}
public static void hello(){
//Déclaration de processus
}
public static void sorry(){
//Déclaration de processus
}
.
.
.
}
↓ Créez d'autres classes et écrivez beaucoup de méthodes!
Main.java
class Main{
public static void main(String[] args){
Person.hello();
}
}
Person.java
class Person{
public static void hello(){
System.out.println("Hello World");
}
}
(En rubis)
index.rb
class Person
#Contenu
end
génial! Nettoyer!
Représente des «choses» dans le monde réel (souvent écrites à divers endroits) Par exemple, s'il y a un objet appelé Otaku
Spécifications (informations) --28 ans --Célibataire --Histoire sans elle = âge --Vierge --Graisse
Ce que vous pouvez faire (comportement)
Peut être expliqué avec le sentiment (biais)
Vous avez besoin d'une classe pour créer une instance. En d'autres termes, la classe est un dessin de conception d'instance. (Il est souvent écrit à divers endroits)
Définissons maintenant otaku. C'est facile. Écrivez simplement les "spécifications" et "ce que vous pouvez faire" de l'instance dans la classe Otaku (dessin de conception).
Main.java
class Main{
public static void main(String[] args){
Otaku otaku1 = new Otaku(); //➀ Créez une instance de la classe Otaku! Assignez l'instance à une variable et utilisez-la!
//Nom de variable de type de classe(Nom de l'instance) =nouveau nom de classe();
Otaku otaku2 = new Otaku();
Otaku otaku3 = new Otaku(); //➁ Vous pouvez créer de nombreuses instances à partir du même type de classe! Il y a beaucoup d'otaku!
//➃ Nom de l'instance.Nom de la méthode()Vous pouvez utiliser ce que Otaku peut faire!
otaku1.usePC();
otaku1.specBody(); //➄ Dans la méthode specBody, "je suis gros!Je veux dire! Valeur du corps du champ d'instance("graisse")Envie d'utiliser!
}
}
Otaku.java
class Otaku{
//➂ Voici les spécifications d'Otaku(information)Je vais définir! Il semble que le mot difficile soit le champ d'instance? Mais c'est une déclaration de variable!(peut être!)
public String age;
public String body;
//➂ Attribuez une valeur dans le constructeur!
Otaku(){
otaku1.age = "28 ans";
otaku1.body = "graisse";
}
//➃ Ce qu'Otaku peut faire à partir d'ici(Comportement)S'exprime par une méthode! Aussi appelée méthode d'instance!
public void usePC(){
System.out.println("Je suis un grand professeur d'ordinateurs personnels!");
}
public void specBody(){
System.out.println("je" * this.body + "est!"); //➄ MainクラスでspecBodyメソッドが呼ばれた時に、thisをインスタンス名に置き換えるよ！ これで「jeデブest!Tu peux dire!
}
}
(Comment utiliser la méthode d'instance dans Ruby)
otaku.rb
class Otaku
def usePC #Définition de la méthode d'instance
puts "Je suis un grand professeur d'ordinateurs personnels!"
end
end
otaku = Otaku.new #Génération d'instance
otaku.usePC
public ・ ・ ・ Peut être appelé de l'extérieur de la classe statique ・ ・ ・ Peut être appelé sans créer d'instance
Un constructeur est une méthode spéciale qui est automatiquement appelée après la création d'une instance à l'aide de new. Synonyme de "méthode d'initialisation" dans Ruby
Si vous utilisez le constructeur lors de la définition de la valeur du champ d'instance et que vous ne l'utilisez pas, le code changera considérablement! Souvenons-nous bien!
Aucun constructeur ver
Main.java
class Main{
public static void main(String[] args){
Otaku otaku1 = new Otaku(); //➀ Créez une instance de la classe Otaku! Assignez l'instance à une variable et utilisez-la!
//Nom de variable de type de classe(Nom de l'instance) =nouveau nom de classe();
Otaku otaku2 = new Otaku();
Otaku otaku3 = new Otaku(); //➁ Vous pouvez créer de nombreuses instances à partir du même type de classe! Il y a beaucoup d'otaku!
otaku1.age = "28 ans"; //➂ Je mettrai des informations détaillées sur Otaku dans chaque cas! Ce n'est pas un bon être humain!
otaku1.body = "graisse";
otaku1.usePC(); //➃ Nom de l'instance.Nom de la méthode()Vous pouvez utiliser ce que Otaku peut faire!
otaku1.specBody(); //➄ Dans la méthode specBody, "je suis gros!Je veux dire! Valeur du corps du champ d'instance("graisse")Envie d'utiliser!
}
}
De ce code otaku1.age = "28 ans"; otaku1.body = "Gras"; J'ai mis la valeur à. Avec cela, ce serait difficile si le nombre de champs d'instance augmentait! Je ne sais pas car il y en a tellement!
Avec le constructeur ver
Main.java
class Main{
public static void main(String[] args){
Otaku otaku1 = new Otaku(); //➀ Créez une instance de la classe Otaku! Assignez l'instance à une variable et utilisez-la!
//Nom de variable de type de classe(Nom de l'instance) =nouveau nom de classe();
Otaku otaku2 = new Otaku();
Otaku otaku3 = new Otaku(); //➁ Vous pouvez créer de nombreuses instances à partir du même type de classe! Il y a beaucoup d'otaku!
//Non!
otaku1.usePC(); //➃ Nom de l'instance.Nom de la méthode()Vous pouvez utiliser ce que Otaku peut faire!
otaku1.specBody(); //➄ Dans la méthode specBody, "je suis gros!Je veux dire! Valeur du corps du champ d'instance("graisse")Envie d'utiliser!
}
}
Otaku.java
class Otaku{
//➂ Voici les spécifications d'Otaku(information)Je vais définir! Il semble que le mot difficile soit le champ d'instance? Mais c'est une déclaration de variable!(peut être!)
public String age;
public String body;
//Je vais utiliser le constructeur ici! nouveau Otaku();Cette méthode est toujours utilisée lors de l'appel!
Otaku(){
otaku1.age = "28 ans"; //➂ Je mettrai des informations détaillées sur Otaku dans chaque cas! Ce n'est pas un bon être humain!
otaku1.body = "graisse";
}
//➃ Ce qu'Otaku peut faire à partir d'ici(Comportement)S'exprime par une méthode! Aussi appelée méthode d'instance!
public void usePC(){
System.out.println("Je suis un grand professeur d'ordinateurs personnels!");
}
public void specBody(){
System.out.println("je" * this.body + "est!"); //➄ MainクラスでspecBodyメソッドが呼ばれた時に、thisをインスタンス名に置き換えるよ！ これで「jeデブest!Tu peux dire!
}
}
Vous pouvez également définir une valeur comme argument lors de la création d'une instance et la transmettre au constructeur!
Main.java
Otaku otaku = new Otaku("graisse");
Otaku.java
class Otaku{
public String body;
Otaku(String body){ //"graisse"Entrer
this.body = body; //otaku.body = "graisse";Pareil que!
}
}
C'est le cas avec Ruby
index.rb
class Otaku
def initialize(name) //Ce que vous voulez faire lors de la création d'une instance
@name = name #Variable d'instance(Informations dont dispose l'instance(Les données))
end
def info
puts "je#{@name}est" #Variables d'instance disponibles uniquement dans la classe
end
end
otaku = Otaku.new("graisse")
otaku.info
Il est temps que ma tête ne me rattrape pas. Cela signifie-t-il que la classe peut également avoir des informations?
Les classes peuvent également avoir des méthodes. En premier lieu public static void main(String[] args){ } C'est aussi une méthode de classe, n'est-ce pas?
Otaku.java
class Otaku{
static int count = 0; //Variable de classe(Variables utilisables dans toutes les instances)
//Champ d'instance
public String age;
public String body;
//constructeur
Otaku(){
Otaku.count++; //Accéder aux champs de classe
}
}
Comment écrire des méthodes de classe dans Ruby
index.rb
class Otaku
@@count = 0 #Définition des variables de classe
def initialize(name)
@name = name
@@count += 1
end
def Otaku.data #Définition de méthode de classe self.Peut aussi être une méthode de classe
puts "est le nom"
end
end
Otaku.data #Appel d'une méthode de classe
#Nom du résultat de sortie
Non, c'est serré En termes simples, exposez les parties sûres des fonctionnalités que vous créez et limitez (encapsulez) les parties que vous ne souhaitez pas utiliser. Cela peut être fait en restreignant l'accès aux champs et aux méthodes.
Wai "J'ai fait un cours! Regarde ça! C'est incroyable! Je l'ai aussi utilisé dans d'autres cours!" Ajoutez "public"!
Main.java
class Main(){
public static void main(String[] args){
Otaku otaku = new Otaku("wai"); //Génération d'instance
System.out.println(otaku.name); //Il est ouvert au public pour que vous puissiez l'utiliser!
}
}
Otaku.java
class Otaku{
//Champ d'instance
public String name; //Ajoutez "public" pour qu'il soit accessible depuis l'extérieur de la classe!
//constructeur
Otaku(String name){
this.name = name;
}
}
Wai "J'ai créé une classe! Regarde ça! Mais si je l'utilise dans une autre classe, cela semble causer un bug, donc je ne peux pas l'utiliser ..." Ajoutez "privé"!
Main.java
class Main(){
public static void main(String[] args){
Otaku otaku = new Otaku(28); //Génération d'instance
System.out.println(otaku.age); //Erreur! !! !! ne peut pas utiliser!
}
Otaku.java
class Otaku{
//Champ d'instance
private int age; //Ajoutez "privé" pour empêcher l'accès de l'extérieur!
//constructeur
Otaku(int age){
this.age = age; //Vous pouvez l'utiliser dans la même classe!
}
}
Les méthodes Ruby sont des méthodes publiques, sauf si vous spécifiez quoi que ce soit. La méthode écrite après private devient une méthode privée et ne peut être appelée que dans la classe.
cependant, Pour les clients qui veulent une valeur sûre même si le champ d'instance est privé, nous fournissons une méthode appelée "getter" qui ne peut utiliser que la valeur de retour du champ!
Main.java
class Main{
public static void main(String[] args){
Otaku otaku = new Otaku("~","~","~");
System.out.println(otaku.getName());
}
}
Otaku.java
class Otaku{
//Champ d'instance
~
private String name; //C'est "privé", mais ...
~
//Méthode d'instance
public String getName(){ //Comme c'est "public", il est accessible depuis l'extérieur de la classe
return this.name; //Renvoie la valeur du champ
}
}
Même dans Ruby, la valeur d'une variable d'instance ne peut être obtenue qu'au sein de la classe, elle peut donc être obtenue de l'extérieur de la classe à l'aide d'un getter.
index.rb
class Otaku
attr_reader:name #Getter définition
def initialize(name)
@name = name
end
end
otaku = Otaku.new("Occupé")
puts otaku.name
Attr_reader définit les getters en faisant la même chose que ↓
def name
@name #Valeur de retour(retour omis)
end
Au contraire, il existe également une méthode "setter" qui change la valeur du champ de l'extérieur.
Main.java
class Main{
public static void main(String[] args){
Otaku otaku = new Otaku("~","~","~");
otaku.setName("washi"); //Argument défini dans la méthode setName
System.out.println(otaku.getName());
//Résultat de sortie: washi
}
}
Otaku.java
class Otaku{
~
private String name;
~
public void setName(String name){
this.name = name; //Définir la valeur dans le champ
}
}
Définition de Setter en Ruby
index.rb
class Otaku
attr_writer:name #Définition de setter
def initialize(name)
@name = name
end
end
otaku = Otaku.new("Occupé")
otaku.name = "mignonne" #Passeur d'appel
puts otaku.name #Le résultat de sortie est mignon
Attr_writer définit un setter en faisant la même chose que ↓
def name=(value)
@name = value
end
Lorsque vous définissez simultanément getter et setter dans Ruby, vous pouvez définir les deux à la fois en utilisant "attr_accessor"
--Le champ est privé
En le définissant sur, la variable est protégée de manière privée et la méthode peut être utilisée publiquement dans d'autres classes, ce qui est pratique.
Quelle bonne chose.
Vous voudrez rassembler du code avec un contenu similaire. La même chose est vraie pour le contenu de la classe. Hériter du contenu d'une classe par une autre classe.
Senior "Ma compétence spéciale est polyvalente! Super utilisable!" (Compétence spéciale héritée (classe): Super classe)
Super.java
class Super{
public void setName(String name){
System.out.println(name);
}
}
Junior "Senior! Let me use it!" (Compétence spéciale (classe) qui peut être héritée: Sous-classe)
Sub.java
class Sub extends Super{ //Hérite de la méthode d'instance de la classe Super
}
Main.java
class Main{
public static void main(String[] args){
Sub sub = new Sub();
sub.setName("Inverseur de position hyperkinétique!!!"); //Appeler une méthode d'instance d'une superclasse
}
}
En Ruby, ça ressemble à ça
index.rb
class Super
def initialize(name)
@name = name
end
def info
puts @name
end
end
class Sub < Super
end
sub = Sub.new("Inverseur de position hyperkinétique!!!") #Lorsque new est exécuté, la méthode initialize de la classe parent est exécutée.
sub.info #Puisqu'elle hérite de la classe parente, la méthode info peut être utilisée
En définissant une méthode portant le même nom que la méthode héritée de la superclasse dans la sous-classe, le contenu de la superclasse peut être écrasé. C'est ce qu'on appelle le «remplacement».
De plus, "private" n'est accessible qu'à partir de cette classe, tandis que "protected" ne peut être accédé qu'à partir de cette classe et de ses sous-classes.
Recommended Posts