java基础复习

2018-11-17 | 阅读：次

Java foundation review -1

1.静态变量问题？

下面代码执行会报编译异常，因为静态变量只能定义在类成员中，静态变量也叫类成员变量，只能定义在类中不能定义在方法内，静态方法也不行。

public class Test {
    public  int aMethod() {
        static int i = 0;//这里不能定义为static
        i++;
        return i;
    }
    public static void main (String args[]) {
        Test test = new Test();
        test.aMethod();
        int j = test.aMethod();
        System.out.println(j);
    }
}

2.继承重写问题？

public class Super {
    public Long getLenght() {
        return new Long(5);
    }
}

public class Sub extends  Super {
     public Integer getLenght() {//这里Integer会报错，因为子类重写的返回值必须是父类的子集，如果父类返回值为Object即可。
        return new Integer(4);
     }
        public static void main(String[] args) {
            Super sooper = new Super();
            Sub sub = new Sub();
            System.out.println(sooper.getLenght().toString() + "," +
                    sub.getLenght().toString() );
        }
    }

3.接口中定义方法问题？

public interface NewTest {//接口中权限修饰符也只能用public修饰，不能用private，protected，static
    int i=0;//正确  接口可以定义变量，但是必须是参数，一般情况大写
    public abstract void test1();//正确
    public final void test2();//错误 接口方法不能被final修饰
    public static void test3();//错误 静态方法必须由方法体
    public static void test4(){};//正确
    protected void test5();//错误 在类中定义时（受保护方法体能被继承但是不能被子类访问）
     void test6();//正确
     default void test7(){//正确
         System.out.println("hello java");
     };
}

4. switch 是否能作用在byte 上，是否能作用在long 上，是否能作用在String 上？

switch :

1.5减 : 作用范围为 int、char、byte、short;

1.5 ：增加枚举类型

1.7 ：增加String

5.说出数据连接池的工作机制是什么？

简单来说，服务器创建时候会为客户端预留创建一定数量的数据库连接对象，当客户端需要使用连接时服务器（池驱动程序）会给客户端一个连接并将这个连接标记为忙，如果没有可用连接，池驱动程序会根据配置参数新建连接。

6.多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么？

7.垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？

简单来说GC在对象一创建出来就开始记录跟踪管理该对象地址、大小、使用情况，GC采用有向图来跟踪对象，长时间不可达的话，变回开始着手收回对象在堆中的内存空间。可以，通过 System.GC(),一般不建议使用。

8. 写一个Singleton（单例模式）出来？

public class singleObject{
    //构造方法用private修饰，为了不能被实例化
    private  SingleObject(){
        
    }
    //自己实例化唯一的对象
    private static SingleObject instance = new SingleObject();
    //为其他类获取该唯一对象提供getInstance方法
    public SingleObject getInstance(){
        return instance;
    }
    public void test(){
        System.out.println("hello singleModle");
    }
}
//使用
public class test{
    public static void main(String [] args){
      //错误，构造函数SingleObject()不可见了
      //SingleObject s = new SingleObject();
      SingleObject s = SingleObject.getInstance();//因为getInstance是静态方法所有可以直接调用
    }
}

9.在main(String[] args)方法内是否可以直接调用一个非静态方法？

静态成员是属于类的，非静态成员属于实例，那么在main方法内调用非静态成员或者方法，是不被允许的，要用new个对象具体原因是（猜想）：静态成员是在的加载时候创建了，非静态方法在实例创建才开始创建，时间段不一样那么也就无法互通？

10. 静态成员内部类、成员内部类、局部内部类与匿名内部类关系？

静态成员内部类：就是在成员内部类加了静态，把它当作类成员便容易理解它作用，通常内部类实例化要等外部类实例化完才能实例化，而且内外类不能同名，且静态内部类不能访问外部类非静态方法或属性(同静态方法是不能调用非静态一个原理)。

package one;
public class StaticInnerClass {
    static class inner{   
    }
    public static void main(String[] args) {
    }
}

成员内部类：如果要实例化内部类，则必须创建外部类的实例

class TestMemberOuter1{  
        private int data=30;  
        class Inner{  
            void msg(){
                System.out.println("data is "+data);
        }  
 }  
 public static void main(String args[]){  
      TestMemberOuter1 obj=new TestMemberOuter1();  
      TestMemberOuter1.Inner in=obj.new Inner();//注意这里创建对象方式  
      in.msg();  
 }  
}

局部内部类：就是定义在方法内或者说代码块的类,作用范围仅仅为这个代码块内，类似局部变量不能被权限修饰符修饰(因为局部变量已经限定了它作用范围，所以无需修饰)

class Outer{
   public void method(){
   		class Inner{}
   }
}

匿名内部类：创建匿名类的对象，该对象由Person类型的p引用变量引用

abstract class Person{
    abstract void eat();//抽象类中可以没有抽象方法，但是抽象方法一定在抽象类中
    void food(){
        System.out.println("soup");
    }
}
class TestAnonymousInner{
    public static void main(String args[]){
        Person p=new Person(){
            void eat(){
                System.out.println("nice fruits");       
            }
            void food(){
                System.out.println("ugly soup");
            }
        };
        p.eat(); //nice fruit
        p.food();//ugly soup
    }
}