Domyślna wartość obiektu z metody i zapisywanie do zmiennych.

0

Chcę stworzyć obiekt klasy Robot który będzie domyślnie pobierał wartości z metod które mu przypisze, oraz jaki sposób będzie najlepszy na sumowanie zmiennych weight z wybranych metod ?

class Program
    {
        static void Main(string[] args)
        {
            Robot r1 = new Robot();
            r1.Engine_great(200, "trlalla", 200);
            r1.Skelly_A(400,300);

        }
    }
    class Robot
    {
        public void Engine_medium(int power, string name, int weight)
        {
            power = 100;
            weight = 230;
            name = "ZX:A100 Engine with medium power and medium weight";
        }
        public void Engine_great(int power, string name, int weight)
        {
            power = 130;
            weight = 350;
            name = "ZX:S100 Engine with high power and great weight";
        }

        public void Skelly_A(int weight, int agility)
        {
            weight = 400;
            agility = 10;
        }
        public void Skelly_S(int weight, int agility)
        {
            weight = 550;
            agility = 15;
        }

    }
} 
0

aleosohozi?

weight = weight + 230;

inaczej

weight += 230;
0
class Robot
    {
        int MyWeight;
        public void Engine_medium(int power, string name, int weight)
        {
            power = 100;
            weight = 230;
            MyWeight += weight;
            name = "ZX:A100 Engine with medium power and medium weight";
        }
        public void Engine_great(int power, string name, int weight)
        {
            power = 130;
            weight = 350;
            MyWeight += weight;
            name = "ZX:S100 Engine with high power and great weight";
        }
}

Swoją drogą po co przekazujesz na parametrze metody, skoro i tak w środku nadajesz inną wartość?

0

Nie o to mi chodzilo, gdybym miał wiecej podobnych metod i zsumowal weight tym sposobem, wynik mialbym z wszystkich metod a nie tylko z dwóch wybranych. Czemu w r1 nadałem inne wartości ? bo nie wiem jak zostawić te domyslne z metod.

Tego mi kompilator nie przyjmuje

r1.Engine_great(); 
r1.Skelly_A();

Gdy uda mi się zachować wartości ustalone w metodach, chce sumować to co pogrubiłem.

r1.Engine_great(200, "trlalla", 200);
r1.Skelly_A(400,300);

0

Przede wszystkim to nie masz tutaj żadnych domyślnych parametrów. Tutaj http://msdn.microsoft.com/en-us/library/dd264739.aspx w sekcji Optional Arguments jest wyjaśnione jak to się robi...

0

lepiej stwórz osobne klasy Engine, Skelly i klasy pochodne np. GreatEngine, a w klasie robota odpowiednie pola typu Engine, Skelly itd.

0

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Robot r1 = new Robot();
           int waga = r1.zliczwage();
            Console.WriteLine(waga);
            Console.ReadLine();
        }
    }
class Skelly
    {

    }
    class Skelly1 : Skelly
    {
        public int skelly1weight()
        {
            return 150;
        }
    }
    public class Engines
    {

    }
    public class Engine1 : Engines
    {
        public int Engine1weight()
        {
            return 100;
        }
        public int Engine1power()
        {
            return 40;
        }
    }
    class Robot
    {
        public int zliczwage()
        {
            Engine1 en1 = new Engine1();
            int x = en1.Engine1weight();
            Skelly1 sk1 = new Skelly1();
            int y = sk1.skelly1weight();
            return x + y;
        }
    }
}

Działa tak jak chciałem, tylko piszcząc to czułem się jakbym szedł w głąb tunelu bez latarki, i teraz gdy się odwrócę.. to nie wiem gdzie jestem.

Da się taki efekt uzyskać prościej ?

0
 using System;
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {

            Console.WriteLine(Robot.zliczwage());
            Console.ReadLine();
        }
    }
    class Skelly
    {

    }
    class Skelly1 : Skelly
    {
       static public int skelly1weight()
        {
            return 150;
        }
    }
    public class Engines
    {

    }
    public class Engine1 : Engines
    {
       static public int Engine1weight()
        {
            return 100;
        }
     static   public int Engine1power()
        {
            return 40;
        }
    }
    class Robot
    {
        static public int zliczwage()
        {

            return (Skelly1.skelly1weight() + Engine1.Engine1weight());
        }
    }
}
0

metody weight i power powinny być wirtualne, a w klasach nadrzędnych abstrakcyjne.

0
class Robot
    {

     static void Main(string[] args)
        {

            Robot r1 = new Robot();
            r1.obliczwage();
            Console.WriteLine(r1.obliczwage());
            Console.ReadLine();

        }

     public int obliczwage()
        {
            return (Engine1.Engine1Weight() + Skelly.SkellyWeight());
        }
    }

    struct Engine1
    {
       static public int Engine1Power()
        {
            return 80;
        }
       static public int Engine1Weight()
        {
            return 200;
        }
    }

    struct Skelly
    {
        static public int SkellyWeight()
        {
            return 1300;
        }
    }

Tak chyba wyglada lepiej ?

Abstrakcja i wirtualizm wciąż są mi obce

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0