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