Java答题技巧（一）

 答题技巧

第一章      Java编程基础

1，方法是一种定义了某种具体抽象的运算。利用具有属性和行为的类，java实现了抽象。行为有抽象的操作来定义。

2，对象是类的实例。对象根据实现抽象的类定义来创建。所以创建对象的那些抽象的具体实现。

3，对象通常是通过new运算符创建的。引用变量的声明创建一个变量，而不管是否向该变量赋值。

4，实例成员是一个字段或一个实例方法。这些成员属于该类的实例而不属于作为整体的类。在类定义中没有显式声明为静态的成员是实例成员。

5，通过调用其他类的实例方法每一个对象可以将消息传递给其他类。

第二章      Java语言基础

1，\u××××表示法可以在源代码中任何地方使用，因为其表示的是Unicode字符。

2，类变量和实例变量可以初始化也可以赋值，但是没有显式给类变量和实例变量初始化或复制时，系统会自动的给其默认值。局部变量可以初始化也可以赋值，但是系统不会给其自动默认值，需要显式的初始化或赋值。静态变量只能初始化不能赋值，若是static修饰的类变量且无显式初始化，系统会自动为其赋值。一般而言，static是不能修饰局部变量的。final可以初始化也可以赋值。

3，如果存在package和import语句，必须位于任何类定义之前。如果文件包含import和package语句，那么package语句必须在import语句之前出现。

4，空文件尽管是无意义的，但空文件可是有效文件。

5，main()方法必须声明为public、static和void并且用一个String对象作为其参数，缺一不可。public、static的次序是无关紧要的只是个人习惯问题而。声明main()方法为final也是无关要紧不相关的。

第三章      运算符和复制

1， 赋值语句是一个表达式语句。左边的表达式的值是表达式语句的值。由于赋值运算是右结合的，因此a=b=c=20语句计算方式如下：(a=(b=(c=120)))。

2， 给引用赋值将只改变引用的值。它不会创建原对象的副本，也不会改变目的引用的就引用值锁指示的对象。换句话说就是，给引用赋值只会对引用表示哪个对象产生影响。

3，

public class  WWW

{    

       public final static void main(String[] args)

       {

                int k=1;

                int a[]={1,3,5};

                a[k]=k=9;

                for (int i=0;i<a.length ;i++ )

                {

                         System.out.println(a[i]);

                }

       }

}

结果：1 9 5

第四章      声明和访问控制

1， Java中数组是对象。每个数组对象都有一个叫做length的final字段，该字段存储了数组的大小。

2， Java中允许数组的长度为零。当一个Java程序不带任何参数运行时，这样就作为参数传递给main()方法。

3， 数组大小是通过初始化代码隐含的给定的。在一个数组引用的声明中，不需要指定数组大小，所以int a[3]={1,3,5};是错误的。数组大小总是同组数组的实例而不是同数组的引用相关的，所以int a[][]={{1,3},new s[2]};是错误的。数组的维度只能从左到右创建，所以int a[][]=new int[][4];是错误的。

4， 非静态方法有一个隐含的this对象的引用。this引用可以在非静态上下文中使用，以指定实例和静态成员，不过它不能呢个用于指定局部变量。

5， 构造函数不能指定任何返回类型，即使是void也不行。构造函数不能使用final，static或abstract修饰。构造函数可以使用private修饰，这就意味着这个构造函数不需要初始化类中的所有字段。如果没有进行显式的的初始化，不那么字段会被赋予一个默认值。构造函数是非静态的，并且可以直接访问静态和非静态成员。

6， 类或接口名称可以通过使用完全标识符名或简化的名称来指明。利用完全标识符名总是行得通的，但是使用简化的名称就必须进行导入。例如，从包net.based;外部引用该类的有效方式，可以通过导入net.based.*;，net.based包中的所有类型都会被导入，并可以使用简化名称引用。导入net.*；不会导入net.based包。

