1.关于参数的传递

class valhold{
public int i = 10;
}
public class obparm{
public void amethod(){
valhold v = new valhold();
another(v);
system.out.println(v.i);
}
public void another(valhold v){
v.i = 20;
valhold vh = new valhold();
v =vh;
system.out.println(v.i);
}
public static void main(string[] argv){
obparm o = new obparm();
o.amethod();
}
}此题的答案是10，20，为什么不是10，10呢？

这样解释吧，按照sun官方的说法：当一个引用变量作为参数传递给一个方法时， 在这个方法内可以改变变量的值，即改变引用指向的对象，（本题中将vh赋给v）但是方法的调用结束后，改变量恢复原来的值，即变量仍然指向原来的对象。 （即another(v)调用结束之后，v又回复到第一次valhold v = new valhold();时指向的地址空间。） 但是如果在方法内改变了引用指向的对象的数据（属性），那么当方法的调用结束后，尽管引用仍然指向原来的对象，这个对象的某个属性已经被改变了（v的i值在 执行v.i=20的时候就已经被改变了，所以调用another结束后，v.i已经变成了20） .

2.关于内部类

public class inout{
string s= new string("between");
public void amethod(final int iargs) {
int iam;
class bicycle{
bicycle() {
system.out.println(s); //这两句话可以，也就是说可以访问s
system.out.println(iargs); //和final int 常量
//system.out.println(iother);
}
}
new bicycle();
}
public void another(){
int iother;
}
public static void main(string[] args) {
inout inout= new inout();
inout.amethod(22);
}
}

inner class能够存取外部类的所有实例变量----无论这些实例变量有什么样的存取控制符（比如private）,就像类中的方法能够存取方法所在类的所有变量一样；如果inner class定义在方法中，则inner class能够存取方法所在的类中的实例变量，也能存取该方法中的局部变量，但该局部变量必须是final的，也就是只能访问方法中的常量.(上面所说的都是普通内部类，不是静态内部类的情况).

public class testinner {
int t=10;
public void a() {
final int u =90;
class inmethod { //方法中内部类
inmethod() { //内部类的构造方法
system.out.println("u="+u); //封装方法内的变量必须是final才能访问到！
system.out.println("t="+t); //外部类的变量可以任意访问！
}
}
new inmethod();//必须在方法a()中创建内部类对象之后，testinner对象才能通过 a()访问到inmethod类
}
public static void main (string[] args) {
testinner t= new testinner();
t.a();
}
}输出：u=90 ，t=10
方法中的内部类不可以是static的！如果一个内部类是静态的（当然只能是类中的内部类啦），那么这个类就自动的成为顶级（top-level）类即普通的类。静态内部类中的方法（无论是静态的方法还是非静态的方法）只能直接访问外部类中的静态成员，要访问外部类中的非静态成员，则必须创建外部类的对象。
　　1．关于在静态方法中访问非静态内部类的问题

public class outer{
public string name = "outer";
public static void main(string argv[]){
//inner myinner = new inner(); //直接用这句话创建会编译错误
outer myouter=new outer(); //先创建外部类的对象
outer.inner myinner=myouter.new inner();
myinner.showname();
}//end of main
//下面这段代码用来测试这种n烦的办法
public void amethod(){
outer myouter=new outer();
outer.inner myinner=myouter.new inner();
myinner.showname();
}
//非静态方法访问非静态内部类
private class inner{
string name =new string("inner");
void showname(){
system.out.println(name);
}
}//end of inner class
}在非静态方法访问非静态内部类直接创建该内部类的对象：new inner().showname();当然也可以采取这种n烦的办法假设private class inner改成static private class inner, 那么在静态方法中访问静态内部类也是直接创建该内部类的对象，即inner myinner = new inner()，或者outer.inner myinner = new outer.inner()也行得通，可见这种n烦的方法在上面三种情况下都是可以用的。

2．abstract方法不能用final,static修饰非abstract方法在abstract类中可以用final,static

抽象类中的抽象方法不能是final,但是非抽象方法前加final可以编译通过因为abstract和final相互排斥，前者专用于继承，后者禁止继承

抽象类中的抽象方法不能为static

非抽象方法可以为static

包裹类integer、 string 、float、 double等都是final类，不能被继承！integer i=new integer(“6”);如果字符串不是数字，会产生运行异常（不会出现编译错误）但是对于boolean，这个规则不适用。当字符串时（大小写无关），boolean对象代表的数值为true，其他字符串均为false如：

boolean b = new boolean(“afiwou”); 代表false
boolean b = new boolean(“true”); 是true3.多态性、虚拟方法调用

public class test8 {
public static void main(string [] args){
base b = new subclass();
system.out.println(b.x);
system.out.println(b.method());
}
}
class base{
int x = 2;
int method(){
return x;
}
}
class subclass extends base{
int x = 3;
int method(){
return x;
}
}结果是2,3,而不是3,3
employee e = new manager()；
e.department = " finance " ;
//department 是manager的一个特殊属性
声明变量e后，你能访问的对象部分只是employee的部分；manager的特殊部分是隐藏的。这是因为编译器应意识到，e 是一个employee，而不是一个manager。但重写的方法除外

在你接收父类的一个引用时，你可以通过使用instanceof运算符判定该对象实际上是你所要的子类，并可以用类型转换该引用的办法来恢复对象的全部功能。为什么说“恢复对象的全部功能”，就是因为上一格所描述的，子类对象赋给父类句柄后，该句柄不能访问子类的那些特殊属性和方法，要用就要重新造型。这其实是多态参数的后续应用，形成这样一个链条：传入多态参数??instanceof判断类型??casting??恢复功能

employee e = new manager();
e.getdetails();

在此例中，manager 重写了employee的getdetail()方法。被执行的e.getdetails()方法来自对象的真实类型：manager。事实上，执行了与变量的运行时类型（即，变量所引用的对象的类型）相关的行为，而不是与变量的编译时类型相关的行为。这是面向对象语言的一个重要特征。它也是多态性的一个特征，并通常被称作虚拟方法调用??“动态绑定”

写了这么多也不知道对你有没有帮助呢?