黑马程序员-基础知识梳理4

------- android培训、java培训、期待与您交流！
----------

finally 代码块：定义一定执行的代码块

第一种格式:try｛｝catch(){}

第二种格式：try{}  catch(){} finally{}

第三种格式：try{} finally{}

重点：catch是用于处理异常，如果没有catch就代表异常没有被处理，如果该异常是检测时异常，那么必须声明

异常在子父类覆盖中的体现：

1.子类在覆盖父类时，如果父类的方法抛出异常；那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类

2.如果父类抛出多个异常，那么子类在覆盖方法时，只能抛出父类方法的子集；

3如果父类或者接口的方法中，没有抛出异常，那么子类在覆盖方法时，也不可以抛出异常。如果子类发生异常必须try处理，绝对不能抛；

异常总结：

定义;将问题进行描述，将问题进行对象的封装

异常体系：

Throwalbe

|----Error

|----Exception

      |------RuntimeException

一般的异常在函数内抛，必须在函数上声明，否则编译失败。

RuntimeException 及其子类在函数内抛，不需要在函数上声明，编译一样通过。如果在函数上声明了该异常，调用可以不用进行处理。

为什么不声明？就是为了让他不处理这个异常。当该异常发生，希望该程序停止，在运行时，出现了无法处理的问题，希望程序停止后，程序员修正代码.

异常体系的特点：

异常体系中的所有类以及简历的对象都具备可抛性，均可以被throw和throws关键字操作，只有异常体系具备这些特点

当函数内容有throw抛出异常对象，并未进行try处理，必须要在函数上声明，否则编译失败，RuntimeException除外

异常处理分为throws 和try

注意：1.finally中定义的通常是关闭资源的代码，因为资源必须释放；

2，finally只有一种情况不执行，当执行System.exit();   此时，JVM关闭

自定义异常：

定义类继承Exception 或者RuntimeException

1，为了让该自定义异常具有可抛性

2，让该类具备操作异常的共性方法，当要定义自定义异常的信息时，可以使用父类已经定义好的功能,将异常信息传递给父类的构造函数。

自定义异常：按照java的面向对象思想，将程序中出现的特有问题进行封装

class MyException extends Exception

{

MyException(String message){

super(message);

}

}

异常的好处：

1，将问题进行封装

2，将正常流程代码和问题处理代码分离，方便阅读

异常处理原则：

1处理方式分：try或者throws

2 调用到抛出异常的功能时，抛出几个异常，处理几个，一个try对应多个catch

3 多个catch 父类的catch放在最下面

4 catch内需要定义针对性的处理方式，不要简单的定义printStackTrace输出语句

当catch 到异常，本功能处理不了时，可以继续在catch中抛出

try{

throw new AException;

}

catch(AException e){

throw e;

}

如果该异常处理不了，但并不属于该类功能的异常可以将异常转换后，在抛出和该功能能相关的异常，或者异常可以处理，但是需要将异常产生的和本功能相关问题提出，让调用者知道。也可以将捕获异常处理后，转换新的异常。

try{

throw new AException;

}

catch (AException e){

throw new BException;

}

非静态内部类中不可以定义静态成员。内部类中如果定义了静态成员，该内部类必须被静态修饰。

静态方法只能覆盖静态；

throw 单独存在时 下面不要跟语句。

习题：

//下列那些函数可以存在该类的子类中

class Demo1{
int show (int a,int b){return 0;}
}

a.  public int show(int a ,int b){return 0;}//kyi
b. private int show(int a,int b){return 0;}//no，权限不够，子类的覆盖方法权限必须大于等于父类
c. private int  show(long a,int b){return 0;}//可以，这是方法的重载
d. public short show(int a,int b){return 0;}//no,该方法不能存在于同一子父类中
e. static int show(int a, int b){ return 0;}//no 静态只能覆盖静态

包：定义包名，所有字母小写

包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰

不同包中的子类还可以直接访问父类中被protected权限修饰的成员。

包与包之间可以使用的权限有两种 public protected

                      public              protected              default        private

在同一个类中 y 
y y y

在同一个包中 y
y y  

子类 y
y

不同包中 y

impo
4000
rt:简化类名书写

一个java文件内不能出现2个或者2个以上的公有类或者接口

jar： 命令： jar -cf xx.jar 包 包

多线程：

