黑马程序员------面向对象（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

 

标签：

相关文章