java子类重写父类带泛型的方法

特殊变量super

* 使用特殊变量super提供对父类的访问

* 可以使用super访问父类被子类隐藏的变量或覆盖的方法

* 每个子类构造方法的第一条语句都是隐含的调用super,如果父类没有这种形式的构造函数就会报错.

code:

class Animal

{

int height,weight

Animal()

{

System.out.println("Animal construct")

}

void eat()

{

System.out.println("Animal eat!")

}

void sleep()

{

System.out.println("Animal sleep!")

}

void breathe()

{

System.out.println("Animal breathe!")

}

}

class Fish extends Animal

{

Fish()

{

System.out.println("Fish construct")

}

void breathe() //override method breathe()

{

System.out.println("Fish bubble")

}

}

class DoMain

{

public static void main(String[] args)

{

//Animal an=new Animal()

Fish fn=new Fish()

//an.breathe()

//fn.breathe()

//fn.height=30

//fn.weight=20

}

}

输出结果:

F:\Java Develop>javac Animal.java

F:\Java Develop>java DoMain

Animal construct

Fish construct

必须重写才能使用搜索

下面一个子类继承泛型父类的例子，可以参考一下：

// 父类是一个泛型

class Parent<T> {

private T val

public T getVal() {

return val

}

public void setVal(T val) {

this.val = val

}

}

class Child1 extends Parent<Integer> {

}

class Child2 extends Parent<String> {

}

public class App {

public static void main(String[] argv) {

Child1 c1 = new Child1()

c1.setVal(123456)

System.out.println(c1.getVal())

Child2 c2 = new Child2()

c2.setVal("abcdef")

System.out.println(c2.getVal())

}

}

其实也不一定会当成 Object。如果没有指定类型，会把类型当成允许的最大类型。

java 泛型可以指定一个上限，如果不制定，上限默认是 Object，因为 Object 是所有类的父类。

// 上限是 Number，如果不指定类型，默认会当成 Number，而不是 Object

public class Test<E extends Number> {

}

因为不知道你需要的类型是什么，所以要最大限度的去容纳你的类型，即把类型当成允许的最大类型。java 子类可以向父类自动转型。

---