黑马程序员---毕向东老师视频笔记（关于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);
  */

 }

}