java之1--10天练习

1--10天练习

/**
 * 10天总结练习
 * 注意:按java规范书写程序代码,如果你认为程序有错误,请指出,并说明程序错误原因
 */

//1.写出程序结果 
class Demo{
	public static void func(){
		try{
			throw new Exception();
		}finally{
			System.out.println("B");
		}
	}
	
	public static void mian(String[] args){
		try {
			func();
			System.out.println("A");
		} catch (Exception e) {
			System.out.println("C");
		}
		System.out.println("D");
	}
    //结果: 编译失败!  func()抛出一个编译异常, 没有 catch 和 throws 
    //如果 func()上面有声明编译时异常  ,结果是?  B  C  D 
}

//2.写出程序结果
class Test{
	Test(){
		System.out.println("Test");
	}
}
class Demo1 extends Test{
	Demo1(){
		//super
		System.out.println("Demo");
	}
	public static void main(String[] args){
		new Demo1();   // Test Demo
		new Test();    //Test
	}
}

//3.写出程序的结果
interface A{}
class B implements A{
	public String func(){
		return "func";
	}
}
class Test1{
	public static void main(String[] args){
		A a=new B();
		System.out.println(a.func());
	}
	//结果: 编译失败. 多态中   接口A没有定义func()
}

//4.写出程序结果
class Fu{
	boolean show(char a){
		System.out.println(a);
		return true;
	}
}
class Zi extends Fu{
	public static void main(String[] args){
		int i=1;
		Fu f=new Zi();
		Zi z=new Zi();
		for(f.show('A');f.show('B') && (i++<2);f.show('c')){
			z.show('D');
		}
		System.out.println(i);
	}
	boolean show(char a){
		System.out.println(a);
		return false;  // 结果:  A  B  1
		//return true; // 结果 :  A  B  D  C  B  3 
	}
}
//5.写出程序结果
interface C{}
class D implements C{
	public String test(){
		return "yes";
	}
}
class Test2{
	static C get(){
		return new D();
	}
	public static void main(String [] args){
		C  c=get();
		System.out.println(c.test());
	}
	//结果:编译失败: 多态中 接口 C对象中没有test()方法.
}

//6.写出程序结果 
class  Super{
	int i=0;
	public Super(String a){
		System.out.println("A");
		this.i=1;
	}
	public Super(){
		System.out.println("B");
		i+=2;
	}
}
class Child extends Super{
	public Child(String a){
		System.out.println("C");
		i=5;
	}
	public static void main(String[] args){
		int i=4;
		Super s=new Child("A");
		System.out.println(s.i);
	}
	//结果 : B  C  5
}

//7.补充代码
interface Inter{
	void show(int a,int b);
	void func();
}
class Test4{
	public static void main(String[] args){
		//补充代码, 要求使用 匿名内部类调用两个函数
		Inter i=new Inter(){
			public void show(int a,int b){
				
			}
			public void func(){
				
			}
		};
		i.show(4, 5);
		i.func();
	}
	
}

//8.写出程序结果
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();
	}
	//结果:编译失败,非静态内部类中个不可以定义静态成员
	//内部内中如果定义静态成员,该内部类必须被静态修饰.
}

//9.选择题,写出错误答案的原因,用单行注释的方式
class Test5{
	int show(int a,int b){return 0;}
} /**
     下面那些函数可以存在于Test5子类中
     A:public int show(int a,int b){return 0;}   //可以,是重写父类的方法
     B:private int show(int a,int b){return 0;}  //不可以:子类的权限范围必须大于等于父类
     C:private int show(int a,long b){return 0;} //可以:在子类中构成重载
     D:public short show(int a,int b){return 0;} //不可以,以为该类函数不可以和给定函数出现在同一类中,或者父子类中.
     E:static int show(int a,int b){return 0;}   //不可以,静态只能覆盖静态
     
  */
  
//10.写出this关键字的含义,final有哪些特点?
/**
 * this:代表本类对象,哪个对象调用this所在函数,this就代表那个对象.
 * 
 * final:
 *   1.修饰类,变量(成员变量,静态变量,局部变量) 函数.
 *   2.修饰的类不可以被继承
 *   3.修饰的函数不可以被覆盖
 *   4.修饰的变量是一个常量只能赋值一次.
 *   5.内部类只能访问 局部变量中的fianl修饰的变量
 */

//11.写出程序的结果
class Fu1{
	int num=4;
	void show(){
		System.out.println("Show Fu");
	}
}
class Zi1 extends Fu1{
	int num=5;
	void show(){
		System.out.println("Show Zi");
	}
}
class Test6{
	public static void main(String[] args){
		Fu1 f=new Zi1();
		Zi1 z=new Zi1();
		System.out.println(f.num);
		System.out.println(z.num);
		f.show();
		z.show();
	}
	//4  5  Show Zi Show Zi
}

//12.补充代码
interface E{
	void show();
}
interface F{
	void add(int a,int b);
}
class AA implements E,F{
	
