1 /*****************
2 ***第五章面向对象(中)
3 *******知识点:
4 **************1.多态
5 ******************1.1 概念
6 ******************1.2 实现方式
7 **************2.抽象类
8 ******************2.1 关键字
9 ******************2.2 概念定义
10 ******************2.3 使用
11 **************3.接口
12 ******************3.1 关键字
13 ******************3.2 概念定义
14 ******************3.3 使用
15 ******************3.4 接口和抽象类的对比
16 **************4.final修饰符
17 ******************4.1 特征
18 ******************4.2 使用
19 **************5.static修饰符
20 ******************5.1 特征
21 ******************5.2 使用
22 */
23 public class test5{
24 public static void main(String[] args){
25 showDemo("1.多态");
26 demoMultimodal();//演示多态
27
28 showDemo("2.抽象类");
29 demoAbstractClass();//演示抽象类
30
31 showDemo("3.接口");
32 demoInterface();//演示接口
33
34 showDemo("4.final修饰符");
35 demoFinalKeyWord();//演示final
36
37 showDemo("5.static修饰符");
38 demoStaticKeyWord();//演示static
39
40 }
41
42 /**1.多态**/
43 public static void demoMultimodal(){
44 Person p1 = new Person();//调用无参构造方法
45 Person p2 = new Person(1,"ciade");//调用有参构造方法
46 System.out.println("========");
47 Boy b1 = new Boy();
48 Boy b2 = new Boy(2,"ciade",25);
49 System.out.println("========");
50 p1.show();//父类调用父类方法
51 System.out.println("========");
52 b1.show();//子类调用子类方法(重载父类方法)
53 System.out.println("========");
54 p1 = b1 ;//父类对象指向子类引用后调用子类方法
55 b1.show();
56
57 //总结：
58 // 1.调用基类static(只会首次调用)
59 // 2.调用本类static(只会首次调用)
60 // 3.调用基类构造器
61 // 4.调用本类构造器
62 //初始化对象时调用顺序为 1->2->3->4
63 //多态是什么 简单来说就是父类对象指向子类引用调用父类方法等同于子类对象调用子类该方法(该方法需要是重载父类的方法)
64 }
65
66 /**2.抽象类**/
67 public static void demoAbstractClass(){
68 //2.1 关键字
69 String[] s_AbstractClass = {"abstract"};
70 System.out.println("抽象类的关键字有：" + s_AbstractClass[0]);
71
72 //2.2 概念定义
73 //抽象类往往用来表征我们在对问题领域进行分析、 设计中得出的抽象概念，
74 //是对一系列看上去不同，但是本质上相同的具体概念的抽象，
75 //我们不能把它们实例化（拿不出一个具体的东西）所以称之为抽象类
76 //如：我们描述水果时。它就是一个抽象类。它有一些共性。比如质量，体积等。但又有一些不同。
77 //比如 苹果、橙子等就有不同的颜色。不同的外观等。所以我们可以定义一个水果抽象类。其他类可以继承这个抽象类
78
79 //2.3 使用 注意事项
80 // 1. 抽象类不能实例对象
81 // 2. 可以带有抽象方法。继承子类必须重写所有的抽象方法(除非这个子类也是抽象类)
82 // 3. 可以带有实现方法(注意区分 实现为空和实现不为空，抽象类两种均可)
83 // 4. 可以带有数据成员
84 // 5. 至少有一个抽象方法(即不能为空类)
85 // 6. 抽象方法只能使用public、protected，默认情况是public
86 // 7. 一个子类只能继承一个抽象类(跟继承类一致)
87 // 8. 抽象类可以继承抽象类
88 // 9. 抽象类可以实现接口
89
90 System.out.println("抽象类定义:\r\n"
91 + "public abstract class Fruit{ \r\n"
92 + " ...... \r\n"
93 + "}"
94 );
95 }
96
97 /**3.接口**/
98 public static void demoInterface(){
99 //3.1 关键字
100 String[] s_demoInterface = {"interface","implements"};
101 System.out.println("接口关键字有：" + s_demoInterface[0] + "," + s_demoInterface[1]);
102
103 //3.2 概念定义
104 //额。这个貌似不知道怎么解释了。暂时理解为一系列方法特征的集合吧。
105 System.out.println("接口定义方式为：\r\n "
106 + "public interface 接口名字 {\r\n"
107 + " .....\r\n"
108 + " }"
109 );
110 //3.3 使用
111 System.out.println("接口实现方式为：\r\n "
112 + "public class implements 接口名字 {\r\n"
113 + " .....\r\n"
114 + " }"
115 );
116 //注意事项：
117 // 1. 接口可以有变量和方法
118 // 2. 变量全部是public static final(有且只能有 外加默认)
119 // 3. 方法全部是public abstract(有且只能有 外加默认)
120 // 4. 接口可以实现接口(多个)
121 // 5. 类可以实现接口(多个)
122
123 //3.4 接口和抽象类的对比
124 //由上面可以得出对比如下：
125 //1.语法上区别————定义不同,内部成员和方法不同,继承数量和实现数量不同
126 //2.设计上区别————抽象必须重写所有抽象方法，而接口不需要(可以选择性重写)
127 }
128
129 /**4.final修饰符**/
130 public static void demoFinalKeyWord(){
131 //4.1 特征
132 //1.final类不能被继承，故不可能有子类
133 //2.final方法不能被重写(final类中的方法均为final)
134 //3.final变量只能赋值一次，后面值不能变(即需要在声明时立刻初始化)
135 //4.final关键字不能用于修饰构造方法
136
137 //4.2 使用
138 //1.final类 public final class A{}
139 System.out.println("1.final类 public final class A{}");
140 //2.final方法 public final void A(){}
141 System.out.println("2.final方法 public final void A(){}");
142 //3.final变量 public final in A = 1;(三种作用域 静态变量、成员变量、局部变量)
143 System.out.println("3.final变量 public final in A = 1;(三种作用域 静态变量、成员变量、局部变量)");
144 }
145
146 /**5.static修饰符**/
147 public static void demoStaticKeyWord(){
148 //5.1 特征
149 //1. 使用static修饰的方法和变量成为全局方法、全局变量(如果在类开始时定义属于类,不属于任何对象)
150 //2. 1.中的全局方法和全局变量也称为静态方法、静态变量
151 //3. 在实例化对象时会先调用static方法再调用非static方法 示例可见下面的Person类和Boy类(且只会调用一次)
152 //4. 任何实例均可访问静态方法和静态变量
153 //5. 在对象的方法中可以调用静态方法和静态变量
154 //6. 在静态方法中可以访问静态变量，但不能直接访问对象方法和变量
155 //7. 在和final组合成final static时用于定义常量(不可发生的变量)
156
157 //5.2 使用
158 /*
159 *用于演示static
160 */
161 /*
162 public class test5_1{
163
164 public static int i = 0;
165
166 static{
167 System.out.println("static方法加载...");
168
169 }
170 public static int show(){
171 return i;
172 }
173
174 public int i_;
175
176 public test5_1(){
177 this.i_ = 1;
178 }
179 public test5_1(int i){
180 this.i_ = i;
181 }
182 public int getI(){
183 return this.i_;
184 }
185
186 public void showI(){
187 System.out.println("非static调用static方法.... i:" + show());
188 }
189
190 public static void main(String[] args) throws Exception{
191 System.out.println("static i:" + i);
192 //getI();//会报错。 static方法中不能直接调用非static方法
193 test5_1.i ++ ;
194
195 System.out.println("static i:" + i);
196
197 System.out.println("getI()...i_" + new test5_1(5).getI());//这样子可以调用非static方法
198
199 test5_1 t = new test5_1();
200 t.i++;
201 t.showI();
202
203 }
204
205 }*/
206 }
207
208 /*
209 * 抽取打印演示函数 用于打印演示功能提示
210 */
211 public static void showDemo(String demoStr){
212 System.out.println("演示:" + demoStr);
213 }
214
215 }
216
217
218 /*
219 * 演示基类
220 */
221 class Person{
222 private int id;
223 private String name;
224 static{
225 System.out.println("这是Person类的static方法在运行....");
226 }
227 public Person(){
228 this.id = 0;
229 this.name = "无名氏";
230 System.out.println("这是Person无参构造器在运行....");
231 }
232
233 public Person(int id,String name){
234 this.id = id;
235 this.name = name;
236 System.out.println("这是Person(id,name)有参构造器在运行....");
237 }
238
239 public void show(){
240 System.out.println("这是父类的show()方法——id：" + id + "，name：" + name);
241 }
242
243 }
244
245 /*
246 * 演示子类
247 */
248 class Boy extends Person{
249 private int age;
250 static{
251 System.out.println("这是Boy类的static方法在运行....");
252 }
253 public Boy(){
254 //super(); 有无此行均会调用父类默认构造方法
255 //super(0,""); 有此行调用父类带参数构造方法
256 this.age = 0;
257 System.out.println("这是Boy无参构造器在运行....");
258 }
259
260 public Boy(int id,String name,int age){
261 super(id,name); //有此行调用基类带参数构造方法 无此行会自行调用基类默认无参方法
262 this.age = age;
263 System.out.println("这是Boy(id,name,age)有参构造器在运行....");
264 }
265
266 //重写show()方法 用于实现多态
267 public void show(){
268 super.show();
269 System.out.println("这是子类的show()方法——age：" + age);
270 }
271
272
273
274 }
