黑马程序员------面向对象(No.3)(static、静态代码块、封装、说明文档制作、main函数)

时间:2023-02-11 17:23:38

---------------------- ASP.Net+Android+IO开发S.Net培训、期待与您交流! ---------------------- 

 黑马程序员------面向对象(No.3)(static、静态代码块、封装、说明文档制作、main函数)static

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

特点

1.随着类的加载而加载(例,Person一加载内存,静态成员country就已经存在),静态会随着类的消失而消失,说明它的生命周期最长。

2.优于对象存在 静态先存在,对象是后存在。

3.被所有对象共享

4.可以直接被类名调用

 

区别

1.存放位置

类变量随着类的加载而存在与方法区中。

实例变量随着对象的建立而存在与堆内存中。

2.生命周期

类变量生命周期最长,随着类的消失而消失

实例变量生命周期随着对象的消失而消失

 

注意

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

静态方法中不可以写this,super关键字;因为静态优先于对象存在,所以静态方法中不可以出现this,super关键字。

主函数是静态的

 

静态有利有弊

好处:

1.对对象的共享数据进行单独空间的存储,节省内存。没有必要每个对象中都存储一份。

2.可以直接被类名调用。

弊端:

生命周期过长,访问出现局限性(静态方法不能访问非静态)。

class Person{
//成员变量(实例变量)。创建对象之后,内存中才出现
String name;
//静态成员变量(类变量)。Person类加载进内存,就存在。
static String country = "CN";
//非静态方法
public void show(){
System.out.println(name+":"+country);
}
//静态方法
public static void show_1(){
System.out.println(country);
//System.out.println(this.name); //this,super不能在静态方法中使用
//System.out.println(name); //name在实例创建前没有。。。
}
}
class StaticDemo{
public static void main(String[] args){
Person p = new Person();
p.name = "zhanggsan";
p.show();
System.out.println(Person.country);//输出CN
Person.show_1();
}
}

 

什么时候使用静态?

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

 

什么时候使用静态变量?

当对象中出现共享数据时,该数据被静态所修饰。

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

 

什么时候使用静态函数?

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

 

静态方法的应用

 

每一个应用程序中都有共性的功能,可以将这些功能进行抽取,独立封装,以便使用

虽然可以用ArrayTool的对象使用这些工具方法,对数组进行操作,但是发现了问题:

1.对象是用于封装数据的,可是ArrayTool对象并未封装特有的数据;

2.操作数组的每一个方法都没有用到ArrayTool对象中特有的数据;

 

静态代码块

 

1.格式:static{

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

       }

2.特点:随着类的加载而执行,只执行一次,用于类的初始化。

class StaticCode{
int num = 9;
StaticCode(){
System.out.println("b");
}
static{
//这里不能访问num;
//System.out.println("a"+num); 这里编译出错
System.out.println("a");
}
{
//这里可以访问num
//System.out.println("c"+num); 这里编译出错
System.out.println("c");
}
StaticCode(int x){
System.out.println("d");
}
public static void show(){
System.out.println("show run");
}
}
class StaticCodeDemo{
public static void main(String[] args){
new StaticCode(4);//输出 a c d
}
}

 

封装原理

这时就考虑,让程序更加严谨、健壮,是不需要对象的。可以将ArrayTool中的方法定义成static的,直接通过类名调用即可。

将方法都静态后,可以方便于使用,但是该类还是可以被其他程序创建对象的,为了更加严谨,强制让该类不能建立对象;可以通过将构造函数私有化完成。

/*封装array操作工具类*/
class ArrayTool{
//构造函数私有化
private ArrayTool(){
}
//得到最大值
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 selecteSort(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);
}
}
}
}
//交换元素
public static void swap(int[] arr,int a,int b){
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
//打印数组
public static void priArray(int[] arr){
System.out.print("[");
for(int i=0;i<arr.length;i++){
if(i!=arr.length-1)
System.out.print(arr[i]+",");
else
System.out.println(arr[i]+"]");
}
}
}
class Demo{
public static void main(String[] args){
int[] arr = {3,6,1,95,45,22,66,42};
System.out.println(ArrayTool.getMax(arr));
System.out.println(ArrayTool.getMin(arr));
ArrayTool.priArray(arr);
ArrayTool.selecteSort(arr);
ArrayTool.priArray(arr);
ArrayTool.bubbleSort(arr);
ArrayTool.priArray(arr);
}
}

 

制作程序的说明书,java的说明书是由文档注释来完成

一个类中默认会有一个空参数的构造函数,这个默认的构造函数的权限和所属类一致。
如果这个类被public修饰,那么默认的构造函数也带public修饰符。
如果类没有被public修饰,那么默认的构造函数,也没有public修饰。
默认的构造函数的权限是随着类的变化而变化的。

制作时要输入的指令:

黑马程序员------面向对象(No.3)(static、静态代码块、封装、说明文档制作、main函数)

要制作的类文件:

/**
这是一个可以对数组操作的工具类,该类中提供了获取最值,排序等功能。
@version v1.0
@author Xiaobi Lee
*/
public class ArrayTool{
/**
空参数构造函数。
*/
private ArrayTool(){
}
/**
获取一个整型数组中的最大值。
@param arr 接收一个int类型的数组。
@return 会返回一个数组中的最大值。
*/
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];
}
/**
获取一个整型数组中的最小值。
@param arr 接收一个int类型的数组。
@return 会返回一个数组中的最小值。
*/
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];
}
/**
给整型数组从小到大选择排序。
@param arr 接收一个int类型的数组。
*/
public static void selecteSort(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);
}
}
}
}
/**
给整型数组从小到大冒泡排序。
@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 要置换的位置。
*/
public static void swap(int[] arr,int a,int b){
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
/**
用于打印数组中的元素,形式[element1,element2,...]。
@param arr 接收一个int类型的数组。
*/
public static void priArray(int[] arr){
System.out.print("[");
for(int i=0;i<arr.length;i++){
if(i!=arr.length-1)
System.out.print(arr[i]+",");
else
System.out.println(arr[i]+"]");
}
}
}

帮助文档如图所示:

图1
黑马程序员------面向对象(No.3)(static、静态代码块、封装、说明文档制作、main函数)

图2

 黑马程序员------面向对象(No.3)(static、静态代码块、封装、说明文档制作、main函数)

 

黑马程序员------面向对象(No.3)(static、静态代码块、封装、说明文档制作、main函数)主函数

public static void main(String[] args)

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

 

主函数的定义:


public:代表该函数的访问权限是最大的。

static: 代表主函数随着类的加载就已经存在。
void: 主函数没有具体的返回值。
main:不是关键字,但是一个特殊的单词,可以被jvm识别。
(String[] args): 函数的参数,参数类型是一个数组,该数组中的元素是字符串,字符串的类型是数组。

  

主函数是固定格式的:jvm识别。

 

jvm在调用主函数时,传入的是new String(0);

 

class MainDemo{
//jvm需要要的主函数,只有args(变量名)可以改变。args是arguments的简写。
public static void main(String[] args){
System.out.println(args);//输出[Ljava.lang.String;@42ff87dc
System.out.println(args.length);//输出0
}
}

黑马程序员------面向对象(No.3)(static、静态代码块、封装、说明文档制作、main函数)

 

 ---------------------- ASP.Net+Android+IOS开发.Net培训、期待与您交流! ---------------------- 

详情请查看:http://edu.csdn.net