问题一：关于继承的问题

class A{
        public int i = 10;
}
class B extends A{

        public int i = 20;
}
public class Demo{
        public static void main(String[] args){
                B b = new B();
                A a = b;// 这一步什么意思，a.i结果为什么是10 呢？？这句是不是省略了点东西还是？
                System.out.println(b.i);
                System.out.println(a.i);
        
        }
}


问题二 ：判断题：
一个类如果实现了某个接口, 那么它必须重载该接口中的所有方法。 这句话为什么是 错误的？？

我是这样理解：接口都是抽象方法，子类实现接口，并覆盖接口中的全部抽象方法，建立子类对象，难道不是必须重载该接口所有方法么？？

问题一：关于继承的问题

class A{
        public int i = 10;
}
class B extends A{

        public int i = 20;
}
public class Demo{
        public static void main(String[] args){
                B b = new B();
                A a = b;// (A   a=b   也就是 A   a=new B()   这里是对象的多态特征；)                           这一步什么意思，a.i结果为什么是10 呢？？这句是不是省略了点东西还是？
                System.out.println(b.i);　　(B  b=new B(),  b.i调用的是成员变量，编译和运行时都看等号左边，所以，结果是:20)
                System.out.println(a.i);　　( A  a  =new B(), a.i调用的也是成员变量，同上。结果是：１０)
        
        }
}


问题二 ：判断题：
一个类如果实现了某个接口, 那么它必须重载该接口中的所有方法。 这句话为什么是 错误的？？
正确的说法是：一个类如果实现了某个接口, 那么它必须重写该接口中的所有方法。只有重写了接口中所有抽象方法的子类，才能够被实例化。

如果仍有问题，请继续追问，如果问题已解决，请将分类改为已解决，谢谢

J_hom 发表于 2013-4-1 22:00
给你看看我的笔记
态性的使用方法

建议你将代码写入代码框中，具体请看帖子：http://bbs.itheima.com/thread-42978-1-1.html

J_hom 发表于 2013-4-1 22:00
给你看看我的笔记
态性的使用方法

建议你将代码写入代码框中，具体请看帖子：http://bbs.itheima.com/thread-42978-1-1.html

第一个是多态的体现 第二个是重写

对着代码和你说吧

问题一：关于继承的问题

class A{
        public int i = 10;
}
class B extends A{

        public int i = 20;
}
public class Demo{
        public static void main(String[] args){
                B b = new B();
                A a = b;// 这一步什么意思，a.i结果为什么是10 呢？？这句是不是省略了点东西还是？
                 你创建了B类的对象，但使用的是他的父类A类的引用，父类引用指向子类对象，java的多态，此时使用a变量只能访问父类中的方法，和字段，打印的当然是10
                 父类和子类中都有一个字段i 创建对象的时候默认会调用父类的构造方法，父类和子类都有自己的字段i， A a = b相当于把变量向上转型了，先得到子类中的i的话
                 可以使用强制向下转型(B)a
                System.out.println(b.i);
                System.out.println(a.i);
        
        }
}
你的第二个问题，是覆写并不是重载，所谓的重载是指方法名相同，返回值类型相同，参数列表个数不同或参数个数不同，在同一个类中可以有重载的方法，在继承的父子类关系中有时也可以有重载关系

相当于A a=new B();这里是多态的体现.重载与覆盖是两个不同的概念,要分清分.

视频里面有详细的解释的。。。 a.i是A的对象，所以还是类A里面的值。。。
第二个：那句话是错误的。可以覆盖接口的方法，也可以不覆盖....
interface  A
{
xxx();
}
class B implements A
{
bbb();
}
这个是可以编译过去的

给你看看我的笔记
态性的使用方法

class A{

public void fun1(){

System.out.println("A------------>Method fun1()");

}

    public void fun2(){

System.out.println("A------------->Method fun2()");

}

};

class B extends A{

public void fun1(){

System.out.println("B------------->Method fun1()");

}

public void fun3(){

System.out.println("B------------->Method fun3()");

}

};

public class PolDemo01{

public static void main(String args[]){

   A a=new B();//对象向上转型

B b=(B)a;//对象向下转型

a.fun1();

a.fun2();

a.fun3();

}

}

以上运行结果是错误：在父类A中因为没有fun3()方法。

对象向下转型格式：A a=new B(); B b=(B)a;

对象向上转型格式: A a=new B();

对象向上转型调用fun1()方法，其实是调用子类B中的覆写方法fun1()方法，如果在父类A中没有fun3()方法，则编译将出现错误。

对象向下转型注意：如果子类B中覆写父类A中的方法，则运行是子类B中的覆写父类A的方法结果。

public class PolDemo01{

public static void main(String args[]){

  A a=new A();

  B b=(B)a;

}

b.fun1();

b.fun2();

b.fun3();

}

注意的是编译时没有出现错误，但运行结果出现异常。

Exception in thread "main" java.lang.ClassCastException: A cannot be cast to B

因为是通过父类A进行实例化对象的，然后再对象向下转型。

因为单独看父类A是找不到的任何关系的，然而通过子类B他可以找到父类A的，从而确定了它们之间的关系。所以说要确定向下转型

首先是确定向上转型关系。A a=new B();

多态性的应用

如果不调用多态性：

class A{

public void fun1(){

System.out.println("A---------------->Method fun1()");

}

public void fun2(){

System.out.println("A---------------->Method fun2()");

}

};

class B extends A{

public void fun1(){

System.out.println("B---------------->Method fun1()");

}

public void fun3(){

System.out.println("B---------------->Method fun3()");

}

}

class C extends A{

public void fun1(){

System.out.println("C----------------->Method fun1()");

}

public void fun4(){

System.out.println("C----------------->Method fun4()");

}

}

public class PolDemo02{

public static void main(String args[]){

fun(new B());

fun(new C());

         

  }

  public static void fun(B b){

    b.fun1();

  }

  public static void fun(C c){

    c.fun1();

  }

}

运行结果：

B---------------------->Method fun1()

C---------------------->Method fun1()

如果按照以上的设计思路，每增加一个子类，fun()方法就要重载一次，如果A有10000个子类呢？

此时，为了解决这样的问题就可以利用多态性设计思路：

class A{

public void fun1(){

System.out.println("A---------------->Method fun1()");

}

public void fun2(){

System.out.println("A---------------->Method fun2()");

}

};

class B extends A{

public void fun1(){

System.out.println("B---------------->Method fun1()");

}

public void fun3(){

System.out.println("B---------------->Method fun3()");

}

}

class C extends A{

public void fun1(){

System.out.println("C----------------->Method fun1()");

}

public void fun4(){

System.out.println("C----------------->Method fun4()");

}

}

public class PolDemo03{

public static void main(String args[]){

  fun(new B());

  fun(new C());//自动机制寻找父类A的子类的覆写方法。从而输出覆写父类的方法fun1();

}

public static void fun(A a){//通过对象向上转型

  a.fun1();

}

}

1.这是多态.B是A的子类.自动向上转型. 由于编译期声明的类型是A,所以运行时系统会优先去访问A的i字段.
2.接口中都是抽象方法,即使我们不写,系统也默认会添加上Abstract.所以接口实现类要复写之.
我觉得这句话的错误在于不是"重载",而是"重写".这是两个概念.不知道对不对.卤煮,仅供参考.