12.8 Java基础8

• 昨天知识回顾
• 数组的应用:
• 数组+循环+  应用:  求最值;平均值,求和 ；查找;排序: 选择排序，冒泡排序
• 二维数组:
• 平面 行+列格式. [][] 应用 杨辉三角. 保存全班每个同学java,C,MySQL成绩
• 面向对象
• 面向对象理解举例

面向过程：自己买材料，肉，鱼香肉丝调料，蒜苔，胡萝卜等等然后切菜切肉，开炒，盛到盘子里。

面向对象：去饭店，张开嘴：老板！来一份鱼香肉丝！（不必去一步一步的实现，只要会用就好，换菜时也方便，降低了耦合性，提高了可维护性）

• 面向对象的优势

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护。

• 面向对象语言的三大特征

封装：将功能封装成一个个独立的单元，减小耦合，避免牵一发而动全身，方便对程序的修改。

继承：代码重用，减少编码量，间接减少维护成本。

多态：不同的场合做出不同相应（比如：上课时大家状态也不一样，有分神的）。

• 类和对象

类: 就是一个模板，是一类对象的模板，它描述一类对象的行为和状态，定义了这些对象应该有的属性及方法。

对象: 万物皆对象。具体某一辆车就一个对象，车有轮胎，颜色等属性，有行驶的行为,对象是类的具体体现（实例）。对象实质是：属性（成员变量）+行为（方法或者函数）。

属性：对应类中的成员变量。属性又称为成员变量，是声明在类中的变量，在方法体中声明的变量称为局部变量或临时变量。

行为：对应类中的成员函数(方法)。

访问类的属性：对象名.属性（要想访问一个类中的非私有成员，必须要先创建该类对象（new），通过对象名来访问。）

调用类的方法：对象名.方法名(实参列表)

• 成员变量与临时变量

成员变量:

   堆内存，声明在类体内方法外；

   可以在声明时赋值或者构造方法赋值，若不赋值，会有默认的初始值；

    作用域：整个类都可以使用。

临时变量:

   栈内存, 方法内，包括方法的参数；

   声明和赋值之后才能使用，否则编译就会报错；

   作用域：找括号(变量声明在哪对{}里，那么它就在哪对{}内生效)，出了括号就不认识了。

成员变量和临时变量如果变量名相同，那么采用就近原则，以局部变量为准。

• 相关样例代码（以基金对象为例）

/**
 * @自定义类 ->创建了基金类后，要去创建对象调用其中的方法和属性
 * @author Administrator
 *
 */
public class Fund {
    // 属性【特征】
    // 变量
    String company;// 公司名
    String name;// 基金名
    String manager;// 基金经理名字
    String condition;// 今年来盈利状态
    int years;// 运行时间

    // 构造方法,是一个方法，但是没有void修饰,同时这个方法名和类名是一样的.
    // ->什么时候执行?
    public Fund(String company, String name, String manager, String condition, int years) {
        this.company = company;
        this.name = name;
        this.manager = manager;
        this.condition = condition;
        this.years = years;
        System.out.println("构造初始化完成");
    }

    // 方法 【行为】 ->特点 ()
    // 方法定义
    // public void 方法名(参数)
    // 退市
    public void exitMarket() {
        System.out.println("基金退市");
    }

    // 分红
    public void sharoutBonus() {
        System.out.println("基金每月分红");
    }

//    {}代码块  ->什么时候执行? 运行发现，创建对象后就可以执行代码块，而且顺序在对象属性和方法之前
    {
        System.out.println("我是代码块，什么时候执行");
    }
    // 静态代码块
    {
        System.out.println("我是静态代码块，什么时候执行");
    }

    // 公共内部类；在一个类内部还有一个类
    public class InnerClass {

    }

    @Override
    public String toString() {
        return "基金公司名：" + company + "\n基金名：" + name + "\n基金经理名：" + manager + "\n今年来盈利状态：" + condition + "\n运作时间："
                + years;
    }
}

 

public class FundTest {

    public static void main(String[] args) {
        // new
        // 类名 引用名 = new 类名();
//        例如 Scanner  input = new Scanner(System.in);

        // 自己写类->new 对象
        Fund f = new Fund("交银", "交银定期支付双息", "杨浩", "亏损", 6);
        // Fund有方法

        // 还有引用名.属性
//        f.company="交银";
//        f.name="交银定期支付双息";
//        f.condition="亏损";
//        f.manager="杨浩";
//        f.years=6;
        // 引用名.方法名()
        f.exitMarket();
        f.sharoutBonus();
        // 输出属性
        System.out.println(f.toString());
    }
}

