面向对象（三）

一、static关键字
1.static关键字的引入
定义一个人类

姓名和年龄都是变化的，每个人的姓名和年龄是不同的但是，我们现在选取的几个人都是中国人，他们的国籍都是一样的一样的国籍，我每次创建对象，在堆内存都要开辟这样的空间，我就浪费了，那怎么办？针对多个对象有共同的成员变量的时候，java就提供了一个关键在来修饰：static.它修饰的变量是被所有的对象所共享的。

class Person{    //姓名    String name;    //年龄    int age;    //国籍    //String country;    static String country;    public Person(){}    public Person(String name,int age){        this.name = name;        this.age = age;    }    public Person(String name, int age, String country){        this.name = name;        this.age = age;        this.country = country;    }    public void show(){        System.out.println("姓名："+name+"，年龄:"+age+"，国籍："+country);    }}class PersonDemo{    public static void main(String[] args){        //创建对象        Person p1 = new Person("xxx",20,"中国");        p1.show();        Person p2 = new Person("xxx",21,"中国");        p2.show();        Person p5 = new Person("xxx",21);        p5.show();        Person p3 = new Person("凤姐",30,"中国");        p3.show();        Person p6 = new Person("凤姐",30);        p6.show();    }}

2.static关键字的特点
static的特点：他可以修饰成员变量，还可以修饰成员方法
A:随着类的加载而加载
回想main方法
B:优先于对象存在
C:被类的所有对象共享
举例：咱们班级的学生应该共用同一个班级编号
其实这个特点也是在告诉我们什么时候使用静态？
如果某个成员变量是被所有对象共享的，那么它就应该被定义为静态的
举例：饮水机（用静态修饰）
水杯（不用静态修饰）
D:可以通过类名调用（这也是main方法为什么是静态的，main方法是由虚拟机调用的
虚拟机只需要通过类名.main()就可以了）
其实他本身也可以通过对象名调用（因为静态的内容是被所有对象共享的）
推荐使用类名调用

