练习题

------- android培训、java培训、期待与您交流！ ----------

注：按Java规范书写程序代码，如果你认为程序有错误，请指出，并说明程序错误原因。

1，写出程序结果

public class Demo {
	public static void main(String[] args) {
		   try {
		 func();
    System.out.println("A");
	} catch (Exception e) {
		System.out.println("C");
	}
   System.out.println("D");
	}
	public static void func()throws Exception
	{
		try {
			throw new Exception();//抛出没处理，编译失败，如果func上声明了该异常，结果是？

		}finally  {
			System.out.println("B");
		}
	}
}

结果：抛出没处理，编译失败，如果func上声明了该异常，结果是？B C D

2，写出程序结果子类的实例化过程。

public class Demo2 extends Test
{
	Demo2()
	{
	 super();
	 System.out.println("demo");
	}
	public static void main(String[] args) {
	new Demo2();
new Test();
	}
}
class Test
{
Test()
{
System.out.println("Test");	
}
}

Test

Demo

Test

考的子类的实例化过程。

3，写出程序结果

interface A {}
class B implements A
{
  public String func()
  {
	  return "func";
  }
}
public class Demo3 {
	public static void main(String[] args) {
	  A a=new B();//多态
  System.out.println(a.func());
	}
}

编译失败，A接口中并未定义func方法。

4，写出程序结果

public class Demo4 extends Fu
{
	public static void main(String[] args) {
int i=0;
Fu f=new Demo4();
Demo4 d=new Demo4();
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;
  }
}
class Fu
{
boolean show(char a)
{
   System.out.println(a);
   return true;
}
}

结果是A B

5，写出程序结果

interface A{}
class B implements A
{
   public String test()
   {
	   return "yes";
   }
}
public class Demo5 {
	static A get()
	{
		return new B();
	}
	public static void main(String[] args) {
	   A a =get();
   System.out.println(a.test());
	}
}

编译失败，因为A接口中没有定义Test方法

6，写出程序结果

public class Demo6 extends Super
{
	public Demo6(String a)
	{
		System.out.println("C");
		i=5;
	}
	public static void main(String[] args) {
		int i=4;
Super d=new Demo6("A");
System.out.println(d.i);
	}
}
class Super
{
 int i=0;
 public Super(String a)
 {
	 System.out.println("A");
	 i=1;
 }
 public Super()
 {
	 System.out.println("B");
	 i+=2;
 }
}

B C 5
7，

 public class Demo7 {
	public static void main(String[] args) {
	//补足代码，调用两个函数，要求用匿名内部类
	Inter in=	new Inter()
		{
			public void show(int a,int b)
			{
			}
			public void func()
			{
			}
		};
		in.show(4, 5);
		in.func();
	}
}
interface Inter
{
 void show(int a,int b);
 void func();
}
<p align="left">
 </p>

8,写出程序结果

public class Demo8 {
	public static void main(String[] args) {
	TD.Inner ti=new TD().new Inner();
ti.show();
	}
}
class TD
{
  int y=6;
  class Inner
  {
	  static int y=3;
	  void show()
	  {
		  System.out.println(y);
	  }
  }
}

编译失败，非静态内部类中不可以定义静态成员，

内部类中如果定义了静态成员，该内部类必须被静态修饰，

9, 选择题，写出错误答案错误的原因，用单行注释的方式。

下面那些函数可以错字于demo的子类中

    int show(int a,int b){return 0;}

/*  public int show(int a,int b){return 0;}

     可以，覆盖

     private int show(int a,int b){return 0;}

     不可以，权限不够

    private int show(int a,long b){return 0;}

    可以，和父类不是一个函数，没有覆盖，相当于重载

     public short show(int a,int b){return 0;}

    不可以，因为该函数，不可以和给定函数出现在同一类中或子父类中

    static int show(int a,int b){return 0;}

    不可以静态只能覆盖静态。*/

10, 写成this关键字的含义，final有那些特点

      this：代表本类对象，哪个对象调用this所在函数，this就代表那个对象

      final

      1，修饰类，变量｛成员变量，静态变量，局部变量｝，函数

      2，修饰的类不可以被继承，

      3，修饰的函数不可以被覆盖

      4，修饰的变量是一个常量，只能赋值一次，

      5，内部类只能访问局部变量中final修饰的变量。

11, 写出程序结果