注意：如果写构造方法时有放参数，那么创建对象时就要传参，参数一一对应。如果类中存在代码块，创建对象后就可以执行代码块，而且它的顺序还在调用的对象属性和方法之前。

 

• 方法定义及声明

定义: 成员方法是类中进行数据处理（对象的行为），实现相关功能的函数。

方法决定了一个对象能够接收什么样的消息。方法的基本组成部分包括：名称、参数、返回值和方法体。

方法若没有返回值，则用关键字void表示，那么该方法中的return语句如果在最后一行可以省略不写。

下图为四种有无参数和返回值的可能，以后会经常遇到。

return放在方法中时，它的作用：方法的终结者。也就是说执行到return语句，方法后续就不执行了，return后这个数据是这个方法作为反馈结果，返回给调用者的。

• Dog练习

public class Dog {
    // 姓名 颜色 年龄 成员属性
    String name;
    String color;
    int age;

    // 数学计算 10以内的加法
    // a 1 b 2 return "汪汪汪";
    // 如果结果 超出范围 return "嗷"
    public String add(int a, int b) {
        System.out.println(name + "-" + color + "-" + age);
        // 要计算
        int sum = a + b;
        if (sum > 10) {
            return "嗷";
        }
        String result = "";
        for (int i = 1; i <= sum; i++) {
            result += "汪";
        }
        return result;
    }

    public String minus(int a, int b) {
        System.out.println(name + "-" + color + "-" + age);
        // 要计算
        if (a - b < 0) {
            return "嗷";
        }

        String result = "";
        for (int i = 0; i < a - b; i++) {
            result += "汪";
        }
        return result;
    }
}

 

import java.util.Scanner;

public class DogTest {

    public static void main(String[] args) {

        Dog d = new Dog();
        d.age = 1;
        d.color = "白色";
        d.name = "大葱";
        
        Scanner input = new Scanner(System.in);
        System.out.println("请输入要计算的两个数字");
        int num1 = input.nextInt();
        int num2 = input.nextInt();
        String result1 = d.add(num1, num2);
        String result2 = d.minus(num1, num2);
        System.out.println(result1);
        System.out.println(result2);
    }
}

• 可变参数

J2SE 1.5中提供了一种允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。

如：public String minus(int a...int[]array){xxx;return;}

如果有多个参数，可变参数一定放在最后，并且一个方法只能有一个可变参数。

调用使用了可变参数的方法时：

1. 可以不写参数，即传入空参；
2. 可以直接在里边写入参数(数组里的元素)，参数间用逗号隔开；
3. 可以传入一个数组；

• Java中可变参数的特点：

Java把可变参数当做数组处理。

可变参数必须位于最后一项。当可变参数个数多余一个时，必将有一个不是最后一项，所以只支持有一个可变参数。因为参数个数不定，所以当其后边还有相同类型参数时，java无法区分传入的参数属于前一个可变参数还是后边的参数，所以只能让可变参数位于最后一项。

可变参数用...代替标识， ...位于变量类型和变量名之间，前后有无空格都可以。

用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。

 

• 方法递归

在程序设计中,方法直接或者间接调用其自身叫做递归调用，简称递归，其设计方法被应用到很多特殊问题的解决上。

注意：就目前所学来说，要做遍历还是多使用for循环。至于递归，以后有专门用到的时候。

示例：使用Java代码求5的阶乘。

分析：

(1)边界条件：阶乘，乘到最后一个数，即1的时候，返回1，程序执行到底；

(2)递归前进段：当前的参数不等于1的时候，继续调用自身；

(3)递归返回段：从最大的数开始乘，如果当前参数是5，那么就是5*4，

   即5*(5-1)，即n*f(n-1) 5*4*3*2*1

• Debug调试

之前已经讲过一些debug操作，今天补充了进入方法（step into）查看变量和表达式变化。之前多用的是step over单步运行。

 

感想：今天学得还好，代码都能敲出来，难点在于递归还不够熟练。

23:56:58 2021-12-08