        静态修饰的内容一般我们称其为与类相关的，类成员

class Student{    //非静态变量    int num = 10;    //静态变量    static int num2 = 20;}class StudentDemo{    public static void main(String[] args){        Student s = new Student();        System.out.println(s.num);        System.out.println(s.num2);        System.out.println(Student.num2);    }}

3.static的内存图解

4.static的注意事项
static关键字的注意事项:
A:在静态方法中是没有this关键字的。
如何理解呢？
静态是随着类的加载而加载，this是随着对象的创建而存在。
静态比对象先存在。
B:静态方法只能访问静态的成员变量和静态的成员方法
静态方法：
成员变量：只能访问静态变量
成员方法：只能访问静态成员方法
非静态方法：
成员变量：可以是静态的，也可以是非静态的
成员方法：可以是静态的成员方法，也可以是非静态的成员方法

简单记：静态只能访问静态

class Teacher{    public int num = 10;    public static int num2 = 20;    public void show(){        System.out.println(num);//隐含的告诉你访问的是成员变量        System.out.println(this.num);//明确的告诉你访问的是成员变量        System.out.println(num2);            //add();            //mul();    }    public static void method(){        //错误: 无法从静态上下文中引用非静态 变量 num        //System.out.println(num);        System.out.println(num2);        //错误: 无法从静态上下文中引用非静态 方法 add()        //add();        //mul();    }    public void add(){}    public static void mul(){}}class TeacherTest{    public static void main(String[] args){        Teacher t = new Teacher();        t.show();        System.out.println("-----------");        t.method();    }}

二、静态变量和成员变量的区别
1.所属不同
静态变量属于类，所以也成为类类型
成员变量属于对象，所以也成为实例变量（对象变量）

2.内存中的位置不同
静态变量存储于方法区中的静态区
成员变量存储于堆内存

3.内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失

4.调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用
三、main方法的格式讲解
main方法的格式讲解：
public static void main(String[] args){…}

public:公共的，访问权限是最大的，由于main方法是被jvm调用，所以权限要够大。static:静态的，不需要创建对象，通过类名就可以方便jvm调用void:因为我们说过，方法的返回值是返回给调用者，而main方法是被jvm调用，你返回内容给jvm没有意义main:是一个常见的方法入口。String[] args:这是一个字符串数组，值去哪里了？    这个东西有什么用啊？怎么给值呢？        格式是：            java MainDemo hello world java

四、如何制作工具类的说明书
我想要对数组进行操作

如何制作一个说明书呢？    A:写一个工具类    B:对这个类加入文档注释        怎么加呢？        加些什么东西呢?    C:用工具解析文档注释        javadoc工具    D：格式    javadoc -d 目录 -author -version ArrayTool.java    目录：就可以写一个文件夹的路径    制作帮助文档出错：        找不到可以文档化的公共或受保护的类，告诉你权限不够        可以将class设定为了public

public class ArrayTool{        //把构造方法私有，外界就不能再创建对象了。        /**        *这是私有构造        */        private ArrayTool(){}        /**        *这是遍历数组的方法，遍历后的格式是：元素1，元素2，元素3...        *@param  arr 这是要被遍历的数组        */        public static void printArr(int[] arr){            for(int x = 0;x < arr.length;x++ ){            if(x == arr.length-1){                System.out.println(arr[x]);            }else{                System.out.print(arr[x]+", ");            }        }    }        /**        *这是获取数组中最大值的方法        *@param  arr 这是要获取最大值的数组        *@return 返回数组中的最大值        */        public static int max(int[] arr){            int max = arr[0];            for(int i=1;i<arr.length;i++){                if(arr[i] > max){                    max = arr[i];                }            }            return max;        }        /**        *这是获取数组中最小值的方法        *@param  arr 这是要获取最小值的数组        *@return 返回数组中的最小值        */        public static int min(int[] arr){            int min = arr[0];            for(int i=1;i<arr.length;i++){                if(arr[i]<min){                    min = arr[i];                }            }            return min;        }        /**        获取指定元素在数组中第一次出现的索引，如果元素不存在，就返回-1        *@param arr 倍查找的数组        *@param value 要查找的元素        *@return  返回元素在数组中的索引，如果元素不存就，就返回-1        */        public static int getIndex(int[] arr , int value){            int index = -1;            for(int i=0;i<arr.length;i++){                if(arr[i] == value){                    index = i;                    break;                }            }            return index;        }}

五、如何使用API帮助文档
1.点击显示，找到索引，出现输入框
2.你应该知道你要找的类。例子：Scanner
3.在输入框中输入Scanner
4. （1）看包
java.lang包下的类不需要导入，其他的全部需要导入。
（2）再简单的看看文档说明和例子
（3）别忘了看看该类的版本。
（4）看类的结构
成员变量 字段摘要
成员方法 方法摘要
构造方法 构造方法摘要
（5）学习构造方法
A:有构造方法 就创建对象
B:没有构造方法 成员可能都是静态的
（6）看成员方法
A:左边
是否静态：如果静态，可以通过类名调用
返回值类型：人家返回什么，你就用什么接收。
B:右边
看方法名：方法名不要写错
看参数列表：人家要什么，你就给什么，人家要几个，你就给几个。

class MathDemo{    public static void main(String[] args){        //获取一个随机数        //double d = Math.random();        //System.out.println(d);        //需求，我要获取一个1-100之间的随机数，怎么办？        for(int x=0;x<100;x++){        int number = (int)(Math.random()*100)+1;        System.out.println(number);        }    }}

六、代码块
代码块：在java中，使用{}括起来的代码被称为代码块。
根据其位置和声明的不同，可以分为
局部代码块:局部位置,用于限定变量的生命周期，及早释放，提高内存的使用率。顺序从上往下，依次执行
构造代码块：在构造方法的位置，在类中的成员位置,用{}括起来的代码。
作用：多个构造方法中相同的代码可以保存到一起，每次调用构造方法时都执行。可以对对象进行初始化
并且是在构造方法之前执行。
静态代码块:在类中成员位置，用{}括起来的代码。只不过它用static修饰了。
作用：一般是对类进行初始化。
面试题？
静态代码块，构造代码块，构造方法的执行顺序？
静态代码块–构造代码块–构造方法
只执行一次 每次调用构造方法都执行

class Code{    //静态代码块    static{        int a = 1000;        System.out.println(a);    }    //构造代码块    {    int x = 100;    System.out.println(x);    }    //构造方法    public Code(){}    //构造代码块    {    int y = 20;    System.out.println(y);    }    //构造方法    public Code(int b){}    //静态代码块    static{        int b = 2000;        System.out.println(b);    }}class CodeDemo{    public static void main(String[] args){        //局部代码块        {        int x = 10;        System.out.println(x);        }        System.out.println("-------------");        //错误: 找不到符号        //System.out.println(x);        Code c = new Code();        Code c2 = new Code(5);    }}

练习：

class Student{    static{        System.out.println("我是静态代码块");    }    {        System.out.println("我是构造代码块");    }    public Student(){        System.out.println("我是构造方法");    }}class StudentDemo{    static{        System.out.println("林青霞都60了，我很伤心");    }    public static void main(String[] args){        System.out.println("我是main方法");        Student s1 = new Student();        Student s2 = new Student();    }}

运行结果：
程序的结果是：
林青霞都60了，我很伤心
我是main方法
我是静态代码块
我是构造代码块
我是构造方法
我是构造代码块
我是构造方法

总结：
静态是随着类的加载而加载
如果在main方法之前有静态代码块
那么程序先执行静态代码块，再执行main方法
其次，在main方法执行之后，
在对类进行初始化。