1 /*
2 static(静态)
3
4 需求：描述一下传智学生类。 都是中国人....
5
6
7 目前存在的问题： 所有的学生都是中国 的，有n个学生就会有n份中国的 数据存内存中，这样子
8 会浪费内存。
9
10 目前方案： 把“中国”这个数据移动 到数据共享区中，共享这个数据给所有的Student对象使用即可。
11
12 问题2： 如何才能把这个数据移动 到数据共享区中共享呢？
13
14 解决方案： 只需要使用static修饰该数据即可。
15
16
17 静态的成员变量只会在数据共享区中维护一份，而非静态成员变量的数据会在每个对象中都维护一份的。。
18
19 */
20
21 class Student{
22
23 String name;
24
25 //使用了static修饰country，那么这时候country就是一个共享的数据。
26
27 static String country = "中国"; //国籍
28
29 //构造函数
30 public Student(String name){
31 this.name = name;
32 }
33 }
34
35 class Demo9 {
36
37 public static void main(String[] args)
38 {
39 Student s1 = new Student("张三");
40 Student s2 = new Student("陈七");
41
42 s1.country = "小日本";
43 System.out.println("姓名："+s1.name+" 国籍："+ s1.country); // 中国
44 System.out.println("姓名："+s2.name+" 国籍："+ s2.country); // 小日本
45 }
46 }
1 /*
2 static(静态\修饰符)
3
4 1. static修饰成员变量 ：如果有数据需要被共享给所有对象使用时，那么就可以使用static修饰。
5
6 静态成员变量的访问方式：
7
8 方式1： 可以使用对象进行访问。
9 格式： 对象.变量名。
10
11 方式二： 可以使用类名进行访问。
12 格式： 类名.变量名;
13
14 注意：
15 1. 非静态的成员变量只能使用对象进行访问，不能使用类名进行访问。
16 2. 千万不要为了方便访问数据而使用static修饰成员变量，只有成员变量的数据是真正需要被共享的时候
17 才使用static修饰。
18
19 static修饰成员变量的应用场景： 如果一个数据需要被所有对象共享使用的时候，这时候即可好实用static修饰。
20
21
22 2. static修饰成员函数:
23
24 */
25
26 class Student{
27
28 static String name; //非静态成员变量
29
30 static String country = "中国"; //静态的成员变量
31
32 public Student(String name){
33 this.name = name;
34 }
35 }
36
37
38 class Demo10 {
39
40
41 public static void main(String[] args)
42 {
43 Student s1 = new Student("狗娃");
44 Student s2 = new Student("狗剩");
45
46 //System.out.println("国籍："+ Student.country);
47 System.out.println("名字："+ s1.name);
48 System.out.println("名字："+ s2.name);
49 }
50 }
1 /*
2
3 构造函数：
4
5
6 构造函数的作用： 初始化对应的对象。
7
8 构造函数的格式：
9
10 修饰符 函数名(形式参数){
11 函数体
12 }
13
14 构造函数要注意的事项：
15 1. 构造函数是没有返回值类型的。
16 2. 构造函数的函数名是必须与类名一致。
17 3. 构造函数不是由我们手动调用的，是我们在创建了对应的对象时，jvm会根据你创建的对象传递的参数调用
18 对应 的对象。
19 4. 如果一个类没有显示写上一个构造函数的时候，那么java编译器会为该类添加一个无参 的构造函数。
20 5. 如果一个类已经显示写上一个构造函数的时候,那么java编译器则不会再为该类添加一个无参 的构造函数。
21 6. 构造函数是可以以函数重载的形式存在多个。
22
23 构造代码块：
24
25 构造代码块的作用：给对象进行统一的初始化。
26
27 构造代码块 的格式：
28 {
29 代码；
30 }
31
32 构造代码块是在创建了代码块所属类的对象时调用一次。
33
34
35 this关键字：
36
37 this关键字代表了所属函数的调用者对象。
38
39 this关键字的作用：
40 1. 一个类中存在同名的成员变量与局部变量时，在方法的内部默认是访问局部 变量的，可以通过this关键字指定访问成员变量 的数据。
41 2. this关键字还可以在构造函数中调用另外一个构造函数初始化对象，
42
43 this关键字调用构造函数要注意的事项：
44 1. this关键字调用其他 的构造函数时，必须要是在第一个语句。
45 2. this关键字调用构造函数时不能出现相互调用，因为是一个死循环。
46 3. 如果在方法的内部访问一个变量时，该变量只存在于成员变量中，局部没有没有，这时候java编译器会为该变量的前面添加this关键字。
47
48 static（静态、修饰符）
49
50
51 static修饰成员变量时：static修饰成员变量时,那么该成员变量的数据就是一个共享的数据.
52
53 静态成员变量的访问方式：
54
55 方式一： 使用对象进行访问。
56 对象.属性名
57 方式二：可以使用类名进行访问。
58 类名.属性名
59 注意：
60 1. 非静态成员变量不能类名直接访问，只能使用对象进行访问。
61 2. 千万不要为了方便访问成员变量而使用static修饰，一定要是该数据是共享数据 时才使用static修饰。
62
63
64
65
66
67 */
68 class Demo1
69 {
70 public static void main(String[] args)
71 {
72 System.out.println("Hello World!");
73 }
74 }
1 /*
2 需求：编写一个数组的工具类。
3 Arrays.toString（） [1,2,3,4];
4 sort()
5 */
6
7 //数组工具类
8 class ArrayTool{
9
10 public static String toString(int[] arr){
11 String result = "";
12 for(int i = 0; i < arr.length ; i++){
13 if (i==0){
14 result+="["+arr[i]+",";
15 }else if(i==(arr.length-1)){
16 result+= arr[i]+"]";
17 }else{
18 result+=arr[i]+",";
19 }
20 }
21 return result;
22 }
23 public static String toString(int [] arr){
24 String result="";
25 for(int i=0;i<arr.length;i++){
26 if(i==0){
27 result="["+arr[i]+","+result;
28 }else if(i==(arr.length-1)){
29 result=arr[i]+"]";
30 }else{
31 result=arr[i]+","+result;
32 }
33 }
34 }
35
36 public static void sort(int[] arr){
37 for(int i = 0; i < arr.length-1 ; i++){
38 for(int j = i+1 ; j<arr.length ; j++){
39 if(arr[i]>arr[j]){
40 int temp = arr[i];
41 arr[i] = arr[j];
42 arr[j] = temp;
43 }
44 }
45 }
46 }
47
48 }
49
50
51
52 class Demo3
53 {
54 public static void main(String[] args)
55 {
56 int[] arr = {12,1,456,165};
57 //ArrayTool tool = new ArrayTool();
58
59 ArrayTool.sort(arr);
60 String info = ArrayTool.toString(arr);
61 System.out.println("数组的元素："+ info);
62 }
63 }
