[黑马程序员]（第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