	//补充代码
	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(sum);  //两种方法都可以
	}
}
class Test7{
	public static void main(String [] args){
		AA a=new AA();
		a.add(4,2);
	    a.show();  //通过该函数答应 以上两个数的和.
	}
}

//13.写出程序结果
class Test8{
	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.写出程序结果
class  Super1{
	int i=0;
	public Super1(String s){
		i=1;
	}
}
class Demo2 extends Super1{
	public Demo2(String s){
		i=2;
	}
	public static void main(String [] args){
		Demo2 d=new Demo2("yes");
		System.out.println(d.i);
	}
	//结果 :编译失败 ,因为父类中缺少空参数的构造函数Super1(){}, 或者子类中 通过super明确调用父类中有参数的构造方法.
	
}


//15.写出程序的记过
class Super2{
	public int get(){return 4;}
}
class Demo3 extends Super2{
	public long get(){return 5;}
	public static void main(String[] args){
		Super2 s=new Demo3();
		System.out.println(s.get());
		
	}
	//结果:编译失败,因为子父类中的get()方法没有覆盖,但是子类调用的时候不能明确返回值的类型.
}

//16.写出程序的结果
class Demo4{
	public static void main(String[] args){
		try{
			throw new  Exception();
			System.out.println("A");
		}catch(Exception e){
			System.out.println("B");
		}finally{
			System.out.println("C");
		}
		System.out.println("D");
	}
	//结果:编译失败, throw 和 return ,break contiue 单独存在时, 后面不能有其他的语句.
}

//17.判断下面的选项,错误的请说出原因
class Demo5{
	public void func(){
		//位置1
	}
	class Inner{}
	
	public static void main(String[] args){
		Demo5 d=new  Demo5();
		//位置2
	}
}
/**
 * A: 在位置1写  new  Inner();       //Ok  
 * B: 在位置2写  new  Inner();       //错误: 因为主函数是 static ,如果要访问 Inner 也必须是 static修饰
 * C: 在位置2写 new  d.Inner();     //错误: 转换下  new new Demo5().Inner();
 * D: 在位置2写 new  Demo.Inner();  //错误: 因为 Inner不是static的
 */

//18.写出程序的结果
class Exce0 extends Exception{}
class Exce1 extends Exce0{}

class Test9{
	public static void main(String[] args){
		try {
			throw new Exce1();
			
		} catch (Exception e) {
			System.out.println("Exception");
		}catch(Exce0 e){
			System.out.println("EXce0");
		}
	}
	//结果:编译失败, 多个 catch时候,父类的catch要放在下面.
}

//19.补充代码
interface Inter1{
	void func();
}
class Demo6{
	public static void main(String[] args){
		//补充代码 匿名内部类 实现 调用 show();
		new Demo6().show(new Inter1(){
			public void func(){
				System.out.println("调用了");
			}
		});
	}
	
	void show(Inter1 i){
		i.func();
	}
}

//20.写出程序的结果
class Test11{
	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.建立一个 图形 类 写出  长方形 和圆形的面积 

//22.补足compare函数内的代码 ,,不许添加其他的函数.
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;
	}
}
class TC1{
	public static void main(String[] args){
		Circle cir[]=new Circle[3];
		cir[0]=new Circle(1.0);
		cir[0]=new Circle(3.0);
		cir[0]=new Circle(4.0);
		System.out.println("最大的半径值是:"+Circle.compare(cir));
	}
	
}

//23.写出程序的结果
class Test12{
	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);
	}
	//结果:j=4, 因为  i<10 =true  methodB(8)不会执行. 
}

//24. 给员工建模   员工包含 3个属性 姓名,工号 以及工资 经理也是员工 .....


/**
 * 25.在一个类中辨析莪一个额方法 ,这个方法搜索一个字符数组中事发后存在某个字符,如果存在,则放回一个字符现在字符数组中第一出现的位置
 * 需要从0 开始  ,否则 返回 -1 ,要搜索的字符数组和字符串都可以用参数的形式传递给方法,如果传递的数组为null,应该抛瞅 IllegalArgumentException异常
 * 在类的main方法中以各种可能出现得到情况验证该方法编写是否正确. 
 */ 
class Test10{
	public int getIndex(char[] arr,char key){
		if(arr==null)
          throw new  IllegalArgumentException("参数不合法");
       
		for(int x=0;x<arr.length;x++){ //如果为null 就不能调用 length
			if(arr[x]==key)
              return x;
        }
		
        return -1;
	 }
}

//26.补足 compare  函数内的代码,不许添加其他函数
class Circle2{
	private double radius;
	public Circle2(double r){
		this.radius=r;
	}
	public Circle2 compare(Circle2 cir){
		//补足代码
		return this.radius>cir.radius ? this:cir;
	}
}

class Test13{
	public static void main(String[] args){
		Circle2 cir1=new Circle2(1.0);
		Circle2 cir2=new Circle2(2.0);
		Circle2 cir3;
		cir3=cir1.compare(cir2);
		if(cir2==cir1)
			System.out.println("圆1的半径比较大");
		else 
			System.out.println("圆2的半径比较大");
	}
}