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

/*****************
***第五章面向对象(中)
*******知识点:
**************1.多态
******************1.1 概念
******************1.2 实现方式
**************2.抽象类
******************2.1 关键字
******************2.2 概念定义
******************2.3 使用
**************3.接口
******************3.1 关键字
******************3.2 概念定义
******************3.3 使用
******************3.4 接口和抽象类的对比
**************4.final修饰符
******************4.1 特征
******************4.2 使用
**************5.static修饰符
******************5.1 特征
******************5.2 使用
*/
public class test5{
    public static void main(String[] args){
        showDemo("1.多态");
        demoMultimodal();//演示多态
        
        showDemo("2.抽象类");
        demoAbstractClass();//演示抽象类
        
        showDemo("3.接口");
        demoInterface();//演示接口
        
        showDemo("4.final修饰符");
        demoFinalKeyWord();//演示final
        
        showDemo("5.static修饰符");
        demoStaticKeyWord();//演示static
        
    }
    
    /**1.多态**/
    public static void demoMultimodal(){
        Person p1 = new Person();//调用无参构造方法
        Person p2 = new Person(1,"ciade");//调用有参构造方法
        System.out.println("========");
        Boy b1 = new Boy();
        Boy b2 = new Boy(2,"ciade",25);
        System.out.println("========");
        p1.show();//父类调用父类方法
        System.out.println("========");
        b1.show();//子类调用子类方法(重载父类方法)
        System.out.println("========");
        p1 = b1 ;//父类对象指向子类引用后调用子类方法
        b1.show();
        
        //总结：
        //        1.调用基类static(只会首次调用)  
        //        2.调用本类static(只会首次调用)   
        //        3.调用基类构造器  
        //        4.调用本类构造器
        //初始化对象时调用顺序为 1->2->3->4
        //多态是什么 简单来说就是父类对象指向子类引用调用父类方法等同于子类对象调用子类该方法(该方法需要是重载父类的方法)
    }
    
    /**2.抽象类**/
    public static void demoAbstractClass(){
        //2.1 关键字
        String[] s_AbstractClass =  {"abstract"};
        System.out.println("抽象类的关键字有：" + s_AbstractClass[0]);
        
        //2.2 概念定义
        //抽象类往往用来表征我们在对问题领域进行分析、 设计中得出的抽象概念，
        //是对一系列看上去不同，但是本质上相同的具体概念的抽象，
        //我们不能把它们实例化（拿不出一个具体的东西）所以称之为抽象类
        //如：我们描述水果时。它就是一个抽象类。它有一些共性。比如质量，体积等。但又有一些不同。
        //比如 苹果、橙子等就有不同的颜色。不同的外观等。所以我们可以定义一个水果抽象类。其他类可以继承这个抽象类
        
        //2.3 使用 注意事项
        // 1. 抽象类不能实例对象
        // 2. 可以带有抽象方法。继承子类必须重写所有的抽象方法(除非这个子类也是抽象类)
        // 3. 可以带有实现方法(注意区分 实现为空和实现不为空，抽象类两种均可)
        // 4. 可以带有数据成员
        // 5. 至少有一个抽象方法(即不能为空类)
        // 6. 抽象方法只能使用public、protected，默认情况是public
        // 7. 一个子类只能继承一个抽象类(跟继承类一致)
        // 8. 抽象类可以继承抽象类
        // 9. 抽象类可以实现接口
        
        System.out.println("抽象类定义:\r\n" 
                            + "public abstract class Fruit{ \r\n"
                            + "    ...... \r\n"
                            + "}"
                            );
    }
    
    /**3.接口**/
    public static void demoInterface(){
        //3.1 关键字
        String[] s_demoInterface = {"interface","implements"};
        System.out.println("接口关键字有：" + s_demoInterface[0] + "," + s_demoInterface[1]);
        
        //3.2 概念定义
        //额。这个貌似不知道怎么解释了。暂时理解为一系列方法特征的集合吧。
        System.out.println("接口定义方式为：\r\n "
                            + "public interface 接口名字 {\r\n"
                            + "    .....\r\n"
                            + " }"
                            );
        //3.3 使用
        System.out.println("接口实现方式为：\r\n "
                            + "public class implements 接口名字 {\r\n"
                            + "    .....\r\n"
                            + " }"
                            );
        //注意事项：
        //            1. 接口可以有变量和方法
        //            2. 变量全部是public static final(有且只能有 外加默认)
        //            3. 方法全部是public abstract(有且只能有 外加默认)
        //            4. 接口可以实现接口(多个)
        //            5. 类可以实现接口(多个)
        
        //3.4 接口和抽象类的对比
        //由上面可以得出对比如下：
                            //1.语法上区别————定义不同,内部成员和方法不同,继承数量和实现数量不同
                            //2.设计上区别————抽象必须重写所有抽象方法，而接口不需要(可以选择性重写)
    }
    
