第04章(面向对象——上)

/*****************
***第四章面向对象(上)
*******知识点:
**************1.类和对象
******************1.1 关键字
******************1.2 定义
******************1.3 使用
**************2.方法和属性
******************2.1 关键字
******************2.2 方法重载和重写
******************2.3 方法参数传递
******************2.4 成员属性和局部属性
**************3.隐藏和封装
******************3.1 关键字
******************3.2 概念定义
******************3.3 访问权限
******************3.4 package和import
**************4.构造器
******************4.1 关键字
******************4.2 概念
******************4.3 定义
******************4.4 使用
**************5.继承
******************5.1 关键字
******************5.2 定义
******************5.3 使用
*/
import java.util.*;
public class test4{
    public static void main(String[] args){
        showDemo("1.类和对象");
        demoClassAndObject();
        
        showDemo("2.方法和属性");
        demoMethodAndField();
        
        showDemo("3.隐藏和封装");
        demoHideAndPackage();
        
        showDemo("4.构造器");
        demoConstructor();
        
        showDemo("5.继承和多态");
        demoExtend();
    }
    
    /**1.类和对象**/
    public static void demoClassAndObject(){
        //1.1关键字
        String[] s_Arr = {"class","new"};
        System.out.println("类和对象的关键字有:" + s_Arr[0] + "," + s_Arr[1]);
        //1.2定义
        String s_demo_class = "public class Person{ \r\n " 
                               +" private int id; \r\n "
                               +" public void setId(int id) { \r\n" 
                               +"      this.id = id;\r\n"
                               +"   }\r\n"
                               +"\r\n}";
        System.out.println("类定义：\r\n" + s_demo_class);//使用class关键字定义类
        
        String s_demo_Object = "  Pernon p = new Person();";
        System.out.println("对象定义：\r\n" + s_demo_Object);//使用new关键字定义该类对象
        
        //1.3使用
        //类是对象的模板。它定义了某类对象特有的属性和方法。
        //对象是类的实例。它根据类定义的属性有属于自己的成员数据，并且可以通过相关的方法获取到该数据
        String s_demo_UseFlow = "1.定义类的方法和属性   2.定义该类的对象  3.使用该对象调用相关操作方法";
        System.out.println("使用步骤：" + s_demo_UseFlow);
        
    }
    
    /**2.方法和属性**/
    public static void demoMethodAndField(){
        //2.1 概念
        //方法 可以为类方法也可以为对象方法   类方法需用static修饰(后面再详细讲述两者的访问差异)
        //属性 可以为类属性也可以为对象属性      类属性需用static修饰(后面再详细讲述两者的访问差异)
        
        //2.2 方法重载和重写
        //方法重载是以统一的方式处理不同类型数据的一种手段。
        //多个同名函数同时存在，具有不同的参数个数/类型 或者 不同类型的返回值  
        System.out.println("Max方法重载1：" + Max(1) + ",    Max方法重载2：" + Max(1,3) + ",    Max方法重载3：" + Max(-1.5,-3.5));
        
        //方法重写
        //方法重写以不同于父类的处理方式去处理子类特有的方式的一种手段
        //比如B类继承A类，A类中有个play()方法。B类可以根据自己的特性重写实现play()方法
        //此特性是实现多态的核心
        
        //2.3 方法参数传递
        //两种方式
        //第一种传递基本数据(即参数是基本数据类型  四类八种)
        //第二种传递引用数据(即参数为引用类型  如数组、对象等)        
        //不管哪一种方式都不能改变参数本身的数据(使用static关键字修饰的参数和方法除外 因为staitc是属于类的)
        
        //2.4 成员属性和局部属性
        //成员属性  针对对象本身(定义在类里面,static修饰除外。因为static修饰是属于类的成员变量，针对类本身)
        //局部属性  针对调用者本身或者创建着本身(定义在方法里面)
        //两者作用域也不一样   前者是于对象共存亡   后者是于方法共存亡
    }
    
