第05章(面向对象——中)

  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 }