4_面向对象-上之属性和方法

属性：

类的设计中，两个重要结构之一：属性　　

　　对比：属性 vs 局部变量

　　1.相同点：
　　* 1.1 定义变量的格式：数据类型变量名 = 变量值
　　* 1.2 先声明，后使用
　　* 1.3 变量都其对应的作用域

　　2.不同点：
　　2.1 在类中声明的位置的不同
　　* 属性：直接定义在类的一对{}内
　　* 局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
　　*
　　* 2.2 关于权限修饰符的不同
　　* 属性：可以在声明属性时，指明其权限，使用权限修饰符。
　　* 常用的权限修饰符：private、public、缺省、protected --->封装性
　　* 目前，大家声明属性时，都使用缺省就可以了。
　　* 局部变量：不可以使用权限修饰符。
　　*
　　* 2.3 默认初始化值的情况：
　　* 属性：类的属性，根据其类型，都默认初始化值。
　　* 整型（byte、short、int、long：0）
　　* 浮点型（float、double：0.0）
　　* 字符型（char：0 （或'u0000'））
　　* 布尔型（boolean：false）
　　*
　　* 引用数据类型（类、数组、接口：null）
　　*
　　* 局部变量：没默认初始化值。
　　* 意味着，我们在调用局部变量之前，一定要显式赋值。
　　* 特别地：形参在调用时，我们赋值即可。
　　*
　　* 2.4 在内存中加载的位置：
　　* 属性：加载到堆空间中（非static）
　　* 局部变量：加载到栈空间

　　补充：回顾变量的分类：
　　方式一：按照数据类型：

　　方式二：按照在类中声明的位置：

方法：　　

　　类的设计中，两个重要结构之二：方法
　　方法：描述类应该具的功能。
　　

　　* 比如：Math类：sqrt()
andom() ...
　　* Scanner类：nextXxx() ...
　　* Arrays类：sort()  binarySearch()  toString()  equals()  ...
　　* 
　　* 1.举例：
　　* public void eat(){}
　　* public void sleep(int hour){}
　　* public String getName(){}
　　* public String getNation(String nation){}
　　*

　　* 2. 方法的声明：权限修饰符返回值类型方法名(形参列表){
　　* 方法体
　　* }
　　* 注意：static、final、abstract 来修饰的方法，后面再讲。
　　*
　　* 3. 说明：
　　* 3.1 关于权限修饰符：默认方法的权限修饰符先都使用public
　　* Java规定的4种权限修饰符：private、public、缺省、protected -->封装性再细说
　　*
　　* 3.2 返回值类型：返回值 vs 没返回值
　　* 3.2.1 如果方法返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用
　　* return关键字来返回指定类型的变量或常量：“return 数据”。
　　* 如果方法没返回值，则方法声明时，使用void来表示。通常，没返回值的方法中，就不需要
　　* 使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
　　*
　　* 3.2.2 我们定义方法该不该返回值？
　　* ① 题目要求
　　* ② 凭经验：具体问题具体分析
　　*
　　* 3.3 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
　　*
　　* 3.4 形参列表：方法可以声明0个，1个，或多个形参。
　　* 3.4.1 格式：数据类型1 形参1,数据类型2 形参2,...
　　*
　　* 3.4.2 我们定义方法时，该不该定义形参？
　　* ① 题目要求
　　* ② 凭经验：具体问题具体分析
　　*
　　* 3.5 方法体：方法功能的体现。

　　4. 方法的使用中，可以调用当前类的属性或方法
　　* 特殊的：方法A中又调用了方法A:递归方法。
　　* 方法中，不可以定义方法。　

return关键字：
　　1.使用范围：使用在方法体中
　　2.作用：① 结束方法
　　* ② 针对于返回值类型的方法，使用"return 数据"方法返回所要的数据。
　　3.注意点：return关键字后面不可以声明执行语句。

方法的重载　

　　1.方法的重载的概念
　　定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
　　*
　　总结："两同一不同":同一个类、相同方法名
　　参数列表不同：参数个数不同，参数类型不同

　　2.构成重载的举例：

　　举例一：Arrays类中重载的sort() / binarySearch()；PrintStream中的println()

举例二：
//如下的4个方法构成了重载
    public void getSum(int i,int j){
        System.out.println("1");
    }
    
    public void getSum(double d1,double d2){
        System.out.println("2");
    }
    
    public void getSum(String s ,int i){
        System.out.println("3");
    }
    
    public void getSum(int i,String s){
        System.out.println("4");
    }
   
不构成重载的举例：
    //如下的3个方法不能与上述4个方法构成重载
//    public int getSum(int i,int j){
//        return 0;
//    }
    
//    public void getSum(int m,int n){
//        
//    }
    
//    private void getSum(int i,int j){
//        
//    }

　　3. 如何判断是否构成方法的重载？
　　严格按照定义判断：两同一不同。
　　跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系！

　　4.如何确定类中某一个方法的调用：

　　方法名 ---> 参数列表　　

面试题：方法的重载与重写的区别？

throwsthrow
StringStringBufferStringBuilder
CollectionCollections
finalfinallyfinalize
...

抽象类、接口
sleep() / wait()

可变个数形参的方法

1.使用说明：
　　* 1.jdk 5.0新增的内容
　　* 2.具体使用：
　　* 2.1 可变个数形参的格式：数据类型 ... 变量名
　　* 2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
　　* 2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
　　* 2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
　　* 2.5 可变个数形参在方法的形参中，必须声明在末尾
　　* 2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。

2.举例说明：

public void show(int i){
        
    }
    
    public void show(String s){
        System.out.println("show(String)");
    }
    
    public void show(String ... strs){
        System.out.println("show(String ... strs)");
        
        for(int i = 0;i < strs.length;i++){
            System.out.println(strs[i]);
        }
    }
    //不能与上一个方法同时存在
//    public void show(String[] strs){
//        
//    }
调用时：
        test.show("hello");
        test.show("hello","world");
        test.show();
        
        test.show(new String[]{"AA","BB","CC"});

java的值传递机制

　　1.针对于方法内变量的赋值举例：

System.out.println("***********基本数据类型：****************");
        int m = 10;
        int n = m;
        
        System.out.println("m = " + m + ", n = " + n);
        
        n = 20;
        
        System.out.println("m = " + m + ", n = " + n);
        
        System.out.println("***********引用数据类型：****************");
        
        Order o1 = new Order();
        o1.orderId = 1001;
        
        Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
        
        System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
        
        o2.orderId = 1002;
        
        System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);

递归方法

　　1.定义：
　　递归方法：一个方法体内调用它自身。

　　2.如何理解递归方法？

　　> 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
　　> 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

　　3.举例：

// 例1：计算1-n之间所自然数的和
    public int getSum(int n) {// 3

        if (n == 1) {
            return 1;
        } else {
            return n + getSum(n - 1);
        }

    }

    // 例2：计算1-n之间所自然数的乘积:n!
    public int getSum1(int n) {

        if (n == 1) {
            return 1;
        } else {
            return n * getSum1(n - 1);
        }

    }
    
    //例3：已知一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
    //其中n是大于0的整数，求f(10)的值。
    public int f(int n){
        if(n == 0){
            return 1;
        }else if(n == 1){
            return 4;
        }else{
//            return f(n + 2) - 2 * f(n + 1);
            return 2*f(n - 1) + f(n - 2);
        }
    }

    //例4：斐波那契数列
    
    //例5：汉诺塔问题
    
    //例6：快排