java的子类如何重写父类的方法?
java中重写父类的方法只需写出与父类一模一样的这个方法即可,包括方法名,参数类型,参数值,返回值。
事例代码如下:
public class Demo extends FDemo{
public static void main(String[] args) {
a();//运行输出b
}
static void a(){
System.out.println(“b”);
}
}
class FDemo{
static void a(){
System.out.println(“a”);
}
}
java重写父类方法后,原有的父类里面的实现全部清空,变为重写后的内容。
java语言中,子类如何覆写父类所定义的值?
你父类的的属性用的private(私有),这个是没办法直接继承使用的,有三种方法修改
一:你可以把修饰改为public(公有),这样在子类中就可以直接修改,如下:
Digimon:
public class Digimon {
public String mon;
public String name;
}
Patamon:
public class Patamon extends Digimon{
public Patamon(){
mon=”Angemon”;
}
}
二:给父类添加get,set方法,如下:
Digimon:
public class Digimon {
private String mon;
private String name;
public String getMon() {
return mon;
}
public void setMon( String mon ) {
this.mon = mon;
}
public String getName() {
return name;
}
public void setName( String name ) {
this.name = name;
}
Patamon:
public class Patamon extends Digimon{
public Patamon(){
setMon( “Angemon” );
}
}
}
三:给父类添加参数构造器(也需要添加get,set不然赋值了你也获取不到),如下:
Digimon:
public class Digimon {
private String mon;
private String name;
public Digimon() {
super();
}
public Digimon( String mon, String name ) {
super();
this.mon = mon;
this.name = name;
}
public String getMon() {
return mon;
}
public void setMon( String mon ) {
this.mon = mon;
}
public String getName() {
return name;
}
public void setName( String name ) {
this.name = name;
}
}
Patamon:
public class Patamon extends Digimon{
public Patamon(){
//调用父类构造器
super( “Angemon”, “豆豆” );
}
}
JAVA中子类重写父类的方法,怎么写,什么要求
1.父类的方法不能降级,同级的话就要覆盖,例如public方法不能在子类中被声明为protected或者private(子类重载除外),否则会有
Cannot reduce the visibility of the inherited method from Father的编译错误。
2.父类的方法可以任意升级,但升级只有两种方式,要么覆盖,要么重载,覆盖就是方法体完全一样,重载则是参数必须改变,方法名称不变。
import java.lang.reflect.Method;
class Father{
int a;
protected int b = 5;
protected void funcpro(){
//父类的保护方法,子类能够访问,但子类自身没有
System.out.println(“father funcpro”);
}
public void funcpub(){
//父类公有方法,子类直接继承
}
private void funcpri(){
//父类私有方法,子类不可见
}
}
public class TestOveride extends Father {
/**
* @param args
*/
//父类保护方法的重写
// public void funcpro(){
// //子类自己可以这样定义,将会覆盖父类protected方法
// System.out.println(“子类的func方法”);
// }
// protected void funcpro(){
// //ok
//}
// public short funcpro(){
// //illegal 父类的protected和public方法在子类中是可见的,试想一下,如果编译器认为这个方法体正确,
//那么子类调用funcpro的时候究竟调用哪个呢?这样没有能构成重载
// }
// private void funcpro(){
// //illegal
// }
private void funcpro(int a){
//这是方法重载,不会报错
System.out.println(“sun funcpro”);
}
//父类公有方法的重写
// private void funcpub(){
// //illegal:Cannot reduce the visibility of the inherited method from Father
// }
// protected void funcpub(){
// //illegal Cannot reduce the visibility of the inherited method from Father
// }
// public void funcpub(){
// //ok
// }
// public int funcpub(){
// //illegal 和父类的返回值不匹配
// }
// public int funcpub(int i){
// //ok 子类构成重载
// return 1;
// }
//父类私有方法的重写
// public void funcpri(){
// //ok
// }
// protected void funcpri(){
// //ok
// }
// private void funcpri(){
// //ok
// }
public static void main(String[] args) {
// TODO Auto-generated method stub
TestOveride testOveride = new TestOveride();
Class class1 = testOveride.getClass();
try {
Method[] methods = class1.getMethods();
System.out.println(“子类中的所有方法:”); //可以看到,并没有父类的funcpro方法
for(Method m:methods){
System.out.println(m);
}
System.out.println(“子类调用父类的protected 方法:”);
testOveride.funcpro();
System.out.println(“子类调用自己的func方法:”);
testOveride.funcpro(1);
System.out.println(“子类调用父类的字段”);
System.out.println(testOveride.b);
}catch(Exception e){
e.printStackTrace();
}
}
}