------- android培训、java培训、期待与您交流！ ----------
1、static关键字：
a) static是一个修饰符，用于修饰成员（成员变量和成员函数）
b) 被修饰后的成员具备以下特点
i. 随着类的加载而加载。也就说：静态会随着类的消失而消失。说明它的生命周期最长。
ii. 优先于对象存在（明确一点：静态是先存在。对象是后存在的。）
iii. 被所有对象所共享
iv. 可以直接被类名调用（除了可以被某一个具体对象调用外，还可以直接被类名调用。类名.静态成员）
c) 实例（成员）变量和类变量（静态的成员变量）的区别：
i. 存放位置
1. 类变量随着类的加载而存在于方法区（或者叫做共享区、数据区）中。
2. 实例变量随着对象的建立而存在于堆内存中，随之对象的消失而消失。
ii. 生命周期：
1. 类变量生命周期最长，随着类的消失而消失。
2. 实例变量生命周期随着对象的消失而消失。
d) 使用注意
i. 静态方法只能访问静态成员（静态变量和静态方法）（非静态方法既可以访问静态也可以访问非静态。）
ii. 静态方法中不可以写this，super关键字（因为静态优先于对象存在。所以静态方法中不可以出现this，super。）
iii. 主函数是静态的
e) 静态有利有弊：
a) 利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要为每一个对象中都存储一份。可以直接被类名调用。
b) 弊端：生命周期过长。访问出现局限性。(静态虽好，只能访问静态。)
2、内存中的方法区（也叫共享区、数据区），这块区域其实还有更细节的划分
方法区用于存储类中的方法、方法体（方法代码）、类中的共享数据（静态的数据）。
main函数：
1、main函数：
a) 是一个特殊的函数。作为程序的入口，可以被JV调用。
b) 主函数的定义：
i. public：代表着该函数访问权限是最大的。
ii. static：代表主函数随着类的加载就已经存在了。
iii. void：主函数没有具体的返回值。
iv. main：不是关键字，但是是一个特殊的单词，可以被JVM识别。（函数名和变量名是不能用关键字来标示的。）
v. （String[] arr）:函数的参数，参数类型是一个字符串数组，该数组中的元素是字符串。字符串类型的数组。
vi. 主函数是固定格式的：JVM识别。（必须这么写）
vii. JVM在调用主函数时，默认传入的是new String[0];这个字符串数组，只不过这个数组有些奇怪，长度为0（JVM自动传入的，不需要人工干预）而不是null值。由此可见public static void main(String[] args)中的字符串数组参数args在默认情况下是一个长度为0的、并且值不为null的字符串数组。
2、主函数main也能实现重载。（也即一个类中可以有多个主函数）
只不过JVM执行的时候从这个特定的main函数（ public static void main(String[] args) ）开始执行
public class Demo
{
public static void main(int[] arr)
{
System.out.print("goddessship");
}
public static void main(String[] args)//JV从这个函数开始执行。
{
int[] arr = new int[2];
System.out.print(arr[0]);
//在这个main函数里可以调用这个main函数。
}
}
主函数可以调用主函数
3、 如果一个java文件里有多个类，并且每个类里都有主函数public static void main(String[] args)，那么这些主函数可以相互调用。
例1：
有一个java文件 Maidenhair.java ：
class Maidenhair
{
public static void main(String[] args)//new String[]
{
String[] arr = {"Shah","che","Heide","dixi","Bahian"};//JVM从这个主函
//数开始执行。因为这个主函数所在的类//Maidenhair与这个java文件名Maidenhair.java
//同名
Faintest.main(arr);//调用类Faintest类里的主函数。
}
}
class Faintest
{
public static void main(String[] args)
{
for(int x=0; x<ags.length; x++)
System.out.print(ags[x]);
}
}
执行结果：
---------- java ----------
Shah
che
Heide
dixi
Bahian
例2：
有一个java文件A.java 里面有若干个类 A、B、C……，并且每个类里都可以有一个这样的public static void main(String[] ags)主函数，那么A类里的主函数作为这个java文件的唯一一个入口最先被JVM执行，并且A类里的主函数可以调用其他任何类里面的主函数。而其他类里的主函数除了不能调用A类里的主函数外，其他类里的主函数都可以调用。
1、静态代码块：
a) 格式：
static
{
静态代码块中的执行语句。
}
b) 特点：
随着类的加载而执行，只执行一次,并优先于主函数。用于给类进行初始化的。
因为静态代码块没有名字，所以没有什么可以调用静态代码块。有名字的都可以被其他东西调用（主函数被jvm调用）
c) 并不是说只有创建该类的对象的时候才加载该类，用类名调用该类的静态成员（包括静态函数和静态变量）的时候也加载该类。
d) 当创建一个类的对象，并把这个对象初始化为null时并不加载该类。
2、静态代码块 给类初始化用的；
3、构造代码块（初始化快） 给（所有）对象初始化用的
4、构造函数 给对应对象初始化用的
5、对象的初始化过程：
a) 加载该类
b) 静态代码块被执行
c) 为创建的该类对象开辟空间
d) 在堆内存中建立对象的特有堆属性（也即非静态属性），非静态的属性（也即非静态的成员变量）被默认初始化（int型的为0、引用类型的为 null）
e) 如果非静态属性被赋的有值，那么再进行普通的显式初始化
f) 构造代码块执行
g) 构造函数执行
h) 将开辟的该对象的内存地址值赋给栈内存中的该对象的引用。
注意：如果有静态的成员变量，那么静态的成员变量存储于方法区中，并且静态成员的默认初始化要早于静态成员的显式初始化和静态代码块的执行
6、对象调用成员过程：
以这个程序PersonDemo.java为例进行说明
class Person
{
private String name;
private int age;
private static String country = "cn";
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public void setName(String name)
{
this.name = name;
}
public void speak()
{
System.out.println(this.name+"..."+this.age);
}
public static void showCountry()
{
System.out.println("country="+Person.country);
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p = new Person("zhangsan",20);
p.setName("lisi"); //这句话的执行过程
}
}
程序需要用到的内存区域有 方法区（或数据区、共享区）、栈内存、堆内存
其中 方法区 中的内容早于栈内存、堆内存中的内容而存在。方法区中的内容在类加载的时候进入方法区中
方法区中存储的内容有：静态成员变量、各种方法（包括构造函数等）的代码（包括各种方法的方法名、方法体）
单例：
1、单例设计模式：
a) 设计模式：解决某一类问题最行之有效的方法。
b) java中23种设计模式：把几种模式综合应用就形成一种复杂的模式，也叫做框架。
c) 单例设计模式：解决一个类在内存只存在一个对象。
2、想要保证对象唯一。
a) 为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
b) 还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
c) 为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
3、这三步的代码体现方式：
a) 将构造函数私有化。
b) 在类中创建一个本类对象。（并静态化之）
c) 提供一个方法可以获取到该对象。（这个方法需要静态化之，由于静态只能访问静态所以在本类中创建的对象也需要静态化之）
4、不要纯粹为了单例而单例，还必须要有自己的东西：
a) 对于事物该怎么描述，还怎么描述。
b) 当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可。
纯粹的单例模式代码：（还需要加上自己的东西）
class Single
{
//还需要加上自己的东西
private Single(){}
private static Single s = new Single();
public static Single getInstance()
{
return s;
}
}
class SingleDemo
{
public static void main(String[] args)
{
Single s1 = Single.getInstance();
Single s2 = Single.getInstance();
}
}
5、饿汉式、懒汉式：
a) 饿汉式：这个是先初始化对象。
b) Single类一进内存，就已经创建好了对象。
class Single
{
private static Single s = new Single(); //先建立对象
private Single(){}
public static Single getInstance()
{
return s;
}
}
c) 懒汉式：对象是方法被调用时，才初始化，也叫做对象的延时加载。
d) Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象
class Single
{
private static Single s = null;
private Single(){}
public static Single getInstance()
{
if(s==null)
{
synchronized(Single.class) //为了防止建立多个Single类型
//对象，这里需要进行同步。而饿汉
//式不需要是因为其getInstance（）
//方法中只有一句return s；
{
if(s==null) //这里不要忘了再判断一下
s = new Single();
}
}
return s;
}
}
记录原则：定义单例，建议使用饿汉式。
总结：大多数情况下都使用饿汉式，懒汉式很少使用。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
