JAVA基础拾遗

最近在面试的时候总是做一些很基础的问题，但是我的回答总是模棱两可，自己都不太确定，所以在这里做一下java基础的复习。
首先、基础数据类型：
java一共有8种基础类型，4种整形、2种浮点型、1种 char类型用于表示Unicode编码、1种表示boolean类型。
四种整型：
1. byte 1字节 8位-128~127
2.short 2字节 16位 -32768~32768
3.int 4字节 32位 -2147483648~2147483648
4.long 8字节 64位 -9223372036854775808~9223372036854775808
两种浮点型：
1.float 4字节 32位 大约3.40282347E+38F
2.double 8字节 64位 大约1.79769313486231570E+308
注：flloat类型后面必需加上f，浮点数默认的是double
char类型：
java默认的字符编码是Unicode，16位、两个字节。
boolean类型：
boolean类型有两个值，false、true。
注：java的boolean是专门的数据类型不可用整型代替。
注：这是个人的一些思考对错不准确哈：java种变量的存在方式是存在java的栈内存中的，java的栈内存除了存放这些基本类型外，还存放对象的引用（这些引用存放对象的堆内存地址或则存放对象的句柄），然后通过这些句柄或者地址找到在堆中的对象。
java数据类型转换规则：
byte–>short—>int—->long
char—>int
int–>double
int–>float long–>float long–>double 这三种转换，有可能丢失信息
注：float和double不能转换
关于printf函数：
这个printf函数沿用C语言的printf函数
由于打不了表格这段内容暂时不写
switch—-case:
从java se7开始java的switch case是支持字符串的。
java运算符优先级

java运算符优先级

i++问题
一. i++与++i的区别
i++表示i先参与运算在做自加运算，++i表示先自加再参与运算。
eg:

int i=0;
sysout(i++);
sysout(i);

结果分别是0,1。表死i先参与sysout再做自加运算。

int j=0;
for(int i=0;i<100;i++){
    j=j++;
}
sysout(j);

int j=0;
for(int i=0;i<100;i++){
    j=++j;
}

结果：第一个是0 后一个是100
解释：java的中间缓存机制

j=j++
等于
temp=j
j=j+1;
j=temp

所以输出的答案是0，后面++j 的答案肯定是100 这里的等号不起任何作用。

用 break ok；可以跳出多重循环中的外层循环
这里的ok只能够写在for循环的外面 不能够写在任意位置
例如

public static void main(String[] args) {
        System.out.println("before ok");
        ok:
            for(int i=0;i<10;i++){
                System.out.println("this is i"+i);
                for(int j=0;j<10;j++){
                    System.out.println("this is j"+j);
                    if(j==5) break ok;
                }
            }
    }

执行结果是

before ok
this is i0
this is j0
this is j1
this is j2
this is j3
this is j4
this is j5

short s1 = s1+1;会报需要强制类型转换错误 正确写法 short s1 =(short)(s1+1);
short s1+=1;不会出错 因为+=是java定义的运算符号 会自动做一些处理

java 中char存储的是Unicode编码的字符所以 占位2字节 汉字也可以用Unicode编码 一个汉字战2字节

所有语言 效率最高的运算就是位移运算 将一个数左移几位就是乘以2的几次方

java整型数据 int是20亿级 short是3万级 long是10的7次方级

fianl 修饰变量是，是引用变量不能变，引用变量所指的对象中的内容是可以变得{
A a = new A(); a指向new的这块内存的指向不能够改变 但是这块内存中的值还是可以变的
final StringBuffer a = new StrinBuffer(“immutable”); a = new StringBuffer(“”);是错的 但是a.append(“tet”);是正确的
}
String a = new String(“foo”);其中a是一个变量 这个变量的值就是new String(“foo”);的内存地址

java math中取整Math.ceil() Math.floor() Math.round()的区别
Math.ceil()向上取整 意味着11.3—>12.0注意 这里是返回的double类型不是返回的int类型
Math.floor()向下取整 11.3—> 11这里也是返回double类型
Math.round(a)将原来的数字加上0.5再向下取整 11.5—>12 -11.5——>-11 注意当你参数a是double（java小数默认的就是double）返回的就是long
但a是float（java中应该在小数后加上f）返回的就是int

override（重写 覆盖）都是对父类方法的重写 方法名 参数 和返回类型都要一致 子类的权限要大于父类的访问权限 要覆盖的方法不能是private方法

overload重载 指本类中的类 可以有相同的方法名 但参数列表一定不一样（参数的个数、参数的类型）

普通类 不能够有抽象方法 抽象类不能够实例化 其他的普通类该有的他都应该有

