1、方法的重载是java多态的体现
2、类中调用本类构造方法用this(表示当前对象)
3、封装：把信息隐蔽。通过成员变量私有化，提供给外界公有化的方法
static(共享的):使之成为类共享，不建议使用(原因:在类加载的时候就产生，占内存)
final(不可变的)：修饰变量：该变量变为常量；修饰方法：不可以被子类复写；修饰类：则类不可以被继承
接口：就是为了弥补java单继承的不足（修饰接口要用static<用类名调用>或default<对象调用>）
内部类：当前类需要继承两个或两个以上的类时
1、普通内部类
Outer o = new outer();
Outer.Inner i=o.new Inner();
2、静态内部类
Outer.Inner i = new Outer.Inner();
内部类想访问外部成员是用Outer.this访问
3、方法中的内部类
4、匿名内部类
public static void main(String[] args) {
Outer outer = new Outer();
Obj obj = new Obj();// 通常我们都要获得一个实现接口的类对象
outer.operator(obj);//然后调用
/**
* 但是匿名内部类直接在方法参数的地方new接口或抽象类来直接用
*/
outer.operator(new Operator() {

        @Override
        public void test() {
            System.out.println("匿名内部类的实现");
        }
    });
}

lombda表达式：

    /**
     * 因为接口中方法的参数为空，固此处也为空（lombda表达式就是匿名内部类的优化写法）
     */
    outer.operator(() -> {
        System.out.println("lombda表达式");
    });
******包装类的功能,JDK5.0之前装箱和拆箱都是手写，在这之后都是自动拆装箱

实现多线程的方法
1.继承Thread
2.实现Runnable接口
synchronized（同步），资源是共享的，把当前对象锁住，当我操作完之后下一个才能操作
例：我去买瓶水，我没付钱或者决定不买之前，下一个顾客不能来
枚举：
修饰符 enum 枚举名{
枚举值1，
枚举值2，
枚举值N；
}

枚举的遍历
for (ESeason x;ESeason.values()) {
System.out.println(x);
}
switch的表达式可以使枚举类型
ESeason s=ESeason.AUTUMN;
Switch(s){
case SPRING:System.out.println("春天");break;
case SUMMER:System.out.println("夏天");break;
case AUTUMN:System.out.println("秋天");break;
case WINNER:System.out.println("冬天");break;
}
泛型:（可以写在类、方法上）E（集合类型的泛型）、T（普通类型的泛型）、K,V（键值对类型的泛型）
局限：1.类型参数不能实例化
new E();//error
正确应该：
GenericGroup<Integer> genericGroup = new GenericGroup();
2.不能实例化类型参数的数组
E[] arr = new E[10];//error
可以声明出来E类型的数组，但是不能实例化
3.类的静态变量不能声明为类型参数类型
public static E name;//error
4.泛型类不能继承自Throwable以及其子类
public class Problem<T> extends Exption//error
泛型与子类继承：
GenericGroup<Integer> gi= new GenericGroup();
GenericGroup<Number> gn= new GenericGroup();
gn=gi;//error
但是可以向Number中添加一个Integer数据
gn.add(88)
泛型与接口：
在implents时就要确定泛型的类型

集合框架：
Vector<Integer> vector = new Vector<Integer>(10);
vector.add(1);
vector.add(2);
vector.add(3);
System.out.println(vector.capacity());
System.out.println(vector.size());
Enumeration<Integer> enumeration = vector.elements();
while (enumeration.hasMoreElements()) {
System.out.println(enumeration.nextElement());
}
/**
* Collection--List有序可重复、Set无序不重复(TreeSet(可以进行排序操作)、hashSet)、Queue(队列) 后进先出、 Map键值对
*/
*LinkedeList和ArrayList的区别

1、数据结构不同

ArrayList是Array(动态数组)的数据结构，LinkedList是Link(链表)的数据结构。

2、效率不同

当随机访问List（get和set操作）时，ArrayList比LinkedList的效率更高，因为LinkedList是线性的数据存储方式，所以需要移动指针从前往后依次查找。

当对数据进行增加和删除的操作(add和remove操作)时，LinkedList比ArrayList的效率更高，因为ArrayList是数组，所以在其中进行增删操作时，会对操作点之后所有数据的下标索引造成影响，需要进行数据的移动。【视频教程推荐：Java视频教程】

3、自由性不同

ArrayList自由性较低，因为它需要手动的设置固定大小的容量，但是它的使用比较方便，只需要创建，然后添加数据，通过调用下标进行使用；而LinkedList自由性较高，能够动态的随数据量的变化而变化，但是它不便于使用。

4、主要控件开销不同

ArrayList主要控 件开销在于需要在lList列表预留一定空间；而LinkList主要控件开销在于需要存储结点信息以及结点指针信息。

迭代器：
Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }

双向迭代器
ListIterator<String> listiterator = list.Listiterator();
    while (listiterator.hasNext()) {
        System.out.println(listiterator.next());
    }


比较器：Comparable(当前对象跟传入对象比较)适合做排序操作
    Comparator(直接比较俩对象)适合对集合整体排序
