[黑马程序员]（第51天）今晚复习小结

------- android培训、java培训、期待与您交流！ ----------编程4大原则：

讨论

边界

异常

逻辑

java中的一场处理机制？

谁调用谁处理，如果一直抛出最终会抛出给虚拟机

方法中的内部类能不能访问方法中的局部变量，为什么？ 

 *  

 *  因为内部类的生存周期比方法中的局部变量长，局部变量再作用域完成后就会被栈内存释放销毁。要想访问局部变量，那么局部变量必须被final修饰。 

 * 

在取Map对象中一个不存在的entry时，get(object key)会返回null

面试:跟我谈谈什么是面向对象

1 面向对象是基于面向过程的

2 告诉他什么是面向过程什么是面向对象

3 在说面向对象的思想特点

4 举例说明(要求每人想一个)

同步函数&同步代码块的锁：

同步函数的锁是this

同步函数和同步代码块的区别：

同步函数的锁死固定的this

同步代码块的锁死任意的对象（传参）

实现Runnable接口开启线程的好处：

1.将线程的任务从线程的子类分离出来，进行了单独的封装

按照面向对象的思想将任务封装成了对象

2.避免了java单继承的局限性（因为是接口，可以多实现再加一个继承来拓展功能）

同步的好处：解决了线程的安全问题。

同步的弊端：相对降低了效率，因为同步外的线程的都会判断同步锁。

同步的前提：同步中必须有多个线程并使用同一个锁。

注意：if判断标记与notify()对应，while和notifyAll()对应，这样单配才不会导致死锁

为什么操作线程的方法wait notify notifyAll定义在了Object类中？

因为这些方法是监视器的方法。监视器其实就是锁。

锁可以是任意的对象，任意的对象调用的方式一定定义在Object类中。

jdk1.5以后将同步和锁封装成了对象。

并将操作锁的隐式方式定义到了该对象中，

将隐式动作变成了显示动作。

Lock接口： 出现替代了同步代码块或者同步函数。将同步的隐式锁操作变成现实锁操作。

同时更为灵活。可以一个锁上加上多组监视器。

lock():获取锁。

unlock():释放锁，通常需要定义finally代码块中。

Condition接口：出现替代了Object中的wait notify notifyAll方法。

将这些监视器方法单独进行了封装，变成Condition监视器对象。

可以任意锁进行组合。

await();

signal();

signalAll();

|--JDK1.5以后出现了更好的方案，★★★

Lock接口替代了synchronized

Condition接口替代了Object中的监视方法，并将监视器方法封装成了Condition

和以前不同的是，以前一个锁上只能有一组监视器方法。现在，一个Lock锁上可以多组监视器方法对象。

阻塞：

1）程序试图获取某个对象的同步锁，而该锁被其他线程说持有---获取到其他线程所持有的锁

2）线程调用了一个阻碍式的io方法---io方法返回

3）线程调用了某个对象的wait()方法---notify()方法唤醒

4）线程调用了Thread的sleep(long millis)方法---等

5）一个线程中调用了另一个线程的join()方法---等

Thread类的三个方法：

yield()--静态

jion()---非静态

sleep()---静态

可以实现一组负责生产者，一组负责消费者。

但是如果线程处于了冻结状态，无法读取标记。如何结束呢？

可以使用interrupt()方法将线程从冻结状态强制恢复到运行状态中来，让线程具备cpu的执行资格。

当时强制动作会发生了InterruptedException，记得要处理

/*class Test implements Runnable

{

public void run(Thread t)

{}

}*/

//如果错误 错误发生在哪一行？错误在第一行，应该被abstract修饰

？？？？？？

10、代码块的面试

一 子父类中如果有 构造方法,构造代码块,静态代码块在创建对象时他们的执行顺序是怎么样的?  

执行顺序:

父静态代码块

子静态代码块

父构造代码块

父构造方法

子构造代码块

子构造方法

注意:当创建多个对象的时候静态代码块只执行一次(class字节码文件对象只加载一次的前提下)

9，代码块。

53

1，局部代码快。

对局部变量的生命周期进行控制。使局部变量用完之后尽快被jvm回收。

2，构造代码块。

对所有对象进行初始化。把构造方法里的共同代码汇合，使之一起进行初始化。（针对性）

