标签：java学习笔记 面向对象 静态static 黑马程序员
面向对象(static静态应用)
静态什么时候使用
要从两方面下手：
它修饰的内容有成员变量和函数。
什么时候定义静态变量？
当对象出现共享数据时（共享值，name是共享变量，country中”CN”是值，数据），该数据被静态修饰。
对象中的特有数据要定义成非静态，存在堆内存中。
什么时候定义静态函数？
当功能内部没有访问到非静态数据（对象的特有数据）
class Person
{
String name;
public void show()//这个功能没有访问对象特有的数据name的。可以用static修饰。
{
system.out.println("haha");
}
}
class Demo
{
public static void main(String[] args)
{
Person p=new Person();
p.show();//显示haha
}
}
对比：
class Person
{
String name;
public static void show()//这个功能没有访问对象中的特有数据name的。
{
system.out.println("haha");
}
}
class
{
public static void main(String[] args)
{
Person.show();//也是显示haha。直接调用类名.功能函数()
}
class Demo
{
public static void main(String[] args)
{
int[] arr={3,4,1,8};//数组
int max=getMax(arr);//max获得数组元素中的最大值
system.out.println("max="+max);
}//函数封装，提高复用。
public static int getMax(int[] arr)
{
int max=0;//令max为0，即数组的下标为0
for(int x=1;x<arr.length;x++)
{
if(arr[x]>arr[max])
max=x;
}
return arr[max];
}
}
对比下面的Test类。发现功能是一样的（即功能重复）。
class Test
{
public static void main(String[] args)
{
int[] arr={3,4,1,8};
int max=getMax(arr);
system.out.println("max="+max);
}
public static int getMax(int[] arr)
{
int max=0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]>arr[max])
max=x;
}
return arr[max];
}
}
见图1.
每个应用程序中都有共性的功能。
可以将这些功能进行抽取，独立封装。
以便复用。
//下面的这个类中包含了多个功能函数。
class ArrayTool
{//定义获取数组最大值方法函数
public int getMax(int[] arr)
{
int max=0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]>arr[max])
max=x;
}
return arr[max];
}//获取最小值的功能函数
public int getMin(int[] arr)
{
int min=0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]<arr[min])
min=x;
}
return arr[min];
}//普通排序法：
public int selectSort(int[] arr)
{
for(int x=0;x<arr.length-1;x++)//防止角标越界，x=arr.length-1时，y= arr.length越界。
{
for(int y=x+1;x<arr.length;x++)//y=x+1;(y=1，减少了比较次数，如：arr[0]>arr[0]；y=1+x;每比较完一次后，下一次比较的次数减少一次。)
{
if(arr[x]>arr[y])
{
swap(arr,x,y);
}
}
}
}//冒泡排序法：
public void bubbleSort(int[] arr)
{
for(int x=0;x<arr.length-1;x++)
{
for(int y=0;x<arr.length-x-1;x++)//每排序完一轮后，下一次排序比较的次数减少1次。随x减少。
{
if(arr[y]>arr[y+1])
{
swap(arr,y,y+1);
}
}
}
public void swap(int[] arr,int a,int b)
{
int temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
}
先是在DOS下编译上面的文件会产生ArrayTool.class文件。见图3.
class ArrayToolDemo
{
public static void main(String[] args)
{
int[] arr={3,1,87,32,8};
ArrayTool tool=new ArrayTool();//ArrayTool调用的就是class文件。
int max=tool.getMax(arr);
system.out.println("max="+max);
}
}
然后编译ArrayToolDemo。结果见图4。
发现产生ArrayToolDemo.class和ArrayTool.class以及它们的java文件是在同一个目录下。见图5
如果直接编译ArrayToolDemo。会出现什么情况？见图6
发现同时出现两个。说明：虚拟机会自动先找ArrayTool.java文件并编译成ArrayTool.class。然后编译ArrayToolDemo
虽然可以通过建立ArrayTool的对象使用这些工具，对数组进行操作。
发现了问题：
1，对象是用于封装数据，可是ArrayTool没有封装特有数据。
2，操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。
这时就考虑，让程序更严谨。是不需要对象的。
可以将ArrayTool中的方法都定义成atatic的。直接通过类名调用即可。
class ArrayTool
{//获取最大值
public static int getMax(int[] arr)
{
...
}
public staticint getMin(int[] arr)
{
...
}//普通排序法：
public static int selectSort(int[] arr)
{
...
class ArrayToolDemo
{
public static void main(String[] args)
{
int[] arr={3,1,87,32,8};
int max=ArrayTool.getMax(arr);
system.out.println("max="+max);//同样也是打印max=87;
}
尽管方法都已经静态了，但是其它用户和程序还是可以通过该类建立对象。这样内存中就会存在多余的对象（占用空间，即“垃圾”）。
可以将构造函数私有化来完成。（这样可以防止不知道该函数功能的程序员建立对象，不让他们建立）
class ArrayTool
{
private ArrayTool(){}//构造函数私有化。
public static int getMax(int[] arr)
{
...
}
public static int getMin(int[] arr)
{
...
}
private void swap(int[] arr,int a,int b)//这个也可以私有化。只在本类中被内部函数调用。
{
int temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
class ArrayToolDemo
{
public static void main(String[] args)
{
int[] arr={3,1,87,32,8};
int max=ArrayTool.getMax(arr);
system.out.println("max="+max);//同样也是打印max=87;
}
版权声明：本文为博主原创文章，未经博主允许不得转载。
标签：java学习笔记 面向对象 静态static 黑马程序员
原文地址：http://blog.csdn.net/dianziagen/article/details/47696167
