第一段。
abstract class Student
{
        public abstract void study();

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

class DoStudent
{
        public void funcation(Student stu)
        {
                stu.study();

                stu.sleep();
        }
}

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

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

class AdvanceStudent extends Student
{
        public void study()
        {
                System.out.println("advance stuay");
        }
}

class DuoTaiDemo
{
        public static void main(String[] args)
        {        
                /*
                new BaseStudent().study();// 1，
                new BaseStudent().sleep();//这里这样调用的话和1，是不是一个new BaseStudent()???
                */

                new DoStudent().funcation(new BaseStudent());

                //DoStudent ds = new DoStudent();

                //ds.funcation(new BaseStudent());
        }
}




第二段。
class InnerTest
{
        public static void main(String[] args)
        {
                Test.function().method();
        }
}


interface Inter
{
        void method();
}

class Test
{
        //补足代码。通过匿名内部类。
        /*
        static class Inner implements Inter
        {
                public void method()
                {
                        System.out.println("method run");
                }
        }
        */

        static Inter function()
        {
                return new Inter()//为什么这里返回的是new Inter?上面的Inner不是静态的吗？那怎么还可以new呢？好，我明白了，但是
                                //为什么不可以返回Inner呢？静态不是可以用类名直接调用吗？内部类局部不可以定义静态？
                {
                        public void method()
                        {
                                System.out.println("method run");
                        }
                };
        }

}

第三段。

class Fu
{
        boolean show(char a)
        {
                System.out.println(a);
                return true;
        }
}
class Demo extends Fu
{
        public static void main(String[] args)
        {
                int i=0;
                Fu f=new Demo();
                Demo d=new Demo();
                for(f.show('A'); f.show('B')&&(i<2);f.show('C'))
                {
                        i++;
                        d.show('D');
                }        
        }
        boolean show(char a)
        {
                System.out.println(a);
                return false;//这里return fasle对该程序的运行没有什么阻碍吗？  在打印一个A之后独到return false没有影响？ 然后在独到f.show('B')
                                打印个B之后，是假所以程序结束了。我的问题是为什么在打印A之后程序读到false是怎么一回事呢？希望具体点。
        }
}


第四段。

interface A{}
class B implements A
{
        public String test()
        {
                return "yes";
        }
}
class Demo
{
        static A get()
        {
                return new B();
        }
        public static void main(String[] args)
        {
                A a=get();//这是怎么调用的，求详细解释。直接可以指向？？？
                System.out.println(a.test());
        }
}



第五段。
class Demo
{
         int show(int a,int b){return 0;}
}
下面那些函数可以存在于Demo的子类中。        


private int show(int a,long b){return 0;}//可以，和父类不是一个函数。没有覆盖，相当于重载。

这个可以？？ private修饰，权限够？？如果这个可以下面的又算什么呢。

B.private int show(int a,int b){return 0;}//不可以，权限不够。  

一、new BaseStudent().sleep();//这里这样调用的话和1，是不是一个new BaseStudent()???//显然不是了，new就是又新创建了一个对象  
二、要求是通过匿名内部类补足代码，所以一定要有匿名内部类          
三、f.show('B')&&(i<2),//f.show('B')调用的是子类的方法所以返回false
四、A a=get();//调用的是本类Demo的get()方法，这个方法返回的是B类的对象，相当于A a=new B();
五、private int show(int a,long b){return 0;}//可以，和父类不是一个函数。没有覆盖，相当于重载。
这个可以？？ private修饰，权限够？？如果这个可以下面的又算什么呢。//由于参数列表和父类的不一样，所以不是一个函数，修饰符就没了限制
B.private int show(int a,int b){return 0;}//不可以，权限不够。//这个方法和父类的一模一样，是覆盖，但是修饰符权限比父类的小，所以不可以。

第一段。
abstract class Student
{
        public abstract void study();

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

class DoStudent
{
        public void funcation(Student stu)
        {
                stu.study();

                stu.sleep();
        }
}

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

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

class AdvanceStudent extends Student
{
        public void study()
        {
                System.out.println("advance stuay");
        }
}

class DuoTaiDemo
{
        public static void main(String[] args)
        {        
                /*
                new BaseStudent().study();// 1，
                new BaseStudent().sleep();//这里这样调用的话和1，是不是一个new BaseStudent()???
                */
                                           //不是一个new BaseStudent()，当对一个对象的方法只进行一次调用 时用匿名对象比较简化，当对对象的多个方法进行调用必须给对象起一上名字，你这里new出的是二个对象 ，上面调用 的是一个匿名对象的study方法，下面是另一个匿名对象的sleep方法。                new DoStudent().funcation(new BaseStudent());

                //DoStudent ds = new DoStudent();

                //ds.funcation(new BaseStudent());
        }
}




第二段。
class InnerTest
{
        public static void main(String[] args)
        {
                Test.function().method();
        }
}


interface Inter
{
        void method();
}

class Test
{
        //补足代码。通过匿名内部类。
        /*
        static class Inner implements Inter
        {
                public void method()
                {
                        System.out.println("method run");
                }
        }
        */

