黑马程序员--- 学习笔记(第六天)

 —————————— ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————
static关键字
静态:static
用法:是一个修饰符,用于修饰成员(成员变量,成员函数)


当成员被静态所修饰后,就多了一种调用方法,除了可以用被对象调用外,还可以
直接被类名调用
类名.静态成员


特有数据存放在对象,存储在堆内存
static存放在方法区(共享区,数据区)


static特点:
1.随着类的加载而加载(代表随着类的消失而消失,生命周期最长)
2.优先于对象存在
3.被所有对象共享
4.可以被类名直接使用


静态成员变量称为类变量,静态函数称为类方法




实例变量和类变量的区别:
1.存放位置: 类变量随着类的加载就存在于方法区中,
  实例变量随着对象的建立而存在堆内存中
2.生命周期: 类变量的生命周期最长,随着类的消失而消失
  实例变量生命周期随着对象的消失而消失
 
静态使用注意事项:
1.静态方法只能访问静态成员,非静态方法能访问静态成员
2.静态方法不可以定义this,super关键字,因为先有类再有对象
2.主函数就是静态的


静态有利有弊:
利:对对象的共享数据进行单独空间的存储,节省空间,没有必要每一个对象中都存储一份,还可以
  直接被类名使用
弊: 生命周期长,访问有局限性.

