Java面向对象练习_如下程序的运行结果为:( )。 interface a { } class c { } class

1.写出程序结果：

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');f.show('C')){ 
			i++;
			d.show('D');
		}
	}
	boolean show(char a){
		System.out.println(a);
		return false;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

运行结果：

for循环的表达式：
for(表达式1;表达式2;表达式3){
    表达式4;
}
执行的顺序为：
1）第一次循环(初始化循环)：1-2-4-3
首先执行表达式1（一般为初始化语句），再执行表达式2（一般为条件判断语句），判断表达式1是否符合表达式2的条件，如果符合，则执行表达式4再执行表达式3，否则停止执行。
2）下次的循环：2-4-3
首先执行表达式2，判断表达式3是否符合表达式2的条件；如果符合，继续执行表达式4，否则停止执行，最后执行表达式3.如果往复，直到表达式3不再满足表达式2的条件。

总结：总的来说，执行顺序是一致的，先进行条件判断（表达式2），再执行函数体（表达式4），最后执行表达式3。如此往复，区别在于，条件判断的对象，在第一次判断时，是执行表达式1，初始化对象，后续的判断对象是执行后的结果（表达式3）。

---

2.写出程序结果：

interface A
{
}

class B implements A
{
	public String test(){
		return "yes";
	}
}

class Demo
{
	static A get (){  //编写一个返回值类型为A的方法get，即返回A类型的B对象。
		return new B();
	}
	public static void main(String[] args){
		A a=get(); //多态，父类引用子类对象
		System.out.println(a.test());
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运行结果：编译失败，接口A中没有定义test方法。

---

3.写出程序结果：

class Super
{
	int i=0;
	public Super(String a){
		System.out.println("A");
		i=1;
	}
	public Super(){
		System.out.println("B");
		i+=2;
	}
}

class Demo extends Super
{
	public Demo(String a)
	{
		System.out.println("C");
		i=5;
	}
	public static void main(String[] args)
	{
		int i=4;
		Super d=new Demo("A");
		System.out.println(d.i);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

运行结果：

1. 根据子类的实例化过程，子类中所有的构造函数默认都会访问父类中空参数的构造函数。因为每一个构造函数的第一行都有一条默认的语句super()。
2. 所以Demo构造函数会先访问super();即打印B，父类i变为2。
3. 父类初始化之后，到子类初始化，所以打印C并且i从2变为5。

---

4.补足代码：

interface Inter
{
	void show(int a,int b);
	void func();
}
class Demo
{
	public static void main(String[] args){
	//补足代码，调用两个函数，要求使用匿名内部类
	}
}
1
2
3
4
5
6
7
8
9
10
11

interface Inter
{
	void show(int a,int b);
	void func();
}
class Demo
{
	public static void main(String[] args){
		Inter in =new Inter(){
			public void show(int a,int b){
				System.out.println(a+" "+b);
			}
			public void func(){
				System.out.println("haha");
			}
		};
		in.show(1,2);
		in.func();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行结果：

---

5.写出程序结果

class TD
{
	int y=6;
	class Inner
	{
		static int y=3;
		void show(){
			System.out.println(y);
		}
	}
}

class TC
{
	public static void main(String[] args){
		TD.Inner ti=new TD().new Inner();
		ti.show();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

运行结果：编译失败。非静态内部类中不能定义静态成员。如果内部类中出现静态成员，则该内部类也必须被静态修饰。

---

6.写出错误答案错误的原因，用单行注释的方式。

class Demo{
	int show(int a,int b);
}
1
2
3

1. public int show(int a,int b){return 0};
   正确。覆盖。
2. private int show(int a,int b){return 0};
   错误。权限不够。
3. private int show(int a,long b){return 0};
   正确。参数类型不同，相当于重载。
4. public short show(int a,int b){return 0;}
   错误。函数返回值类型不同，不能存在于子类中，不然编译会报错。
5. static int show(int a,int b){return 0};
   错误。静态只能调用静态。

---

7.写出程序结果：

class Demo
{
	public static void func(){
		try{
			throw new Exception();//抛出了异常，执行不到下面的语句
			/*
			改为showExce()不会出现编译错误;
			即调用一个有可能出错的方法，但是也有可能没有出错（因为方法内的语句被封装无法知道），所以之后的语句也有可能可以执行。
			*/
			System.out.println("A");
		}
		catch(Exception e){
			System.out.println("B");
		}
	}

	public static void showExce() throws Exception{//声明可能会出现异常
		throw new Exception(); //把抛出异常封装在方法当中，外部不了解内部情况
	}

	public static void main(String[] args){
			try{
				func();
			}
			catch(Exception e){
				System.out.println("C");
			}
			System.out.println("D");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

输出结果：编译失败

---

8.判断

class Demo
{
	public void func(){
		//位置1
		new Inner();
	}
	class Inner
	{
	}
	public static void main(String[] args){
		Demo d= new Demo();
		//位置2
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• A.在位置1写 new Inner();//正确
• B.在位置2写 new Inner();//错误，主函数是静态的，所以如果内部类要被主函数调用需要static修饰
• C.在位置3写 new d.Inner();//错误，格式不正确。相当于new new Demo().Inner();应该为：d.new Inner()
• D.在位置4写 new Demo.Inner();//错误，Demo不是静态的。应该为：new Demo().new Inner();

---

9.补足代码：

interface Test
{
	void func();
}
class Demo
{
	public static void main(String[] args){
		//补足代码；（匿名内部类）	
	}
	void show(Test t){
		t.func();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

实现：

interface Test
{
	void func();
}
class Demo
{
	public static void main(String[] args){//主函数为静态，不能直接调用show()
		new Demo().show(new Test() 
		{
			public void func(){};  
		});					
	}
	void show(Test t){
		t.func();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1. 因为主函数为静态的所以不能直接调用show方法，只能通过对象调用。即new Demo().show()
2. 但是show方法里的参数是接口，所以需要传递一个接口类型的对象。我们看到接口只有一个方法，所以可以传匿名内部类。即new Demo().show(new Test(){});
3. 再实现接口的func方法，就完成了对非静态函数show的调用：

new Demo().show(new Test() 
		{
			public void func(){};  
		});		
1
2
3
4

对于可以在主函数中通过对象调用非静态函数：

当类被加载的时候静态方法和静态属性（全局静态变量）被加载到内存中，但此时没有被实例化的类在内存中是不存在的，所以静态方法无法访问非静态的成员。在类被实例化的时候，在内存中会给这个类开辟一些内存空间保存这个类的对象，这个时候就可以用静态方法去访问非静态的全部变量。

---