Java：类、方法的定义及调用、重载

1、面向对象与面向过程

1、面向过程适合处理一些较为简单的问题

2、面向对象过程适合处理一些复杂的问题，适合处理多人协作的问题。

3、面向对象编程本质就是：以类的方式组织代码，以对象的组织（封装）数据

4、二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为。面向对象，将功能封装进对象，强调具备了功能的对象。

2、类（class）

Java是由类组成的，类包含对象的属性和功能（方法）；

2.1 类的语法格式

修饰符 class 类名{    
	属性声明；
	方法声明；
}

属性声明： 修饰符 类型 属性名 = 初值；

​ 1、修饰符private：该属性只能由该类的方法访问。

​ 2、修饰符public：该属性可以被该类以外的方法访问。

​ 3、初值如果不确定可以先不赋值。

---

方法声明：修饰符 返回值类型 方法名（参数列表）{
方法体语句；
}

1、如果返回值类型不为void，则需要return语句传递返回值。

3、方法

3.1 方法是什么

通俗一点来说：在我们的日常生活中，方法可以理解为要做某件事情，而采取的解决办法。在Java中则是为了实现某种功能的，可以被重复调用的代码段。

3.2 方法的优点

1、使用方法可以提高代码的复用性：

因为它是定义在类里面方法外面，只有调用的时候才会执行，而且可以被重复使用，以用来实现某种独立的功能；

2、方法便于后期维护：

每个方法块都是独立的，便于后期修改内容；

3.3 方法的定义：

3.3.1 定义方法的分析步骤

1.方法的需求

2.返回值---------是否有返回值，什么数据类型

3.参数------------是否需要定义参数

4.方法名---------见名知意

3.3.2 方法的分类：

有返回值类型的方法

修饰符 返回值类型 方法名(参数列表){

	实现功能的代码段;

	return 返回值;

}

无返回值类型的方法

修饰符 void 方法名(参数列表){
           方法体语句;
           return;
}

修饰符：

表示访问权限修饰符，一般默认为public static；

返回值类型：

方法体代码执行完毕之后,是否需要得到一个结果或者数据值,如果需要就定义为有返回值类型的方法,不需要就定义为没有返回值类型的方法；

方法名：

用来调用该方法使用的标识符，遵循标识符的命名规范，驼峰命名法；

参数列表：

可以定义参数,可以不定义参数,可以定义多个参数；

如果在方法的实现过程中存在未知、不确定、可能会改变的数据，那么就定义在方法的参数列表上，定义参数和定义变量的格式相同，可以为任意的数据类型；

参数分类：

1.形式参数(形参) : 定义方法时()中的参数

2.实际参数(实参) : 调用方法时()中的参数

形参与实参之间需要一一对应，个数一致，类型一致，不同类型的形参顺序一致；

tips：1、形参如果不赋值，是没有默认值的；

	   2、接收返回值类型的变量同样适用于自动类型转换，也就是大类包括小类；

3.3.3 return

有两个作用：1、提前结束方法，2、带出返回值给到调用处；

tips：1、在一个有返回值类型的方法必须 存在return关键字；

	   2、return后面执行不到的语句会报错，没有执行时机，为不可达语句；

3.4 方法的调用

1、普通调用: 方法名(参数列表);

有返回值类型的方法调用时候需要接收返回值

没有返回值类型的方法，只能使用普通调用！！

2、赋值调用

数据类型 变量名 = 方法名(参数列表);

System.out.println(变量名);

3、输出调用

System.out.println(方法名(参数列表));

public class Class001_Method {
    //类中方法外的位置
    public static void main(String[] args) {
        //赋值调用
        double d = getPI();
        System.out.println(d);

        //输出调用
        System.out.println(getPI());

        System.out.println(getSum(3,5));

        //普通调用:无法接受返回值
        getPI();
    }

3.5 方法的重载

3.5.1 方法重载的前提

当一个类中实现某个功能的时候,这个功能却有不同的实现方式或者需要接受不同的参数,可以让这些相同功能实现的方法,这就构成方法的重载；多个方法的方法名相同。

3.5.2 方法重载的要求

1、同一个类中的多个方法

2、方法名相同

3、参数列表不同（也叫做方法签名不同，方法签名就是方法名+参数列表）

tips：参数列表不同具体表现在：参数个数不同、参数的类型不同、不同类型的参数顺序不同；

3.5.3 方法重载的调用

在调用处输入方法名(实参)，由输入的实参（数量、数据类型等等）决定重载方法的调用；

public static void main(String[] args) {
        getSum(1,1.1);
    }
    //对数求和
    public static void getSum(int x,int y){
        System.out.println("两个int类型参数的和"+(x+y));
    }

    public static void getSum(int x,int y,int z){
        System.out.println("三个int类型参数的和"+(x+y+z));
    }

    public static void getSum(int x,double y){
        System.out.println("一个int,一个double类型参数的和"+(x+y));
    }

    public static void getSum(double y,int x){
        System.out.println("一个double,一个int类型参数的和"+(x+y));
    }

3.6 static关键字（静态修饰符）

static 静态的
成员修饰符 : 只能修饰成员位置的内容,不能修饰局部
修饰变量 : 静态变量|类变量
修饰方法 : 静态方法|类方法
修饰块 : 静态块
修饰类 : 静态内部类

    静态内容的使用:
                1.跟随类名使用
                    类名.静态变量名
                    类名.静态方法名(参数列表);
                2.跟随对象使用
                    引用.静态变量名
                    引用.静态方法名(参数列表);

    成员是是属于对象的
    静态的是属于类的

    成员变量 :
        被static修饰的变量 --> 静态变量|类变量
        不被static修饰的变量 --> 实例变量
    成员方法:
        被static修饰的方法 --> 静态方法|类方法
        不被static修饰的方法 --> 实例方法

注意:
this只能使用在非静态环境中

​ 在非静态方法中使用this,默认指代当前调用实例方法的对象

​ 静态内容是独一份的,静态变量存在与静态区中,多个对象共享的资源

​ 成员内容跟随对象存在与对象的堆内存中,多个对象,就有多份成员

​ 初始加载顺序: 先静态后成员

​ 静态内容在类第一次加载完成之后就会进行初始化

​ 成员变量必须在执行到new对象的时候,才会存在对象的堆内存,在对象的堆内存中才会有成员变量

4、递归：

定义：在方法定义中调用方法本身

4.1 递归的优缺点：

优点：用在合理的位置可以简化代码结构；

缺点：如果代码结构复杂，可能会大量占用内存，造成内存溢出，降低效率。

临界条件: 停止自己调用自己的条件

递归前进段: 不停的自己调用自己,知道临界条件之间这个过程

递归后退段: 从临界条件开始,将结果返回给调用的上一层的过程

public static void main(String[] args) {
        System.out.println(recursion(3));;
    }
    //递归 : 求某个数阶乘   5! = 5*4!
    //返回值: 需要 int
    //参数: int i
    public static int recursion(int i){
        //临界条件
        if(i==1){
            return 1;
        }
        return i * recursion(i-1);
    }