    /**3.隐藏和封装**/
    public static void demoHideAndPackage(){
        //3.1 关键字
        String[] s_demoHideAndPackage = {"public","protected","default","private"};
        System.out.println("隐藏和封装的关键字有:" + s_demoHideAndPackage[0] + "," 
                            + s_demoHideAndPackage[1] + ","
                            + s_demoHideAndPackage[2] + ","
                            + s_demoHideAndPackage[3]);
        
        //3.2 概念定义
        //隐藏   将相关的信息封闭起来不对外公开    
        //封装   将对象的状态信息隐藏在对象内容中,不允许外部程序直接访问对象的内部信息，
        //       但可以通过该类所提供的方法来实现对内部信息的操作和访问
        //是面向对象编程的核心之一
        
        //3.3 访问权限
        //public      全局 - 子类  - 同包中 - 同类中
        System.out.println("public访问权限：全局 - 子类  - 同包中 - 同类中");
        
        //protetcted  子类  - 同包中 - 同类中
        System.out.println("protetcted访问权限：子类  - 同包中 - 同类中");
        
        //default(如果不加任何关键字修饰的話,java默认)      同包中 - 同类中
        System.out.println("default访问权限：同包中 - 同类中");
        
        //private      同类中
        System.out.println("private访问权限：同类中");
        //建议：一般情况下 方法使用public  属性使用private
        
        //3.4 package和import
        //package   生成包
        System.out.println("package生成包语法: package + 包名(需注意全名且该行在页首)");
        
        //import 导入包
        System.out.println("import生成包语法: import + 包名(需注意全名且该行在页首)");
    }
    
    /**4.构造器**/
    public static void demoConstructor(){
        //4.1 关键字
        String[] s_demoConstructor = {"this","super"};
        System.out.println("构造器的关键字有:" + s_demoConstructor[0]+ ","  + s_demoConstructor[1]);
        //4.2 概念
        //构造器  一个特殊的方法  用于创建对象
        //this关键字   引用当前对象
        //super关键字   引用基类对象
        //4.3 定义
        String s_demoConstructor_str = "权限符 类名() {\r\n"
                                        +"      ...\r\n"
                                        +"} //其中权限符通常为public";
        System.out.println("构造器定义：\r\n" + s_demoConstructor_str);
        
        //4.4 使用
        //注意：
        //    假如一个类没有设置字定义构造器，那么编译器会默认一个无参构造器
        //      假如定义了一个带参数的构造器没无参构造器时，那么将无法使用无参构造器
        //      支持重载
        //      子类构造器在调用时会先调用基类的构造器    
        
        System.out.println("构造器的使用：Person p = new Person();");
    }
    
    /**5.继承**/
    public static void demoExtend(){
        //5.1 关键字
        String[] s_demoExtendAndMultimodal = {"extends","implements"};
        System.out.println("继承和多态关键字有:" + s_demoExtendAndMultimodal[0]+ ","  + s_demoExtendAndMultimodal[1]);
        
        //5.2 定义
        //extends 继承自基类(需注意java中只能继承一个基类)
        //implements 实现某些接口(需注意java中可以实现多个接口)
        // class B extends class A
        System.out.println("继承基类语法定义：子类名(可以是接口) extends 基类名");
        // class B implements interface C
        System.out.println("实现接口语法定义：子类名(可以是接口) implements 接口1,接口2.....");
        
        //5.3 使用
        //使用步骤：1.定义基类  2.定义子类继承父类
    }
    
    /*
    *演示重载方法1
    */
    public static int Max(int i){
        return i > 0 ? i : 0;
    }
    
    /*
    *演示重载方法2
    */
    public static int Max(int i1,int i2){
        return i1 > i2 ? i1 : i2;
    }
    
    /*
    *演示重载方法3
    */
    public static double Max(double d1,double d2){
        return d1 > d2 ? d1 : d2;
    }
    
    /*
    *    抽取打印演示函数  用于打印演示功能提示
    */    
    public static void showDemo(String demoStr){
        System.out.println("演示:" + demoStr);
    }
}