黑马程序员---毕向东老师视频笔记（关于static）

关于static
StaticDemo：
package cstatic;

 

 /*static 静态关键字，是一个修饰符，用户修饰成员（成员变量、成员函数）

 *每个人都能访问，并不是每一个对象都有一份，节约空间

    *当成员被静态修饰后，就多了一个调用方法，除了可以被对象调外，还可以直接被类名调用，格式为：类名.静态成员

    *contry="cn"存在方法区、共享区、数据区

    *

    *

    *static特点：

    *1、随着类的加载而加载，

    *      也就是说静态会随着类的消失而消失，说明它的生命周期最长。

    *2、优先于对象存在

    *      静态时先存在的，对象是后存在的。

    *3、被所有对象所共享

    *4、可以直接被类名调用

    *

    *

    *

    *实例对象和类对象的区别：

    *1、存放位置：

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

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

    *2、生命周期：

    *     类变量生命周期最长，随着类写的消失而消失。

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

    *

    *

    *静态的使用注意事项：

    *static 既能修饰变量也能修饰方法

    *1、静态方法只能访问静态成员

    *      非静态方法既可以访问静态也可以访问非静态。

    *2、静态方法中不可以定义this、super关键字

    *      因为静态优先于对象存在，所以静态方法中不可以出现this。

    *3、 主函数是静态的

    *     

    *     

    *静态有利有弊：

    *利： 对对象的共享共享数据进行单独空间的存储，节省空间，没有必要每个对象都存储一份

    *  可以直接被类名调用。

    *弊： 生命周期过长。

    *   访问出现局限性（方法中只能访问静态）

    *

    *

 

 */

 class Person{

  String name;//成员变量，实例对象，随对象的存在存在，生命周期短

  static String country="cn";//静态的成员变量也称为类变量，static静态修饰符

 

 public  void show() {

  System.out.println(name+","+country);

 }

 /*public  static void show() {

  System.out.println(","+country);//静态方法

 }*/

 

}

class  StaticDemo

{

 public static void main(String[] args)

 {

  Person p=new Person();

  p.name="zhangsan";

  p.show();

  Person p2=new Person();

  p2.name="lisi";

  p2.show();

  

  System.out.println(Person.country);//类名调用

 }

}

 

 

StaticCode：

package cstatic;

/*

 * 静态代码块

 * 格式：

 * static{

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

 * }

 *

 * 特点：

 * 随着类的加载而执行，只执行一次，

 * 用于给类进行初始化的。

 */

class StaticCode{

 static {

  System.out.println("a");

 }

 public static void show(){

  System.out.println("show");

  

 }

}

class StaticCodeDemo {

 static{

  System.out.println("b");

 }

 public static void main(String[] args) {

  new StaticCode();

  new StaticCode();

  System.out.println("over");

 }

 static{

  System.out.println("c");

 }

}

 

static1：

package cstatic;

/*

 * 什么时候使用静态？

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

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

 *

 * 什么时候定义静态函数？

 * 当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的

 */

class Person1

{

 static String name;

 

 public static void show(){

  System.out.println(name+"haha");

 }

}

public class static1 {

 public static void main(String[] args) {

  Person1 p=new Person1();

  p.name="zhangsan";

  p.show();

  Person1.show();

 

 }

}

 

 

 

ArrayTool：

package cstatic;

/*

 *静态的应用：

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

 *可以将这些功能进行抽取，独立封装。

 *以便复用

 *

 *

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

 *发现了问题：

 *1、对象时用于封装数据的，可是ArrayTool对象并未封装特有的数据

 *2、操作数组的每一个方法都没有用到ArrayTool中的特有数据

 *

 *这时就考虑，让程序更严谨，是不需要对象的。

 *可以将ArrayTool中的方法都定义为static，直接调用类名调用即可

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

 *为了更为严谨，强迫让该类不能建立对象。

 *可以通过将构造函数私有化完成，

 *

 */

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

    }

   }

  }

 }

 

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){

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

  

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

}

}

 

 

/*

 class Demo {

 public static void main(String[] args) {

  int[] arr={2,4,3,8};

  int max=0;

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

  {

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

    max=x;

   

  }

  System.out.println(arr[max]);

 }

 

 public static void getMax(int[] arr){

  int max=0;

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

  {

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

    max=x;

   

  }

  System.out.println(arr[max]);

 }

}

*/

ArrayToolDemo：

package cstatic;

 class ArrayToolDemo {

 

 public static void main(String[] args) {

  int[] arr={7,6,4,9,2,4,1};

  

  int max=ArrayTool.getMax(arr);

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

  

  int min=ArrayTool.getMin(arr);

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

  

  ArrayTool.printArray(arr);

  ArrayTool.selectSort(arr);

  System.out.println();

  ArrayTool.printArray(arr);

  

  /*ArrayTool tool=new ArrayTool();

  

  int max=tool.getMax(arr);

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

  int min=tool.getMin(arr);

  System.out.println("min="+min);

  

  tool.printArray(arr);

  tool.selectSort(arr);

  System.out.println();

  tool.printArray(arr);

  */

 }

}