AM上午總結:
1 package com.java.kudy.day17_2.ObjectReview;
2
3 public class ObjectTest {
4
5 /**
6 *虛擬機做了什么事情?
7 *1.在棧內存中定義了一個變量p
8 *2.在類加載器中加載Person.class
9 *3.在堆內存中開辟空間,分配了一個物理地址
10 *4.初始化成員變量,如果沒有初始值,那么虛擬機會自動初始化,所有的引用數據類型都為null
11 *5.調用構造函數,為成員賦值(field)
12 *6.將對象的首地址給變量p2
13 */
14 public static void main(String[] args)
15 {
16 Person p = new Person("小細",18);
17
18 }
19 }
20
21 class Person
22 {
23 private String name;
24 private int age;
25 public Person(){}
26 public Person(String name,int age)
27 {
28 this.name = name;
29 this.age = age;
30 }
31
32 @Override
33 public String toString()
34 {
35 return name+"~"+age;
36 }
37 }
抽象類的回顧:
1 package com.java.kudy.day17_2.Extends;
2
3 public class ExtendsTest {
4 /*
5 * 抽象類:
6 * 1.用abstract修飾的類叫做抽象類
7 * 2.如果該類有抽象的方法,這個類必須要定義成抽象類
8 * 3.抽象類是更好的為了多態而服務,我們在設計軟件的時,會有一些列類都具備相同的功能,這時方法一樣的聲明,即使是方法也可以復用.
9 * 我們應該抽象出一個抽象的父類,方便別人學習軟件,也能實現一部分代碼.說白了就是:更好的為了多態而服務.
10 * 4.繼續抽象類需要實現抽象方法,或者把繼承過來的類定義成抽象類.
11 */
12 public static void main(String[] args) {
13
14 }
15
16 }
17
18 abstract class Student
19 {
20 public abstract void run();
21 }
接口和內部類的簡單復習:
1 package com.java.kudy.day17_2.Extends;
2
3 /*
4 * 接口:一種特殊的抽象類,所有的方法都是抽象的.
5 * 1.實現接口用關鍵字:implements.可以實現多個接口,接口繼承接口可以使用extends 關鍵字
6 * 2.接口中的所有的方法默認為:public abstractor 共同修飾,所以不需要另外聲明
7 * 3.接口中所有的變量默認為常量:public static final所修飾,不需要聲明(一份)
8 *
9 * 匿名內部類實現:
10 * new fulei(){
11 * //內部類的定義
12 * };
13 * final關鍵字:
14 * 1.修飾變量成常量.
15 * 2.修飾類不能被繼承.
16 * 3.修飾方法不能被重寫.
17 */
18 public class InterfacesTest {
19
20
21 public static void main(String[] args) {
22 Teacher kudy = new Teacher(){
23 @Override
24 public void teching() {
25 System.out.println("同學們,其實我什么也不懂~~!");
26 }
27 //匿名內部類實現
28
29 };
30 }
31
32 }
33
34 interface Teacher
35 {
36 void teching(); //public abstract void teching();
37 }
38
39
40 package com.java.kudy.day17_2.Extends;
41
42 public class ExtendsDemo {
43 /*使用extends關鍵字,讓子類繼承父類
44 * 1.子類會自動復用于父類的方法
45 * 2.可以把一個子類的實例當做父類來使用,調用方法時,是調用子類的方法(多態),但必須是重寫了父類的方法,不過可以轉型.訪問屬性是訪問父類的
46 * (靜態綁定,-->在編譯的期間就已經完成了變量的綁定)而訪問方法是訪問子類的(動態的綁定-->)
47 * 如果是調用子類特有的方法,需要強制轉換成子類的類型.
48 * 假設:A的父類是B B的父類的C --> 如果父類型的C 引用指向子類型的對象-->A
49 * 但我想使用B類型的方法,我們只需要把B b = (B)c;強制轉換就可以.因為c對象本來就是A.
50 * 3.子類的實例化: 子類在實例化過程中一定調用父類的構造方法,我們在子類的構造函數的第一行可以用this(實參)調用自己的其他方法,
51 * Super(實參)調用父類的某個構造方法,如果第一行什么也不寫.默認super()調用父類的不帶參數的構造方法
52 * 4子類覆蓋父類的方法: 方法名相同,參數類型相同.方法的返回值也必須要相同.
53 *
54 */
55 public static void main(String[] args) {
56 C c = new A();
57 //如果我想調用b的方法,原因: 我是你A的父類
58 B b = (B)c;
59 b.run();
60 b.happy();
61 }
62
63 }
64 class C
65 {
66 public void run()
67 {
68 System.out.println("a");
69 }
70 }
71
72 class B extends C
73 {
74 public void run()
75 {
76 System.out.println("b");
77 }
78 public void happy()
79 {
80 System.out.println("我是happy達人");
81 }
82 }
83
84 class A extends B
85 {
86 public void run()
87 {
88 super.run();
89 System.out.println("c");
90 }
91 }
ArrayList(元素有序,底層數組實現.)
1 package com.java.kudy.day17_2.CollectionTest;
2
3 import java.util.ArrayList;
4 import java.util.Iterator;
5
6 import com.java.kudy.day17_2.reflectDemo.Person;
7
8 public class ArrayListTest {
9
10 public static void main(String[] args)
11 {
12 ArrayList<Person> al = new ArrayList<Person>();
13 al.add(new Person("a",1));
14 al.add(new Person("b",2));
15 al.add(new Person("c",3));
16 al.add(new Person("d",4));
17 al.add(new Person("e",5));
18
19 /*
20 * 迭代的三種方式:
21 */
22 Iterator<Person> it = al.iterator();
23 while(it.hasNext())
24 {
25 Person p = it.next();
26 System.out.println(p);
27 }
28
29 for(Person p : al)
30 System.out.println(p);
31
32 for(int i=0; i<al.size(); i++)
33 {
34 System.out.println(al.get(i));
35 }
36 }
37
38 }
39
40 package com.java.kudy.day17_2.CollectionTest;
41
42 import java.util.HashSet;
43
44 import com.java.kudy.day17_2.reflectDemo.Person;
45
46 public class HashSetTest {
47 /*
48 * 通過哈希算法保證元素沒重復性
49 * 首先通過哈希算法比較,再用equals比較.
50 * 1.hashCode
51 * 2.equals
52 */
53 public static void main(String[]args)
54 {
55 HashSet<Person> al = new HashSet<Person>();
56 al.add(new Person("a",1));
57 al.add(new Person("b",2));
58 al.add(new Person("c",3));
59 al.add(new Person("d",4));
60 al.add(new Person("a",1));
61
62 for(Person p : al)
63 System.out.println(p);
64 }
65 }
TreeSet:可以寫比較器..(如果沒有實現接口的方法,會出異常信息)
1 package com.java.kudy.day17_2.CollectionTest;
2
3 import java.util.Comparator;
4 import java.util.TreeSet;
5
6 import com.java.kudy.day17_2.reflectDemo.Person;
7
8 public class TreeSetTest {
9 public static void main(String[]args)
10 {
11 TreeSet<Person> ts = new TreeSet<Person>(new Comparator<Person>(){
12
13 @Override
14 public int compare(Person s1, Person s2) {
15 int num = s1.getAge()-s2.getAge();
16 if(num!=0)
17 return num;
18 return s1.getName().compareTo(s2.getName());
19 }
20
21 });
22 ts.add(new Person("a",1));
23 ts.add(new Person("b",2));
24 ts.add(new Person("c",3));
25 ts.add(new Person("d",4));
26 ts.add(new Person("a",1));
27 for(Person p :ts)
28 System.out.println(p);
29 }
30 }
Map回顧練習:
1 package com.java.kudy.day17_2.CollectionTest;
2
3 import java.util.HashMap;
4 import java.util.Iterator;
5 import java.util.Map.Entry;
6 import java.util.Set;
7
8 public class HashMapTest {
9
10 /**
11 * @param args
12 */
13 public static void main(String[] args)
14 {
15 HashMap<Teacher, Integer> hm =
16 new HashMap<Teacher, Integer>();
17 hm.put(new Teacher("a",1), 1);
18 hm.put(new Teacher("a",1), 1);
19 hm.put(new Teacher("b",2), 1);
20 hm.put(new Teacher("c",3), 1);
21 //保證了key的無重復性
22
23 /* //方式一:
24 Set<Entry<Teacher, Integer>> entrys = hm.entrySet(); //獲取一個試圖
25 Iterator<Entry<Teacher, Integer>> it = entrys.iterator();
26 while(it.hasNext())
27 {
28 Entry<Teacher, Integer> e = it.next(); //迭代器,迭代下一個內容
29 Teacher key = e.getKey();
30 Integer value = e.getValue();
31 System.out.println(key +"--"+value);
32 }*/
33
34 //方式二:
35 Set<Teacher> keys= hm.keySet();
36 for(Teacher t : keys)
37 {
38 Integer value = hm.get(t);
39 System.out.println(t+"--"+value);
40 }
41
42 }
43
44 }
Properties的應用:
1 package com.java.kudy.day17_2.CollectionTest;
2
3 import java.io.FileNotFoundException;
4 import java.io.FileReader;
5 import java.io.IOException;
6 import java.io.PrintStream;
7 import java.util.Enumeration;
8 import java.util.Properties;
9
10 public class PropertiesTest {
11
12 /**
13 * @param args
14 * 用于讀寫配置文件
15 * @throws IOException
16 * @throws FileNotFoundException
17 */
18 public static void main(String[] args) throws FileNotFoundException, IOException {
19 Properties prop = new Properties();
20 prop.load(new FileReader("src/a.properties")); //讀取進來
21 Enumeration e = prop.propertyNames();
22
23 //通過枚舉獲取到鍵-->值
24 while(e.hasMoreElements())
25 {
26 String key = (String)e.nextElement();
27 String value = prop.getProperty(key);
28 System.out.println(key+"----"+value);
29 }
30
31 // 調用 Hashtable 的方法 put 鍵和值進來 key value
32 prop.setProperty("name","my_kudy");
33 prop.setProperty("age", "19");
34 //直接把內容打印到一個配置文件里面去
35 prop.list(new PrintStream("src/a.properties")); //直接把字節和字符寫入進去
36 //把內容輸入里面去
37 }
38
39 }
PM下午總結:
JAVA語言中的反射機制：
在Java 運行時 環境中，對于任意一個類，能否知道這個類有哪些屬性和方法？
對于任意一個對象，能否調用他的方法？這些答案是肯定的，這種動態獲取類的信息，以及動態調用類的方法的功能來源于JAVA的反射。從而使java具有動態語言的特性。
JAVA反射機制主要提供了以下功能：
1.在運行時判斷任意一個對象所屬的類
2.在運行時構造任意一個類的對象
3.在運行時判斷任意一個類所具有的成員變量和方法（通過反射甚至可以調用private方法）
4.在運行時調用任意一個對象的方法（*****注意：前提都是在運行時，而不是在編譯時）
Java 反射相關的API簡介：
位于java。lang。reflect包中
--Class類：代表一個類
--Filed類：代表類的成員變量
--Method類：代表類的方法
--Constructor類：代表類的構造方法
--Array類：提供了動態創建數組，以及訪問數組的元素的靜態方法。該類中的所有方法都是靜態方法
----Class類
在 java 的Object類中的申明了數個應該在所有的java類中被改寫的methods：
hashCode(), equals(),clone(),toString(),getClass()等，其中的getClass()返回yige
Class 類型的對象。
Class類十分的特殊，它和一般的類一樣繼承自Object，其實體用以表達java程序運行
時的 class和 interface，也用來表達 enum，array，primitive，Java Types 以及關鍵字void
，當加載一個類，或者當加載器（class loader）的defineClass（）被JVM調用，便產生一個Class
對象，
Class是Reflection起源，針對任何你想探勘的class（類），唯有現為他產生一個Class
的對象，接下來才能經由后者喚起為數十多個的反射API。
Java允許我們從多種途徑為一個類class生成對應的Class對象。
--運用 getClass（）：Object類中的方法，每個類都擁有此方法
String str="abc";
Class cl=str.getClass();
--運用 Class。getSuperclass（）：Class類中的方法，返回該Class的父類的Class
--運用 Class。forName（）靜態方法：
--運用 ,Class：類名.class
--運用primitive wrapper classes的TYPE語法： 基本類型包裝類的TYPE，如：Integer.TYPE
注意：TYPE的使用，只適合原生（基本）數據類型
----運行時生成instance
想生成對象的實體，在反射動態機制中有兩種方法，一個針對無變量的構造方法，一個針對帶參數的
構造方法，，如果想調用帶參數的構造方法，就比較的麻煩，不能直接調用Class類中的newInstance（）
，而是調用Constructor類中newInstance（）方法，首先準備一個Class[]作為Constructor的參數類型。
然后調用該Class對象的getConstructor（）方法獲得一個專屬的Constructor的對象，最后再準備一個
Object[]作為Constructor對象昂的newInstance（）方法的實參。
在這里需要說明的是 只有兩個類擁有newInstance（）方法，分別是Class類和Constructor類
Class類中的newInstance（）方法是不帶參數的，而Constructro類中的newInstance（）方法是帶參數的
需要提供必要的參數。
1 package com.java.kudy.day17_2.reflectDemo;
2
3 import java.lang.reflect.Constructor;
4 import java.lang.reflect.Field;
5 import java.lang.reflect.InvocationTargetException;
6 import java.lang.reflect.Method;
7 import java.lang.reflect.Modifier;
8
9 public class ClassTest {
10
11 /**
12 * @param args
13 * 反射的引用:
14 * ----Class類
15 在 java 的Object類中的申明了數個應該在所有的java類中被改寫的methods：
16 hashCode(), equals(),clone(),toString(),getClass()等，其中的getClass()返回一個
17 Class 類型的對象。
18 Class類十分的特殊，它和一般的類一樣繼承自Object，其實體用以表達java程序運行
19 時的 class和 interface，也用來表達 enum，array，primitive，Java Types 以及關鍵字void
20 ，當加載一個類，或者當加載器（class loader）的defineClass（）被JVM調用，便產生一個Class
21 對象，
22 Class是Reflection起源，針對任何你想探勘的class（類），唯有現為他產生一個Class
23 的對象，接下來才能經由后者喚起為數十多個的反射API。
24 的類
25 * @throws ClassNotFoundException
26 * @throws NoSuchFieldException
27 * @throws SecurityException
28 * @throws IllegalAccessException
29 * @throws IllegalArgumentException
30 * @throws NoSuchMethodException
31 * @throws InvocationTargetException
32 * @throws InstantiationException
33 */
34 public static void main(String[] args) throws ClassNotFoundException,
35 SecurityException, NoSuchFieldException,
36 IllegalArgumentException, IllegalAccessException,
37 NoSuchMethodException, InvocationTargetException,
38 InstantiationException
39 {
40 Object obj = new Person();
41
42 //獲取實例三中方法
43 //通過對象.getClass獲取到運行時的類
44 Class clazz1 = obj.getClass(); //獲取到一個類
45 System.out.println(clazz1.getName());
46 Class clazz2 = Person.class;
47 System.out.println(clazz2.getName());
48 String className = "com.java.kudy.day17_2.reflectDemo.Person";
49 Class clazz3 = Class.forName(className);
50 System.out.println(clazz3.getName());
51 Class clazz4 = int.class;
52 System.out.println(clazz4.getName()); //我們已經映射出一個類
53
54 //獲取到一個類中所有的屬性(成員屬性-->字段)
55 Class clazz = Person.class;
56 Field[] fields = clazz.getDeclaredFields();
57
58 //遍歷,.獲取每一個成員屬性
59 for(Field field : fields)
60 {
61 /*
62 * 基本的 Java 類型（boolean、byte、char、short、int、long、float 和 double）
63 * 和關鍵字 void 也表示為 Class 對象-->所以我們返回它的父類的正確的
64 */
65 String name = field.getName(); //字段名
66 String type = field.getType().getName(); //類型
67 System.out.println("類型:"+type+"字段名:"+name);
68 }
69 /*
70 //獲取一個obj對象name的屬性,并且改變name屬性的值
71 Field declareField = clazz.getDeclaredField("name"); //必須要知道一個字段的名字
72 declareField.setAccessible(true); //編譯檢查去掉-->private-->public
73 Object value = declareField.get(obj); //獲取這個對象字段的值
74 System.out.println(value); //其實這個是打印了對象的toString方法
75 //如果底層字段的類型為基本類型，則對新值進行自動解包
76 declareField.set(obj,"kudy"); //異常信息:有可能底層是不能被訪問的
77 Object oj = declareField.get(obj); //返回該字段的值,返回的是object 其實是String類型
78 System.out.println(oj.toString());*/
79
80 /*
81 * 獲取一個類中定義的所有方法
82 */
83 Method[] methods = clazz.getDeclaredMethods();
84 for(Method method : methods)
85 {
86 //1.獲取到一個方法的名稱
87 String name = method.getName();
88 //2.獲取到一個方法的修飾符
89 System.out.print(name+"\t");
90 int num = method.getModifiers();
91 if(Modifier.isPublic(num))
92 System.out.print("public\t");
93 if(Modifier.isPrivate(num))
94 System.out.print("Private\t");
95 if(Modifier.isAbstract(num))
96 System.out.print("abstractor\t");
97 //3.獲取到形參類型
98 Class[] parameterTypes = method.getParameterTypes();
99 for(Class type : parameterTypes)
100 System.out.print(type.getName()+"\t");
101
102 //4.獲取到一個返回值類型
103 Class returnType = method.getReturnType(); //返回一個返回值類型 void
104 System.out.println(returnType.getName());
105 System.out.println();
106 }
107 /*
108 * 調用obj的setName方法將名字更改成王五
109
110 Method method =clazz.getDeclaredMethod("setName",String.class);
111 method.setAccessible(true);//去掉安全的檢查
112 method.invoke(obj, "my_kudy");
113 System.out.println(obj.toString());
114 */
115
116 //獲得類中定義的構造方法
117 Constructor[] constructors = clazz.getDeclaredConstructors();
118 for(Constructor constructor : constructors)
119 {
120 String name = constructor.getName();
121 System.out.println("構造方法名為:"+name);
122 Class[] types = constructor.getParameterTypes();
123 System.out.println("參數類型為:");
124 for(Class type : types)
125 System.out.print(type.getName()+" ");
126 System.out.println();
127 }
128
129 //調用有參的構造方法,創建對象
130 //Class cz = String.class
131 /* Constructor constructor =
132 clazz.getDeclaredConstructor(String.class,int.class);*/
133 //基本參數和引用參數都要進行方法調用轉換。
134 Constructor constructor =
135 clazz.getDeclaredConstructor(new Class[]{String.class,int.class});
136 Person p =(Person)constructor.newInstance("小細",19);
137 System.out.println(p);
138
139 //獲得包名
140 Package pa = clazz.getPackage();
141 System.out.println(pa.getName());
142
143 //獲得該類或接口的修飾符
144 int mod = clazz.getModifiers();
145 if(Modifier.isPublic(mod))
146 System.out.println("public修飾");
147 if(Modifier.isAbstract(mod))
148 System.out.println("Abstractor修飾");
149 }
150
151 }
面向接口編程思想:
接口:
1 package com.java.kudy.day17_2.GraphDemo;
2
3 public interface GetGraph {
4
5 Double getArea();
6
7 }
8 Round.class
9 package com.java.kudy.day17_2.GraphDemo;
10
11 public class Round implements GetGraph{
12
13 private double r;
14 @Override
15 public Double getArea() {
16 return Math.PI*r*r;
17 }
18
19 }
20
21 Test類:
22 package com.java.kudy.day17_2.GraphDemo;
23
24 import java.io.BufferedReader;
25 import java.io.IOException;
26 import java.io.InputStreamReader;
27 import java.lang.reflect.Field;
28
29 public class Test {
30
31 /**
32 * @param args
33 * @throws IOException
34 * @throws ClassNotFoundException
35 * @throws IllegalAccessException
36 * @throws IllegalArgumentException
37 * @throws InstantiationException
38 */
39 public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalArgumentException, IllegalAccessException, InstantiationException
40 {
41 BufferedReader br = new
42 BufferedReader(new InputStreamReader(System.in));
43 System.out.println("請輸入你需要實現的圖形:");
44 String className = br.readLine();
45 //映射出一個圓
46 Class clazz = null;
47 try
48 {
49 clazz = Class.forName("com.java.kudy.day17_2.GraphDemo."+className);
50 }catch(RuntimeException e)
51 {
52 System.out.println("您輸入的功能還沒有實現!!!,等待更新!!");
53 return ;
54 }
55 //獲取到一個類.為這個類創建對象
56 //獲取到的類是Round.class
57 GetGraph g = (GetGraph)clazz.newInstance(); //為這個類創建對象
58 //本來是一個Person類型的引用,現在是Object
59 //Object obj = new Person();
60 //GetGraph g = (GetGraph) Person(); //如果是繼承關系.是可以把它更改一吧.
61 //接口指向實現接口
62 /*
63 * Object obj = new Round();
64 * (GetGraph)
65 * 接口--> = 實現接口
66 */
67 Field[] fields = clazz.getDeclaredFields();
68 //遍歷所有的屬性,并且為他賦值 field.getName()意思: 獲取這個屬性的名字
69 for(Field field :fields)
70 {
71 System.out.println("請輸入"+field.getName()); //獲取到這個屬性的名字
72 String value = br.readLine();
73 field.setAccessible(true);//去掉安全檢查
74 Double d = Double.parseDouble(value);
75 field.setDouble(g, d);
76 }
77 double area = g.getArea();
78 System.out.println(area);
79 }
80
81 }
小小的案例回顧:
1 package com.java.kudy.day17_2.GraphDemo;
2
3 class A {
4 public void run()
5 {
6 System.out.println("A.running");
7 }
8 }
9
10 class B extends A
11 {
12 public void run()
13 {
14 System.out.println("B.running");
15 }
16 }
17
18 class C extends B
19 {
20 public void run()
21 {
22 System.out.println("C.running");
23 }
24 }
25 public class TestExtends
26 {
27 /*
28 * 我父類型的引用指向子類型的對象
29 * 但是我們如果想拿第二個子類指向第一個父類.是不可以的.所以我們必須要把它所指向的類型更改為B
30 */
31 public static void main(String[]args)
32 {
33 A a = new C();
34 a.run();
35 B b =(B)a;
36 b.run();
37 }
38 }
39
40
41 ------------用面向接口的思想實現一個長方形(要求用到反射.)
42
43 接口:
44 package com.java.kudy.day17_2.CollectionTest;
45
46 public interface GetSRound {
47
48 //實現一個面積
49 double getArea();
50 }
51
52 實現長方形的方法:
53 package com.java.kudy.day17_2.CollectionTest;
54
55 public class Square implements GetSRound{
56 private double broder ;
57
58 @Override
59 public double getArea() {
60 return broder*broder;
61 }
62 }
63
64 Test:
65 package com.java.kudy.day17_2.CollectionTest;
66
67 import java.io.BufferedReader;
68 import java.io.IOException;
69 import java.io.InputStreamReader;
70 import java.lang.reflect.Field;
71
72 import com.java.kudy.day17_2.GraphDemo.GetGraph;
73
74 public class Test {
75
76 /**
77 * @param args
78 * 用反射求一個正方形的面積
79 * @throws IOException
80 * @throws ClassNotFoundException
81 * @throws IllegalAccessException
82 * @throws InstantiationException
83 */
84 public static void main(String[] args) throws IOException,
85 ClassNotFoundException,
86 InstantiationException,
87 IllegalAccessException
88 {
89
90 //字節流轉換成字符流
91 BufferedReader br =
92 new BufferedReader(new InputStreamReader(System.in));
93 System.out.println("請輸入你要希望求的圖形");
94 String className = br.readLine(); //獲取一個類
95 System.out.println(className);
96 Class clazz = null;
97 try
98 {
99 //獲取一個類
100 //Class clazz = Square.class
101 clazz = Class.forName("com.java.kudy.day17_2.CollectionTest."+className);
102 }catch (RuntimeException e) {
103 System.out.println("該功能還沒有實現.程序已經退出..");
104 return;
105 }
106 //為這個類創建對象
107 GetSRound g = (GetSRound)clazz.newInstance(); //接口指向實現接口.由于接口里面的方法已經被實現.所以調用她其實就是調用實現接口里面的方法
108 Field[] fields = clazz.getDeclaredFields(); //遍歷成員變量
109 for(Field field : fields)
110 {
111 //遍歷所有的成員變量,為屬性賦值
112 System.out.println("請輸入:"+field.getName()); //獲取成員變量名
113 field.setAccessible(true); //去掉私有的檢查,因為這個類是私有的就oh啦
114 String str = br.readLine();
115 Double value = Double.parseDouble(str);
116 field.setDouble(g, value);
117 }
118 double area = g.getArea();
119 System.out.println(area);
120 }
121
122 }
posted on 2012-08-19 18:54
、小細 閱讀(159)
評論(0) 編輯 收藏