        static Inter function()
        {
                return new Inter()//为什么这里返回的是new Inter?上面的Inner不是静态的吗？那怎么还可以new呢？好，我明白了，但是
                                //为什么不可以返回Inner呢？静态不是可以用类名直接调用吗？内部类局部不可以定义静态？（Inner是一个类，怎么可以返回一个类呢，只能返回一个类的对象，所以要new一个Inner的对象出来，因为他们在同一个类中，function()又不是外部类中的，所以不用加上类调用 了，直接new就行了）                {
                        public void method()
                        {
                                System.out.println("method run");
                        }
                };
        }

}

第三段。

class Fu
{
        boolean show(char a)
        {
                System.out.println(a);
                return true;
        }
}
class Demo extends Fu
{
        public static void main(String[] args)
        {
                int i=0;
                Fu f=new Demo();
                Demo d=new Demo();
                for(f.show('A'); f.show('B')&&(i<2);f.show('C'))
                {
                        i++;
                        d.show('D');
                }        
        }
        boolean show(char a)
        {
                System.out.println(a);
                return false;//这里return fasle对该程序的运行没有什么阻碍吗？  在打印一个A之后独到return false没有影响？ 然后在独到f.show('B')
                                打印个B之后，是假所以程序结束了。我的问题是为什么在打印A之后程序读到false是怎么一回事呢？希望具体点。（因为Demo继承了Fu。而且重写了父类的show()方法，f是一个父类引用的子对象，它在编译的时候要看引用型变量，就是=左边的，但运行时先看子类，所以是运行的子类中的show方法，而子类中的show方法返回的是false，有个总结：在多态中非静态成员函数的特点：在编译时期参阅引用型变量所属的类中是否有调用的方法，如果有编译成功，没有，编译失败。在运行时期参阅对象所属的类中是否有调用的方法，简单一句话就是编译看左边，运行看右边）        }
}


第四段。

interface A{}
class B implements A
{
        public String test()
        {
                return "yes";
        }
}
class Demo
{
        static A get()
        {
                return new B();
        }
        public static void main(String[] args)
        {
                A a=get();//这是怎么调用的，求详细解释。直接可以指向？？？
                System.out.println(a.test());（因为A是一个接口，a是一个接口的对象指向了get方法，而get方法运行后的结果是一个new 的B的对象，所以就相当于是a指向一个B的对象，也就是多态）        }
}



第五段。
class Demo
{
         int show(int a,int b){return 0;}
}
下面那些函数可以存在于Demo的子类中。        


private int show(int a,long b){return 0;}//可以，和父类不是一个函数。没有覆盖，相当于重载。

这个可以？？ private修饰，权限够？？如果这个可以下面的又算什么呢。

B.private int show(int a,int b){return 0;}//不可以，权限不够。
（上面那个是重载，函数的参数不同。而下面这个参数一样方法一样是重写，重写子父类方法要一模一样才行，而这里是私有的，上面是默认的，所以权限不够了）