Java基础——Static修饰符+静态相关+帮助文档制作+对象初始化_调用成员过程+单例设计

时间:2022-05-31 21:08:06


一、Static修饰符

String name;//成员变量,实例(对象)变量。

Static String name;//静态的成员变量,类变量。

用于修饰成员(变量,函数)

当每个对象都有共性的数据(不是属性)时,可以用Static修饰,此时被修饰的变量数据不在堆内存,被放在共享区(方法区,数据区)对象建立后直接引用该数据。既静态所修饰内容被对象所共享。

当成员被静态修饰后,就多了一个调用方式,除了可以被对象调用,还可以直接被类名调用。类名.静态成员;

1. Static特点:

随着类的加载而加载,消失而消失,说明它的生命周期最长

优先于对象的存在

被所有对象共享

静态成员可以直接被类名调用,因此静态成员变量又称为类变量。非静态成员变量又被称为实例变量。

 

2. 实例变量和类变量的区别:

存放位置:类变量随着类的加载而存在方法区(共享区)中。实例变量随着对象的建立而存在于堆内存中。

生命周期:类变量生命周期最长,随着类的消失而消失。实例变量生命周期随着对象的消失而消失。

3. 静态使用注意事项:

静态方法只能访问静态成员,非静态方法既可以访问静态也可以访问非静态。

静态方法中不可以定义this,super关键字,因为静态优先于对象存在。

主函数是静态的;

4.静态利弊:

利处:对对象的共享数据开辟单独空间的存储,节省空间,没必要每一个对象中都存储一份;

可以直接被类名调用;

弊端:生命周期过长,访问出现局限性(静态虽好,只能访问静态)

二、什么时候使用静态?

两方面下手:静态修饰的内容有成员变量和函数。

1. 什么时候定义静态变量(类变量)呢?

当对象中出现共享数据(数据指:具体的值,学校名称属于学生的共享数据)时,该数据被静态所修饰。例如:学生都有自己特有的姓名。

对象中特有的数据要定义成非静态存在于堆内存中。

2.什么时候定义静态函数呢?

当功能内部没有访问到非静态数据(对象的特有数据),那么该功能可以定义成静态的。

 

三、静态的应用-工具类

Java基础——Static修饰符+静态相关+帮助文档制作+对象初始化_调用成员过程+单例设计

当一个类中创建了另一个类的对象,编译的时候会同时编译两个类文件;

 

/*

每一个应用程序中都有共性的功能,

可以将这些功能进行抽取,独立封装,以便复用。

 

虽然         可以通过建立ArrayTool的对象使用这些工具方法,对数组进行操作。

 

发现问题:

对象是用于封装数据的,可是ArrayTool对象并未封装特有(非公性)数据。

操作数组的每一个方法度没有用到ArrayTool对象中的特有数据。

考虑让程序更严谨,不需要对象。

 

直接将这些方法定义成静态的,直接通过类名调用即可。

 

方法都静态后,可以方便于使用,但是该类还是可以被其他程序建立对象的,

为了更为严谨,强制让该类不能建立对象,

可以通过将默认的构造函数私有化完成。

 

空参数的构造函数不一定是默认构造函数,默认的是看不见的,写了就不是默认的了。

class Demo

{

   Demo(){}:当你定义了空参数的构造函数,就不是默认的了,而是自定义构造函数了。

}

*/

1. class ArrayTool//工具类,通常是静态的方法

{

         private ArrayTool(){};//将默认的构造函数私有化,对方不能建立对象。

         //获得最大值

         public static int getMax(int[] arr)

         {

         int max=0;

         for(int x=1; x<arr[max];x++)

                   {

                   if(arr[x]>arr[max])

                            max=x;

                   }

         return arr[max];

         }

    //获得最小值

         public static int getMin(int[] arr)

                   {

                            int min=0;

                   for(int x=1; x<arr[min],x++)

                            {

                            if(arr[x]<arr[min])

                                     min=x;

                            }

         return arr[min];

              }

         //选择排序

         public static void selectSort(int[] arr)

         {

                   for (int x=0;x<arr.length-1 ;x++ )

                   {

                            for (int y=x+1;y<arr.length ;y++ )

                            {

                                     if (arr[x]>arr[y])

                                     {

                                               swap[arr,x,y];

                                      }

                             }

                     }

                   }

    //冒泡排序

         public static void bubbleSort(int[] arr)

         {

                   for (int x=0;x<arr.length-1 ;x++ )

                   {

                            for (int y=0;y<arr.length-x-1 ; y++)

                            {

                                     if(arr[y]>arr[y+1])

                                     {

                                               swap(arr,y,y+1);

                                     }

                            }

                   }       

         }

         //互换数值,没必要提供出去,私有化

         private static void swap(int[] arr,int a,int b)

         {

                   int temp=arr[a];

                   arr[a]=arr[b];

                   arr[b]=temp;

         }

         //打印数组

         public static void printArray(int[] arr)

         {

                   System.out.print("[");

                   for (int x=0;x<arr.length ;x++ )

                   {

                            if(x!=arr.length-1)

                            System.out.print(arr[x]+",  ");

                            else

                            System.out.print(arr[x]+"]");

                   }

         }

         }

