რომელი მეთოდი ვერ იქნება ობიექტზე ორიენტირებულ პროგრამირებაში გადაწერილი?

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

სხვა ენებში, მაგალითად Java ან C#, არ არსებობს "მომხმარებლის" მეთოდები, რომლებიც ტრადიციულად ვერ იქნება გადაწერილი, რადგან ნებისმიერი საჯარო ან დაცული (!) მეთოდი, რომელიც არ არის მონიშნული როგორც final (Java) ან sealed (C#), შეიძლება იყოს გადაწერილი. თუმცა, შეიძლება ითქვას, რომ კონსტრუქტორები არიან განსაკუთრებული ტიპის "მეთოდები", რომლებიც ჩვეულებრივ მნიშვნელობაში ვერ იქნება გადაწერილი: შეუძლებელია გამოაცხადო მეთოდი იგივე სახელით და სიგნატურით შვილობილი კლასში, რომელიც შეცვლის მშობლის კონსტრუქტორს. შვილობილი კლასი შეიძლება ჰქონდეს საკუთარი კონსტრუქტორები, რომლებიც, თავის მხრივ, იძახიან მშობლის კონსტრუქტორებს super (Java) ან : base (C#) საშუალებით.

class Parent {
    Parent() {
        System.out.println("მშობლის კონსტრუქტორი");
    }
    void method() {
        System.out.println("მშობლის მეთოდი");
    }
}

class Child extends Parent {
    Child() {
        // მშობლის კონსტრუქტორის ღიად გამოძახება საჭირო არაა,
        // თუ პარამეტრები არ არის, ის ავტომატურად გამოიძახება.
        System.out.println("შვილის კონსტრუქტორი");
    }
    @Override // მეთოდის გადაწერა შესაძლებელია
    void method() {
        System.out.println("შვილის მეთოდი");
    }
}

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