疯狂java讲义_day_03——第五章：类和对象、方法、递归

1. 类和对象

静态可调静态	静态不可调非静态
非静态可调静态	非静态可调非静态

// 一. 定义类
public class java04 {

    // 二. 定义成员变量
    String name;

	// 构造方法不能定义返回值类型，也不能有void和return
    // 三. 无参数构造方法
    public java04() {
    }

    // 四. 有参数构造方法
    public java04(String name) {
        this.name = name;
    }

    // 五. 定义一个方法 ，由于 ⑥ 中的静态main方法调用了jump方法，所以jump方法要加上static。
    public static void jump() {
        System.out.println("执行jump方法");
    }

    // 六. 通过 this 可以调用同一个类中的另一个方法。此处非静态的run方法调用了静态的jump方法。此处的run方法可以加上static。
    public void run() {
        // 或 this.jump(); 因为run是非静态，所以可以用this。
        jump();
        System.out.println("执行run方法");
    }

    // 七. 静态方法里不能有this
    // 类名. 的方式访问类中的静态方法/静态成员变量；new 一个实例 test ，test.的方式访问类中的非静态方法/非静态成员变量
    public static void main(String[] args) {
        java04 test = new java04();
        test.name = "DL";
        java04.jump(); //可以直接写成 jump()，因为它们是在同一个类中的静态方法。
        test.run();
    }
}

注意事项：

• 定义类：【修饰符】 class 类名 { }
• 定义成员变量：【修饰符】 类型 成员变量名 【=默认值】
  例如 public String name = null ； 或者 String name ；
• 定义构造方法：【修饰符】 构造方法名*上面的类名 （形参列表） { }
• 定义方法：【修饰符】 方法返回值类型 方法名（形参列表）{ }
• 构造方法名必须和类名相同，而且不能定义返回值类型，也不能有void和return
• 静态不能访问非静态
• 类名必须由有意义的单词连缀而成，单词之间不要使用任何分隔符
• 类名. 的方式访问类中的静态方法/静态成员变量；new 一个实例 test ，test.的方式访问类中的非静态方法/非静态成员变量

2. 方法

• 一旦将一个方法定义在某个类中，如果这个方法使用static修饰，则这个方法属于这个类，采用类名. 的方式调用，否则这个方法属于这个类的实例，采用对象. 的方式调用
• 同一个类中的一个方法调用另外一个方法时，如果被调方法时普通方法，则默认使用 this 作为调用者；如果被调方法是静态方法，则默认使用类作为调用者。
• 方法的属性：
  ① 方法不能独立定义，只能在类中定义
  ② 方法要么属于该类本身（static），要么属于该类的一个对象（非静态）
  ③ 不能独立执行方法，必须使用类或对象作为调用者，静态使用类名点，非静态使用对象点。

3. 递归

/**
 * f(0)=1，f(1)=4，f(n+2)=2×f(n+1)+f(n)，求f(10)
 */
public class java06 {
    public static int fn(int n) {
        if (n == 0)
            return 1;
        if (n == 1)
            return 4;
        else
            return 2 * fn(n - 1) + fn(n - 2);
    }

    public static void main(String[] args) {
        System.out.println(fn(10));
    }
}

注意：递归一定要向已知方向递归
① 已知 f(0)、f(1) ，求 f(10)，方向 10 → 0，1，构造 n-1，n-2
② 已知 f(20)、f(21) ，求 f(10)，方向 10 → 20，21，构造 n+1，n+2

/**
 * f(20)=1，f(21)=4，f(n+2)=2×f(n+1)+f(n)，求f(10)
 */
public class java06 {
    public static int fn(int n) {
        if (n == 20)
            return 1;
        if (n == 21)
            return 4;
        else
            return fn(n + 2) - 2 * fn(n + 1);
    }

    public static void main(String[] args) {
        System.out.println(fn(10));
    }
}

4. 成员变量和局部变量

• 成员变量：在类里定义的变量
• 局部变量：在方法里定义的变量
  
• java允许局部变量和成员变量同名，如果成员变量和方法里的局部变量同名，局部变量会覆盖成员变量。如果需要在这个方法里引用被覆盖的成员变量，则可使用 this.(对于实例变量) 或类名.(对于类变量)的方式来访问成员变量。

class Person {
    //定义类变量
    public static int eyeNum;

    //定义实例变量
    public String name;
}

public class java07 {
    public static void main(String[] args) {

        //创建两个Person对象
        Person p1 = new Person();
        Person p2 = new Person();

        //为它们的类变量赋值
        p1.eyeNum = 2;
        p2.eyeNum = 3;

        //为它们的实例变量赋值
        p1.name = "实例变量1";
        p2.name = "实例变量2";

        System.out.println(p1.eyeNum);  // 3
        System.out.println(p2.eyeNum);  // 3

        System.out.println(p1.name);    // 实例变量1
        System.out.println(p2.name);    // 实例变量2
    }
}

上述程序的内存示意图：