public class Demo11 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
   Fu1 f=new Zi();
		   Zi z=new Zi();
		   System.out.println(f.num);
		   System.out.println(z.num);
		   f.show();
		   z.show();
	}
}
class Fu1
{
int num=4;
void show()
{
System.out.println("showFu");	
}
}
class Zi extends Fu1
{
  int num=5;
  void show()
  {
	  System.out.println("showZi");
  }
}

//打印结果是

4

5

showZi

showZi

12,

interface A1
{
 void show();	
}
interface B1
{
void add(int a,int b);	
}
class C implements A1,B1
{
//程序代码	
	private int a,b;
	//private int sum;
	public void add(int a,int b)
	{
		this.a=a;
		this.b=b;
		//sum=a+b;
	}
	public void show()
	{
		System.out.println(a+b);
//		System.out.println(a+b);
	}
}
public class Demo12 {
	public static void main(String[] args) {
	  C c=new C();
  c.add(4,2);
  c.show();//通过该函数打印以上两个数的和。
	}
}

13, 写出程序结果

public class Demo13 {
	public static void main(String[] args) {
	try
{  showExce();
	System.out.println("A");
}
catch(Exception e)
{
	System.out.println("B");
}
finally
{
  System.out.println("C");	
}
System.out.println("D");
	}
	public static void showExce()throws Exception
	{
		throw new Exception();
	}
}
// B C D

14, 写出程序结果

public class Demo14  extends Super1{
	public Demo14(String s)
	{
		i=2;
	}
	public static void main(String[] args) {
	   Demo14 d=new Demo14("yes");
   System.out.println(d.i);
	}
}
class Super1
{
int i=0;
Super1(){}//空参数的构造函数。
public Super1(String s)
{
 i=1;	
}
}

编译失败，因为父类中缺少空参数的构造函数或者子类应该通过super语句指定要调用的父类中的构造函数。

15, 写出程序结果

public class Demo15 extends Super2
{
	public long get(){return 5;}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
  Super2 s=new Demo15();
  System.out.println(s.get());
	}
}
class Super2
{
public int get(){return 4;}	
}

编译失败，因为子父类中的get方法没有覆盖，但是子类调用时候不能明确返回的值是什么类型所以这样的函数不可以存在子父类中。

16, 写出程序结果

public class Demo16 {
	public static void func()
	{
		try
		{
			throw new Exception();
			System.out.println("A");
		}
		catch(Exception e)
		{
			System.out.println("B");
		}
	}
	public static void main(String[] args) {
try{
	func();
}catch(Exception e)
{
 System.out.println("C");	
}
System.out.println("D");
	}
}

编译失败，因为打印“A“的输出语句执行不到。

13题为何没有异常, 把异常封装到方法中，调用方法时可能有问题。

如果16题，一定抛出异常。

记住：throw 单独存在，下面不要定义语句，因为执行不到。

17,

public class Demo17 {
	public void func()
	{
		//位置1；
	}
	class Inner{}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
   Demo17 d=new Demo17();
   //位置2
	}
}

在位置1写 new Inner(); ok

在位置2写 new Inner();  不可以，因为主函数是静态的，如果要访问Inner需要被静态修饰

在位置2写 new d.Inner();错误，格式错误。 new new Demo().Inner();

在位置2写 new Demo.Inner();错误，因为Inner不是静态的。

18, 写出程序结果

class Exc0 extends Exception{}
class Exc1 extends Exc0{}
public class Demo18 {
	public static void main(String[] args) {
	     try
     {
     }
     catch(Exception e)
     {
    	 System.out.println("Exception");
     }
     catch(Exc0 e)
     {
    	 System.out.println("Exc0");
     }
	}
}

编译失败，多个catch时，父类的catch要放在下面。

19,

interface Test1
{
  void func();	
}
public class Demo19 {
	public static void main(String[] args) {
	    //补足代码，(匿名内部类)
		new Demo19().show(new Test1(){
			public void func(){}
		});
	}
	void show(Test1 t)
	{
		t.func();
	}
}

20, 写出程序结果

public class Demo20 {
	public static String output="";
	public static void foo(int i)
	{
		try
		{
			if(i==1)
				throw new Exception();
			output+="1";
		}
		catch(Exception e)
		{
			output+="2";
			return;
		}
		finally
		{
			output+="3";
		}
		output+="4";
	}
	public static void main(String[] args) {
	     foo(0);
     System.out.println(output); //134
     foo(1);
     System.out.println(output); //13423
	}
}

21,

建立一个图形接口，声明一个面积函数。圆形和矩形都实现这个接口，并得出两个图形的面积。

