黑马程序员——学习笔记——知识复习2

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！
-------

2014年12月1日
天气：大风
心情：挺开心的

今天早上发现我的帖子不见了，还以为被删了，心中莫名的惆怅，中午回来的时候，发现还在，又开心起来了，也许这就是我的情绪，虽然很幼稚，但是，享受这些就好
所以我继续努力了一天，把毕姥爷的视频又消灭了一部分，加油

一.this关键字：谁调用该方法，就指向谁的引用。挺逗的解释，跟绕口令一样，我懂了就好
二.static关键字：静态成员变量。存放在data segment中，被所有的对象共享，优先于对象的存在。
注意：
1.静态调用非静态不能通过，是应为静态变量是先于成员变量的生成
2.不能使用this,super关键字，因为并没有生成对象
成员变量与静态变量的区别
1.生命周期不同：
成员变量：随对象创立而产生，随对象回收而释放
静态变量：随类的加载而生成，随类的消失而消失
2.调用方式不同：

成员变量：只能被对象调用
静态变量：既可以被对象调用，也可以被类名调用
3.别名不同：

成员变量：实例变量
静态变量：类变量
4.存放位置不同：

成员变量：堆内存
静态变量：方法区（data segment）

静态代码块也可以对对象进行初始化

static{
xxx;
}

什么时候使用静态：
1.静态变量：
当分析对象中所具备的成员变量的值都是相同的时候，这时这个成员变量就可以被静态修饰了，只要数据在对象中都是不同的，就是对象的特有数据，必须存放在对象中，是非静态的。如果是相同数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，可以定义成静态的。
2.静态函数：
函数功能是否访问到对象中的特有数据
简单说就是从源代码看，该功能是否需要访问非静态的成员变量，如果需要，则该功能就是非静态的，如果不需要，则可以定义成静态的，也可以不定义

三.单例设计模式
1.解决的问题就是可以保证一个类在内存中的对象是唯一的们必须对于多个程序使用同一个配置信息对象时，就需要保证对象的唯一性。说白了就是只要这个类被实例化了，之后的实例化都不会改变对象里面属性的值
2.如何保证对象唯一性？
1.不允许其他程序用new来创建该类对象
2.在该类中创建一个本类的实例
3.对外体统一个方法让其他程序可以获取该对象
3.步骤
1.私有化该类构造函数
2.通过new在本类中创建一个本来对象
3.定义一个公有的方法

public class SingleDemo{
public static void main(String[] args){
Single s1 = Single.getInstance();
Single s2 = Single.getInstance();

//				Single ss = Single.s;//不可控

System.out.println(s1 == s2);

//				Test t1 = new Test();
//				Test t2 = new Test();
Test t1 = Test.getInstance();
Test t2 = Test.getInstance();

t1.setNum(10);
t2.setNum(20);

System.out.println(t1.getNum());
System.out.println(t2.getNum());
}
}
//饿汉式
class Single{//类一加载，对象就已经存在了
private static Single s = new Single();
private Single(){

}

public static Single getInstance(){

return s;
}
}

//懒汉式（延迟加载形式）
class Single2{类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象
private static Single2 s = null;
private Single2(){}
public static Single2 getInstance(){
if(s == null)
s = new Single2();
return s;
}
}

class Test{
private int num;

private static Test t = new Test();
private Test(){}
public static Test getInstance(){
return t;
}

public void setNum(int num){
this.num = num;
}

public int getNum(){
return num;
}
}

引用单例前

D:\Java>javac ExtendsDemo.java

D:\Java>java ExtendsDemo
zi run 0
who run 8
zi run 8
zi run 8

引用单例后

D:\Java>javac ExtendsDemo.java

D:\Java>java ExtendsDemo
zi run 0
who run 8
zi run 8
zi run 8

所以单例是不会让我们改变对象的值得，只能实例化一次

注意：
之所以不用Single.s;的方式获取Single对象，而采用getInstance获取是因为在getInstance方法中我们可以做一些判断来决定是否返回Single的对象，也就是实现了对单例对象的可控。
所以，给Single的构造方法加上了private限制，禁止使用者直接采用Single.s;的方式获取

注意：

这段代码中有两个不同的类，都实现了单例模式，但是一个叫饿汉式，一个叫懒汉式
饿汉式就是类一加载，对象就已经存在了

懒汉式就是类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象
四.继承
1.继承的好处
1.提高代码的重用性
2.让类与类之间产生了uganxi，给第三个特征——多态提供了前提
2.子父类构造函数的关系
在子类构造对象时，父类的构造函数也运行，因为有一个隐式语句super();
子类在实例化过程中，子类中所有的构造函数都默认会访问父类中的空参数的构造函数
3.super语句必须要定义在子类构造函数的第一行，因为父类的初始化动作要先完成

public class ExtendsDemo {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}

class Fu {
Fu() {
super();
show();
}

void show(){
System.out.println("fu run ");
}
}

class Zi extends Fu {
int num = 8;

Zi() {
super();
System.out.println("who run " + num );
show();
}

void show() {
System.out.println("zi run " + num);
}
}

运行结果

D:\Java>javac ExtendsDemo.java

D:\Java>java ExtendsDemo
zi run 0
who run 8
zi run 8
zi run 8

这里我们就可以看出，我们在实例化子类的时候，首先调用子类的构造函数，然后子类构造函数里面第一步，先实例化父类的构造函数，而此时的Num值默认为0，所以是zi run 0;然后赋值给了num ，然后是who run 8,其实这是子类的调用，

[align=left]总结：[/align]
一个对象实例化过程，以Person p = new Person();为例：

1、JVM会读取指定的路径下的Person.class文件，并加载进内存，并会先加载Person的父类（如果有直接的父类的情况下）。

2、在内存中开辟空间，并分配地址。

3、并在对象空间中，对对象的属性进行默认初始化。

4、调用对应的构造函数进行初始化。

5、在构造函数中，第一行会先到调用父类中构造函数进行初始化。

6、父类初始化完毕后，再对子类的属性进行显示初始化。

7、再进行子类构造函数的特定初始化。

8、初始化完毕后，将地址值赋值给引用变量。

今天复习的比较慢，因为发现了很多问题，是以前没有弄明白的，还好复习，继续努力。