进程：每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫控制单元；

线程：进程中的一个独立控制单元。线程在控制着进程的执行

一个进程中至少有一个线程

java VM启动的时候，会有一个进程 java.exe

该进程中至少有一个线程，负责java程序的执行，而且该线程运行的代码存在于main方法中，该线程称为主线程

如何在自定义的代码中，自定义一个线程？

步骤：

1 定义类继承Thread

2 复写Thread 类中的run方法，将自定义的代码存储在run方法中，让线程运行；

3 调用线程的start方法，该方法有2个作用：启动线程和调用run方法；

为什么要覆盖run方法？

Thread 类用于描述线程

该类定义一功能，用于存储线程要运行的代码。

 

static Thread currentThread(); 获取当前线程对象

getName();获取线程名称

设置线程名称：setName或者构造函数；

创建线程的另一种方法：

实现Runnable接口

步骤：

1定义类实现Runnable 接口

2 覆盖Runnable 接口中的run方法

3 通过Thread 类建立线程对象

4 将Runnable 接口的子类对象作为实际参数传递给Thread类的构造函数

5 调用Thread 类的start方法开启线程并调用Runnable接口子类的run方法；

为什么要将Runnable接口的子类对象传递给Thread的构造函数？

因为自定义的run方法所属对象是Runnable接口的子类对象，所以要让线程去指定对象的run方法。就必须明确run方法所属对象。

实现方式和继承方式有什么区别？

实现方式好处：避免了单继承的局限性。在定义线程时，建立实现方式；

继承Tread：线程代码存放在Thread子类run方法中，

实现Runnable:线程代码存在接口的子类的run方法中

多线程的安全问题：

问题原因：多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

解决办法：

对多条操作共享数据的语句，只能让一个线程执行完。在执行过程中，其他线程不可以参与执行。

同步代码快：

synchronized (对象)

{

需要被同步的代码;

}

同步的前提： 1 必须要有两个或者两个以上的线程

2.必须是多个线程使用同一个锁

如何找到问题

1.明确那些代码是多线程运行代码

2.明确共享数据

3.明确多线程运行代码中那些语句是操作共享数据的

同步函数用的锁对象是this

如果同步函数被静态修饰，锁不是this ，因为静态方法中不能定义this

静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。类名.class 该对象的类型是class

重点掌握懒汉式一些问题：

static class Single{
private static Single s= null;
private Single(){}
public static Single getInstance(){
if(s==null){
synchronized(Single.class){
if(s==null)
s=new Single();
}
}
return s;

}
}
}

懒汉式和饿汉式有什么区别"?

懒汉式实现实例延迟加载

延时加在有问题，如果多线程加载会出现安全问题

处理：可以通过同步代码块或者同步函数来处理

用双重判断形式可以提高效率，加锁时候，使用的对象是该类所属对象的字节码对象

死锁：

多线程问题：多个线程操作同一个资源，但操作动作不同

等待唤醒机制

wait：

notify();

notifyAll();

都使用在同步中，因为要对持有监视器（锁）的线程操作，所以要使用在同步中。因为只有同步才有锁。

为什么这些操作线程的方法要定义在Object类中？

因为这些方法所操作的线程只有的锁，只有同一个锁上的被等待线程可以被同一个锁上的notify唤醒；不可以对不同锁中的线程进行唤醒。

而锁可以是任意对象，可以被任意对象调用的方法定义在object类中

对于多个生产者和消费者

为什么定义while判断标记？

为了让被唤醒的线程再一次判断标记

为什么要定义notifyall

因为需要唤醒对方线程

只用notify 容易出现只唤醒本方线程的情况，导致程序中的所有线程都等待。

java1.5的心特性

lock接口

condition接口

如何停止线程？

只有一种，run方法结束

开启多线程运行，运行代码通常是循环结构

只要控制住循环，就可以让run方法结束，也就是线程结束

特殊情况：当线程处于冻结状态，就不会读取标记，那么线程就不会结束

当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除。

强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束

Thread类中提供该方法interrupted方法

setDaemon 守护线程：后台线程

后台线程“当所有前台进程结束后，后台进程自动结束

join：等待线程终止

当A线程执行到b线程的,join()；方法时A就会等待。等b线程都执行玩了，A才会再执行。join可以用来临时加入线程执行

yield（）方法：释放线程执行权；