7， 当一个类被声明为abstract时，该类是不能被实例化的。抽象方法不能提供一个实现。如果类中有一个方法被声明为abstract，那该类必须声明为abstract。

8， native只能声明于方法而不能用于类或字段。

9， 我们不能指定局部变量的可访问性。局部变量只能在声明它的块中访问。对象本身没有任何可访问性，只有对象的引用可以访问。如果在类的成员声明中没有给定可访问性修饰符（public，private，protacted等）那么该成员只能由相同包中的类来访问。一个类不能使用超类中声明的具有默认可访问性的成员，除非两个类都位于相同的包中。对于相同包中具有默认可访问性的成员来说，继承是没有影响的。局部变量不能声明为static或给定的可访问性修饰符。

10，              关键字this只能在想非静态方法那样的非静态代码中使用。类的每一个静态变量只能实现一次，这种实现是该类的所有对象共享。局部变量只是在局部作用域中可以访问，而不是该局部变量是否在静态上下文定义过。

11，              抽线类可以包含final方法和非抽象方法。非抽象类不能包含抽象方法。抽象类不能是final的。构造方法不能声明为abstract。

12，              transient关键字意味着当对象串行化时不应该存储这些字段。

13，              子类必须实现父类中的所有抽象方法，但是可以不实现非抽象方法。子类必须实现接口的所有方法。

第五章      控制流、异常处理和断言

1， switch表达式的类型必须是byte、char、short、int。case标签的类型必须是可以向switch表达式赋值的。case和default标签不需要人任何特定的次序来指定。break语句的使用不是强制的，并且没有它的话控制流也会简单的在switch语句标签处结束。

2， continue不能在循环的上下文之外使用，所以{continue;}是无效的。

3，

public class  MyClass

{

   public static void main(String[] args)

   {

            int i=1;

            int n=1;

            boolean b=false;

            do

            {

                     i++;

                     ++n;

                     System.out.println("里面的i："+1);

                     System.out.println("里面的n："+n);

            }

            while (b=!b);

            //while (b==(!b));//可是正确的

            System.out.println("外面的i："+1);

            System.out.println("外面的n："+n);

   }

}

                                     结果：

里面的i：1

里面的n：2

里面的i：1

里面的n：3

外面的i：1

外面的n：3

请按任意键继续. . .

4，

public class  MyClass1

{

    public static void main(String[] args)

    {

             int i=0;

             int n;

             for (n=0;n<5 ;++n )

             {

                       System.out.println("最里面的i："+i);

                       System.out.println("最里面的n："+i);

                       i++;

                       System.out.println("里面的i："+i);

                       System.out.println("里面的n："+n);

             }

             System.out.println("***************");

             System.out.println("外面的i："+i);

             System.out.println("外面的n："+n);

    }

}

           结果：

最里面的i：0

最里面的n：0

里面的i：1

里面的n：0

最里面的i：1

最里面的n：1

里面的i：2

里面的n：1

最里面的i：2

最里面的n：2

里面的i：3

里面的n：2

最里面的i：3

最里面的n：3

里面的i：4

里面的n：3

最里面的i：4

最里面的n：4

里面的i：5

里面的n：4

***************

外面的i：5

外面的n：5

请按任意键继续. . .                   

5，

public class  MyClass2

{

        public static void main(String[] args)

        {

                  int i,j;

                  outer:

                           for ( i=0;i<3 ;i++ )

                           {

                                    for ( j=0;j<2 ;j++ )

                                    {

                                              System.out.println("里面的i："+i);

                                              System.out.println("里面的n："+j);

                                              if (i==j)

                                              {

                                                       continue outer;

                                              }

                                    }

                                    System.out.println("外面的i："+i);

                                    //System.out.println("外面的n："+j);

                           }

                 

        }

}

           结果：

里面的i：0

里面的n：0

里面的i：1

里面的n：0

里面的i：1

里面的n：1

里面的i：2

里面的n：0

里面的i：2

里面的n：1

外面的i：2

请按任意键继续. . .

                            

 

