基本概念

JDK,JRE,JVM的作用及关系

1.JRE只是java程序的运行环境，包含JVM及核心类库

2.JDK是java开发工具，不仅提供了java程序运行所需的JRE，还提供了一系列的编译、运行等工具，如javac、java等

环境变量CLASSPATH的作用

CLASSPATH环境变量保存的是一些目录和jar文件地址，这些路径是为java程序在编译和运行时搜索类而用

垃圾回收机制

1.Java.lang.Object中有个finalize()方法，它会在垃圾回收器认为这个对象是垃圾之后，真正回收之前被调用
2.Java.lang.System中有个gc()方法，通过显示调用它可以请求垃圾回收器线程，但线程是否开始还是由JVM的算法决定
3.Java.lang.Runtime中的gc()方法和System的作用一样，只不过Runtime是一个单例模式的类，需要用getRuntime()获得它的实例，然后才能调用gc()方法

    System.gc();    Runtime.getRuntime().gc();

Java基础数据类型及其包装类

1.byte1字节-Byte，short2字节-Short，int4字节-Integer，float4字节-Float，double8字节-Double

2.char2字节-Character，boolean1字节-Boolean

3.数据类型转换默认从小到大，byte,short,char之间不相互转换，直接转成int类型参与运算

4.从大到小进行强转，可能有精度损失，目标数据类型 变量名 = (目标数据类型) (被转换的数据)

    byte b1=3,b2=4,b;    b=b1+b2;//错，b1、b2要转成int做加法，赋给byte要强转    b=3+4;//正确，常量相加，首先做加法，然后看结果是否在赋值的数据类型范围内

进制

1.二进制-0b开头、八进制-0开头、十六进制-0x开头

2.其他进制到十进制：(用乘推导)

3.十进制到其他进制：(用除推导)

//其他进制到十进制十进制12345=1*10^4 + 2*10^3 + 3*10^2 + 4*10^1 + 5*10^0 = 12345二进制0b100=1*2^2 + 0*2^1 + 0*2^0 = 4八进制0100=1*8^2 + 0*8^1 + 0*8^0 = 64十六进制100=1*16^2 + 0*16^1 + 0*16^0 = 256//十进制到其他进制十进制12345（到十进制）：不断除以10，记余数，直到0，余数反转，为12345十进制20（到二进制）： 不断除以2，记余数，直到0，余数反转，为0b10100

原码、反码、补码

原码：正数的原码最高位是0，负数的原码最高位是1，其他是数值位    +7      0   0000111    -7      1   0000111反码：正数的反码与原码相同，负数的反码与原码符号位相同，数值位取反    +7      0   0000111    -7      1   1111000补码：正数的补码与原码相同，负数的补码是在反码的基础上加1    +7      0   0000111    -7      1   1111001

运算符

1.相除想得到小数，至少一个为float类型，可在输出时*1.0把int变为float2.++,--运算符：放前放后，都使操作数变1，放前作为整体，变，放后面作为整体，不变3.扩展赋值运算符隐含强换，s += 1;等价于s = (s的数据类型)(s + 1);4.&&具有短路效果，左边是false，右边不执行,&两边都一定执行

static关键字

*随着类加载而加载，优先于对象存在，被类的所有对象共享*一个对象赋值或修改静态成员变量，其他的和再创建的对象都改变*静态方法中没有this关键字，静态方法只能访问静态的成员变量和方法

继承、this、super

1.子类只能继承父类所有非私有的成员
2.子类所有构造方法默认访问父类空参构造方法，子类不能继承父类的含参构造方法，可以通过super关键字访问
3.调用成员变量this.成员变量，调用构造方法this(数据类型)，调用成员方法this.成员方法

重写、重载

*方法重载：本类中出现的方法名一样，参数列表不同的方法，与返回值无关

*方法重写：子类出现了和父类中方法声明一样的方法访问权限不能更低，私有方法不能继承，更不能重写

*注意：静态方法不存在重写，但子类若存在同名方法，也要加静态

final关键字

*修饰类，该类不能被继承，修饰方法，该方法不能被重写，修饰变量，该变量不能重新赋值

*修饰引用类型变量，地址值不能改变，但内容可以改变

多态

*前提：继承或实现关系、方法重写、父类引用指向子类对象

*多态中的对象只能访问父类有的成员，不能使用子类特有功能

抽象类和接口

1.都只能通过多态实例化

2.接口成员变量默认public static final修饰，无构造方法，只有抽象方法，默认public abstract

3.抽象类成员变量可以是变量，也可以是常量，有构造方法，成员方法至少一个是抽象的