面向对象四个特征 封装 抽象 继承 多态

java中多态的实现机制{
多态 是靠父类或者结构定义的应用变量可以指向子类或具体实现类的实例对象，也就是A a = new A();a指向new A()是在运行期 动态绑定的 而这个动态绑定的对象
可以是A的 也可以是A的子类的 而实现的多态
}

abstract修饰的方法不能同时时static 应为抽象方法是要被子类实现的，而static与子类没有任何关系

定义在方法体体外的内部类 能够有四种修饰符权限用法和类中的变量的用法相同 但是方法体内部的类不能够有访问修饰符 就想方法体内部的局部变量一样

方法体外部的内部类前面可以加上static关键字 从而成为static netsted class（静态内部类{
static netsted class能够直接访问外部类的静态变量 也能通过外部类的对象访问外部内的非静态变量（就算非静态变量是private也能访问）
当外部使用static netsted class类时 TestNext.test test = new test();TestNext是外部类的类名
}
Anonymous Inner Class（匿名内部类）可以继承其他类或接口 而且是必须继承

super.getClass().getName()输出的是当前类的类名 无法输出父类的类名 要想通过输出父类的类名getClass().getSuperclass().getName()获取 这里getName()都应该是带包名的

String s = “hello” s=s+”world!” String类是不可变类 这里的+是重新穿件了一个string的对象他的类容是 hello world！ 然后将r指向新生的对象。

String 是final对象 不可以继承

String s = new String(“xyz”) 创建一个或两个对象 new String（）会创建一个对象 “xyz”会在缓冲区中创建一个对象 如果之前在缓冲区中创建了xyz的话 将不会再创建一个xyz对象

sleep()和wait()的区{ sleep是线程（Thread）的方法，导致此线程暂停执行指定时间，将机会给其他线程，但是监控状态依然保持，对象琐依然保持
wait()是Oject类的方法 是此对象放弃本对象琐，进入等待对象的等待索定池 只有针对此对象发出notify或notify all方法后本线程 才能够进入对象琐进入运行状态

同步和异步{同时被两个或多个线程读取的资源 就是共享资源 必须进行同步存取，当程序不用等待返回时 调用一个方法可能要消耗很长的时间是采用异步更有效}
线程的状态 就绪 运行 synchronize阻塞 wait和sleep 挂起 结束 wait必须在synchroize内部调用
}
List{
List借口有三个实现类 分别是ArrayList Vector LinkedList ArrayList是常见的List，内部通过数组实现的适合对数据的随机访问和遍历，不适合插入删除，允许空袁术
Vector和ArrayList是一样的 但Vector是线程安全的 使用的效率没有ArrayList高，LinkedList是链表结构实现的，适合数据的动态插入和删除，但是随机访问的速度较慢，不适合遍历，随机访问，适合插入 删除等操作
LinkedList可以当做栈和队列来使用
}
Set{
Set和List都继承自Collection接口 只是行为不停Set不允许有相同的值，而List允许有相同的值。Set的实现类有HashSet TreeSet HashSet是使用散列函数实现的，他不保证顺序很久不变，允许null元素
TreeSet使用自然顺序对元素进行排序，能够保障元素的顺序是一定的，一般是按照插入顺序一定的。
}
Map{
Map常用的实现类有HashMap TreeMap Hashtable LinkedHashMap
HashMap使用的是哈希表实现，在keys和values之中都是无序的
TreeMap基于红黑树数据结构实现的 按key排序
LinkedHashMap保持插入顺序
Hashtable和HashMap实现方式一样，但是Hashtable属于同步的
}

Vector（矢量）和ArryList都继承自AbstractList Vector是线程安全的 ArrayList是非线程安全，但是ArrayList的效率比Vector高，当不只有一个线程访问的时候使用ArrayList，多个线程访问的时候使用vector
Hashtable 和HashMap 前面是线程安全的 后面不是线程安全的

java异常{
在java程序运行时，常常会出现一些非正常的现象，统称为错误。错误可以根据其性质分为错误和异常
RuntimeException 运行时异常代表java虚拟机生成的异常，原因是编程出错。
常见的运行时异常 如 ClassCastException(类转换异常)
IndexOutOfBoundsException(数组越界)
NullPointerException(空指针)
ArrayStoreException(数据存储异常，操作数组时类型不一致)
还有IO操作的BufferOverflowException异常

异常关键字{

    try catch throw throws finally
    try catch finally均不能单独使用 可搭配成try catch  /  try catch finally  /  try finally 。catch可以有多个但finally只能有一个
    throw用于方法体内部，用来抛出Throwable类型的异常，throws用于方法体外部 用于声明可能抛出的异常
}

}