Day09-Java面向对象，JavaObject01-2

今天我们主要学习了，static关键字及其特点

static关键字

• static引例

 1 package com.cskaoyan.keystatic;
 2 
 3 /**
 4  * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/15.
 5  * @version 1.0
 6  */
 7 public class Demo1Intro {
 8 
 9   public static void main(String[] args) {
10 
11     Student stu1 = new Student("张三", true, 18, 1);
12     //手动给stu1对象的，schoolName成员变量赋予初值
13     stu1.schoolName = "王道码农训练营";
14 
15     Student stu2 = new Student("李四", false, 20, 2);
16     //手动给stu1对象的，schoolName成员变量赋予初值
17     //stu1.schoolName = "王道训练营";
18     System.out.println(stu2.schoolName);
19 
20   }
21 
22 }
23 
24 /*
25     假设，该Student类描述 同一所学校 的所有 学生对象
26  */
27 class Student {
28 
29   // 姓名
30   String name;
31 
32   //性别
33   boolean isMale;
34 
35   //年龄
36   int age;
37 
38   //学号
39   int sno;
40 
41   //学校名称 用static关键字修饰
42   static String schoolName;
43 
44   public Student(String name, boolean isMale, int age, int sno) {
45     this.name = name;
46     this.isMale = isMale;
47     this.age = age;
48     this.sno = sno;
49   }
50 
51   // 学生具有的吃饭行为
52   public void eat() {
53     System.out.println(name + "吃饭");
54   }
55 
56 
57   //睡觉行为
58   public void sleep() {
59     System.out.println("sleeping");
60   }
61 
62   //学习
63   public void study() {
64     System.out.println(sno + " 在学习");
65   }
66 
67 }

 图：static引例

  1 package com.cskaoyan.keystatic;
  2 
  3 import java.util.Arrays;
  4 
  5 /**
  6  * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/15.
  7  * @version 1.0
  8  *
  9  *  static关键字：可以修饰普通 成员变量 和 普通成员方法
 10  *  说明一下： 按照严格意义上的面向对象思想， static修饰成员变量，和static修饰成员方法，
 11  *           都不能算做类中定义的成员
 12  *
 13  *           我们之所以称static修饰的变量为  静态成员变量(习惯上的称呼)
 14  *                                方法为  静态成员方法(习惯上的称呼)
 15  *
 16     static关键字的特点：
 17      1. 被类的所有 对象所共享：（判定是否使用static的关键)
 18         a. 当static修饰了成员变量，该成员变量变量的值，就不在存储与对象中了，
 19            而是，单独存储了一份，被类的所有对象所共享
 20 
 21         b. 当static修饰成员方法的时候，该方法被当前类的所有对象共享
 22            当前类对象.方法（和普通成员方法从共享的角度，几乎没有太大区别）
 23 
 24      2. 可以通过类名访问
 25         a. 可以通过类名直接访问，static成员变量的值
 26         b. 直接通过类名直接调用，static成员方法
 27 
 28      3. 随着类的加载而加载
 29         a. static成员变量，随着类加载过程，其实就已经在方法区中，分配了内存
 30         b. static成员方法, 一旦类加载完毕，我们就可以直接访问，static方法，而不必等待，创建对象，然后在对象名. 访问方法
 31 
 32      4. 优先于对象而存在
 33         1. 不依赖于对象而存在
 34            a. 成员变量的角度来理解，static修饰的成员变量，不在依赖于对象而存在，因为static修饰的成员变量的值，
 35               不在存储在，该类的每个对象中
 36               作为对比，没有被static修饰的成员变量，都依赖于对象而存在，因为他们的值，都存储在对象中
 37 
 38            b. 成员方法角度，被static修饰的成员方法，在没有对象存在的情况下，也可以直接通过类名来调用方法
 39               ，作为对比，没有被static修饰的，普通成员方法，它依赖于对象而存在, 原因是，普通成员方法中，
 40                 可以访问，普通成员变量的值，而普通对象的值又是依赖于对象而存在的
 41 
 42        2. 先出现在内存
 43           静态成员变量， 一定 先于 没有被static修饰的普通成员变量，出现在内存中
 44 
 45     注意事项：
 46        a. 非静态成员变量(非静态的成员方法)，不能在静态上下文(静态方法的方法体)中被访问
 47           为什么？
 48            1） 之所以静态方法，的方法体中，不能访问非静态成员变量，因为静态方法，优先于对象而存在
 49                首先，我们可以在，没有任何对象存在情况下，就可以直接通过类名，运行静态方法，
 50                所以静态方法，是访问不到当前对象的普通成员变量值(因为此时，当前对象不存在)
 51 
 52            2) 之所以静态方法方法体中，不能访问非静态的成员方法，因为，如果静态方法可以直接调用非静态的的方法
 53               非静态的方法，可以去访问当前对象的成员变量值，而当前对象，此时有能还不存在
 54 
 55        b. 静态方法 or 非静态方法，方法体中都不能使用static关键字定义变量
 56 
 57        c. 静态方法的使用场景
 58           静态方法和非静态方法除了访问方式不同，
 59           最大的区别，就是静态方法可以访问到的数据集合和非静态的方法不同(静态方法方法体中，不能直接访问非静态的成员变量)
 60           所有，通常，静态方法它所访问的数据：要么是静态的成员变量，要么是方法的形式参数
 61 
 62          通常，定义静态方法，都是为了，方别使用该方法的功能(工具方法), 让别人使用该方法的功能，
 63          为了方便使用该方法，通常，将这种工具方法定义为静态方法(访问的数据通常是方法参数)，不用创建对象就可以使用
 64 
 65  */
 66 public class Demo2 {
 67 
 68   public static void main(String[] args) {
 69     //StaticClass staticClass = new StaticClass();
 70     //1. 被类的所有 对象所共享：（判定是否使用static的关键)
 71     //静态成员变量的值，被类的所有对象共享
 72     //System.out.println(staticClass.staticField);
 73     ////静态成员方法，被类的所有对象共享
 74     //staticClass.testStatic();
 75 
 76 
 77     // 2. 可以通过类名访问
 78     System.out.println(StaticClass.staticField);
 79     StaticClass.testStatic();
 80 
 81     //3. 在不创建对象的情况下，通过类名，直接访问static成员变量或者成员方法，也会触发该类的类加载
 82     //StaticClass.testStatic();
 83 
 84     int[] arr = {1, 2, 3};
 85     System.out.println(Arrays.toString(arr));
 86   }
 87 
 88 }
 89 
 90 
 91 class StaticClass {
 92 
 93   //定义静态成员变量
 94   static int staticField = 100;
 95 
 96   double doubleValue = 9.9;
 97 
 98 
 99   public static void testStatic() {
100     System.out.println("testStatic");
101 
102     //被static修饰的静态方法体中，访问一下没有被static普通成员变量
103     //System.out.println(this.doubleValue);
104     //被static修饰的静态方法体中，访问一下没有被static普通成员方法
105     //this.testMethod();
106 
107     //可以访问静态的成员变量，可以调用静态的方法
108     test();
109     System.out.println(staticField);
110 
111 
112   }
113   public void testMethod() {
114     System.out.println("testMethod " + this.doubleValue);
115 
116     //可以直接访问, 静态方法和静态变量
117     System.out.println(staticField);
118     testStatic();
119   }
120 
121   public static void test() {
122 
123   }
124 }

 图：static修饰的成员变量存储在方法区

 1 package com.cskaoyan.keystatic;
 2 
 3 /**
 4  * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/15.
 5  * @version 1.0
 6  *
 7  * 静态成员变量和普通成员变量：
 8     所属不同
 9     静态变量属于类，所以也称为为 类变量
10     成员变量属于对象，所以也称为 实例变量(对象变量)
11 
12     内存中的位置不同
13     静态变量存储于方法区的静态区
14     成员变量存储于堆内存
15 
16     内存出现时间不同
17     静态变量随着类的加载而加载，随着类的消失而消失
18     成员变量随着对象的创建而存在，随着对象的消失而消失
19 
20     调用不同
21     静态变量可以通过类名调用，也可以通过对象调用
22     成员变量只能通过对象名调用
23 
24  */
25 public class Demo3 {
26 
27 }

面向对象思想