class A{
	static void doStuff(){
		System.out.println("A");
	}
}

class B extends A{
	static void doStuff(){
		System.out.println("B");
	}
}

მშვენივრად კომპილირდება და როგორც წიგნში წერია redifinition არის.
და როცა final ს ვუმატებ ორივე მეთოდს აღარ კომპილირდება და ვერ გავიგე რატო აღიქვამს თითქოს მაინდამაინც ოვერრაიდი მინდა პირველი მეთოდის და არა რედეფინიცია.

და კიდევ სტატიკური ფუნქციიდან super.myFunction()
რატო არ შემიძლია გამოვიძახო ? სადაც myFunction არის მშობლის სტატიკური ფუნქცია ? (არასტატიკურს რატოც ვერ გამოვიძახებ ცხადია მარა სტატიკურის გამოძახებაზე ხო არ უნდა ექმნებოდეს პრობლემა ?)

@brolia
final მეთოდების რედეფინიცია ან გადაფარვა არ შეიძლება.

super-ს რაც შეეხება, მაგ შემთხვევაში ვერ გამოიყენებ, რადგან ობიექტი არ გაქვს საერთოდ. სტატიკურ მეთოდებს ხომ ობიექტები არ სჭირდებათ, დამოუკიდებლად არსებობენ კლასის განსაზღვრებასთან ერთად. თან მაგათ გამოძახებაზეც კომპილაციის დონეზევე გარკვეულია უკვე ყველაფერი. ამიტომ არ მოქმედებს პოლიმორფიზმის თვისებებიც, რომლის მიხედვითაც runtime-ში ირკვევა რომელი კლასის მეთოდი გამოიძახოს. ის გამოიძახება, რომელი კლასის რეფერენსიც ჰქონდა.

Elle

xo magram super.myFunction() (statukuri funqciidan) viZaxeb mSoblis statikur funqcias da obieqti rom arsebobdes arc araferSi Wirdeba mSoblis statikur funqcias.

კი, მაგრამ super-ზეა საუბარი. super შეგიძლია გამოიძახო მხოლოდ ობიექტის მეთოდში, ობიექტის ინიციალიზატორში ან ობიექტის კონსტრუქტორში. სტატიკების დროს კი ობიექტები არ გაქვს..

Elle
va ra cudia, me megona super is xmarebisTvis obieqti saWiro ar iqneboda, da realurad arc unda iyos saWiro Tuki mSoblis statikurs iZaxeb :|

შეგიძლია პირდაპირ დაწერო - "კლასის სახელი"."ფუნქციის სახელი"

მაგ.
int k = ParentClass.stFunction();

და არა ეს: int k = super.stFunction();

:D:D:D

ეგ ვიცი პირდაპირ რომ შემიძლია, მე მაინტერესებდა სუპერის გამოყენება რატო არ შეიძლებოდა, იმიტომ რომ ვერანაირ წინააღმდეგობას ვერ ვხედავ რის გამოც შეიძლება აეკრძალათ ჯავას შემქმნელებს სტატიკურ ფუნქციაში სუპერის გამოყენება.

ალბათ ეს იქნება პასუხი:

თვითონ super უნდა იყოს ან სტატიკური ანდაც არასტატიკური.

1) არასტატიკური თუ იქნა - მაშინ სტატიკურ მეთოდში ვერ გამოიყენებ.
2) სტატიკური თუ იქნა - მაშინ მის არასტატიკურ ფუნქციებს ვერ გამოიყენებ.


ხოდა super არის არასტატიკური, ანუ სტატიკურ კლასში ვერ გამოიყენებ.

Varlevani

ვერ გავიგე რას ამბობ.

"super უნდა იყოს სტატიკური ანდაც არასტატიკური"
რისი თქმა გინდოდა აქ ?

კიდე ერთხელ აგიხსნი :
ვარ სტატიკურ ფუნქციაში და მინდა დავწერო super.myFunct()
რა უშლის ხელს იმას რომ ეს შესაძლებელი იყოს ?

static List<Integer> intArrayAsList(final int[] a) {
		if (a == null)
			throw new NullPointerException();
		return new AbstractList<Integer>() {
			public Integer get(int i) {
				return a[i]; // Autoboxing (Item 5)
			}

			@Override
			public Integer set(int i, Integer val) {
				int oldVal = a[i];
				a[i] = val;
				// Auto-unboxing
				return oldVal; // Autoboxing
			}

			public int size() {
				return a.length;
			}
		};
	}

მეთოდი რომელსაც გადაყავს მასივი ლისტად, მაგრამ ერთი რაღაც არ მესმის
როცა ქმნის აბსტრაქტლისტის ობიექტს და იქვე აკეთებს აბტრაქტული მეთოდების იმპლემენტაციას, ეს ობიექტი საიდან იმახსოვრებს იმ მასივის რეფერენსს a_ს ? (რომელსაც მერე get/set მეთოდებში იყენებს ? )

უფრო მარტივად დავსვამ კითხვას :
როცა ანონიმური კლასის ობიექტს ვქმნი მეთოდში, და ამ კლასის
მეთოდები იყენებენ გარე მეთოდის რეფერენს ცვლადებს (რომელიც როგორც ჩანს final უნდა იყოს), რანაირად იმახსოვრებს ამ კლასის ობიექტი იმ რეფერენსებს ?