【面试之java基础】小知识点汇总

1.java中的类型

      包括基本数据类型和引用类型

     · 基本数据类型（4类8种）      字节数                                对应封装类：

            ·字符型（char）          2    默认值\u0000                  Character

            ·整型

                    ·字节型（byte）  1     默认值0                       Byte

                    ·短整型（short） 2     默认值0                       Short

                    ·整型（int）     4     默认值0  (默认类型)           Integer

                    ·长整型（long）  8     默认值0                       Long  

                （定义时可以不加l，是int类型，低→高自动转换）          (定义时要加l，自动拆装箱，必须是Long对象类型)

             ·浮点型

                     ·单精度（float） 4   默认值0.0                       Float（定义时要加f）

                     ·双精度（double）8   默认值0.0 （默认类型）          Double（定义时要加d）

             ·布尔型（boolean）          默认值false                      Boolean

2.自动装箱和拆箱（jdk1.5）

   ·自动装箱：把基本数据类型用对应的引用类型包装起来，使他们具有对象的特质

            

Integer num = 4;//会自动调用Integer类的valueOf(int i)方法，  相当于  Integer num = Integer.valueOf(4);,

           

               关于Integer类的valueOf方法中使用IntegerCache，jvm默认会缓存-128-127之间的数字(可以通过配置修改)，所以引出以下的陷阱

              （Byte、Short、Long类的默认缓存-128-127 ；Character类的默认缓存0-127；Float和Double类不缓存）

/**
 * Created by 111 on 2016/2/24.
 */
public class BoxTest {
    public static void main(String [] args){
        Integer a = 4;
        Integer b = 4;
        Integer c = 200;
        Integer d = 200;
        Integer e = new Integer(4);
        Integer f = new Integer(4);
        System.out.println(a==b);       //true
        System.out.println(c==d);       //false
        System.out.println(c.equals(d));//true
        System.out.println(e==f);       //false
        System.out.println(e.equals(f));//true
    }
}

    ·自动拆箱：把引用类型简化为基本数据类型

   

int i = new Integer(4);//会自动调用Integer类的intValue()方法  

             

3.java中的值传递和引用传递

        一种说法：基本数据类型属于值传递：传递的是原参数的拷贝，实参传递给形参的值，形参发生改变并不影响实参的值。

                  引用类型属于引用传递，传递的是对象的引用地址，形参和实参指向的同一个地址，形参发生改变实参也会发生改变。

        另一种说法：java中均属于值传递，没有引用传递这一说。不管是基本数据类型和引用数据类型，传递的都是副本（即传值），有争议的是引用传递，当一个对象实例作为一个参数被传递到方法中时，参数的值就是该对象的引用一个副本。指向同一个对象,对象的内容可以在被调用的方法中改变，但对象的引用本身(不是引用的副本)是永远不会改变的。基本数据类型传递的是原始参数的值，引用类型传递的是引用参数的副本，这个副本存放的是参数的地址，如果函数中没有改变这个副本的地址，只是改变了地址中的值，那么在函数内的改变会影响到传入的参数，如果在函数中改变了副本的地址，如new一个对象，那么副本就指向 了一个新的地址，此时传入的参数还是指向原来的 地址，所以不会改变参数的值。（引用于：java中的值传递和引用传递）

4.for循环的面试题

**
 * Created by 111 on 2016/2/24.
 */
public class BoxTest {
    public static void main(String [] args){
        int i = 4;
        for (com('A');com('B');com('C')){
            i--;
        System.out.print('D');
       if(i<0){
                break;
            }
        }
    }
    private static boolean com(char c){
        System.out.print(c);
        return true;
    }
}

运行上面的代码输出为：ABDCBDCBDCBDCBD

这里考察的是for循环的运行过程，下面这个简单的for循环是我们经常会使用的

 for (int m = 0;m<4;m++){
            System.out.print(m);
      }

这里会输出： 0123