2. class  ArrayToolDemo //调用工具类的方法

{

         public static void main(String[] args)

         {

                   int[] arr={3,6,89,43,56};

                   int max=ArrayTool.getMax(arr);

                   System.out.println("Max="+max);

                   //能够创建对象,因为工具类有个默认的空构造函数。只要有属性或行为,就可以创建对象。

                   /*ArrayTool tool=new ArrayTool();//此对象没必要生成,将工具类的方法改为静态

                   int max=tool.getMax(arr);

                   System.out.println("Max="+max);

 

                   tool.printArray(arr);

                   tool.selectSort(arr);

                   tool.printArray(arr);

                   */

         }

}

四、主函数

是一个特殊的函数,作为程序的入口,可以被JVM调用。

1. 主函数的定义:

Public:代表着该函数的访问权限的最大的。

Static :代表着主函数随着类的加载就已经存在了。

Void :主函数没有具体的返回值。

Main :不是关键字,但是是一个特殊的单词,可以被JVM识别。

(String[] args):函数的参数,是一个字符串类型的数组。(arguments)

主函数是固定格式,包括参数(参数名自定义),才能被JVM识别。

数组有两种值:数组和NULL

JVM在调用主函数时,传入的是new string[0];    hiahia

 

五、帮助文档的制作javadoc

当有工具类.CLASS文件时,只要将该文件设置到class路径下,就可以使用该工具类了。

但无法知道定义了多少方法。可以制作程序说明书,通过文档注释,javadoc程序;

识别符:@param等。

在命令行输入

javadoc -d myhelp -author -version ArrayTool.java

               D盘自动创建html文件的存放文件夹

需要制作说明文档的类要public修饰,否则不能生成相应的注释;

一个类中默认会有一个空参数的构造函数,权限与所属类一致;

空参数的构造函数不一定是默认构造函数,默认的是看不见的,写了就不是默认的了。

 

class Demo

{

Demo(){}:当你定义了空参数的构造函数,就不是默认的了,而是自定义构造函数了。

}

*/



/**

这是一个可以对数组操作的工具类,提供了获取最值,排序等功能。

@author 杨xx

@version v1.1

*/

class ArrayTool//工具类,通常是静态的方法

{

/**

空参数构造函数。

*/

private ArrayTool(){};//将默认的构造函数私有化,对方不能建立对象。

/**

获取一个数组中的最大值

@param arr 接收一个INT类型数组

@return 返回一个该数组中的最大值

*/

public static int getMax(int[] arr)

{

int max=0;

for(int x=1; x<arr[max];x++)

{

if(arr[x]>arr[max])

max=x;

}

return arr[max];

}

/**

获取一个数组中的最小值

@param arr 接收一个INT类型数组

@return 返回一个该数组中的最小值

*/

public static int getMin(int[] arr)

{

int min=0;

for(int x=1; x<arr[min];x++)

{

if(arr[x]<arr[min])

min=x;

}

return arr[min];

}

/**

给int数组进行选择排序

@param arr 接收一个INT类型数组

*/

public static void selectSort(int[] arr)

{

for (int x=0;x<arr.length-1 ;x++ )

{

for (int y=x+1;y<arr.length ;y++ )

{

if (arr[x]>arr[y])

{

Swap(arr,x,y);

}

}

}

}

/**

给int数组进行冒泡排序

@param arr 接收一个INT类型数组

*/

public static void bubbleSort(int[] arr)

{

for (int x=0;x<arr.length-1 ;x++ )

{

for (int y=0;y<arr.length-x-1 ; y++)

{

if(arr[y]>arr[y+1])

{

swap(arr,y,y+1);

}

}

}

}

/**

给数组中的元素进行位置置换

@param arr 接收一个INT类型数组

@param a 要置换的位置

@param b 要置换的位置

*/

private static void swap(int[] arr,int a,int b)//互换数值,没必要提供出去,私有化

{

int temp=arr[a];

arr[a]=arr[b];

arr[b]=temp;

}

/**

打印int数组元素,打印形式是:[elemet 1,elemet2, ...]

@param arr 接收一个INT类型数组

*/

public static void printArray(int[] arr)

{

System.out.print("[");

for (int x=0;x<arr.length ;x++ )

{

if(x!=arr.length-1)

System.out.print(arr[x]+", ");

else

System.out.print(arr[x]+"]");

}

}

}


 

