//第一段代码。
abstract class Animal
{
        public abstract void eat();
}

class Cat extends Animal
{
        public void eat()
        {
                System.out.println("吃鱼");
        }

        public void catchMouse()
        {
                System.out.println("抓老鼠");
        }
}

class Dog extends Animal
{
        public void eat()
        {
                System.out.println("吃骨头");
        }

        public void kanJia()
        {
                System.out.println("看家");
        }
}

class Pig extends Animal
{
        public void eat()
        {
                System.out.println("吃饲料");
        }

        public void gongDi()
        {
                System.out.println("拱地");
        }
}

class DuoTaiDemo1
{
        public static void main(String[] args)
        {
                funcation(new Dog());
                /*
                Cat c1 = new Cat();
                //c.eat();
                //c.catchMouse();
                funcation(c1);

                //Dog d1 = new Dog();
                funcation(new Dog());

                Pig p = new Pig();
                p.eat();
                */
               
               
        }
               

        public static void funcation(Cat c)
        {
                c.eat();
        }

        /*
        public static void funcation(Dog d)
        {
                d.eat();
        }
        */
}


1，上面为什么在主函数里面不能这样调用：funcation(new Dog1());？
但是funcation(d)却可以呢，为什么d1却是可以的呢。
2，上面的Cat,Dog,里面的特有方法可以私有吗？即private。
3，funcation加static是不是因为要被主函数调用，因为主函数是静态的，
所以它也要加静态的？

//第二段代码。
abstract class Student
{
        public abstract void study();
        
        public void sleep()
        {
                System.out.println("躺着睡");
        }
}


class DoStudent
{
        public void doSome(Student s)//为什么这里加不加静态都可以？都可以运行成功。
        {
                s.study();
                s.sleep();
        }
}

class BaseStudent extends Student
{
        public void study()
        {
                System.out.println("base study");
        }

        public void sleep()
        {
                System.out.println("坐着睡觉");
        }
}

class AdvStudent extends Student
{
        public void study()
        {
                System.out.println("adv studay");
        }
}

class DuoTaiDemo3
{
        public static void main(String[] args)
        {
               

                DoStudent ds = new DoStudent();
                ds.doSome(new BaseStudent());
                ds.doSome(new AdvStudent());

               


                //BaseStudent bs = new BaseStudent();
                //doStudent(new BaseStudent());
               
                //doStudent(new AdvStudent());

                //bs.study();
                //bs.sleep();
                /*
                AdvStudent as = new AdvStudent();
                as.study();
                as.sleep();
                */
        }
        /*
        public static void doStudent(BaseStudent bs)//这里不加静态就会报错。这是为什么呢？
        {
                //BaseStudent bs = new BaseStudent();
                bs.study();
                bs.sleep();
        }

        
        
        public static void doStudent(AdvStudent as)
        {
                as.study();
                as.sleep();
        }
        */
}


//上面的主函数调用自己类中的方法时候要加静态，而调用外部类的时候加不加都行呢，为什么？

1.funcation(new Dog1());没有定义Dog1类所以不能调用
2.可以
3.静态代码块static{}  ：用于给类初始化。静态方法在类加载的时候就已经加载，可以用类名直接调用。
4.执行main时，还没有创建类的对象，需要加static修饰，调用外部类的方法时对象在堆中已经创建，可以访问成员方法，如果没有创建类的方法也可以调用，在方法前加static不需要实例化就可以被调用

第一段代码：
1> 代码中无名为Dog1的类，所以编译器找不到它，无法通过编译。function(d1)可以，因为d1 指向了一个 Dog 类的对象。function(d)，不可以吧，没发现哪儿定义了d啊。
2>Cat,Dog类不是抽象类，特有方法可以私有。
3>定义为静态的话可以直接调用，如果不是静态，则必须实例化一个本类的对象调用，比如： new DuoTaiDemo1().function(d);
第二段代码：
dosome()方法都是DoStudent类创建的对象调用的，如下；
DoStudent ds = new DoStudent();
                ds.doSome(new BaseStudent());
                ds.doSome(new AdvStudent());
doStudent(new BaseStudent()); 这样调用时，方法前面没有任何对象，而静态方法可以这样调用。
如果改变方法的定义，如下
public  void doStudent(BaseStudent bs)
        {
                //BaseStudent bs = new BaseStudent();
                bs.study();
                bs.sleep();
        }
则必须实例化一个本类的对象来调用： new DuoTaiDemo3().doStudent(new BaseStudent());

我觉得这个主要是初始化的顺序决定的，先初始化的不能调用在它之后才初始化的。
静态方法随着类的加载而完成初始化，普通成员方法在创建对象时才完成初始化话。所以静态方法可以在没有创建对象时被调用，普通方法只有在所属的类创建对象后，通过对象调用。