黑马程序员——java第六天：面向对象（静态、帮助文档、对象初始化过程、单例）

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

关键字—static：

修饰符：用于修饰成员（成员变量、成员方法）

被修饰的成员有以下特点：

1、  随着类的加载而加载（说明他的生命周期最长）

2、  优先于对象存在（它先存在所以对象可以调用它）

3、  被所有对象所共享

4、  可以直接被类名调用（比普通成员多的一种调用形式：类名.方法、类名.属性）

注意：1、静态方法只能访问静态成员（非静态方法既可以访问静态成员也可以访问非静态成员）。

2、静态方法中不可写this、super、关键字（因为静态优先于对象存在，this代表的是对象）

3、主函数是静态的。

静态成员既不放在栈内存中也不放在对内存中，而被放在方法区中（数据区）。

方法区：里面存有类中的方法和类中共享数据（静态成员是共享的所以。。）。

成员变量也叫实例变量（实例就是对象，因为随着对象的存在而存在所以叫实例变量）。

静态变量也叫类变量（因为它随着类的存在而存在）。

classPerson{

Stringname;

staticString country=”CN”;

publicvoid show(){

System.out.println(name+”…”+country)

}

}

classStaticDemo{

publicstatic void main(String[ ] args){

System.out.println(Person.country)

}

}

 

实例变量与类变量的区别：

1、  存在位置：

类变量随着类的加载而存在于方法区中

实例变量随着对象的建立存在于堆内存中

2、  生命周期：

类变量生命周期最长，随着类的消失而消失

实例变量生命周期随着对象的消失而消失

静态成员的利与弊：

利：对对象共享数据进行单独空间的存储，节省空间，没有每一个对象中都存一份

弊：生命周期过长。访问出现局限性（静态只能访问静态）

main函数：是一个特殊的函数，作为程序的入口可以被jvm调用
主函数的定义：

public：代表该函数被访问的权限是最大的。

static：代表主函数随着类的加载就已经存在。

main：不是关键字，但，是一个特殊的单词，可以被jvm识别。

（String[]  arr）:函数的参数，参数类型是一个数组，该数组中的元素是字符串类型的数组。args全称为arguments（参数），此处不是固定（可以写成（String[] aaa）等）当然数组额可以这样表示（String… args）.

 

什么时候使用静态成员：

1、  静态类变量的定义：当对象中出现共享数据时（是数据是值不是属性），该数据被静态所修饰。（对象中的特有数据要定义成非静态存在于堆内存中）

2、  静态函数的定义：当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的。

静态代码块：

class Student{

static{                                                     //这一块就是构造代码块

System.out.println(“a”);

}

public static void main(String[] args){

System.out.println(“b”);

}

}

 

特点：随之类的加载而执行，只执行一次（因为静态的随着类的加载而加载）

作用：用于给类进行初始化（优先于主函数执行）。

例：

classStaticClide{

static{

System.out.print(“a”);

}

classStaticCodeDemo{                     //因为这个类有main函数所以先加载这个类

static{

System.out.print（“b”）；

}

publicstatic void main（String[]args）{

newStaticClode（）；                     //调用了StaticClode类所以在这加载这个类

new StaticClode（）；                                        //因为已经加载了StaticClode类所以，这里虽然调用

//了StaticClode类但是并不用再次加载

System.out.print（“over”）；

}

static{

System.out.print（“c”）；

 

}

}

}

}

 

打印结果为b  c  a  over

如果在上面的程序中的main方法中把“new StaticClode（）；newStaticClode（）；”替换成StaticClodes=null;当执行到此处代码时StaticClode类不会被加载（因为当用到类中的内容时才加载（创建对象时因为用到了里面的构造方法所以才加载类。一般（new类名）时创建时就加载了））。

注意：1、静态代码块（加载类时加载）在构造代码块（创建对象时调用执行）之前执行。

3、  静态代码块不可调用非静态的成员变量，因为他是静态的只能调用静态成员；而构造代码块可以调用非静态的成员变量。

对象初始化过程：

一个类：Person

Personp=new Person(“zhangsan”,20);

该语句先后都做了什么事？

1、  因为new用到了Person.class，所以会先找到Person.class文件并加载到内存。

2、  执行该类中的static代码块（如果有的话），给person.class类进行初始化。

3、  在堆内存中开辟空间，分配内存地址。

4、  在堆内存中建立对象的特有属性，并进行默认初始化。

5、  对属性进行显示初始化。

6、  对对象进行构造代码块初始化。

7、  对对象进行对应的构造函数初始化。

8、  将内存地址赋给栈内存中的变量。

单力设计模式：（饿汉式和懒汉式）

设计模式：解决某一问题最行之有效的方法。

java中有23中设计模式。

单利设计模式应用范围：解决一个类在内存中只存在一个对象。

想保证对象唯一性：思想

1、  为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象。

2、  还为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象。

3、  为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

这三步如何用代码实现？（对应上面的思路）

1、  将构造方法私有化。

2、  在本来中创建一个本类对象。

3、  提供一个方法可以获取到该对象。

饿汉式：先初始化对象

例：

class Single{

private single(){}                                            //构造方法私有化，防止外类创建对象、

private static Single s=new Single();   //创建一个本类对象（new初始化了）。

public static Single getInstance() {      //对外提供的获取对象的方法

return s

}

}

class SingleDemo{

public static void main(String[] args){

Single ss=Single.getInstance();

}

}

 

懒汉式：对象方法调用时才初始化，也就是对象的延迟加载。

例：

class Single{

private static Single s=null;      //先有了个对象但没有实例化。

private Single(){}                                   //构造方法私有化。

public static Single getInstance（）{

if(s==null){

s=new Single();

return s;

}

}

}

 

上面例子懒汉式的缺点：

第一次当执行到（if(s==null){）上面红字后cpu跳到了另一个调用publicstatic Single getInstance（）时，又执行到（if(s==null){）时，cpu又去执行第一个执行到（if(s==null){）接着执行，创建完对象后，cpu又跳到了第二个又创建了对象，这样就创建了两个对象。

对懒汉式的缺点弥补：

class Single{

private static Single s=null;      //先有了个对象但没有实例化。

private Single(){}                                   //构造方法私有化。

public static  synchronized  Single getInstance（）{

if(s==null){

s=new Single();

return s;

}

}

}

 

加个synchronized相当于上了把锁只要有程序执行着这段方法代码，别的程序就进不来。

但是这样也有缺点——执行变慢。

对懒汉式的缺点再弥补：

class Single{

private static Single s=null;      //先有了个对象但没有实例化。

private Single(){}                                   //构造方法私有化。

public static  synchronized  Single getInstance（）{

if(s==null){

synchronized（Single.class）{

if(s==null) s=new Single();

}

}

return s;

}

}

 

因为懒汉式的缺点和就算优化后相比饿汉式有太多的代码所以一般开发定义单例用饿汉式

------- android培训、java培训、期待与您交流！ ---------- 详细请查看：http://edu.csdn.net