关于java考试的很多内容 希望对大家有所帮助 谢谢

				覆盖与隐藏的区别
				下面这个例子很好地说明了它们的区别：
				class Father
				{
				        public static void getStr()
				        {
				                System.out.println("abc");
				        }
				        public void getString()
				        {
				                System.out.println("123");
				        }
				}
				
				class Son extends Father
				{
				        public static void getStr()
				        {
				                System.out.println("def");
				        }
				        public void getString()
				        {
				                System.out.println("456");
				        }
				        public static void main(String[] args)
				        {
				                Father f=new Son();  //父类的引用指向子类的对象
				                f.getStr();         //此时依然调用父类的getStr()方法，打印出abc
				                f.getString();       //此时调用子类的getString()方法，打印出456
				        }
				} 
				
				
				
				class food {
				String name="food";
				public void showMess(String mess){
				System.out.println("food.showMess="+mess);
				}
				}
				
				class bread extends food{
				String name="bread";
				public void showMess(String mess){
				System.out.println("bread.showMess="+mess);
				}
				public static void main(String[] args) 
				{
				bread b=new bread(); 
				food f=b;
				f.showMess("f");  
				//f.showMess()调用的是b的showMess方法
				System.out.println("f.name"+f.name); 
				//那为什么这里f.name为"food",不是b的name子段?
				}
				} 
				创建一个父类的引用，指向子类的实例对象。该对象有两个name ,即super.name和this.name。因为是父类的引用，所以调用的是super.name，而在运行的时候，子类方法覆盖了父类的方法，据动态绑定，引用所指向的是一个实例化对象的那个方法，在这，也就是复写的那个方法。
				
				
				
				该程序展示了在继承关系中，方法的传递分配关系
				
				class A {    
				A() {        
				System.out.println("A的构造被调用");    
				}    
				void f() {System.out.println("A.f()");   
				 }
				}
				class B extends A {    
				B() { System.out.println("B的构造被调用");    
				}    
				void f() { 
				//重写了A类的f方法        
				System.out.println("B.f()");    
				}
				}
				class C extends A {    
				C() {        System.out.println("C的构造被调用"); 
				   }    
				void fc() {        System.out.println("C.fc()");  
				  }
				}
				public class LearnInheritMethod {   
				 public static void main(String args[]) {        System.out.println("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");    
				    B bb = new B();      
				  A ab;       
				 ab = (A) bb;//以上三行相当于A ab = new B();  
				               ab.f(); //A型的ab调用的竟是B类重载过的f      
				  //（原因：与域不同，调用两次构造，并不能产生两个f方法，而是第二次的覆盖了第一次的，这时两个类型共同拥有第二次产生的f）  
				      ((B) ab).f(); //B型的ab调用的竟…竟也是B类重载过的f     
				   //竟然可以由父转子（原因：因为ab是由bb转来的，只要bb还没被释放，ab就还可以转回去）       
				 System.out.println("cccccccccccccccccccccccccccccc");     
				   A ac = new C();        ac.f(); //ac.fc()非法       
				 //原因：虽然类型对方法不能起选择作用（因为就一套，两个类型共用），但是类型对方法还是由屏蔽作用（即只能访问该类中声明过的方法）      
				  ((C) ac).f();     
				   ((C) ac).fc();   
				 }
				}
				
				
				该程序展示了在继承关系中，域的传递分配关系
				
				class A{    int x1,x2;    A(){        x1=1;        x2=2;        System.out.println("A的构造被调用");    }}class B extends A{    char x2;  //x2甚至可以是int型的    int x3;    B(){        x2='#';  //此x2与A中的x2各占各的内存        x3=33;         System.out.println("B的构造被调用");    }}public class LearnInheritField {    public static void main(String[] args) {        B b =new B();  //创建b时，调用了构造A()和构造B()，且分配了4份内存（但没人可以同时拥有它们），分别存放a＝1，b＝2，b＝‘＃’，c＝33       //A型实例拥有的域：A.x1＝1，A.x2＝2      //B型实例拥有的域：A.x1＝1(继承)，B.x2＝‘＃’(重载)，B.x3＝33(自定义)               System.out.println(((A)b).x2);  //类型转化时，并不再调用构造，而b的值却可以随类型改变，说明了有两份b，且用类型加以却别               System.out.println(b.x2);  //两个x2是互斥的，即一个类型只能访问到其相应的x2       }}