4.抽象类被继承是is a的关系，体现共性，接口被实现是like a的关系，体现拓展

权限修饰符

*private只有本类内部可以访问

*默认情况只在同一个包下自由访问

*protected同一个包下，或不同包下的子类可以访问

内部类

1.内部类可以访问外部类的成员，包括私有，外部类要访问内部类的成员，必须创建对象

2.访问非静态内部类：Outer.Inner oi = new Outer().new Inner();（外部类对象.内部类对象）

3.访问静态内部类：Outer.Inner oi = new Outer.Inner();

4.局部内部类访问的局部变量必须用final修饰

==和equals

*==比较基本类型是比较值，比较引用类型是比较地址

*equals方法只能比较引用类型，默认调用==比较地址，String类重写了该方法，比较的是字符串内容

String

1.String s = new String(“hello”);创建2个对象，堆内存一个，常量池一个

2.String s = “hello”;创建1个对象，在常量池

3.字符串变量相加，先开空间，再拼接，常量相加，编译后相当与一个整体

    String s1 = "hello";    String s2 = "world";    String s3 = "helloworld";    System.out.println(s3 == s1 + s2);// false    System.out.println(s3 == "hello" + "world");// true（若s3是new的，则false）

4.常用方法：

    boolean startsWith(String str):以某个指定的字符串开头，区分大小写    boolean endsWith(String str):以某个指定的字符串结尾，区分大小写    boolean isEmpty():内容是否为空    char charAt(int index):获取指定索引位置的字符    int indexOf(int ch):返回指定字符第一次出现的索引（形参传入'a'和97都代表'a'）    String substring(int start):从指定位置开始截取字符串,默认到末尾    包含start这个索引String substring(int start,int end):截取字符串包括start，不包括end    byte[] getBytes():把字符串转换为字节数组    char[] toCharArray():把字符串转换为字符数组    static String valueOf(char[] chs): valueOf方法可以把任意类型的数据转成字符串    String concat(String str):字符串拼接

Stirng、StringBuffer、StringBuilder

1.String是内容不可变的，而StringBuffer，StringBuilder都是内容可变的

2.StringBuffer是同步的，安全，效率低、StringBuilder是不同步的，不安全，效率高

Arrays工具类

    public static String toString(int[] a)：把数组转成字符串    public static void sort(int[] a)：对数组进行排序(底层是快排)    public static int binarySearch(int[] a,int key)：二分查找

用LinkedList模拟栈数据结构

    public class MyStack {        private LinkedList link;        public MyStack() {            link = new LinkedList();        }        public void add(Object obj) {            link.addFirst(obj);        }        public Object get() {            // return link.getFirst();//这样会导致无法弹栈            return link.removeFirst();        }        public boolean isEmpty() {            return link.isEmpty();        }    }

集合

Collection：    List：有序，可重复        ArrayList：数据结构是数组，适合查询，线程不安全        Vector：同ArrayList，但线程安全        LinkedList：数据结构是链表，适合做增删，线程不安全    Set：无序，唯一        HashSet：数据结构是哈希表，依赖hashCode和equals方法            LinkedHashSet：链表保证有序，哈希表保证唯一        TreeSet：数据结构是红黑树Map：数据结构只针对键有效    HashMap：数据结构是哈希表，线程不安全，允许null键和null值        LinkedHashMap：数据结构是链表和哈希表    Hashtable：数据结构是哈希表，线程安全，不允许null键和null值    TreeMap：数据结构是红黑树

TreeSet集合保证元素排序

*自然排序(元素具备比较性)，让元素类实现自然排序接口Comparable

    TreeSet<Student> ts = new TreeSet<Student>();

*比较器排序(集合具备比较性)，使用一个带参构造方法

    TreeSet<Student> ts = new TreeSet<Student>(new MyComparator());

*都重写方法：

        public int compare(Student s1, Student s2) {            int num = s1.getName().length() - s2.getName().length();            int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;            int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;            return num3;        }

Collections类

    public static <T> void sort(List<T> list)：默认情况下是自然顺序。    public static <T> int binarySearch(List<?> list,T key)：二分查找    public static <T> T max(Collection<?> coll)：最大值    public static void reverse(List<?> list)：反转    public static void shuffle(List<?> list)：随机置换

throw和throws

*throws用在方法声明后，跟的是异常类名，可以多个，表示出现异常的可能性

*throw用在方法中，跟的是异常对象名，表示抛出了异常

final,finally和finalize

*final：修饰类，类不能被继承，修饰变量，变量是常量，修饰方法，方法不能被重写

*finally：是异常处理的一部分，用于释放资源

*finalize：是Object类的一个方法，用于垃圾回收