基础学习day06---面向对象二---static，类的初始化和调用顺序、单例模式
一、static关键字
1.1、static关键字
静态：static
用法：是一个修饰符，用于修饰成员（成员变量，成员函数）
static 修饰的内容，所有对象共享
当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以被类名.静态成员
packagecom.day06;/*** 人类
*@authorAdministrator
*静态：static
*用法：是一个修饰符，用于修饰成员（成员变量，成员函数）
*static 修饰的内容，所有对象共享
*当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，
*还可以被类名.静态成员*/publicclassPerson {//属性staticString country="CN";
String name;publicvoidshow(){
System.out.PRintln(this.name+" "+this.country);
}publicstaticvoidmain(String[] args) {//多个对象使用同一个属性国家Person p=newPerson();
Person p1=newPerson();
p.name="张三";
p1.name="李四";
p.show();
p1.show();
System.out.println(Person.country);//类名.静态成员变量}
}
特点：
1.随着类的加载而加载--也就是：静态会随着类的消失而消失，它的生命周期最长。
2.优先于对象存在---
静态是先存在，对象是后存在。
3.被所有对象共享
4.可以直接被类名所调用
1.2、实例变量和类变量的区别
1.存放位置
类变量随着类的加载而加载存在方法区中。
实例变量随着对象的建立而存在于堆内存中。
2.生命周期
类变量生命周期最长，随着类的消失而消失
实例变量生命周期随着对象的消失而消失
1.3、使用注意事项
静态方法只能访问静态成员（静态成员和静态方法）
非静态方法既可以访问静态也可以访问非静态
静态方法中不可以定义this. super关键字
因为静态优先于对象存在，所以静态中不可以出现this
主函数是静态的
静态有利有弊
利处：对对象共享数据进行单独空间的存储，节省内存空间，没有必要每个对象都存储一份
可以直接被类名调用。
弊端：生命周期过长
访问出现局限性。（静态虽好，只能访问静态。）
1.4、主函数是静态的
主 函数：是一个特殊的函数，作为程序的入口，可以被JVM调用
定义：
public :代表差该该函数访问权限是最大的
static:代表主函数随着类的加载就已经存在了。
void:主函数没有具体的返回值。
main():不是关键字，但是是一个特殊的单词，可以被JVM识别。
函数的参数：String[] args--是一个数组，数组中的元素是字符串，字符串类型的数组
主函数是固定格式的，JVM识别。
args:arguments
JVM在调用主函数时，传入的是new String[0]
packagecom.day06;publicclassMainTest {publicstaticvoidmain(String[] args) {//遍历主函数for(inti = 0; i < args.length; i++) {
System.out.println(args[i]);
}
}
}packagecom.day06;publicclassMainDemo {publicstaticvoidmain(String[] args) {
String [] arr={"张三","李四","王五","赵六","钱七"};
MainTest.main(arr);
}
}
结果：
张三
李四
王五
赵六
钱七
1.5、什么时候使用静态
2个方面：
静态修饰的内容有成员变量和函数
什么时候定义静态变量？
当对象在出现共享数据时，该数据被static修饰
对象中的特有数据要定义成非静态，存在于堆内存，对象内部
什么时候定义静态函数
当功能内部没有访问到非静态数据（对象的特有数据）
那么该 功能可以定义成静态
1.6、静态工具类
packagecom.day06;/*** 建立一个用于操作数组的工具类， 其中包含着常见的对数组操作的函数， 如：最值，排序等。
*
*@authorDenny
*@versionv1.0*/publicclassArrayTool {/*** 为了不让外界创建对象，将构造方法私有化
*@authorDenny
*
*@versionv1.0*/privateArrayTool() {
}/*** 获取整型数组的最大值
*
*@paramarr
* 接收一个元素为int 类型的数组
* @Return 该数组的最大的元素值*/publicstaticintgetMax(int[] arr) {intmaxIndex = 0;for(intx = 1; x < arr.length; x++) {if(arr[x] >arr[maxIndex])
maxIndex=x;
}returnarr[maxIndex];
}/*** 对数组进行选择排序
*
*@paramarr
* 接收一个元素为int 的数组*/publicstaticvoidselectSort(int[] arr) {for(intx = 0; x < arr.length - 1; x++) {for(inty = x + 1; y < arr.length; y++) {if(arr[x] >arr[y])
swap(arr, x, y);
}
}
}//用于给数组进行元素的位置置换。privatestaticvoidswap(int[] arr,inta,intb) {inttemp =arr[a];
arr[a]=arr[b];
arr[b]=temp;
}/*** 获取指定的元素在指定数组中的索引
*
*@paramarr
* 接收一个元素为int 类型的数组
*@paramkey
* 要找的元素
*@return返回该元素第一次出现的位置，如果不存在则返回 -1*/publicstaticintgetIndex(int[] arr,intkey) {for(intx = 0; x < arr.length; x++) {if(arr[x] ==key)returnx;
}return-1;
}
/*** 将int数组转换成字符串，格式是：[e1,e2,...]
*
*@paramarr
* 接收一个元素为int类型的数组
*@return返回该数组的字符串表现形式*/publicstaticString arrayToString(int[] arr) {
String str= "[";for(intx = 0; x < arr.length; x++) {if(x != arr.length - 1)
str= str + arr[x] + ",";elsestr= str + arr[x] + "]";
}returnstr;
}
}
使用类名.静态方法
二、静态代码块
2.1、静态代码块
static{
代码块;
}
packagecom.day06;/*** 静态代码块
*
*@authorDenny static{ 静态代码块中的语句 }
* 特点：随着类的加载而执行， 只执行一次 用于给类进行初始化
* 并优先于主函数*/classStaticDemo {static{
System.out.println("static code A");
}
}
publicclassStaticCode{static{
System.out.println("static code B");
}static{
System.out.println("static code C");
}publicstaticvoidmain(String[] args) {//2个匿名对象newStaticDemo();newStaticCode();
}
}
结果：
static code B
static code C
static code A
只执行一次就不在执行了
三、对象初始化过程
3.1、初始化过程
packagecom.day06;/*** 静态代码块
*
*@authorDenny
* static{ 静态代码块中的语句 }
* 特点：随着类的加载而执行， 只执行一次 用于给类进行初始化 并优先于主函数*/publicclassStaticCode {intnum=9;publicStaticCode() {
System.out.println("static code A");
}static{
System.out.println("static code B");
}
{
System.out.println("con code C "+this.num);
}publicStaticCode(intnum) {
System.out.println("con code D");
}publicstaticvoidshow(){
System.out.println("E");
}publicstaticvoidmain(String[] args) {newStaticCode(4);
}
}
结果：
static code B
con code C 9
con code D
四、对象调用成员过程
4.1、初始化过程
1.因为new 用到了类.class，所以会先找到类.class
2.执行该类中的static代码块，如果有的话，给类.class进行初始化
3.堆内存中开辟空间，分配内存地址，
4.在堆内存中建立对象的特有属性，并默认初化成员变量
5.对对象进行显示初始化
6.对对象进行构造代码块初始化
7.对对象进行对应的构造函数初始化。
8.将内存地址赋给内存中的对象变量
五、单例模式
设计模式：对问题行之有效的解决方式，其实，它是一种思想。
单例设计模式解决的问题：就是可以保证一个类在内存中的对象唯一性。
比如多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。
如何保证对象唯一性呢？
1、不允许其他程序用new创建该类对象。
2、在该类创建一个本类实例。
3、对外提供一个方法让其他程序可以获取该对象。
步骤：
1、私有化该类构造函数。
2、通过new在本类中创建一个本类对象。
3、定义一个公有的方法，将创建的对象返回。
5.1、饿汉式
packagecom.day06;/*** 饿汉式
*@authordenny
**/publicclassSingleDemo {privateString name;privateintage;privatestaticSingleDemo singleDemo=newSingleDemo();//私有 构造方法privateSingleDemo(){
}//提供公有的访问publicstaticSingleDemo getNewIntance(){returnsingleDemo;
}publicstaticvoidmain(String[] args) {
SingleDemo s1=SingleDemo.getNewIntance();
SingleDemo s2=SingleDemo.getNewIntance();
System.out.println(s1==s2);
}
}
结果：true
5.2、懒汉式
packagecom.day06;/*** 饿汉式
*@authordenny
**/publicclassSingleDemo2 {privateString name;privateintage;privatestaticSingleDemo2 singleDemo2;//私有 构造方法privateSingleDemo2(){
}//提供公有的访问publicstaticSingleDemo2 getNewIntance(){if(singleDemo2==null){
singleDemo2=newSingleDemo2();
}returnsingleDemo2;
}publicstaticvoidmain(String[] args) {
SingleDemo2 s1=SingleDemo2.getNewIntance();
SingleDemo2 s2=SingleDemo2.getNewIntance();
System.out.println(s1==s2);
}
}
结果：true