🍖详细杂乱知识总结

语法类问题

关于 equals 的问题

答： 对于Objects的equals更安全，当出现空指针时候不会出现空指针异常。

ClassA a=null;
ClassB b=new ClassB();
//1.此处会报空指针异常
System.out.println(a.equals(b));
//2.此处返回false
System.out.println(Objects.equals(a,b));

关于类的权限修饰符问题

答：class 无法使用 private 修饰

           - 解释：private 类内访问，本身类内就可以访问，无意义

构造器问题

继承问题

内部类问题

关于内部类的两种创建方法

//1.静态内部类
OutClass.InerClass className=new OutClass.InerClass();
//2.成员内部类
OutClass.InerClass className=new OutClass().new InerClass();

静态内部类是否可以直接访问外部类的静态成员 ？

  **答：可以的**，外部类的静态成员只有一份，可以被共享

静态内部类是否可以直接访问外部类的实例成员 ？

答：不可以，静态内部类属于外部类本身，不属于外部类对象。

成员内部类不能定义静态成员

答：静态成员只加载一次，在初始化时加载至静态区

           - 成员内部类是外部类的成员，成员是没有静态区的

静态内部类可以定义静态成员 。

成员内部类是否可以直接访问外部类的静态成员 ？

答：可以的，外部类的静态成员可以被共享

成员内部类是否可以直接访问外部类的实例成员 ？

答：可以的，成员内部类属于外部类对象，可以直接访问当前外部类对象的实例成员

总结： 成员内部类可以访问外部类的所有成员

局部内部类成分特点

答：只能定义实例成员，不能定义静态成员 。可以定义常量。

总结： 局部内部类基本没啥用

抽象类问题

接口类问题

面向对象类问题

多态使用前提

     1. 必须存在**继承**或者**实现**关系
     1. 必须存在父类类型的变量引用子类类型的对象
     1. 需要存在方法重写

容器类问题

整个容器的继承体系问题

整个容器的祖宗接口Collection

• List 接口：有序，索引，重复

  • LinkedList ： [ 添加元素 ] 有序，有索引，可重复———基于双向链表
  • ArrayList ： [ 添加元素 ] 有序，有索引，可重复———基于连续数组

• set 接口： 无序，无索引，不重复

  • HashSet 实现类： [ 添加元素 ] 无序，无索引，不重复
    • LinkedHashSet 实现类： [ 添加元素 ] 有序，不重复，无索引
  • TreeSet 实现类： [ 添加元素 ] 默认升序排序（可排序集合），无索引，不重复

Set判重标准

     1. 首先判断2个对象的 HashCode 是否相同
        - 若相同则重复，false
     2. 接着用 equals 判断2个对象的内容是否相等
        - 若相同则重复，false

故new出的2个相同内容的对象，依旧会被插入进去 因此想内容相同的对象不被插入，就必须重写hashcode和equals

Java 规定的比较规则的返回值

     1. 程序员认为比较者 > 被比较者，返回正数
     1. 程序员认为比较者 < 被比较者，返回负数
     1. 程序员认为比较者 = 被比较者，返回零值

return this.num - o.num ;

TreeSet 容器内排序的两种方法

     1. 实现comparable接口，重写compareTo方法
     1. 为集合设置比较器Comparator

二者共存，优先使用类内的比较准则

凡是 Set、Map 接口实现类需要保证不重复

必须需要重写 HashCode 和 equals

多线程问题

多线程实现的3种方式

     1. 继承Thread类，重写 run 方法
     1. 实现runnable接口，重写 run 方法 
     1. 实现callable接口

//1.创建一个线程任务类实现callable接口，申明线程返回结果类型
public class MyCallable implements Callable<String> {
    //2.重写call方法
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName()+"-->>"+i);
        }
        return "Are You Ok ?";
    }
}
public class MyTest{
    public static void main(String[] args) {
        //3.创建一个Callable的线程任务对象
        Callable call=new MyCallable();
        //4.把Callable包装成未来任务对象
        FutureTask<String> task=new FutureTask<>(call);
        //5.把未来任务对象包装成线程对象
        Thread t=new Thread(task);
        t.setName("子线程");
        //6.启动线程对象
        t.start();
        //7.模拟主线程任务
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName()+"-->>"+i);
        }
        //8.最后获取线程执行结果
        try {
            String res=task.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

Java集合保证线程安全的有 ？

（1）Vector：所有方法均加锁 sycnhronized 修饰 （2）Hashtable：底层的方法或变量使用 sycnhronized 关键字修饰 （3）ConcurrentHashMap：线程安全的Map （4）Statck：堆栈类，先进后出 （5）Enumeration：枚举，相当于迭代器。 [ 亦可防暴力反射破解 ]