class A {
    public static void fun(B b) {
    }
}

abstract class B {
    public abstract void funB();
}
---------------
class C extends B {
     public void funB() {}
}

main() {
    B b = new C();
    A.fun(b);
}

想问一下这些代码都是什么关系，看不懂啊

A类中有个静态方法，需要传递一个B类型的对象，但B是抽象类，不能实例化，而C继承了B，且实现了B中的抽象方法，所以可以传递一个C类的实例；
B类是一个抽象类，里面有一个抽象方法，B类不能自己实例化；
C类继承了B类，且实现了方法
在main方法中，调用A.fun，要传入对象B b = new C();

class A {
    public static void fun(B b) {  //当要调用类A，fun函数时， 必须传给他一个类型为B类的参数！ 通过，实例化B类对象得出这个参数！
    }
}


abstract class B {
    public abstract void funB();
}
---------------
class C extends B {//C类继承了B类！
     public void funB() {}
}

main() {
    B b = new C();由于，C类继承了B类，所以，可以通过，C类，实例化，出B类的这个对象b！
    A.fun(b);//由于，A类的fun(参数)这个方法，只能接受，B 这个类型的参数！（一般，接受类为类型参数的方法，接收的我学过的只有，实体类！或者有构造方法的类！其他的我还没用到过！）
}

C继承B，并覆写B的方法。B b=new C是创建子类对象，并向上转型（即父类引用指向子类对象），A.fun(b)是b对象调用A类的方法。

class A {
    public static void fun(B b) {
    }
}

abstract class B {
    public abstract void funB();
}
---------------
class C extends B {
     public void funB() {}
}

main() {
    B b = new C();
    A.fun(b);
}
A是一个工具类，有静态方法，可以静态调用，
B是一个抽象类，有一个抽象方法，该类不可以实例化，
C是一个普通的类，继承了抽象类B并覆盖了抽象方法funB（）。
在主方法中，B b=new C（）；是通过父类类型创建子类对象，用到多态特性，A.fun（b)是用类名调用静态方法。

这个代码是先从C继承B,然后看main方法中B b = new C();这个是向下转型，然后就是A.fun(b);方法，这个就是从A类中开始，这里给你一些抽象类的资料
通过继承它实现多态，后期绑定，可以为将来要实现的东西做好接口，实现重用性，
例如：
abstract class A {
    public abstract void doSomething();
}

class B extends A {
    public void doSomething() {
        System.out.println("do B");
    }
}

class C extends A {
    public void doSomething() {
        System.out.println("do C");
    }
}

public class Test {
    public static void main(Stringp[] args) {
        A a1 = new B();
        A a2 = new C();
        B b = new B();
        C c = new C();
        doSomething(a1); //这里
        doSomething(a2); //这里
         doSomething(b); //这里，如果下面的方法不是用抽象类作参数，比如用C c做参数，这里会有什么问题？
         doSomething(c); //这里
    }

    public static void doSomething(A a) {//这里，用抽象类，为什么，自己思考
        a.doSomething();
    }
}

C继承了B，在main方法中B b=new C();是用了多态（编译看左边，运行看右边）,然后在调用A类的方法，给他传个B的类型或者B的子类，这里就传的C