注：体现面向对象的特征，对数值进行判断。用异常处理。不合法的数值要出现“这个数值是非法的”提示，不再进行运算。

class NoValueException extends RuntimeException
{
	NoValueException(String message)
	{
		super(message);
	}
}
interface Shape
{
	void getArea();
}
class Rec implements Shape
{
	private int len,wid;
	Rec(int len ,int wid)//throws NoValueException
	{
		if(len<=0 || wid<=0)
			throw new NoValueException("出现非法值");
		this.len = len;
		this.wid = wid;
	}
	public void getArea()
	{
		System.out.println(len*wid);
	}
}
class Circle implements Shape
{
	private int radius;
	public static final double PI = 3.14;
	Circle(int radius)
	{
		if(radius<=0)
			throw new NoValueException("非法");
		this.radius = radius;
	}
	public void getArea()
	{
		System.out.println(radius*radius*PI);
	}
}
class  ExceptionTest1
{
	public static void main(String[] args) 
	{		
		Rec r = new Rec(3,4);
		r.getArea();
		Circle c = new Circle(-8);
		System.out.println("over");
	}
}

22, 补足compare函数内的代码，不许添加其他函数。

public class Demo22 {
	public static void main(String[] args) {
Circle cir[]=new Circle[3];//创建了一个类类型数组
cir[0]=new Circle(1.0);
cir[1]=new Circle(2.0);
cir[2]=new Circle(4.0);
System.out.println("最大的半径值是:"+Circle.compare(cir));
	}
}
class Circle
{
private static double pi=3.14;
private double radius;
public Circle(double r)
{
  radius=r;	
}
public static double compare(Circle[]cir)
{
//程序代码，其实就是在求数组中的最大值，	
	int max=0;// double max=cir[0].radius;
	for( int x=1;x<cir.length;x++)
	{
		if(cir[x].radius>cir[max].radius)
			max=x;
	}
	return cir[max].radius;
}
}

23, 写出程序结果

public class Demo23 {
	private static int j=0;
	private static boolean methodB(int k)
	{
		j+=k;
		return true;
	}
	public static void methodA(int i)
	{
		boolean b;
		b=i<10|methodB(4);
		b=i<10||methodB(8);
	}
	public static void main(String[] args) {
	methodA(0);
System.out.println(j);
	}
}
结果是：4

24.

假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。

class Employee
{
	private String name;
	private String id;
	private double pay;
	Employee(String name,String id,double pay)
	{
		this.name = name;
		this.id = id;
		this.pay = pay;
	}
	public abstract void work();
}
class Manager extends Employee
{
	private int bonus;
	Manager(String name,String id,double pay,int bonus)
	{
		super(name,id,pay);
		this.bonus = bonus;
	}
	public void work()
	{
		System.out.println("manager work");
	}
}
class Pro extends Employee
{
	Pro(String name,String id,double pay)
	{
		super(name,id,pay);
	}
	public void work()
	{
		System.out.println("pro work");
	}
}

25,在一个类中编写一个方法，这个方法搜索一个字符数组中是否存在某个字符，如果存在，则返回这个字符在字符数组中第一次出现的位置（序号从0开始计算），否则，返回-1。要搜索的字符数组和字符都以参数形式传递传递给该方法，如果传入的数组为null，应抛出IllegalArgumentException异常。在类的main方法中以各种可能出现的情况测试验证该方法编写得是否正确，例如，字符不存在，字符存在，传入的数组为null等。getIndex(null,'a');

 public int getIndex(char[]arr, char key)
	{  if(arr==null)
		throw new IllegalArgumentException("数组为null");
		for(int x=0;x<arr.length;x++)
		{
			if(arr[x]==key)
				return x;
		}
		return -1;
	}

26, 补足compare函数内的代码，不许添加其他函数。

class Circle1
{
  private double radius;
  public Circle1(double r)
  {
	  radius=r;
  }
  public Circle1  compare(Circle1 cir2)
  {
	  //程序代码
	 /* if(this.radius>cir.radius)
		  return this;
	  return cir;*/
	  return (this.radius>cir2.radius)?this:cir2;
  }
}
public class Demo26 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
   Circle1 cir1=new Circle1(1.0);
   Circle1 cir2=new Circle1(2.0);
   Circle1 cir;
   cir=cir1.compare(cir2);
   if(cir1==cir)
	   System.out.println("圆1的半径比较大");
   else
	   System.out.println("圆2的半径比较大");
	}
}

 

———寄语：今天有点累，但感觉自己在提高，都说先苦后甜。———    濛濛