Retour sur les bases de Java

Préface

Je passais en revue Java, mais j'ai remarqué que la partie de base était subtile. Gardez une trace de votre compréhension

Passer par référence et passer par valeur

Passer par référence → Passer l'emplacement sur la mémoire Passer par valeur → Passer la valeur telle quelle

Et Java?

Passer uniquement par valeur en Java Type primitif → Passer par valeur telle quelle Type d'objet → Référence "valeur" passée

Que signifie passer par valeur de référence?

Passer un pointeur (informations sur l'emplacement de stockage des données en mémoire) Alors Vous pouvez manipuler la valeur d'origine en passant une valeur de référence à la méthode

public void sampleMethod(Object o){
	o = 1;
}

Cependant, si new est utilisé, la valeur de référence sera réécrite, donc même si des modifications sont apportées après cela, la valeur d'origine ne sera pas affectée. Si vous ne revenez pas avec, une valeur de référence qui ne sera pas utilisée sera née

public void sampleMethod(Object o){
	o =  new Object();
	o = 1;
}

À propos de String

Puisque String est un type d'objet, il est passé par valeur de référence Mais même si vous remplacez la valeur, la valeur d'origine ne change pas → Parce que c'est une classe qui ne peut pas être modifiée Chaque fois que vous apportez une modification à String, un nouvel objet est créé dans les coulisses (remplacé par un nouveau pointeur) Par conséquent, l'objet d'origine ne peut pas être modifié Par conséquent, il s'agit d'un mouvement différent du passage par valeur même si le résultat est le même.

Composition

Incorporer une autre classe dans une classe

Pourquoi es-tu

Il existe un héritage pour utiliser d'autres classes, mais l'utilisation de l'héritage peut provoquer un comportement inattendu
Héritage

public class InstrumentedHashSet<E> extends HashSet<E> {
private int addCount = 0;

public InstrumentedHashSet(){
}

@Override
public boolean add(E e){
 addCount++;
 return super.add(e);
}

@Override
//addAll boucle l'argument en interne et ajoute
//Par conséquent, dans cette classe, l'ajout remplacé est utilisé et le nombre avance du montant d'ajout et du montant d'addAll.
//En d'autres termes, lors de l'héritage et du remplacement d'une méthode, si la méthode cible utilise une autre méthode remplacée, elle sera affectée.
public boolean addAll(Collection<? extends E> c){
 addCount += c.size();
 return super.addAll(c);
}

public int getAddCount(){
 return addCount;
}
}

Composition

//Classe de transfert
//La composition elle-même peut être faite sans faire cela séparément.
public class ForwardingSet<E> implements Set<E>{
//Composition
private final Set<E> s;

//L'ensemble utilisé ici est juste celui passé en argument
public ForwardingSet(Set<E> s){
 this.s = s;
}

public void clear(){
 s.clear();
}

public boolean add(E e){
 return s.add(e);
}

public boolean addAll(Collection<? extends E> c){
 return s.addAll(c);
}

//Remplacer la méthode abstraite de Set(réduction)
}


//Classe de wrapper
public class RapperSet<E> extends ForwardingSet<E>{
private int addCount = 0;

//Passez l'ensemble sur lequel vous voulez baser la superclasse
public RapperSet(Set<E> e){
 super(e);
}

@Override
public boolean add(E e){
　addCount++;
　return super.add(e);
}

@Override
public boolean addAll(Collection<? extends E> c){
addCount += c.size();
//AddAll utilisé ici()Est utilisé dans la superclasse addAll()
//Autrement dit, addAll de la classe passée en argument().. rappeurSet ajouter()N'a pas d'importance
return super.addAll(c);
}

public int getAddCount(){
return addCount;
}
}