第一段。
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;}//不可以，权限不够。 作者: 李伟 时间: 2012-6-28 03:46
一、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;}//不可以，权限不够。//这个方法和父类的一模一样，是覆盖，但是修饰符权限比父类的小，所以不可以。作者: 孙飞 时间: 2012-6-28 07:48
第一段。
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;}//不可以，权限不够。
（上面那个是重载，函数的参数不同。而下面这个参数一样方法一样是重写，重写子父类方法要一模一样才行，而这里是私有的，上面是默认的，所以权限不够了）