第六章      面向对象编程

1， extends子句用于指定一个类扩展另一个类。子类可以声明为abstract，而不管父类是不是声明为abstract的。子类不继承父类的私有、重载和隐藏成员。一个类不能同时声明为abstract和final的，因为abstract类需要扩展才能称为有用的类，而final类是不能被扩展的。类的可访问性不能受其成员的可访问性的限制。所有的成员都声明为private的类仍然可以声明为public。

2， 继承是is-a关系。聚集定义了一种has-a关系。Object类有一个叫做equals()的刚刚方法，但是它没有任何叫做length()的方法。所有的类都是Object类的子类，所以他们都继承了equals()方法，因此所有的对象都有一个equals()方法。在java中是单继承的，但是可以一个父类有多个子类。

3， super()和this()的使用不是强制性的。super()和this()都要放在首句。

4， 接口没有任何实现，并且只允许许多接口继承。一个接口可以扩展任意数量的其他接口，并且可以被任意数量的接口扩展。接口中的字段是静态的，而接口中的方法原型从来不是静态的。

第七章      嵌套类和嵌套接口

1， 静态成员类在许多方面看起来是像一个顶级类，并且可以包含非静态类字段。非静态成员类实例是一个outer实例的上下文中创建的。outer实例同inner是内在相关的，可以建数个inner类实例，并且和相同的outer实例相关联。静态类没有任何固定的ourer实例。静态成员接口就像上层接口一样包含非静态字段。嵌套的接口重视静态的。

2， 跟顶级接口不一样的是，非静态的成员类可以拥有任意的可访问性修饰符。静态成员类只能在上层或嵌套层的静态成员类和接口中声明。只有静态成员可以声明为静态的。把一个类声明为静态的只是意味着该类的实例是没有outer实例的情况下创建的。这与类成员是否是静态的无关。

3， 除了final之外，非静态成员类中再也不能声明任何其他静态成员。outer实例中的成员可以利用简单名称直接访问（假设它们都不隐藏）。嵌套静态类成员类中的字段不必是final的。匿名不可能有构造函数，因为它们没有名称，嵌套类定义了与外围不同的类型，并且instanceof运算符没有考虑outer实例的类型。

4， 类可以声明为顶级的成员。如果它被声明为static，这样的类就是一个静态成员类，否则它就是一个非静态成员类。顶级类、局部类和匿名类不能声明为静态类的。

第八章      对象生存期

1， 如果所有剩余的对象引用都是来自其他适合进行垃圾收集对象。这个对象就是最适合垃圾收集的。Java中没有delete关键字。对象在变得不可达之后不必马上作为垃圾被收集掉。让呢，该对象会适合进行垃圾收集。环状引用不会阻止对象成为垃圾收集的目标，只有可达的引用能做到。只要对象可以被任何存活的活线程访问，就不适合对该对象进行垃圾收集。一个已经成为垃圾收集的目标对象还可以消除这种适合性。当对象的finalize()方法创建了一个指向该对象的可达到引用时，就会出现这种情况。

2， Object类定义了一个受保护的finalize()方法。所有的类都是Object类的子类，因此所有类都包含一个finalize()方法。类可以覆盖finalize()方法，并且像所有的覆盖一样，新方法不得不降低可访问性。垃圾收集器调用一个适合对象的finalize()方法，使得该对象在被销毁之前可以做任何的清理。当垃圾收集器调用finalize()方法时，它会忽略任何由finalize()方法抛出的异常。在所有其他的情况下，当执行finalize()方法期间抛出的一个异常时，常规的异常处理就会发生，及不会被忽略。调用finalize()方法本身不会破坏该对象。finalize()方法的链锁不是编译器强制实施的，也不是强制要求调用覆盖的finalize()方法。

3， finalize()方法想任何其他方法一样，如果它可以访问的，就可以显式地进行调用，不过，为了在销毁对象之前进行清理工作，该方法的意图就是让垃圾收集器可以调用它。