class base
{
public void superMethod()
{
System.out.println("Hello i m a super class method");
}
}
class der extends base
{
super.superMethod();// error identifier expected
}
i need to call a base class method without overloading it into derive class please provide me solution for it
You don't have to do anything apart from calling the method. You do need to be inside a instance method, constructor or a instance initializer block to do that though. You only need the super keyword if you have to make a distinction when you are overriding the method.
class Base
{
public void superMethod()
{
System.out.println("Hello i m a super class method");
}
}
class Der extends base
{
public void method()
{
superMethod();// error identifier expected
}
public void superMethod()
{
super.superMethod()
}
}
You can't put code inside a method. The following should work:
class base {
public void superMethod() {
System.out.println("Hello i m a super class method");
}
}
class der extends base {
public void someMethod() {
super.superMethod();
}
}
You don't need to do anything special. Just call the method in the base class. Since you have not overloaded it, it will automatically call the base class method.
You can call the super class method following the below example.
class base
{
public void superMethod()
{
System.out.println("hello i m a super class method");
}
}
class der extends base
{
{
super.superMethod();
}
}
class Supertest
{
public static void main(String args[])
{
new der();
}
}
class base{
public void superMethod(){
System.out.println("hello i am super class method");
}
}
class der extends base{
void supermethod(){
super.superMethod();
System.out.println("hello this is der class");
}
}
class mainclass{
public static void main(String[] args){
der r=new der();
r.supermethod();
}
}
Related
Let me describe my intention with an example,
class Base {
public void sayHi() {
System.out.println("Hi");
}
}
class ChildOne extends Base {
public void sayBye() {
System.out.println("Bye-1");
}
}
class ChildTwo extends Base {
public void sayBye() {
System.out.println("Bye-2");
}
}
public class MainClass {
public static <T extends Base> void genericFunction(T child) {
child.sayBye();
}
public static void main(String[] args) {
ChildOne childOne = new ChildOne();
ChildTwo childTwo = new ChildTwo();
genericFunction(childOne);
genericFunction(childTwo);
}
}
This code is wrong. But my intention is the child class (some already existing classes in a project) which has similar properties between them are they extend the base class and have sayBye() member function.
Is there a way to pass all the child classes as parameter to a generic function and to call the member function sayBye() (as per this example)?
Sure, you can either create a common base class or common interface for all the classes that have a sayBye method.
Then you can change the type bound of your generic type parameter:
public static <T extends CommonInterface> void genericFunction(T child) {
child.sayBye();
}
or without generics:
public static void nonGenericFunction(CommonInterface child) {
child.sayBye();
}
You can bring common functionality together without adjusting the hierarchy by introducing an interface that defines it and creating empty classes extending the common objects.
class Base {
public void sayHi() {
System.out.println("Hi");
}
}
class ChildOne extends Base {
public void sayBye() {
System.out.println("Bye-1");
}
}
class ChildTwo extends Base {
public void sayBye() {
System.out.println("Bye-2");
}
}
// The common functionality I want to use.
interface Bye {
public void sayBye();
}
class ChildOneBye extends ChildOne implements Bye {
// Don't need anything here.
}
class ChildTwoBye extends ChildTwo implements Bye {
// Don't need anything here.
}
public static <T extends Bye> void genericFunction(T child) {
child.sayBye();
}
public void test(String[] args) {
Bye childOne = new ChildOneBye();
Bye childTwo = new ChildTwoBye();
genericFunction(childOne);
genericFunction(childTwo);
}
One way is to mark the base class as abstract and have an abstract method sayBye(). In this way you don't need to change anything else in your codebase.
abstract class Base {
public void sayHi() {
System.out.println("Hi");
}
public abstract void sayBye();
}
Another approach is to use interface ByeInterface and use it to call sayBye(). Here is the with the required changes.
interface ByeInterface {
void sayBye();
}
class Base {
public void sayHi() {
System.out.println("Hi");
}
}
class ChildOne extends Base implements ByeInterface {
public void sayBye() {
System.out.println("Bye-1");
}
}
class ChildTwo extends Base implements ByeInterface {
public void sayBye() {
System.out.println("Bye-2");
}
}
public class MainClass {
public static <T extends ByeInterface> void genericFunction(T child) {
child.sayBye();
}
public static void main(String[] args) {
ChildOne childOne = new ChildOne();
ChildTwo childTwo = new ChildTwo();
genericFunction(childOne);
genericFunction(childTwo);
}
}
This approach can be used if you can not mark your base class as abstract class. Using interface, you can even call it without using generic.
public static void nonGenericFunction(ByeInterface child) {
child.sayBye();
}
In Java, I use an anonymous class inside a class A which extends B. How can I access to B from this anonymous class? I can't use the keyword super, because this means super class of the anonymous class, not super class of A.
public class A {
void foo() {
System.out.println("Good");
}
}
public class B extends A {
void bar() {
Runnable r = new Runnable() {
#Override
public void run() {
foo(); // Bad: this call B.foo(), not A.foo()
// super.foo(); // Bad: "Method foo is undefined for type Object"
}
};
r.run();
}
#Override
void foo() {
System.out.println("Bad");
}
}
In run, you could change foo() to B.super.foo(); when I changed that and then ran B.bar() I get Good.
In such a case, you need to qualify this to capture the outer class, B
B.this.foo()
Or, in your case, as you want the super class, use
B.super.foo()
Relevant parts of Java Language Spec:
Qualified this
Accessing superclass members with super
Please call as fallows:
B.super.foo();
After this change B class looks as follows:
public class B extends A {
public static void main(String[] args) {
new B().bar();
}
void bar() {
Runnable r = new Runnable() {
#Override
public void run() {
B.super.foo(); // this calls A.foo()
}
};
r.run();
}
#Override
void foo() {
System.out.println("Bad");
}
}
How can I override instance methods of super class as static in subclass? I think this is impossible but is there any indirect way?
public class A {
public void test(){
System.out.println("");
}
}
public class B extends A{
public static void test(){//test() in B cannot override test() in A
//overriding method is static
}
}
You can't, since a static method is not an instance method. You could override the instance method with an instance method that calls the static method.
public class B extends A {
#Override
public void test(){
staticTest();
}
public static void staticTest() {
}
}
I'm not sure how much sense that would make though.
I have 3 classes. It seems basic question. But I can'nt find answer by googling.
public abstract class Test {
void t1()
{
System.out.println("super");
}
}
public class concret extends Test{
void t1()
{
System.out.println("child");
}
void t2()
{
System.out.println("child2");
}
}
public class run {
public static void main(String[] args) {
Test t=new concret();
t.t1();
}
}
How do I call abstract class t1 method? Since I cant create object from abstract class how do I call t1 in abstract class?
Thank you.
Either you create a concrete class which doesn't override the method, or within a concrete class which does override the method, you can call super.t1(). For example:
void t1()
{
super.t1(); // First call the superclass implementation
System.out.println("child");
}
If you've only got an instance of an object which overrides a method, you cannot call the original method from "outside" the class, because that would break encapsulation... the purpose of overriding is to replace the behaviour of the original method.
you should be able to do it using
Test test = new Test(){};
test.t1();
Abstract class means the class has the abstract modifier before the class keyword. This means you can declare abstract methods, which are only implemented in the concrete classes.
For example :
public abstract class Test {
public abstract void foo();
}
public class Concrete extends Test {
public void foo() {
System.out.println("hey");
}
}
See following tests:
public abstract class BaseClass {
public void doStuff() {
System.out.println("Called BaseClass Do Stuff");
}
public abstract void doAbstractStuff();
}
public class ConcreteClassOne extends BaseClass{
#Override
public void doAbstractStuff() {
System.out.println("Called ConcreteClassOne Do Stuff");
}
}
public class ConcreteClassTwo extends BaseClass{
#Override
public void doStuff() {
System.out.println("Overriding BaseClass Do Stuff");
}
#Override
public void doAbstractStuff() {
System.out.println("Called ConcreteClassTwo Do Stuff");
}
}
public class ConcreteClassThree extends BaseClass{
#Override
public void doStuff() {
super.doStuff();
System.out.println("-Overriding BaseClass Do Stuff");
}
#Override
public void doAbstractStuff() {
System.out.println("Called ConcreteClassThree Do Stuff");
}
}
public class Test {
public static void main(String[] args) {
BaseClass a = new ConcreteClassOne();
a.doStuff(); //Called BaseClass Do Stuff
a.doAbstractStuff(); //Called ConcreteClassOne Do Stuff
BaseClass b = new ConcreteClassTwo();
b.doStuff(); //Overriding BaseClass Do Stuff
b.doAbstractStuff(); //Called ConcreteClassTwo Do Stuff
BaseClass c = new ConcreteClassThree();
c.doStuff(); //Called BaseClass Do Stuff
//-Overriding BaseClass Do Stuff
c.doAbstractStuff(); //Called ConcreteClassThree Do Stuff
}
}
use keyword 'super' to do that
void t1()
{ super.t1();
System.out.println("child");
}
Make sure you use that in the overriden method though.
Your code seems to call t1(). However this is calling the concrete t1() because the abstract t1() has been overridden by the concrete class.
If you wish to call the abstract t1 method from main code, do not override the t1() in concrete.
Or you can create a method in the concrete class for example:
public void invokeSuperT1(){
super.t1();
}
Create an anonymous Inner class,
Abstract class:
abstract class Test{
abstract void t();
public void t1(){
System.out.println("Test");
}
}
Here is how to create anonymous inner class:
Test test = new Test() {
#Override
void t() {
//you can throw exception here, if you want
}
};
Call the class via the object created for abstract class,
test.t1();
An abstract class is used when we want that every class that inherited from our abstract class should implement that abstract method, so it is must to implement method otherwise it gives the compile-time error.
void t1()
{
super.t1; // means the parent methods
System.out.println("child");
}
For example: Bird class has method sing() and there other classes that inherited from it like the sparrow, Pigeon, Duck, so these all have sing method so we make Bird class Abstract and make the sing() method abstract in it so every child of bird that implements Bird class should have a method of sing() with its on implementation.
First Create abstarct class like as shown in link: Creating Abstract Class
Create Sub-Classs like as shown in link: Sub-class extending
Creating main method for executing this as show in link: Instanciate the subclass to access
Result as shown here: Result
Java 8 introduces default methods to provide the ability to extend interfaces without the need to modify existing implementations.
I wonder if it's possible to explicitly invoke the default implementation of a method when that method has been overridden or is not available because of conflicting default implementations in different interfaces.
interface A {
default void foo() {
System.out.println("A.foo");
}
}
class B implements A {
#Override
public void foo() {
System.out.println("B.foo");
}
public void afoo() {
// how to invoke A.foo() here?
}
}
Considering the code above, how would you call A.foo() from a method of class B?
As per this article you access default method in interface A using
A.super.foo();
This could be used as follows (assuming interfaces A and C both have default methods foo())
public class ChildClass implements A, C {
#Override
public void foo() {
//you could completely override the default implementations
doSomethingElse();
//or manage conflicts between the same method foo() in both A and C
A.super.foo();
}
public void bah() {
A.super.foo(); //original foo() from A accessed
C.super.foo(); //original foo() from C accessed
}
}
A and C can both have .foo() methods and the specific default implementation can be chosen or you can use one (or both) as part of your new foo() method. You can also use the same syntax to access the default versions in other methods in your implementing class.
Formal description of the method invocation syntax can be found in the chapter 15 of the JLS.
This answer is written mainly for users who are coming from question 45047550 which is closed.
Java 8 interfaces introduce some aspects of multiple inheritance. Default methods have an implemented function body. To call a method from the super class you can use the keyword super, but if you want to make this with a super interface it's required to name it explicitly.
class ParentClass {
public void hello() {
System.out.println("Hello ParentClass!");
}
}
interface InterfaceFoo {
public default void hello() {
System.out.println("Hello InterfaceFoo!");
}
}
interface InterfaceBar {
public default void hello() {
System.out.println("Hello InterfaceBar!");
}
}
public class Example extends ParentClass implements InterfaceFoo, InterfaceBar {
public void hello() {
super.hello(); // (note: ParentClass.super could not be used)
InterfaceFoo.super.hello();
InterfaceBar.super.hello();
}
public static void main(String[] args) {
new Example().hello();
}
}
Output:
Hello ParentClass!
Hello InterfaceFoo!
Hello InterfaceBar!
The code below should work.
public class B implements A {
#Override
public void foo() {
System.out.println("B.foo");
}
void aFoo() {
A.super.foo();
}
public static void main(String[] args) {
B b = new B();
b.foo();
b.aFoo();
}
}
interface A {
default void foo() {
System.out.println("A.foo");
}
}
Output:
B.foo
A.foo
You don't need to override the default method of an interface. Just call it like the following:
public class B implements A {
#Override
public void foo() {
System.out.println("B.foo");
}
public void afoo() {
A.super.foo();
}
public static void main(String[] args) {
B b=new B();
b.afoo();
}
}
Output:
A.foo
It depends on your choice whether you want to override the default method of an interface or not. Because default are similar to instance method of a class which can be directly called upon the implementing class object. (In short default method of an interface is inherited by implementing class)
Consider the following example:
interface I{
default void print(){
System.out.println("Interface");
}
}
abstract class Abs{
public void print(){
System.out.println("Abstract");
}
}
public class Test extends Abs implements I{
public static void main(String[] args) throws ExecutionException, InterruptedException
{
Test t = new Test();
t.print();// calls Abstract's print method and How to call interface's defaut method?
}
}