—————————— ASP.Net+Android+IOS开发、.Net培训、期待与您交流!——————————
面向对象(二)
static关键字
含义:
静态。
作用:
1.用于修饰成员(变量、函数)。
2.当成员被静态修饰后,除了用对象调用外,还可以直接被类名调用(格式:类名.静态成员)。
特点:
1.随着类的加载而加载。
2.优先于对象存在。
3.被所有对象共享。
4.直接被类名调用
实例变量与类变量的区别
1.存放位置
类变量随着类的加载而存在于方法区中,随着类的消失而消失。
实例变量随着对象的建立存在于堆内存中。
2.生命周期
类变量生命周期最长,随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。
static使用注意:
1.静态方法只能访问静态成员。
非静态方法既可以访问静态成员,也可以访问非静态成员。
2.静态方法中不可以定义this、super关键字。
因为静态优先于对象存在。
3.主函数是静态的。
静态利弊
利:
1.对对象的共享数据进行单独空间的存储,节省空间。
2.可以直接被类名调用。
弊:
1.生命周期过长。
2.访问出现局限性。
静态什么时候使用
1.静态变量
当对象中出现共享数据时,该数据被静态所修饰。
对象中的特有数据要定义成非静态存在于堆内存中。
2.静态函数
当功能内部没有访问到非静态数据时,则这个方法可以定义为静态的。
静态的应用————工具类
每个应用程序中都有共性的功能,可以对这些功能进行抽取,独立封装,以便复用。
代码1:ArrayTools.java
/*
封装的工具类
*/
class ArrayTools
{
/*该对象创建没有意义,所以要私有化防止其他程序创建对象*/
private ArrayTools()
{
}
/*获取最大值*/
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];
}
/*获取最小值*/
public static 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 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] + "]");
}
System.out.println();
}
}
ArrayTest01.java
/*
用于调用ArrayTools类的方法操作数组
*/
class ArrayTest01
{
public static void main(String[] args)
{
int[] arr = {3,2,5,45,4,6,9,7,12};
int max = ArrayTools.getMax(arr);
System.out.println("max = " + max);
int min = ArrayTools.getMin(arr);
System.out.println("min = " + min);
System.out.println("排序前的数组:");
ArrayTools.printArray(arr);
ArrayTools.selectSort(arr); // 排序操作
System.out.println("排序后的数组:");
ArrayTools.printArray(arr);
}
}
java帮助文档的制作
1.制作时,classpath路径要在当前运行的目录下。
2.设置classpath路径后,可以使用该工具类,但是需要知道该工具类有哪些功能,所以要看说明书。
3.使用java支持的文档注释来制作帮助文档(说明书)。
4.类要带有public修饰符,才能提取帮助文档
5.默认构造函数的权限与类的权限是一致的。
主要标识格式:
类上:
@autor 作者信息
@version 版本信息
方法上:
@param 参数名 作用
@return 返回值类型 作用
提取帮助文档的命令
javadoc -d 目录名 -autor -version 类名.java
静态代码块
格式:
static
{
执行语句;
}
特点:
用于给类初始化,随着类的加载而执行,只执行一次,并且优先于主函数的执行。
对象初始化过程
如:Person p = new Person();
1.new用到了Person.class,所以会先找到Person.class并加载到内存中。
2.如果该类有static代码块,则执行。
3.在堆内存中开辟空间,分配内存地址。
4.在堆内存中建立对象的特有属性,并进行默认初始化。
5.对属性进行显示初始化。
6.对对象进行构造代码块初始化。
7.对对象进行对应的构造函数初始化。
8.将内存赋给栈内存中的p变量。
设计模式
概念:
解决某一类问题的一个最佳方法。
单例设计模式:
解决一个类在内存中只存在一个对象。
保证对象的唯一性:
1.为了避免其他程序过多建立该类对象,先禁止其他程序建立该对象。
2.为了让其他程序可以访问到该类对象,只好在本类中自定义一个对象。
3.为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式。
步骤:
1.将构造函数私有化。
2.在类中创建一个本类对象。
3.提供一个方法获取到该对象。
比如:
class Student
{
private Student(){} // 第一步
private static Student s = new Student(); // 第二步
public static Student getStudent() // 第三步
{
return s;
}
}
class Demo
{
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
// 这里的s1和s2对应的时同一个对象,不是两个。
}
饿汉式:先初始化对象。
懒汉式:获取实例的方法被调用时才初始化。
如:class Student
{
private Student(){}
private static Student s = null;
public static Student getStudent()
{
if (s == null)
{
synchronized(Student.class)
{
if (s == null)
{
s = new Student();
}
}
}
return s;
}
}
class Demo
{
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
// 这里的s1和s2对应的时同一个对象,不是两个。
}