【JavaSE】常见的错误点总结1

1.基本数据类型

按字节大小分别为：

类型	字节数	位数
byte	1字节	8位
char	2字节	16位
short	2字节	16位
int	4字节	32位
float	4字节	32位
long	8字节	64位
double	8字节	64位
Boolean	按1字节处理	true/false

注意以下几点：
1.1 int类型可以完全包含char类型：如int a=’好’;

1.2 char与short的字节长度一样，但是数值范围不一样，char：0~65535，short：-32768~32767，二者之间转换都需要进行强转。

        char c='1';
        //char转short
        short i=(short) c;
        //short转char
        char c1=(char) i;

1.3 Java默认的整形为int，给long型赋值需要加后缀L；默认实数类型为double，给float类型赋值需要加f。如 float f=0.2;会报错！应改为：float f=0.2f;

1.4 不同数据类型的运算，运算结果是范围最大的那个数据类型，如3*0.1结果为double。

1.5 低级变量向高级变量转换时需要强转，强转可能会造成精度下降或内存溢出等情况；高级变量向低级变量转换时自动转换。

1.6 无论在Linux还是Windows上这些数据的字节长度和位数均不变，这是因为Java是和平台无关的语言。

1.7 Java中默认的编码方式为Unicode，一个Unicode码元占2个字节，char类型的变量也占两个字节，因此可以用char存一个汉字。

2.位运算

位运算的思路在于将现有的数制转为二进制进行运算。

十进制	二进制
2	0010
4	0100

2&4=0（11得1，其余均为0）
2|4=6（00得0，其余均为1）
2^4=6（相同为0，不同为1）
右移>>（等同于除以2） 左移<<（等同于乘以2） >>>(无符号右移，高位均已0补齐)

3.break与continue

continue：结束本次循环进入下一次循环。
break：结束并跳出本层循环，如果有外层嵌套循环可以用标记进行跳出外层循环。

//跳出外层i循环
    x：
    for(int i=0;i<10;i++){
        for(int j=0;j<10;j++){
            break x;
        }
    }

4.switch分支语句中的参数类型

JDK7之前支持byte、char、short、int以及枚举类型，JDK7及其以后又支持了String类型。
枚举类型即为自己定义的类型：

        //定义枚举
        public enum SSS{
        A,B,C,D
        }

        //使用枚举类型
        SSS[] values = SSS.values();
        switch (values[0]) {
        case A:
            System.out.println("111111");
            break;
        case B:
            System.out.println("222222");
            break;  
        default:
            System.out.println("333333");
            break;
        }

5.this与super区别

第一点：this.和super.的用法
一是表示当前对象；二是当方法的形参与实例变量同名时用this.实例变量来区分。

class Person {
    private int age = 10;
    public Person(){
    System.out.println("初始化年龄："+age);
    }

    public int GetAge(int age){
        this.age = age;//用this.实例变量名来区分形参
        return this.age;
    }
}

一是表示super.父类方法名或变量名；二是当子类和父类的变量名和方法名同名时，用super.父类方法名或变量名来区分子类的。

//父类
class Country {
    String name;
    void value() {
       name = "China";
    }
}
 //子类
