corejava一些零碎知识点的总结（考前复习）

部分还未更新完毕，持续更新中············

shell

Bourne shell （sh）
Korn shell (ksh)
C shell (csh)
Bourne-again shell (bash)

操作系统的三大组成及各自作用

kernel 管理硬件 管理内存 管理进程
shell 用户与内核进行交互的接口
fire system文件存放在磁盘等存储设备的组织方法

Linux常见目录结构

/opt 第三方软件
/etc 系统的配置文件
/edv 设备文件
/usr 用户级文件
/var 日志文件
/kernel 内核文件
/home 用户的家目录

类装载器：

1、启动类装载器：bootstrap class loader
从jdk的安装目录下 jdk/jre/lib/rt.jar
rt.jar 是个包，放的是Java作为开发环境的所有的库
2、扩展类装载器：extensible class loader
从jdk的安装目录下 jdk/jre/lib/ext/*.jar
jdk下的所有的.jar 文件
3、系统类装载器：system class loader
$CLASSPATH
你所配置的classpath
4、网络类装载器：network class loader
类加载器:从一个指定路径下面去加载代码运行时需要用到的java类

类修饰符-成员变量修饰符-方法修饰符

类修饰符：
public（访问控制符），将一个类声明为公共类，他可以被任何对象访问，一个程序的主类必须是公共类。
abstract，将一个类声明为抽象类，没有实现的方法，需要子类提供方法实现。
final，将一个类生命为最终（即非继承类），表示他不能被其他类继承。
friendly，默认的修饰符，只有在相同包中的对象才能使用这样的类。

成员变量修饰符：
public（公共访问控制符），指定该变量为公共的，他可以被任何对象的方法访问。
private（私有访问控制符）指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。
protected（保护访问控制符）指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。
friendly ，在同一个包中的类可以访问，其他包中的类不能访问。
final，最终修饰符，指定此变量的值不能变。
static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。
transient（过度修饰符）指定该变量是系统保留，暂无特别作用的临时性变量。
volatile（易失修饰符）指定该变量可以同时被几个线程控制和修改。

方法修饰符：
public（公共控制符）
private（私有控制符）指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类）
protected（保护访问控制符）指定该方法可以被它的类和子类进行访问。
final，指定该方法不能被重载。
static，指定不需要实例化就可以激活的一个方法。
synchronize，同步修饰符，在多个线程中，该修饰符用于在运行前，对他所属的方法加锁，以防止其他线程的访问，运行结束后解锁。
native，本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。

局部变量和实例变量的区别

局部变量：
1).定义在类中的大括号中的{}中的变量都是局部变量，如方法中，匿名代码块，流程控制语句等
2).使用前必须进行初始化（自己进行）
3).作用范围，声明位置开始到声明所在的{}大括号结束

实例变量：
1).定义中类中
2).创建实例（对象）时，JVM会对类中的实例变量进行默认初始化
3).创建实例时，实例变量开始存在这个对象消失时，实例变量消失

break，continue以及return的用法

break 跳出当前循环，继续往下执行
//    alble + break，跳出外层循环
continue 跳出本次循环，继续下一次循环
return 结束当前方法, return 之后的语句不会执行 

不同位置创建对象的方式

1).通过java的new关键字创建对象
2).通过反射手段返回对象
调用java.lang.Class类的newInstance()方法
调用java.lang.reflect.Constructor类的newInstance()方法
3)通过I/O流泛型（反序列化）返回对象
调用java.io.ObjectInputStream对象的readObject()方法返回对象
需要实现Serializable接口
4).通过工厂方法返回对象
如：String str = String.valueOf(10);
5).通过对象的clone()方法返回对象
需要满足一下两点条件:
需实现Cloneable接口、覆盖clone方法

方法重载和方法重写的区别

目的（作用）：
方法重载是：行为相同结果不同时 进行使用
方法重写是：父类不能满足子类的方法要求

要求：
方法重载是：定义在同一个类中，方法名相同，参数列表不同（个数，顺序，类型不同），抛异常等可以相同可以不同
方法重写是：在子类中重写父类的方法，方法名相同，参数列表相同，返回值类型“相同”（当父类的返回值类型是子类的返回值类型的父类时也可以），访问修饰符不能被缩小，抛异常不能被放大
必须是非静态方法（静态的可以再次声明但不是重写）
该方法必须是可以直接访问的

多态：
方法重载是：编译时多态
方法重写是：运行时多态

this和super的各自的作用

构造器的调用方面：
this 调用本类的构造器this.constructorName；
super调用父类的构造器super(constructorName)；

都需要放在第一行

调用方法：
this调用本类方法
super调用父类方法

调用属性：
this调用本类属性
super调用父类属性

this 指当前类对象 还能用于get，set方法种区别实例变量和局部变量

this和super不能存在于同一个构造方法

对拥有子类的父类方法进行初始化时，父类的构造方法也会执行，且优先于子类的构造方法。

this super 不能被static修饰

访问修饰符的范围

public 同类 同包 不同包子类 不同包
protected 同类 同包 不同包子类
default 同类 同包
private 同类

static

1、修饰成员变量
2、修饰成员方法
3、静态代码块
4、修饰类【只能修饰内部类也就是静态内部类】
5、静态导包

一句话来概括：方便在没有创建对象的情况下来进行调用。

1.被static修饰的成员变量叫做静态变量，也叫做类变量，说明这个变量是属于这个类的，
而不是属于是对象，没有被static修饰的成员变量叫做实例变量，说明这个变量是属于某个具体的对象的。
2.修饰方法的时候，其实跟类一样，可以直接通过类名来进行调用。
3.静态代码块在类第一次被载入时执行。
4.static修饰内部类，普通类是不允许声明为静态的，只有内部类才可以。
5.静态导包就是java包的静态导入，用import static代替import静态导入包是JDK1.5中的新特性。
好处：这种方法的好处就是可以简化一些操作，例如打印操作System.out.println(…);就可以将其写入一个静态方

代码块的执行顺序

代码块执行顺序静态代码块——> 构造代码块 ——> 构造函数——> 普通代码块
（构造代码块与普通代码块的区别：构造代码块是在类中定义，普通代码块则是在方法体中定义）

继承中代码块执行顺序：父类静态块——>子类静态块——>父类代码块——>父类构造器——>子类代码块——>子类构造器

1.加载静态代码块先加载父类的，再加载本类的
2.调用父类的匿名代码块
3.调用父类的构造器
4.调用本类的匿名代码块
5.调用本类的构造器
    
p.s.new一个对象的时候JVM都做了那些事情
1.类加载,(java -cp xx.xx.xx,Class.forName/load)
   同时初始化类中静态的属性(赋默认值)
2.执行静态代码块(先父类后自己)
    //如果之前做过类加载，从第三步开始执行
3.分配内存空间,同时初始化非静态的属性(赋默认值)
4.调用父类构造器,如果父类中有匿名代码块先调用匿
   名代码块
5.父类构造器执行完后,如果自己声明属性的同时有
   显示的赋值,那么进行显示赋值把默认值覆盖
6.执行匿名代码块
7.执行构造器
8.返回内存地址

Abstract与Interface

1).共同点
A.两者都是抽象类，都不能实例化
B.Interface实现类和abstract继承类都必须实现抽象方法
2).不同点
A.Interface需要实现,用implements;Abstract 需要继承,用exends
B.一个类可以实现多个Interface ;一个类只能继承一个Abstract
C.抽象类可以有构造方法，接口中不能有构造方法。
D.抽象类中可以有普通成员变量，接口中没有普通成员变量
E.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
F.抽象类中可以包含静态方法，接口中不能包含静态方法
G.抽象类中的抽象方法的访问类型可以是public，protected；但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型

两种单例模式

//懒汉式单例类.在第一次调用的时候实例化自己 
public class Singleton {
    private Singleton() {}
    private static Singleton single=null;
    //静态工厂方法 
    public static Singleton getInstance() {
         if (single == null) {  
             single = new Singleton();
         }  
        return single;
    }
}

//饿汉式单例类.在类初始化时，已经自行实例化 
public class Singleton {
    private Singleton() {}
    private static final Singleton single = new Singleton1();
    //静态工厂方法 
    public static Singleton getInstance() {
        return single;
    }

内部类

1).static Inner classes
2).member Inner classes
3).local Inner classes
4).anonymous Inner classes
A.在哪定义
B.怎么定义
C.内部类里能定义什么
D.内部类中可以使用外部类的什么
E.外部类怎么使用内部类
F.外部类的外面怎么使用内部类

静态内部类：
静态内部类也是作为一个外部类的静态成员而存在，创建一个类的静态内部类对象不需要依赖其外部类对象。

A.定义中类中的大括号{}中
B.static class ClassName 定义
C.可以定义变量 和 静态变量
可以定义public，protected，default，private修饰的属性，可以定义static属性。
方法也可以定义public，protected，default，private修饰的方法，static方法。
可以定义构造器。
D.可以使用外部类的静态属性，静态方法，非静态的不能使用
E.无需依赖外部类对象，可以直接创建内部类对象，对象.属性 ，方法调用内部类
F.要依赖外部类创建对象，外部类类名.静态内部类类名 new对象

​ 静态内部类就像外部类的一个静态成员一样，创建其对象无需依赖外部类对象（访问一个类的静态成员也无需依赖这个类的对象，因为它是独立于所有类的对象的）。但是于此同时，静态内部类中也无法访问外部类的非静态成员，因为外部类的非静态成员是属于每一个外部类对象的，而本身静态内部类就是独立外部类对象存在的，**所以静态内部类不能访问外部类的非静态成员，而外部类依然可以访问静态内部类对象的所有访问权限的成员，**这一点和普通内部类无异。

成员内部类：

内部类是一个编译时概念，一旦编译成功，它就与外围类属于两个完全不同的类（联系：内部类含有外部类对象的引用）。

A.定义中类中的大括号{}中
B.class ClassName 定义
C.可以定义变量
可以定义public，protected，default，private修饰的属性
方法也可以定义public，protected，default，private修饰的方法
可以定义构造器。
但不能定义静态东西
D.静态的 与 非静态的属性，方法，变量都可以使用
E.需要创建成员内部类的对象，调用对象的属性，方法等
F.外部类类名.内部类类名 变量名= new 外部类类名().new内部类类名();

当内部类的属性与外部类同名时，会覆盖外部类的同名属性。
成员内部类可以无限制的访问外部类的属性和方法**（包括 private）**，但是外部类要访问内部类的成员属性和方法，则需要通过内部类实例来访问。
成员内部类是依附与外围类的，只有先创建了外部类，才能够创建内部类。

局部内部类：

​ 局部内部类使用的比较少，其声明在一个方法体 /一段代码块的内部，而且不在定义类的定义域之内便无法使用，其提供的功能使用匿名内部类都可以实现，而本身匿名内部类可以写得比它更简洁，因此局部内部类用的比较少。

A.定义在外部类的方法体/代码块中
B.Class ClassName{}定义
C.可以定义变量，属性，方法，但是不能定义static修饰的静态的东西
D.静态的 与 非静态的属性，方法，变量都可以使用
E.局部内部类本身就存在于方法中，需要通过创建外部类的对象，调用局部内部类
F.依赖外部类创建对象，new外部类对象，外部类类名.方法名 调用

​ 在局部内部类里面可以访问外部类对象的所有访问权限的字段，而外部类却不能访问局部内部类中定义的字段，因为局部内部类的定义只在其特定的方法体 / 代码块中有效，一旦出了这个定义域，那么其定义就失效了。

匿名内部类：

匿名内部类有多种形式，其中最常见的一种形式莫过于在方法参数中新建一个接口对象 / 类对象，并且实现这个接口声明 / 类中原有的方法了。

A+B.new一个接口/类对象时
new Interface(){
};
C.可以定义属性，重写方法，定义变量，同样不能定义静态东西（能定义的必定为静态内部类）
由于匿名内部类没有名字，自然不能定义构造函数
D.静态的 与 非静态的属性，方法，变量都可以使用
E+F.不能使用匿名内部类的属性方法等

在匿名内部类中可以使用外部类的属性，但是外部类却不能使用匿名内部类中定义的属性，因为是匿名内部类，因此在外部类中无法获取这个类的类名，也就无法得到属性信息。

"=="与equals

基本数据类型包括：int，char，float，long，double，boolean，byte，short(注：String不是基本数据类型)；基本数据类型之间的比较用"=="。

​ 引用数据类型包括：Integer，Char，Float，Long，Double，Boolean，Byte，Short。引用数据类型“==”比较的是他们在内存中的存放地址，equals比较的是值是否相等。

Object中的.equals()方法和"==’功能一样,但是String类中的.equals()方法重写了.

方法调用有几种方式

1）静态方法直接调用
2）通过对象调用普通方法
3）通过反射invoke调用方法

构造器调用的有几种方式

1）new对象调用构造器
2）this
3）super
4）Constructor<?>[] cons=c.getDeclaredConstructors(); 取出构造器
反射 创建对象调用有参/无参的构造器Object o =con.newInstance();
5）反射 调用无参构造器Class 的new Instance();

集合

唯一吗?

是：Set

排序吗?

是：TreeSet或LinkedHashSet
否：HashSet
如果你知道是Set，但是不知道是哪个Set，就用HashSet。

线程安全用HashTable

否：List

要安全吗?

是：Vector
否：ArrayList或者LinkedList

查询多：ArrayList
增删多：LinkedList
如果你知道是List，但是不知道是哪个List，就用ArrayList。

如果你知道是Collection集合，但是不知道使用谁，就用ArrayList。
如果你知道用集合，就用ArrayList。

遍历一个List有哪些不同的方式？

for(int i=0;i<list.size;i++){System.out.println(list.get(i));}

for(Object o:list){System.out.println(o);}

Iterator iterator = list.iterator();
while(iterator.hasNext()){System.out.println(iterator.next());}

泛型

泛型将接口的概念进一步延伸，”泛型”字面意思就是广泛的类型，类、接口和方法代码可以应用于非常广泛的类型，代码与它们能够操作的数据类型不再绑定在一起，同一套代码，可以用于多种数据类型，这样，不仅可以复用代码，降低耦合，同时，还可以提高代码的可读性和安全性。
通过使用泛型，开发环境和编译器能确保你不会用错类型，为你的程序多设置一道安全防护网。使用泛型，还可以省去繁琐的强制类型转换，再加上明确的类型信息，代码可读性也会更好。

泛型的上下限：

向下限定： 
List<? extends Object> list = new ArrayList<>(); 
//泛型只能为 Object或者Object的子类 

向上限定： 
List<? super String> list = new ArrayList<>(); 
//泛型只能为：String以及String的父类

1.泛型的类型参数只能是类类型，不能是简单类型。
2.不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错。
if(ex_num instanceof Generic<Number>){   
} 

泛型的通配符"?"
此处"?"是类型实参，而不是类型形参
换一种方式理解就是此处的?和Number、String、Integer一样都是一种实际的类型，可以把?看成所有类型的父类。是一种真实的类型。

枚举

枚举是JKD1.5 新增的一个关键字enum，表示一种枚举类型。
枚举类型也是一种类(class)，是一种特殊的类，枚举类型中所列出的元素，就是枚举类型的对象，默认是用public static final修饰的，所以这些对象的名字一般都是全字母大写

反射

反射main方法下

Class<?> c1 = ClassName.class;

ClassName Name=new ClassName(null);
Class<? extends ClassName> c2 = Name.getClass();

Class<?> c3=Class.forName(“PackageName.ClassName”);

newInstance();
invoke();

常见的一些异常

InterruptedIOException
IOException
FileNotFoundException
FileException
FileSystemException
InterruptedException

RuntimeException:
ArrayStoreException
EmptyStackException
FileSystemNotFoundException
NullpointerException
IndexOutOfBoundsException： ArrayIndexOutOfBoundsException
StringIndexOutOfBoundsException
Arith metic Exception
UnknownHostException
ClassCastException

线程

创建线程的方法：
使用接口implements Runnable
或者继承extends Thread

区别：
接口需要具体实现接口下的方法，但是原class类可以继承其他类
而继承不需要实现方法，可以继承父类Thread下的所有方法，但是不能继承其他的类

start和run的区别：
start方法：
通过该方法启动线程的同时也创建了一个线程，真正实现了多线程。**无需等待run()方法中的代码执行完毕，就可以接着执行下面的代码。此时start()的这个线程处于就绪状态，当得到CPU的时间片后就会执行其中的run()方法。**这个run()方法包含了要执行的这个线程的内容，run()方法运行结束，此线程也就终止了。
run方法：
通过run方法启动线程其实就是调用一个类中的方法，当作普通的方法的方式调用。并没有创建一个线程，程序中依旧只有一个主线程，必须等到run()方法里面的代码执行完毕，才会继续执行下面的代码，这样就没有达到写线程的目的。

java线程中的七种状态

新建状态(New)
就绪状态(Runnable)
运行状态(Running)
阻塞状态(Blocked)
等待状态(WAITING)
限时等待状态(TIMED_WAITING)
死亡状态(TERMINATED)

sleep()方法与wait()方法有什么区别？

sleep()是使线程暂停执行一段时间的方法。wait()也是一种使线程暂停执行的方法。二者区别为：

​ ①原理不同。
​ sleep()方法是Thread类的静态方法，是线程用来控制自身流程的，它会使此线程暂停执行一段时间，而把执行机会让给其他线程，等到计时时间一到，此线程会自动苏醒。而wait()方法是Object类的方法，用于线程间的通信，这个方法会使当前拥有该对象锁的进程等待，直到其他线程用调用notify()或notifyAll()时才苏醒过来，开发人员也可以给它指定一个时间使其自动醒来。

​ ②对锁的处理机制不同。
​ 由于sleep()方法的主要作用是让线程暂停一段时间，时间一到则自动恢复，不涉及线程间的通信，因此调用sleep()方法并不会释放锁。而wait()方法则不同，当调用wait()方法后，线程会释放掉它所占用的锁，从而使线程所在对象中的其他synchronized数据可被别的线程使用。+

​ ③使用区域不同。
​ wait()方法必须放在同步控制方法或者同步语句块中使用，而sleep方法则可以放在任何地方使用。
​ sleep()方法必须捕获异常，而wait()、notify()、notifyAll()不需要捕获异常。在sleep的过程中，有可能被其他对象调用它的interrupt()，产生InterruptedException异常。
​ 由于sleep不会释放锁标志，容易导致死锁问题的发生，一般情况下，不推荐使用sleep()方法，而推荐使用wait()方法。