面向对象2

final public class Foobar{}

final防止子类继承，但final不可以和abstract连用

abstract public void methodA（）

abstract声明的方法强迫它的子类实现它

public class Test1
{
private static int j=0;
public static boolean methodB(int k)
{
   j+=k;
   return true;
}
public static void methodA(int i)
{
   boolean b;
   b=i>10&methodB(1);
   b=i>10&&methodB(2);
}
public static void main(String[] args)
{
   methodA(10);
   System.out.print(j);
}
}

运行结果j=1

原因methodsA方法的参数i对结果影响不大，methodB(1)调用造成j=1，但是methodB(2)由于短路没有被调用。

class EnclosingOne
{
public class InsideOne
{
}
}
public class InnerTest
{
public static void main(String args[])
{
   EnclosingOne eo=new EnclosingOne();
   //此处插入代码
}
}

应该为 EnclosingOne.InsideOne ei=eo.new InsideOne();

下面讨论下声明和访问内部类的一些固定形式。

静态方法访问非静态内部类：

Outer myouter=new Outer();                      //myouter 是创建的外部类的对象

Outer.Inner myinner=myouter.new Inner();                 //myinnner 是内部类的对象

非静态方法访问非静态内部类：

直接创建内部类的对象： new Inner().showName();

静态方法访问静态内部类：

也是直接创建该内部类的对象，即 Inner myinner=new Inner()

或者 Outer.Inner myinner=new Outer.Inner()

有关参数传递的一些讨论

public class X
{
private static int a;
public static void main(String[] args)
{
   modify(a);
   System.out.println(a);
}
public static void modify(int a)
{
   a++;
}
}

运行后a=0

class A
{
class Dog
{
   private String name;
   private int age;
   public int step;
   Dog(String s,int a)
   {
    name=s;
    age=a;
    step=0;
   }
   public void run(Dog fast)
   {
    fast.step++;
   }
}
public static void main(String[] args)
{
   A.a=new A();
   Dog d=a.new Dog("Tom",3);
   d.step=25;
   d.run(d);
   System.out.println(d.step);
}
}

运行后结果为26.

第一段代码的a为所有实例说共有的，一个实例对其进行修改，那么其他实例的方法也就都已经修改了，所以a++结果应该为1。但是最后输出为0呢？原因在于modify方法中定义的a是参数变量，在方法中修改的变量时参数a，调用modify方法时，只是将a的值传过来了，成员变量a的值并没有改变。

第二段代码d为一个引用，引用作为参数，引用对象的内容改变在方法之外是可见的。也就是调用对象d的run方法后，对d的成员变量step的改变可以影响到方法之外。所以最后输出为26.

抽象方法

abstract class AbstractIt
{
abstract float getFloat();
}
public class AbstractTest extends AbstractIt
{
private float f1=1.0f;
private float getFloat()//第八行
{
   return f1;
}
}

编译错误，原因在于为抽象方法提供具体实现时，不能再加限定词，因为抽象方法本身就是一个约定或协议，实现抽象方法必须遵守原来的约定。因此错误出现在第八行上。