六、静态代码块

静态代码块。

格式:

static

{

         静态代码块中的执行语句。

}

 

特点:随着类的加载而执行,只执行一次,并优先于主函数。

用于给类进行初始化的。

  

class StaticCode

{

int num = 9;//非静态成员

StaticCode()

{

System.out.println("b");

}

//静态代码块,给类初始化

static

{

System.out.println("a");//这里加上NULL,无法编译,因为静态代码块不能访问实例变量;

}

//构造代码块,给对象初始化

{

System.out.println("c"+this.num);

}



StaticCode(int x)

{

System.out.println("d");

}

public static void show()

{

System.out.println("show run");

}

}



class StaticCodeDemo

{

static

{

//System.out.println("b");

}

public static void main(String[] args)

{

new StaticCode(4);//a c d

//new StaticCode();//执行一次

//new StaticCode();//不执行

//System.out.println("over");

//StaticCode.show();

//StaticCode s = null;//没有指向,未加载StaticCode

//s = new StaticCode();



//StaticCode.show();





}

static

{

///System.out.println("c");

}

}


//d:\>java0217\day06>java StaticCodeDemo

//b c a over

七、对象的初始化过程

Java基础——Static修饰符+静态相关+帮助文档制作+对象初始化_调用成员过程+单例设计

class Person

{

private Person(){}

private String name = "hah";//,先默认初始化null,然后输出hah,既显示初始化

private int age;

private static String country = "cn";

Person(String name,int age)

{

this.name = name;

this.age = age;

}



{

System.out.println(name+".."+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);

Person.method();

}

public static void method()

{

System.out.println("method run");

}



}



class PersonDemo

{

public static void main(String[] args)

{

Person p = new Person("zhangsan",20);

p.setName("lisi");

new Person();

}

}


<span style="font-family:Calibri;font-size:14px;">Person p = new Person("zhangsan",20);</span>

该句话都做了什么事情?

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

2,  执行该类中的static代码块,如果有的话,给Person.class类进行初始化。

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

4,在堆内存中建立对象的特有属性。并进行默认初始化(NULL,0)

5,对属性进行显示初始化。(给属性赋值的时候)

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

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

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

八、对象调用成员过程

Java基础——Static修饰符+静态相关+帮助文档制作+对象初始化_调用成员过程+单例设计

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Java基础——Static修饰符+静态相关+帮助文档制作+对象初始化_调用成员过程+单例设计

对象调用非静态成员时访问堆内存,调用静态成员是没有访问堆内存;

静态成员调用静态成员,前面省略了类名.

九、单例设计模式(饿汉士)

 

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

java23种设计模式:

单例设计模式:解决一个类在内存只存在一个对象。

 

想要保证对象唯一。

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

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

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

 

这三部怎么用代码体现呢?

1,将构造函数私有化。

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

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

 

对于事物该怎么描述,还怎么描述。

当需要将该事物的对象保证在内存中唯一时,就将以上的三步加上即可。

  

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();



s1.setNum(23);



System.out.println(s2.getNum());





// Single s1 = new Single();//没有将构造代码块私有化时可以NEW 新对象,对象间互不影响

// Single s2= new Single();

// s1.setNum(30);

// System.out.println(s2.getNum());



// Student s1 = new Student();

// s1.setAge(30);

//

// Student s2 = new Student();

// s2.setAge(12);



Student s1 = Student.getStudent();

Student s2 = Student.getStudent();



}

}



class Student

{

private int age;



private static Student s = new Student();

private Student(){}

public static Student getStudent()

{

return s;

}



public void setAge(int age)

{

this.age = age;

}

public int getAge()

{

return age;

}

}


十、单例设计模式(懒汉士)

这个是先初始化对象。

称为:饿汉式。(开发中较多使用,安全简单

Single类一进内存,就已经创建好了对象。

 

class Single

{

private static Single s = new Single();

private Single(){}

public static Single getInstance()

{

return s;

}

}

*/



//对象是方法被调用时,才初始化,也叫做对象的延时加载。成为:懒汉式。

//Single类进内存,对象还没有存在,只有调用了getInstance方法时,才建立对象。

class Single

{

private static Single s = null;

private Single(){}

public static Single getInstance()//同步加在此处,效率低,每次都要加载锁,判断是否空

{

if(s==null)

//假设两个对象A,B;-->A,-->B(CPU处理是急速的轮流切换的,即A执行这条语句后B接着执行)

{

synchronized(Single.class)//A加锁,B进不来,保证只生成一个对象,也降低了加载锁的次数

{

if(s==null)

s = new Single();

}

}

return s;

}

}



//记住原则:定义单例,建议使用饿汉式。



class

{

public static void main(String[] args)

{

System.out.println("Hello World!");

}

}