class City extends Country {
    String name;
    void value() {
    name = "Shanghai";
    super.value();      //调用父类的方法
    System.out.println(name);
    System.out.println(super.name);//调用父类的变量
    }

第二点：this()和super()的用法
前者表示调用了本类的构造器；后者调用的是父类的构造器。

6.异常处理中throws与throw的区别

二者都是异常处理的关键字。
throw用在方法体内，后面是new +异常对象，表示产生了一个异常对象。
throws用在方法的声明后，后面是异常的类型，表示该方法可能抛出的异常。

//throw的用法
void t1() {
        //非检查异常类型:不需要配合throws往上抛
        throw new NullPointerException();       
    }

//throws的用法
void t2()throws ClassCastException{
        System.out.println("====");
    }

void t3() throws SQLTransientException {
        //检查异常：必须配合使用throws往上抛或者用try-catch捕捉异常
        throw new SQLTransientException();
    }

void t4(){
        //检查异常：必须配合使用throws往上抛或者用try-catch捕捉异常
        try {
            throw new SQLTransientException();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

7.finally和return的执行关系

首先要明白return语句的执行原理：

例如：return x+y；
这句代码先执行x+y，再执行return；先执行将x以及y从局部变量区复制到操作数栈顶，然后执行加法指令，这个时候结果x+y的值会保存在操作数栈的栈顶，最后执行return指令，返回操作数栈顶的值。
重要结论1： return指令只是用来负责返回栈顶值的！

接着分析含有finally语句的执行顺序：
如下面这段代码：
try{
return expression;
}finally{
do some work;
}
首先我们知道，finally语句是一定会执行，但他们的执行顺序是怎么样的呢？他们的执行顺序如下：
1、执行：expression，计算该表达式，结果保存在操作数栈顶；
2、执行：操作数栈顶值（expression的结果）复制到局部变量区作为返回值；
3、执行：finally语句块中的代码；
4、执行：将第2步复制到局部变量区的返回值又复制回操作数栈顶；
5、执行：return指令，返回操作数栈顶的值；
我们可以看到，在第一步执行完毕后，整个方法的返回值就已经确定了，由于还要执行finally代码块，因此程序会将返回值暂存在局部变量区，腾出操作数栈用来执行finally语句块中代码，等finally执行完毕，再将暂存的返回值又复制回操作数栈顶。所以无论finally语句块中执行了什么操作，都无法影响返回值，所以试图在finally语句块中修改返回值是徒劳的。因此，finally语句块设计出来的目的只是为了让方法执行一些重要的收尾工作，而不是用来计算返回值的。
重要结论2： finally语句是在try中return之前执行的！

特别注意： finally语句块中含有return语句时会将try块中的return返回值覆盖掉，根据上面的执行过程可知。另外是强烈不推荐在finally语句块中使用return语句的，因为eclipse会报warning：“finally block does not complete normally”。

protected static int t5(int a,int b){
        try {
            System.out.println("return语句的执行");
            return a+b;
        }finally{           
            System.out.println("finally总会执行");
            return a+b+1;
        }
    }

//测试
public static void main(String[] args) {
     System.out.println(t5(1,2));
}
//输出结果：
return语句的执行
finally总会执行
4

8.在PL/SQL中写一个9*9乘法表

begin
   for i in 1..9 loop
     for j in 1..i loop
       dbms_output.put_line(j||'*'||i||'='||j*i||'   ');
      end loop;
        dbms_output.put_line('');
    end loop;
 end;

9.==、equals方法和hashCode方法

首先要搞清楚以下几个问题？

9.1 ==，equals方法，hashCode都是干什么的？
==是比较运算符，基本数据类型比较的是值是否相等；引用类型比较的是两个对象的引用（内存地址）是否相同。
equals方法是Object类的方法，没有重写的equals方法的类中和==使用是一样的；被重写的类中，比较的是两个对象的内容是否相同。
hashCode方法也是Object类的方法，被用来获取给定对象的唯一整数，返回这个对象存储的内存地址的编号。

9.2 为什么要重写equals方法？怎么重写？
没有重写equals方法时，比较对象的内存地址是否相同，然而需要进行基于对象特征的计较时，重写equals方法很有必要。
参考String等重写了equals方法的类。
orm中重写equals时注意变量懒加载的问题，最好使用get/set方法进行比较。

9.3 为什么重写equals方法时为什么要同时重写hashCode方法？
有关hashCode作用继承参考以下文章：
http://c610367182.iteye.com/blog/1930676
http://blog.csdn.net/fenglibing/article/details/8905007

10.集合泛型与原始类型的区别？

泛型被设计出来的主要目的是为了Java类型的安全。
例如：

List lists=new ArrayList();
List<String> lists=new ArrayList<String>();

原始类型进行编译时不进行安全检查，可以接受任何带参数的类型。集合泛型在编译期间会进行安全检查，并告知编译器接受的类型为String类。