public class Bus 
{
private String sLine;
public Bus()
   {
   }
   public Bus(String sLine) 
   {
   this.sLine=sLine;
   }
   public void setSLine(String sLine)
   {
   this.sLine=sLine;
   }
   public String getSLine()
   {
   return this.sLine;
   }
}
其中在方法体中：
   public void setSLine(String sLine//只在该方法体中有有效？？)
   {
      this.sLine/*（是全局还是局部?)*/=sLine/*（是全局还是局部?)*/;
   }
当然，若在this.sLine=sLine中拼写正确是肯定可以通过的。
可是我将其改为
   public void setSLine(String sdsLine/＊请注意已经改变，只在该方
                                             法体中有效？？＊/)
   {
      this.sLine/*（是全局还是局部?)*/=sLine/*（是全局还是局部?)*/;
   }
此时，编译也可通过，是什么原因？？？我是偶尔一次拼写错误，居然编译过去，但运行错误才发现此类错误，为什么可以编译通过？？？

你这个问题牵扯两个方面，第一,this的用法；第二，变量的生命期。
    第一， 在你这个问题里，this是指向当前类对象的一个句炳，即指向Bus类的一个句柄，因此我们不难理解this.sLine指的是private String sLine这个变量。
    第二，变量的生命期。由private String sLine定义的sLine虽然是私有的，但是他的生命期确实整个Bus类。而每个方法的参数String sLine定义的sLine的生命期只再这个方法内。
    通过上面得分系，你的第一个关于局部还是全局的问题就很明显了。
    public void setSLine(String sLine//只在该方法体中有有效？？（是）)
  {
    this.sLine/*（是全局还是局部?)（整个类）*/=sLine/*（是全局还是局部?)（只再这个方法内）*/;
  }
    下面我们来看你的哪个写错了的程序，
public void setSLine(String sdsLine/＊请注意已经改变，只在该方
                                            法体中有效？？＊/)
  {
    this.sLine=sLine;
  }
   此时，this.sLine和sLine是同一个变量，他们都是由private String sLine定义的，至于调用此方法的参数sdsLine根本就没有用，所以编译是也不会出错。
    那么，在
public void setSLine(String sLine)
  {
    this.sLine=sLine;
  }
中，为什么this.sLine和sLine不一样呢？那正是因为有个优先级的问题，因为在方法setSLine(String sLine)中，参数sLine要比变量private String sLine定义的sLine优先级高，这应该比较好理解。
   为了更好的理解，我们看下面的两个例子，第一个是没有误写的
public class Bus {
private String sLine;
public Bus() {}
    public Bus(String sLine) {
     this.sLine=sLine;
    }
    public void setSLine(String sLine) {//正确
     this.sLine=sLine;
    }
    public String getSLine() {
     return this.sLine;
    }
    public static void main(String[] args) {
     String s;
     Bus bus1=new Bus();
     bus1.setSLine("101");//正确设置
     s=bus1.getSLine();
     System.out.println(s);
   }      
}
结果为：101，因为参数传递正确，所以设置成功
第二个是误写的
public class Bus {
private String sLine;
public Bus() {}
    public Bus(String sLine) {
     this.sLine=sLine;
    }
    public void setSLine(String sdsLine) {//误写，所以此方法得不到正确调用
     this.sLine=sLine;
    }
    public String getSLine() {
     return this.sLine;
    }
    public static void main(String[] args) {
     String s;
     Bus bus2=new Bus("102");
     bus2.setSLine("103");//没有起作用
     s=bus2.getSLine();
     System.out.println(s);
    }      
}
结果：102，本来我们想得到103，是因为setSLine("103")没有得到正确调用。
如果觉得有用，给分吧！^_^

public class TestVarScope {
  int i;
  {
    int i = 10; // 在自己的 scope内， 隐藏了 成员变量 this.i
    System.out.println(i);
  } // i 死亡期到，消失了
  
  void prt() {
    System.out.println(i);  // 打印 成员变量 this.i
  }
  
  void prt(int i) {
    System.out.println(i);  
    // 成员变量 this.i 在方法的可视范围(scope)内被隐藏
    // 如果使用成员变量用this.i
    {
      //int i = 100;//! 出错，i is already defined in prt(int)
      //不允许在嵌套的 可是范围内重新声明变量。和C++不同，C++允许
    }
  }
  
  public static void main(String[] args) {
    TVarScope vs = new TestVarScope();
    vs.prt();
    vs.prt(20);
  }
}

很简单
当变量名重复时，内层变量将被采用。
当需要访问外层变量时，必须添加限制符
如
public void setSLine(String sLine)
{
  sLine=sLine;
}
由于方法的参数(String sLine)是最内层变量,因此sLine=sLine将没有任何效果
而
public void setSLine(String sLine)
  {
  this.sLine=sLine;
  }
能将参数(String sLine)传给实例变量sLine
public void setSLine(String sdsLine)
{
  this.sLine=sLine;
}
由于this.sLine和sLine都代表实例变量，将没有任何效果

你所用到的this.sLine都是private String sLine；定义的这个变量。
而在set方法里面用的sLine是你的局部变量，即你的参数。
参数故意写错以后，sLine会被认为就是this.Line.编译不会有任何问题。

to ezyw
benediction(一颗神石)的说法比较好，我就是那个意思。