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

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

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

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

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

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

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

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

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

break，continue以及return的用法

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.加载静态代码块先加载父类的，再加载本类的
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 singleton = new Singleton1();
    //静态工厂方法 
    public static Singleton getInstance() {
        return singleton;
    }

内部类

1).static Inner classes
2).member Inner classes
3).local Inner classes
4).anonymous Inner classes
A.在哪定义
B.怎么定义
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());}

泛型

泛型将接口的概念进一步延伸，”泛型”字面意思就是广泛的类型，类、接口和方法代码可以应用于非常广泛的类型，代码与它们能够操作的数据类型不再绑定在一起，同一套代码，可以用于多种数据类型，这样，不仅可以复用代码，降低耦合，同时，还可以提高代码的可读性和安全性。

通过使用泛型，开发环境和编译器能确保你不会用错类型，为你的程序多设置一道安全防护网。使用泛型，还可以省去繁琐的强制类型转换，再加上明确的类型信息，代码可读性也会更好。

枚举

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

反射

反射main方法下

Class c1 = ClassName.class;

ClassName Name=new ClassName(null);
ClassClassName> 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()方法。