/*static 关键字*/class Demo1 {public static void main(String[] args) {Student.show();//多了种类名直接调用的方式  static代码块执行new Student().show_1();//在new static代码块也不会执行了}}class Student{{System.out.println("我是构造代码块,优先于构造函数");}public Student(){System.out.println("构造函数,随着对象的加载而加载");}private String name;private static String schoolName="xx学校";//共享数据public void setName(String name){this.name=name;}public String getName(){return name;} static {System.out.println("我是static代码块,随着类的加载而加载,我只会被执行一次"); }/*错误的 类方法不能调用非静态变量public static void show(){System.out.println("我叫"+name+"来自"+schoolName);} *//*类方法只能访问静态变量*/public static void show(){System.out.println("静态方法,我来自"+schoolName);}/*非静态方式可以访问静态变量*/public void show_1(){System.out.println("非静态方法,我来自"+schoolName);}} 

解析main主函数:


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


    public static void main(String []args){
    
    }
主函数的定义:
public:代表该函数访问权限最高
static:代表函数是随着类的加载就已经存在了
void:主函数没有具体的返回值
main:不是关键字,可以被jvm识别的特殊单词
String[]args:字符串类型数组


主函数是固定的格式才被jvm识别,只有字符串类型数组名可以改

jvm在调用函数时,传入的new String[0];在调用的时候可以传入参数,
用空格隔开,jvm会自动封装成数组

/*主函数测试 给主函数传参 这这是一种方式*/class Demo2 {public static void main(String[] args) {String []arr={"a","b","c","d"};Test.main(arr); //给test主函数传can}}class Test{public static void main(String []args){System.out.println(args.length);for(int i=0;i<args.length;i++){System.out.print(args[i]+"\t");}}}

例子:java 类名 字符串1 字符串2 字符串3


什么时候使用静态:
什么时候定义类变量:
当对象出现共享数据时,非共享数据属性
例如:学生在同一学校 学校就是共享数据


什么时候定义类方法:
当功能内部没有访问到内部非静态数据(对象的特有数据),那么该功能可以定义成静态的


静态的应用: 工具类

class Demo3 {public static void main(String[] args) {   int []arr={5,4,6,8,15,11,78,55,226,456};  System.out.println(ArrTools.getMax(arr)); //获取最大值  System.out.println(ArrTools.getMin(arr)); //获取最小值    ArrTools.printArr(arr); // ArrTools.selectSort(arr); //选择排序 ArrTools.bubbleSort(arr);//冒泡排序   ArrTools.printArr(arr);   System.out.println(ArrTools.halfSearch(arr,5)); //位置是1}}/**static 应用 数组工具类  @author 刘阳文  @version v1.0*/public class ArrTools{/**@param arr int型数组求数组最大值*/public static int getMax(int []arr){  int max=0;  for (int i=0;i<arr.length ;i++ )  {  if(arr[i]>arr[max])  max=i;  }  return arr[max];}/*求数组中最小值*/public static int getMin(int []arr){int min=0;for(int i=0;i<arr.length;i++){if(arr[i]<arr[min])min=i;}return arr[min];}/*选择排序*/ public static void selectSort(int []arr){  for (int i=0;i<arr.length-1 ;i++ )  for (int j=i+1;j<arr.length-1 ;j++ )  if(arr[i]>arr[j])  swap(arr,i,j); }/*冒泡排序*/ public static void bubbleSort(int []arr){ for (int i=0;i<arr.length-1 ;i++ )for (int j=0;j<arr.length-i-1 ;j++ )if(arr[j]>arr[j+1])swap(arr,j,j+1); }/*位置交换*/private static void swap(int arr[],int i,int j){arr[i]=arr[i]^arr[j];arr[j]=arr[i]^arr[j];arr[i]=arr[i]^arr[j];}/*打印数组*/public static void printArr(int []arr){for(int u : arr)System.out.print(u+"\t");}/*二分查找*/public static int halfSearch(int []arr,int want){int min=0,max=arr.length-1,mid;do{mid=(min+max)>>>1;if(arr[mid]==want)return mid;else{if(arr[mid]<want)min=mid+1;else if(arr[mid]>want)max=mid-1;else return mid;}}while (min<=max);return -1;}}

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


虽然可以通过new实体操作这些方法,对数组进行操作时发现了问题:
1.对象时用于封装数据的,可是实体并未封装特有数据
2.操作数组的每一方法都没有用到实体的特有数据


这时,为了让程序更严谨,是不需要对象的,这时可以定义用private私有对象构造函数


制作帮助文档:
//制作时,claspath 路径要在当前运行的目录下
将工具类发送给别人用,对方只要设置classpath即可,但也要看说明书
这就用到了java的文档注释,生成程序说明书


@author 作者
@version 版本


@param 变量名  作用
@return 返回值类型  作用


public,protected权限可以生成java注释文档




在cmd生成的方法:
javadoc -d 目录名 -author -version 类名


-d:就是存放目录  后面接的目录名 没有则新建
作者和版本是可选的..  类名就是要生成注释的类


一个的默认构造函数根据与该类权限一致,如果被public修饰,那么默认
构造函数就是public的,随着类权限变化而变化


静态代码块
static{
执行语句;
}


特点: 随着类的加载而执行,只执行一次,优先于主函数


即使重新new实体也不会改变,类方法执行,static代码块也会加载


对象初始化过程:
Person p=new Person("track",20);


该语句都做了什么事情呢?
1.因为new用到了Person.class,所以会先找到Person.class并加载到内存中
2.执行该类static代码块,如果有的话,给Person.class进行初始化
3.在堆内存中开辟空间,分配内存地址
4.在堆内存中建立对象的特有属性,并进行默认初始化
5.对属性进行显示初始化
6.对对象进行构造代码块初始化
7.对对象的构造函数进行初始化
8.将内存地址赋给栈内存中的变量(引用)


设计模式
解决某一类问题最有效的方式,java有23中设计模式
单例模式就是其中一种


想要保证对象的唯一:
1.为了避免其他程序过多的建立该类对象,先控制进制其他程序建立该类对象
2.还为了让其他程序可以访问到该类对象,只好在本类中定义一个对象
3.为了方便其他程序对对象的访问,可以对外提供访问方式


用代码实现以上三种步骤:
1.将构造函数私有化
2.在类中定义一个对象 private static
3.提供一个方法可以获取该对象


对于事物怎么描述还是怎么描述,当需要将该事物的对象保证在内存中的唯一
时,就可以加上上诉三步即可.


单例模式有两种方式:
1.饿汉式
2.懒汉式
两种方法的区别:
1.饿汉式:类一进内存就已经初始化对象
2.懒汉式:类进内存,对象还没有存在,只有调用获取实例方法才建立对象.

简而言之:就是先初始化,后出初始化的问题.

/*单例模式*/class Demo4 {public static void main(String[] args) {Single s=Single.getInstance();s.show();}} /*懒汉式 class Single { private static Single s=new Single(); private Single(){}; public static Single getInstance(){return s; }  public void show(){System.out.println("我是饿汉式"); } } */ /*饿汉式*/ class Single { private static Single s=null; private Single(){}; public static Single getInstance(){if(s==null){synchronized(Single.class){if(s==null)s=new Single();}}return s; }  public void show(){System.out.println("我是懒汉式"); } }

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