    /**4.final修饰符**/
    public static void demoFinalKeyWord(){
        //4.1 特征
        //1.final类不能被继承，故不可能有子类
        //2.final方法不能被重写(final类中的方法均为final)
        //3.final变量只能赋值一次，后面值不能变(即需要在声明时立刻初始化)
        //4.final关键字不能用于修饰构造方法
        
        //4.2 使用
        //1.final类   public final class A{}
        System.out.println("1.final类   public final class A{}");
        //2.final方法  public final void A(){}
        System.out.println("2.final方法  public final void A(){}");
        //3.final变量  public final in A = 1;(三种作用域  静态变量、成员变量、局部变量)
        System.out.println("3.final变量  public final in A = 1;(三种作用域  静态变量、成员变量、局部变量)");
    }
    
    /**5.static修饰符**/
    public static void demoStaticKeyWord(){
        //5.1 特征
        //1. 使用static修饰的方法和变量成为全局方法、全局变量(如果在类开始时定义属于类,不属于任何对象)
        //2. 1.中的全局方法和全局变量也称为静态方法、静态变量
        //3. 在实例化对象时会先调用static方法再调用非static方法 示例可见下面的Person类和Boy类(且只会调用一次)
        //4. 任何实例均可访问静态方法和静态变量
        //5. 在对象的方法中可以调用静态方法和静态变量
        //6. 在静态方法中可以访问静态变量，但不能直接访问对象方法和变量
        //7. 在和final组合成final static时用于定义常量(不可发生的变量)
        
        //5.2 使用
        /*
            *用于演示static
            */
            /*
            public class test5_1{

                public static int i = 0;
                
                static{
                    System.out.println("static方法加载...");
                    
                }
                public static int  show(){
                        return i;
                }
                
                public int i_;
                
                public test5_1(){
                    this.i_ = 1;
                }
                public test5_1(int i){
                    this.i_ = i;
                }
                public int getI(){
                    return this.i_;
                }
                
                public void showI(){
                    System.out.println("非static调用static方法.... i:" + show());
                }    
                
                public static void main(String[] args) throws Exception{
                   System.out.println("static i:" + i);
                   //getI();//会报错。  static方法中不能直接调用非static方法
                   test5_1.i ++ ;
                   
                   System.out.println("static i:" + i);
                   
                   System.out.println("getI()...i_" + new test5_1(5).getI());//这样子可以调用非static方法
                   
                   test5_1 t = new test5_1();
                   t.i++;
                   t.showI();
                   
                }
                
            }*/
    }
    
    /*
    *    抽取打印演示函数  用于打印演示功能提示
    */    
    public static void showDemo(String demoStr){
        System.out.println("演示:" + demoStr);
    }
    
}


/*
*  演示基类 
*/
class Person{
    private int id;
    private String name;
    static{
        System.out.println("这是Person类的static方法在运行....");
    }
    public Person(){
        this.id = 0;
        this.name = "无名氏";
        System.out.println("这是Person无参构造器在运行....");
    }
    
    public Person(int id,String name){
        this.id = id;
        this.name = name;
        System.out.println("这是Person(id,name)有参构造器在运行....");
    }
    
    public void show(){
        System.out.println("这是父类的show()方法——id：" + id + "，name：" + name);
    }
     
}

/*
*  演示子类 
*/
class Boy extends Person{
    private int age;
    static{
        System.out.println("这是Boy类的static方法在运行....");
    }
    public Boy(){
        //super();  有无此行均会调用父类默认构造方法
        //super(0,""); 有此行调用父类带参数构造方法
        this.age = 0;
        System.out.println("这是Boy无参构造器在运行....");
    }
    
    public Boy(int id,String name,int age){
        super(id,name);  //有此行调用基类带参数构造方法  无此行会自行调用基类默认无参方法
        this.age = age;
        System.out.println("这是Boy(id,name,age)有参构造器在运行....");
    }
    
    //重写show()方法 用于实现多态
    public void show(){
        super.show();
        System.out.println("这是子类的show()方法——age：" + age);
    }
    

    
}