解析：for循环的结构为 

          for(赋值语句；判断条件（true/false）;做运算）{

                 //如果满足条件则执行此内容

           }

         运行过程为: 执行运行赋值语句→判断条件为true→执行大括号的内容→做运算→判断条件为true→执行大括号的内容→做运算。。。循环直到判断条件为false或者break跳出循环。

5.final、static修饰符的作用

       ·final  :因为继承打破了封装的特性，一旦被继承，父类的属性就可能会被重写，所以该关键词很好的解决了该问题
                 ★final修饰的变量是一个常量，只能赋值一次
                 ★final修饰的方法不能被覆盖
                 ★final修饰的类不能被继承
       ·static :★static是一个修饰符，用于修饰成员；
                 ★static修饰的数据是共享数据，被所有对象共享，而对象中的存储是特有数据。
                 ★static优先于对象存在，static修饰的成员随着类的加载就已经存在，可以用类名.进行调用
6.接口、抽象类、类
      ·接口：用interface修饰类名，
                 ★接口中的方法都是抽象的（方法只有声明，没有实现）
                 ★接口中的成员都是公共权限，常见成员包括全局常量（public static final）和抽象方法(public abstract,一般可省略)
      ·抽象类：用abstract 修饰 class。
                 ★抽象类中含有被abstract修饰的抽象方法
                 ★抽象类中成员可以是公共权限，可以是被保护的权限，也可以是私有的，但是抽象方法不可以是私有的，也不能被static,final修饰
                 ★抽象类中有构造函数，但是不可以被实例化，是用于给子类对象初始化。

            

      ·类：

       三者之间的关系：★接口可以继承接口

                       ★抽象类可以继承抽象类、类，可以实现多个接口

                       ★类可以继承抽象类、类，可以实现多个接口

7.多态中成员变量的特点

     ·成员变量：编译和运行均看等号左边

     ·成员函数：编译看左边（左边类中如果没有该方法则编译报错），运行看右边（运行右边类中覆盖的方法）

     ·静态成员函数：编译和运行均看左边，静态函数是和类同时存在的

父类

/**
 * Created by 111 on 2016/2/29.
 */
public class Fu {
    int num = 1;
    public void method1(){
        System.out.println("fu_1");
    }
    public void method3(){
        System.out.println("fu_3");
    }
    public static void method4(){
        System.out.println("fu_4");
    }
}

子类
/**
 * Created by 111 on 2016/2/29.
 */
public class Son extends Fu {

        int num = 2;


        public void method1() {
            System.out.println("zi_1");
        }
        public void method2(){
            System.out.println("zi_2");
        }
        public static void method4(){
            System.out.println("zi_4");
        }


}

测试类

/**
 * Created by 111 on 2016/2/29.
 */
public class Test {
    public static void main(String[]args){
        int num = 4;
        Fu fu = new Son();
        fu.method1();//zi_1
        fu.method3();//fu_3
        fu.method4();//fu_4
    }
}

8.public、protected、default、private

      · private 修饰的成员在同一类中可以被访问

      · default 默认的在同一个包中可以被访问

      · protected 修饰的成员在同一个包中和子类中均可以访问

      · public 修饰的成员均可以访问

9. == 和 equals

    ·对于基本数据类型的比较用==比较两个字段值是否相等

    ·对于引用类型的比较：==比较的是两个引用类型所指向的对象的地址的值是否相等

                         equals比较的是两个引用类型所指向的对象中保存的内容是否相等（这里要注意String的比较）

/**
 * Created by 111 on 2016/2/29.
 */
public class Demo8 {
    public static void main(String [] args){
        String s1 = "a";
        String s2 = "b";
        String s3 = "ab";
        String s4 = "a"+"b"; //编译器会提前优化为 ab，保存在常量池中
        String s5 = s1+s2;//未知，不可以优化，重新分配内存，保存在堆内存中
        System.out.println(s3==s4);//true
        System.out.println(s3==s5);//false
    }
}

常量池(constant pool):指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量.