3，静态代码块。

对类进行初始化。

private：

1、修饰成员，被它修饰的成员只能在本类中被访问

2.可以修饰构造方法（不想让外界通过new关键字创建这个类的对象）

this（super）：

用在普通方法，this(super).变量名表示调用本类（父类）中成员变量

用在构造和方法，表示调用本类（父类）中的其他的构造方法

final

修饰成员变量，变成常量

修饰成员方法，方法不能被重写

修饰类，该类不能被继承

内部类访问特点：

1）内部类可以直接访问外部类的成员

2）外部类要访问内部类，必须建立内部类的对象

内部类之所以能直接访问外部类的成员，是因为内部类持有了外部类的引用，即外部类名.class（外部类的字节码对象）

局部内部类如果访问方法中的局部变量，这个变量必须用final修饰

为什么？

为了延迟该局部变量的生命周期（因为一般局部变量在方法调用后都会消失（出栈），而final可以将局部变量变为堆内存中的常量）

多态的前提：

要有继承

要有方法重写

要有父类引用指向子类

（其实所谓多态，就是向上转型或者向下转型）

---所谓父类引用指向子类，即父类的栈内存指针，指向的堆内存其实是子类的，用代码表示就是：

Animal a = new Dog();

抽象类既然不能实例化，那么其构造方法作用？

是为了初始化成员变量，给子类继承使用

抽象类中的抽象方法是为了强制子类实现某些功能。

抽象类中的非抽象方法，是为了提高代码的复用性，让子类继承的。

这其实是自动类型提升，但子类的特有功能无法访问。专业讲：向上转型，将子类型隐藏，就不使用子类的特有方法。

Dog d = (Dog) a---向下转型的目的是为了使用子类中的特有方法

多态中的成员特点：

成员变量：编译看左边，运行看左边

成员方法：同上

判断父类中是否有存在这样的成员变量或者成员方法，如果有编译就能通过，而运行结果还是要依据子类

多态的好处：

提高了代码的扩展性（继承是复用性），前期定义的代码可以使用后期的内容（都是继承打的基础啊，使得父类可以使用子类的方法）

多态的弊端：

父类引用无法使用子类的特有功能

解决方法：

父类向下转型（强转）

abstract不能和final，static和private共存

final：被final修饰的方法不能被重写

static：没有方法体，所以直接用类名调用没有意义

private：被private修饰的方法只在该类中可见

接口的特点：

1）接口不能实例化

2）接口中的方法要么被子类实现，要么子类也是抽象也是抽象类

接口的成员特点：

1.成员变量：接口中只有常量，用public static final修饰

2、没有构造方法

如果任何类没有继承父类，都继承Object类

3.成员方法：

接口中的都是抽象方法

（但可以有返回值）

接口的特点：

1.接口时对外暴露的规则

2.接口时程序的功能扩展

3.接口的出现降低耦合性

4.接口可以用来多实现

String类的indexOf()方法值得关注下:

int indexOf(String str,int fromIndex)---从指定位置查找str第一次出现的位置

该包装对象主要用基本类型和字符串之间的转换。

*

* 基本类型--->字符串

* 1,基本类型数值+""

* 2,用String类中的静态方法valueOf(基本类型数值);

*

*

* 字符串--->基本类型

* 1,使用包装类中的静态方法 xxx parseXxx("xxx类型的字符串");*****

* int parseInt("intstring");---valueOf（String str）也可以将字符串转为Integer

* long parseLong("longstring");

* boolean parseBoolean("booleanstring");

* 只有Character没有parse方法

* 2,如果字符串被Integer进行对象的封装。

* 可使用另一个非静态的方法，intValue();

* 将一个Integer对象转成基本数据类型值。

整数具备不同的进制体现。

*

* 十进制-->其他进制。

* toBinaryString

* toOctalString

* toHexString

*

* 其他进制-->十进制。

* parseInt("string",radix)

this：代表的是本类对象的引用

super：代表的是父类内存空间的标识

数组的两种静态初始化方式（即一开始实例化就赋值）

类型[] 数组名 = new 类型[]{元素，元素，。。。。。。};

类型[] 数组名 = {元素，元素，。。。。。。}；

抽象类：垒用abstract修饰

抽象方法：方法声名要用abstract，没有方法