Map的三种遍历方式： 
    Map<String, String> map = new HashMap<>();
    map.put("1", "qweqfwasavf");
    map.put("2", "sagfvdse");
    Iterator<String> iterator = map.keySet().iterator();
    while (iterator.hasNext()) {
        System.out.println(map.get(iterator.next()));
    }

    Set<Map.Entry<String, String>> set = map.entrySet();
    Iterator<Entry<String, String>> it = set.iterator();
    while (it.hasNext()) {
        Entry<String, String> entry = it.next();
        System.out.println(entry.getKey());
        System.out.println(entry.getValue());
    }
    for (Map.Entry<String, String> entry : map.entrySet()) {
        System.out.println(entry.getKey() + "：" + entry.getValue());
    }

正则表达式：

public class Pettern {
/**
*
* 正则表达式
*/

public static void main(String[] args) {
    /**
     * 规则验证
     */
    String st = "123456";
    Pattern p = Pattern.compile("[0-9]{6}");
    Matcher m = p.matcher(st);
    boolean f = m.matches();
    System.out.println(f);
    /**
     * 匹配字符串
     */
    String s = "qwer1asf";
    boolean flag = s.matches("[a-z][a-zA-Z0-9]{7,15}");
    System.out.println(flag);

    String str = "1r2r3t4y";
    String[] arr = str.split("[a-z]");
    for (String temp : arr) {
        System.out.println(temp);
    }
    /**
     * 匹配替换
     */
    String re = str.replaceAll("[32]", "A");
    System.out.println(re);
}

}
io文件输入输出，流操作：

对象序列化：
定义：将对象某一时刻的状态保存到外部存储介质上（将序列化的对象读取出来叫反序列化）
功能：由于程序运行时的某个状态可以保存，可以很好地完成对象深克隆
实现方法：实现Serializable接口、Externalizable接口
public static void main(String[] args) throws IOException, ClassNotFoundException {
// 序列化
Employee employee = new Employee(null, 0, 0);
employee.setName("李建军");
employee.setAge(10);
employee.setSalary(20.30);
FileOutputStream fos = new FileOutputStream("io.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(employee);
// 反序列化
FileInputStream fis = new FileInputStream("io.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
Employee e1 = (Employee) ois.readObject();
System.out.println(e1.getName());
}
反射： 在运行状态中，对于任意一个类，都能知道这个类的所有属性和方法；对于任意一个对象都能调用它的任意一个方法和属性；
这种动态获取信息以及动态调用对象的方法的功能称为反射机制
获取对象，然后调取方法
直接利用invoke()调用方法

自定义注解： @Target(value = { ElementType.TYPE }) 表示这个注解用在什么地方
@Retention(RetentionPolicy.RUNTIME)表示在运行的时候这个注解被运行
public enum ElementType{
TYPE, //类、接口（包括注释类型）或枚举声明
FIELD, //字段声明（包括枚举常量）
METHOD, //方法声明
PARAMETER, //参数声明
CONSTRUCTOR, //构造方法声明
LOCAL_VARIABLE, //局部变量声明
ANNOTATION_TYPE, //注释类型声明
PACKAGE //包声明
}
public enum RetentionPolicy {
SOURCE, /* Annotation信息仅存在于编译器处理期间，编译器处理完之后就没有该Annotation信息了 /
CLASS, / 编译器将Annotation存储于类对应的.Class文件中，默认行为 /
RUNTIME / 编译器将Annotation存储于Class文件中，并且可由JVM读入 */
}

例子：@Retention(RetentionPolicy.RUNTIME)
@Target(value = { ElementType.TYPE })
public @interface ActionAnnotation {

}
public @interface MethodAnnotation {
// 注解参数
public String path();

// 带默认值的注解参数
public String method() default "get";

}
@ActionAnnotation
public class AnnoDemo {
@MethodAnnotation(path = "test")
public void show() {
System.out.println("测试");
}
}
public class AnnoClassDemo {

public static void main(String[] args) {
    try {
        // 获取大Class对象
        Class<AnnoDemo> Clazz = (Class<AnnoDemo>) Class.forName("Anno.AnnoDemo");
        // 获取当前所有的注解
        Annotation[] annotations = Clazz.getAnnotations();
        // 遍历
        for (Annotation annotation : annotations) {
            System.out.println(annotation.annotationType().getName());
            // 判断注解名是否为指定注解
            if (annotation.annotationType().getName().equals("Anno.ActionAnnotation")) {
                AnnoDemo a = Clazz.newInstance();
                a.show();
            }
        }
        Method m = Clazz.getMethod("show");
        Annotation[] arr = m.getDeclaredAnnotations();
        for (Annotation temp : arr) {
            System.out.println(temp.annotationType().getName());
            if (temp.annotationType().getName().equals("Anno.MethodAnnotation")) {
                MethodAnnotation ma = (MethodAnnotation) temp;
                System.out.println(ma.path());
                System.out.println(ma.method());
            }
        }
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (SecurityException e) {
        e.printStackTrace();
    }
}

}