11.Java面向对象（二）

01.面向对象（static关键字）

用法：是一个修饰符，用于修饰成员（成员变量和成员函数）。
当成员被静态修饰后，就多了一种调用方式，除了可以被对象调用之外，还可以被类名直接调用。类名.静态成员。
对象的特有内容随着对象存储，共有内容可以定义为静态的，放在共享区。
类中的方法区，共享区，数据区都在同一个区。

static的特点：
（1）随着类的加载而加载，随着类的消失而消失。也就是说，静态会随着类的消失而消失，说明他的生命周期最长。
（2）优先于对象存在；明确一点：静态先存在，对象后存在。
（3）被所有对象所共享；
（4）可以直接被类名调用。
实例变量和类变量的区别：
（1）存放位置：类变量随着类的加载而存在与方法区中；实例变量随着对象的建立而存在于堆内存中。
（2）生命周期：类变量的生命周期最长，随着类的消失而消失；实例变量的生命周期随着对象的消失而消失。
静态的使用注意事项：
（1）静态方法只能访问静态成员和静态方法。因为静态方法和变量在类加载时就在了，非静态变量在对象存在时才存在
（2）非静态方法可以访问静态也可以访问非静态。
（3）静态方法中不可以定义this，super关键字。因为静态优先于对象存在，所以静态方法不可以出现this。
（4）主函数是静态的。
静态有利有弊：
利：对对象的共享数据进行单独空间的存储，节省空间的内存，没有必要每个对象都存储一份；可以直接被类名调用。
弊：生命周期过长，访问出现局限性，静态虽好只能访问静态。

02.面向对象（主函数main）

主函数：是一个特殊的函数，作为程序的入口，可以被jvm调用。
主函数的定义：
public：代表着该函数访问权限是最大的。
static：代表着主函数随着类的加载就已经存在。
void：主函数没有具体的返回值。
main：不是关键字，但是是一个特殊的单词，可以被jvm识别。
函数的参数（String[] args）：参数类型是一个数组，该数组中的元素是字符串，字符串类型的数组。

jvm在调用主函数时，传入的是new String[0];
启动jav虚拟机，并为主函数传参数：java TestMain haha heiehi
这说明java虚拟机在执行TestMain时给主函数传入了haha和嘿嘿两个参数。
还可以用下面的方法：
class MainDemo
{
 public static void mian(String[] args)
 {
  String[] arr={"1","2","3"};
  Maintest(arr);
 }
}
class Maintest
{
 public static void main(String[] args)
 {
  for(int i=0;i<args.length;i++)
  {
   System.out.println(args[i]);
  }
 }
}

03.面向对象（什么时候使用静态）

要从两方面下手：
因为静态修饰的内容是成员变量和函数。
什么时候定义静态变量（类变量）呢？
当对象中出现共享数据时，该数据被静态所修饰；对象中的特有数据要定义成非静态存在于堆内存中。

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

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

04.面向对象（静态的应用--工具类）

每个应用程序中都有共性的功能，可以将这些功能进行抽取，进行封装。
当考虑让程序更严谨时，如果不需要对象，可以将一个类中的成员设为静态的，直接通过类名调用即可。
将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的，为了更严谨，应该强制该类不能建立对象，可以将构造函数私有化就不允许建立对象了。

05.面向对象（帮助文档的制作）

java的说明书通过文档注释来完成。
格式：
/**
功能说明语句
@author 作者
@version 版本
@param 参数
@return 返回值
*/
每个类和凡是用public修饰的成员函数都要用文档注释给说明。

给一个类生成文档：
javadoc -d 目录（路径） -author -version
给一个类生成文档，该类必须是public的

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

06.面向对象（静态代码块）

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

特点：随着类的加载而执行，只执行一次用于给类进行初始化的。在主函数前的静态代码块优先于主函数执行。

当一个类被new一个对象时，类中的构造代码块，静态代码块，构造函数执行顺序是：静态代码块，构造代码块，构造函数。

静态代码块随着类的加载而加载，只能调用静态成员。

07.面向对象（对象的初始化过程）

加载“类.class”文件；静态代码块执行（没有就不执行）；构造代码块初始化；构造函数初始化；
Person p=new Person（“张三”，20）;
这一句话所做的事：
1.因为new用到了Person.class，所以会先找到Person.class文件并加载到内存中。
2.执行该类中的静态代码块，如果有的话，给Person.class类进行初始化。
3.在堆内存中开辟空间，分配内存地址。
4.在堆内存中建立对象的特有属性，并进行默认初始化。

5.对属性进行显示初始化。
6.对对象进行构造代码块初始化。
7.对对象进行对应的构造函数初始化。
8.将内存地址赋给栈内存中的变量。

08.面向对象（对象调用成员过程）

09.面向对象（单例设计模式）

设计模式：java中有23中设计模式。
解决某一类问题最行之有效的方法。
单例设计模式：解决一个类在内存中只存在一个对象。
想要保证对象唯一：
（1）为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象。
（2）还为了让其它程序可以访问到该类对象，只好在本类中自定义一个对象。
（3）为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
这三部怎么体现：
（1）将构造函数私有化
（2）在类中创建一个本类对象，
（3）提供一个方法可以获取到该类对象。

class Single
{
 private Single(){}
 private static Single s=new Single();
 public Static Single getInstance()
 {
  return s;
 }
}
在类外，用Single s=Single.getInstance();访问。

对于事物该怎么描述，还怎么描述。
需要将该事物的对象保存在内存中唯一时，只要加上面三步就行。

10.面向对象（单例设计模式2）

单例设计模式的第二种写法：
class Single
{
 private static Single s=null;
 private Single(){}
 public static synchronized Single getInstance()
 {
  if(s==null)
   s=new Single();
  return s;
 }
}
第一种模式是先初始化对象，称为饿汉式。
特点：Single类一进内存，就已经创建好了对象。饿了就做。
搞开发时一般用饿汉式。
第二种方式调用时才被初始化，称为懒汉式。
特点：Single类进内存，对象还没有存在，只有调用了getInstance()方法时，才建立对象。刚开始时不做，什么时候需要什么时候做。
synchronized是给该方法上锁，当有一个对象操作该方法时，别的对象就不能操作。是为了防止两个对象同时操作该方法。
懒汉式最终解决方案：
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;
 }
}
记住原则：定义单例，建议使用饿汉式。