Metody – Java – Fórum – Programujte.com

* Vytvořte třídu MyInstructios </code>, která bude potomkem této abstraktní třídy. Ten
 * Překrývat metodu {@link #instructionOne()}
 * Přetíží metodu {@link #instructionTwo()}  
 
public abstract class Instructions {

* Překrujte tuto metodu tak, aby vracela hodnotu překryté funkce v kulatých závorkách.
	public String instructionOne() {
		return "instructionOne";

* Přetěžte tuto metodu tak:
aby vracela hodnotu původní přetížené metody zopakovanou podle int hodnoty jediného parametru.
aby přetížená metoda měla proměnný počet parametru typu String a její návratová hodnota se rovnala jejich zřetězení. 
	
	public String instructionTwo() {
		return "instructionTwo";
	}

Public class MyInstructions extends Instructions {
	
	Public String instructionOne(){
		Return “instructionOne”
}

Public String instructionTwo(){

}

}

Prosím poradíte někdo máme taková nejasná zadání....

Co je na tom nejasného?

Přepíšeš -> bude dělat to co cheš ty v té dědící třídě, k původní "zděděné" metodě se dostaneš pomocí super.instructionOne();

@Override
public String instructionOne() {
	return "("+super.instructionOne()+")";
}

Přetěžování -> metody se musí lišit, mohou mít stejný název, ale musí se lišit počtem/typy param, případně jejich návratové hodnoty musí být jiných typů atd.

Proměnná délka parametrů -> String...param . Chová se to jako pole

    public String instructionTwo(int param){
        String retVal="";
        for (int i=0; i<param; i++){
            retVal += super.instructionTwo();
        }
        return retVal;
    }
    
    public String instructionTwo(String...param){
        String retVal = "";
        for(int i=0; i<param.length; i++){
            retVal += param[i];           
        }
        return retVal;
    }

Nevím jesti je to správně, přišel jsem z hospody a neměl co dělat, ale myslím že by to mohlo být OK .. možná že jsou nějaký lpší metody pro práci se String než to moje spojování, ale snad by to mohlo fungovat :)

jen bych opravil, že přetížená funkce se MUSÍ lišit jen počtem, případně typem parametrů, ale název funkce a jeji návratová hodnota MUSÍ být stejná

jink správně by to mělo být takto, nebo aspoň já bych to tak dělal :) 

public class MyInstructions extends Instructions {

    @Override
    public String instructionOne() {
        return "(" + super.instructionOne() + ")";
    }

    public String instructionTwo(int pocet) {
        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < pocet; i++) {
            sb.append(super.instructionTwo()).append("\n");
        }
        return sb.toString();
    }

    public String instructionTwo(String... params) {
        if (params == null) {
            return null;
        }
        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < params.length; i++) {
            sb.append(i).append(") ").append(params[i]).append("\n");
        }
        return sb.toString();
    }
}

vzhledem k té třídě by bylo lepší ten StringBuilder dát přímo do třídy instrukce a použít ho jako buffer... ale pro ilustraci to takto stačí

:D když si to čtu ted, tak ta moje definice přetížený metody je fakt ubohá :D dík za opravu