riscrittura Java (Override) e sovraccarico (Overload)

Rewrite (Override)

Riscrittura è una sottoclasse del processo di implementazione per consentire l'accesso ai metodi della classe genitrice di riscrivere! I valori restituiti e parametri non vengono modificati. Questo è lo stesso caso, il nucleo riscrivere!

Riscrittura vantaggio di sottoclassi come necessario, definire specifici nelle loro azioni.

Questa è una sottoclasse di un metodo della classe genitore può essere realizzato in base alle esigenze.

In principi orientati agli oggetti, la riscrittura significa che è possibile ignorare i metodi esistenti. Esempi sono i seguenti:

class Animal{

   public void move(){
      System.out.println("动物可以移动");
   }
}

class Dog extends Animal{

   public void move(){
      System.out.println("狗可以跑和走");
   }
}

public class TestDog{

   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象

      a.move();// 执行 Animal 类的方法

      b.move();//执行 Dog 类的方法
   }
}

Gli esempi sopra risultati elaborati sono i seguenti:

动物可以移动
狗可以跑和走

Nell'esempio precedente si può vedere, anche se b appartiene al tipo di animale, ma è un'operazione di spostamento classe metodo Dog.

Questo perché in tempo di compilazione, ma il controllo dei parametri tipo di riferimento.

Tuttavia, in fase di esecuzione, il tipo di macchina virtuale Java (JVM) dell'oggetto e funzionamento dell'oggetto specificato.

Così nell'esempio precedente, il compilatore ha potuto riuscire perché il metodo mossa esiste classe animale, ma in esecuzione, l'esecuzione è un metodo per un particolare oggetto.

Considerate i seguenti esempi:

class Animal{

   public void move(){
      System.out.println("动物可以移动");
   }
}

class Dog extends Animal{

   public void move(){
      System.out.println("狗可以跑和走");
   }
   public void bark(){
      System.out.println("狗可以吠叫");
   }
}

public class TestDog{

   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象

      a.move();// 执行 Animal 类的方法
      b.move();//执行 Dog 类的方法
      b.bark();
   }
}

Gli esempi sopra risultati elaborati sono i seguenti:

TestDog.java:30: cannot find symbol
symbol  : method bark()
location: class Animal
                b.bark();
                 ^

Il programma gettare un errore di compilazione perché non esiste un metodo di riferimento b corteccia tipo di animale.

Il metodo delle regole di riscrittura

• Elenco parametri deve essere esattamente lo stesso come il metodo da riscrivere;
• Il tipo di ritorno deve essere completamente riscritto con il tipo di ritorno del metodo è lo stesso;
• L'accesso non è inferiore ai metodi di accesso classe genitore ignorata. Ad esempio: se una classe genitore è dichiarata pubblica, quindi sovrascrivere questo metodo in una sottoclasse non può essere dichiarato come protetto.
• I membri della classe genitore possono essere sostituite solo le sue sottoclassi.
• Dichiarato come metodi finali non possono essere sostituiti.
• Dichiarati come metodi statici non possono essere riscritti, ma possono essere dichiarati di nuovo.
• La classe genitore e sottoclasse nello stesso pacchetto, la sottoclasse possibile sostituire la classe madre di tutti i metodi, diversi da dichiarazioni di approccio privato e finale.
• Sottoclasse e superclasse non è lo stesso pacchetto, in modo che solo le sottoclassi possono ignorare la dichiarazione di metodi non-finali della classe genitore pubblico e protetto per.
• metodo ignorato può lanciare qualsiasi eccezione non obbligatorio, indipendentemente dal fatto che il metodo è stato riscritto un'eccezione. Tuttavia, il metodo non può ignorare l'eccezione obbligatoria gettare nuova o più ampia della dichiarazione obbligatoria è il metodo override un'eccezione, altrimenti è possibile.
• Costruttore non può essere riscritta.
• Se un metodo non può essere ereditata, non può sovrascrivere questo metodo.

Utilizzando la parola chiave super

Quando avete bisogno di essere riscritto per chiamare il metodo classe padre in una sottoclasse, per usare la parola chiave super.

class Animal{

   public void move(){
      System.out.println("动物可以移动");
   }
}

class Dog extends Animal{

   public void move(){
      super.move(); // 应用super类的方法
      System.out.println("狗可以跑和走");
   }
}

public class TestDog{

   public static void main(String args[]){

      Animal b = new Dog(); // Dog 对象
      b.move(); //执行 Dog类的方法

   }
}

Gli esempi sopra risultati elaborati sono i seguenti:

动物可以移动
狗可以跑和走

Overload (sovraccarico)

Overload (sovraccarico) è in una classe all'interno del metodo con lo stesso nome, ma con diversi parametri. Il tipo di ritorno possono essere uguali o differenti.

Ogni metodo di overload (o costruttore) devono avere una lista unica di tipi di argomenti.

costruttori Solo overload

Sovraccarico regole

• metodo di overload deve cambiare la lista dei parametri;
• metodi di overload può cambiare il tipo di ritorno;
• metodi di overload possono cambiare modificatori di accesso;
• metodi di overload può dichiarare un nuovo eccezioni o più ampia controllato;
• Il metodo può essere nella stessa classe o essere sovraccaricato in una sottoclasse.

Esempi

public class Overloading {
 
	public int test(){
		System.out.println("test1");
		return 1;
	}
 
	public void test(int a){
		System.out.println("test2");
	}	
 
	//以下两个参数类型顺序不同
	public String test(int a,String s){
		System.out.println("test3");
		return "returntest3";
	}	
 
	public String test(String s,int a){
		System.out.println("test4");
		return "returntest4";
	}	
 
	public static void main(String[] args){
		Overloading o = new Overloading();
		System.out.println(o.test());
		o.test(1);
		System.out.println(o.test(1,"test3"));
		System.out.println(o.test("test4",1));
	}
}

Riscrivere la differenza tra sovraccarico