抽象类与接口的区别是什么

1.接口是抽象方法的集合，接口中的变量定义为public static final，接口以interface声明
2.对象都是通过类来描述的，但类不一定用来描述对象，当一个类中没有包含足够的信息来描绘一个具体的对象，就是抽象类。
3.抽象类不能实例化对象，其他跟普通方法一样，所以抽象类必须被继承才能使用。其作用是根据其格式来创建和修改新的类。
（例如，构造一个动物类，包括“吃”，‘嚎叫’等方法。由于不同动物的 吃 和 嚎叫 是不同的，可以将 吃 和 嚎叫定义为抽象类。在继承这个动物类时，不同的动物再实现不同的 吃 和 嚎叫方法。

public abstract Animal {
public void sleep{
 // sleeping time
 }
 public void eat(food)
 {
 //eat something
 }
 public abstract void makeNoise();
 }public Dog extends Animal {
 public void makeNoise() {
 System.out.println(“Bark! Bark!”);
 }
 }public Cow extends Animal {
 public void makeNoise() {
 System.out.println(“Moo! Moo!”);
 }
 }

Object是所有类的超类，Java的基类。如果父类是Object，任意类都可以是他的子类。
　instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例，用法为：
boolean result = obj instanceof Class instanceof 双目运算符，obj若是Class中的对线就返回true 不是就返回false
equals()、hashCode()来判断两个对象是否相同，类似，但不完全相同
clone()克隆对象
相比于new一个对象，new为引用的复制，地址跟原地址一样，clone相当于创建一个新的对象，地址不同。
clone实用性:a已经含有某些有效值，但需要一个完全相同的b，但修改时又不会影响a，可以用clone。
toString:返回一个以文本方式表示的字符串。一般用于boolean字符
finalize()方法：垃圾回收器准备释放内存的时候，会先调用finalize()。
　　 (1).对象不一定会被回收。
(2).垃圾回收不是析构函数。
(3).垃圾回收只与内存有关。
(4).垃圾回收和finalize()都是靠不住的，只要JVM还没有快到耗尽内存的地步，它是不会浪费时间进行垃圾回收的。

java单继承的优点

1.兼容性：单继承的所有对象归根结底都是相同类型，兼容性问题降低。
2.便利性：对于父类传递下来的对象，我们可以进行便利的操作，参数传递得到简化。
3.垃圾回收：单继承使得垃圾回收简便。（较难）

工具类

jdk源代码中提供了很多工具类。
Collections类提供容器使用的实用方法
sort方法：对集合排序，默认升序
reverse方法：对已知集合list进行反转
shuffle方法：对集合list随机排序
fill方法：用对象x替换list中的所有元素
copy方法:将集合n的元素复制到m中，并覆盖一部分元素
min/max
indexOfSubList方法：寻找n在m中首次出现位置的索引
swap方法：交换集合中指定位置的元素位置
…

Arrays类提供给数组容器使用的方法
跟Collections类似

Objects类提供了一些给Object类中的实用方法（前文提过）

Java里的方法重载

方法重载指的是两个同名方法共存的一种方式
方法返回值不相同，其他相同的情况，不能重载，方法返回值不作为方法标识

public class A{
 public void method(String s ,int i){}
 public void method(int i,String s){}
 } //可重载public class B{
 public void method(){return “1”}
 public void method(){return “2”}
 } //仅返回类型一样，不能重载

JVM JDK JRE的关系

JVM:java虚拟机，运行java代码的引擎
JDK:java se开发库
JRE:java运行的环境

java里的枚举实现机制是什么

由一个final继承enum类，是实在的enum类，编译器生成了枚举类的实例对象，这些对象分别对应枚举中定义的每个枚举类型本身。

java关键字

continue关键字

public class A{
 public void main(String[] args){
 for(i=0;i<10;i++){
 if(0==i%2)
 continue;
 System.out.println(i);
 }
 }
 }


只能用于循环里面，作用是直接开启下次循环

break关键字

public class A{
 public void main(String[] args){
 for(i=0;i<10;i++){
 if(0==i%2)
 break;
 System.out.println(i);
 }
 }


}
用于循环里面，作用是直接跳出循环
用于switch里面，作用是跳出case

this关键字
指的是访问类中的成员变量，用来区分成员变量和局部变量（重名）

public class Test{
 private String name;
 public Test(String name){
 this.name=name;
 }
 }

final关键字
可以修饰类，方法，变量，作用是表明他修饰的东西不可改变
final方法可以被继承，不能被重写
private方法都被隐式指定为final
final类不能被继承

transient关键字
被这个关键字修饰，变量不能被序列化，静态变量不管有无被他修饰都无法序列化
变量被他修饰后，序列化后将不能访问
敏感信息可以用他修饰

super关键字
可以访问父函数，属性，构造函数

return关键字
指定地方返回值
退出当前方法

instanceof关键字
返回一个布尔值，告诉我们一个对象是不是某个特定类的实例
if (x instanceof Kiki){

}
判断x是不是Kiki类的实例

size()和length属性
size()是链表的一个方法，获取链表的长度
length是数组的属性，获取值按属性的方法获取

java中的float和double
尽量用double
用float系统不仅不会省内存还会因为校验float的精度消耗更多系统资源
尽量不要用short
最好只用int 和long

四种权限控制关键字（可访问）
private 本类里
default 本类里 同一个包的类里
protected 本类里 同一个包的类里 子类
public 本类里 同一个包的类里 子类 其他包的类

Java中的内部类

1.把一个类的定义放在另一个类的定义里，称之为内部类。
2.一般修饰了static的内部类称为嵌套类。
3.内部类能访问外围成员所有变量，非常方便！
4.内部类互相独立而且可以独立继承，达到了类似于多继承的效果。

位运算符

A=0100 0100
B=0000 1100
A&B=0000 0100 都是1则为1其他为0
A|B=0100 1100 只要有一个为1则为1
A^B=0100 1000 相同为0不同为1
A<<4=100 0000 向左位移四位
A>>4=100 向右位移四位
A>>>3=0000 1000 向右位移四位，并补齐空位
位运算都要先转换到2进制再进行位运算