如果一个类继承抽象类，那么想要代码不出错怎么解决：

1.子类继承抽象类，子类必须重写父类的所有抽象方法

2.要么子类也定义为抽象类

在继承中，我们为什么有些时候会选择父类时抽象类呢？

可以强制子类做某些事

字父类之间的成员方法注意：

1）父类的私有方法不能被重写

2）子类的访问权限修饰符要大于父类的访问权限修饰符

3）静态的方法只能重写静态方法（不属于类与类之间的关系）

重写的应用：

当子类需要父类的功能，而子类自己又有特有的代码体，就可以重写

this关键字的应用场景：

可以解决局部变量隐藏成员变量的问题(成员变量和局部变量重名时无法给成员变量赋值)

Random和scanner类都是next(),nextInt(),nextByte(),nextFloat()....

(Random的next(int bit)生产下一个伪随机数，scanner的next()是返回下一个完整的扫描内容）

局部变量前不能放置任何访问修饰符（private，public，protected），但可以用final来修饰

（因为final同abstract一样，都是非访问修饰符）

final修饰的成员变量必须在定义之时就赋值（因为要给定一个default）

static修饰的方法，内部类不能直接调用非静态的成员方法和成员变量

成员变量和局部变量的区别：

（1）：定义位置不同

（2）：

而成员变量有初始化默认值，局部变量没有，所以必须在new的时候就赋值

（3）：储存位置不同：

成员变量储存在堆内存中，随着对象的存在而存在，局部变量储存在栈内存中，与方法共存亡

使用变量的规则：

程序的运行遵循就近原则

匿名对象的优点：

用完即扔，即使用完之后就立即被回收，不会造成内存浪费

应用场景：

1）当只用一次该类的对象的时候（当只调用一次该类的方法的时候）

2）可以当作实际参数进行传递

内部类要访问外部类的成员变量的话，格式：

A.this.x

访问内部类的成员变量，直接：

this.x

集合的删除方法：

remove()---删除单个元素（Iterator的删除方法也是remove())

clear()---删除所有

clearAll(Object[] o)---删除与o相同的集合

集合类的由来：

对象用于封装特有数据（非特有就是静态了），对象多了需要存储，

如果对象的个数不确定。就使用集合容器进行存储。

集合的三特点：

1）用于存储对象的容器

2）长度可变

3）不能存储基本数据类型值（同泛型）

//在jdk1.5后，使用泛型来接收类中要操作的引用数据类型。

//泛型类。什么时候用？当类中的操作的引用数据类型不确定的时候，就使用泛型来表示。

一般在存储元素的时候都是用上限，因为这样取出都是按照上限类型来运算的，不会出现类型安全隐患。

什么时候用下限呢？通常对集合中的元素进行取出操作时，可以是用下限。

关于Arrays工具类的补充：

asList()方法：

 如果数组中的元素是对象， 那么转成集合时， 直接将数组中的元素作为集合中的元素进行集合存储。

*

* 如果数组中的元素是基本类型数值，那么会将该数组作为集合中的元素进行存储。

还有一点：

数组的长度固定，所以对集合的增删方法是不可以使用的

而且，但集合转为数组（toArray())，也不允许对其进行增删

toArray方法需要传入一个指定类型的数组。

* 长度该如何定义呢？

* 如果长度小于集合的size，那么该方法会创建一个同类型并和集合相同size的数组。

* 如果长度大于集合的size，那么该方法就会使用指定的数组，存储集合中的元素，其他位置默认为

* null。

* 所以建议，最后长度就指定为，集合的size。

如：

int... arr

字符流的由来：

其实就是：字节流读取文字直接数据后，不直接操作而

是先查指定的编码表，将字节转为文字，然后再对文字进行操作。

简单说：字节流+编码表= 字符流

所以，字符流只适用于纯文本数据（即能用记事本打开且不是乱码的）

分析选择什么样的IO流：

比如将一个文本文件数据显示子在控制台上。

1）是否是纯文本？

是，

源：Reader

目的：Writer

2）明确具体设备

源：硬盘File

目的：控制台：System.out

3）需要额外功能吗？

需要，要转换

得到结论：

源：FileReader fr = new FileReader("a.txt");

目的：OutputStreamWriter osw = new OutputStrea