概念
概念：具有一定特殊功能的一段代码，将需要在多个位置重复使用的一组代码，定义在方法内部
意义：1、避免了重复的代码 2、增强了程序的扩展性
方法定义
**访问修饰符** **返回数据类型** **方法名**（参数类型 参数名称） {
方法体
return 返回值;
}
- 访问修饰符 ：
控制方法使用的范围，如果不写默认访问，[有四种: public, protected, 默认, private] - 返回数据类型：表示成员方法输出,
void 表示没有返回值， 返回类型可以为任意类型，基本类型或引用类型(数组，对象) - 方法名： 小驼峰命名法
- 参数类型：进入方法的数据是什么类型
- 参数名称：进入方法的数据对应的变量名：
cal(int n) ， getSum(int num1, int num2) - 方法主体：表示为了实现某一功能代码块
- return ：停止当前方法，将返回值返回调用处
- 返回值：方法执行后最终产生的数据结果
注意：return后面的返回值，必须和方法前面的返回值类型保持一致，语句不是必须的，方法有返回数据类型，则方法必须有 return 值;，
要求返回值类型必须和 return 的 值类型一致或兼容， 如果方法是 void，则可没 return 语句或只写 return ;
方法三种调用格式
1、单独调用：**方法名称(参数)** 没有返回值就用此调用
2、打印调用：**System.out.println(方法名称(参数));** 返回值跟参数的方法调用
3、赋值调用：**数据类型 变量名称 = 方法名称(参数);** 有返回值跟参数的方法调用
1、无返回值的方法调用: **方法名称(参数);**
public class Method01 {public static void main(String[] args) {//无返回值的方法调用getSum();}public static void getSum(){int sum = 0;for (int i = 0; i <= 10; i++) {sum +=i;}System.out.println("1~10之间的和"+ sum);}}
2、有返回值方法调用 **数据类型 变量名 = 方法名;**
public class Method02 {public static void main(String[] args) {//有返回值方法调用 数据类型 变量名 = 方法名int result = getSum();System.out.println("1~10之间的和是："+result);}public static int getSum() {int sum = 0;for (int i = 0; i <= 10; i++) {sum += i;}return sum;}}
3、有返回值跟参数的方法调用 **数据类型 变量名 = 方法名(参数);**
public class Method03 {public static void main(String[] args) {//有返回值跟参数的方法调用 数据类型 变量名 = 方法名(参数);int result = getSum(10);System.out.println("1~10之间的和是："+ result);}//定义有返回值跟参数的方法public static int getSum(int num){int sum = 0;for (int i = 0; i <= num; i++) {sum += i;}return sum;}}
4、有static跟无static调用
static的方法：静态方法
**类名.方法名();**本类中类名可以省略
非static的方法：非静态方法
方法练习
定义一个方法，用来判断两个数字是否相同 ```java public class Demo01MethodSame {
public static void main(String[] args) {
System.out.println(isSame(10, 20)); // falseSystem.out.println(isSame(20, 20)); // true
}
public static boolean isSame(int a, int b) {
/*boolean same; if (a == b) { same = true; } else { same = false; }*/ // boolean same = a == b ? true : false; // boolean same = a == b; return a == b;}
}
- 定义一个方法，用来求出1-100之间所有数字的和值
```java
public class Demo02MethodSum {
public static void main(String[] args) {
System.out.println("结果是：" + getSum());
}
public static int getSum() {
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
return sum;
}
}
定义一个方法，用来打印指定次数的HelloWorld ```java public class Demo03MethodPrint {
public static void main(String[] args) {
printCount(10);}
public static void printCount(int num) {
for (int i = 0; i < num; i++) { System.out.println("Hello, World!" + (i + 1)); }}
}
<a name="KUU0v"></a>
## 方法的注意事项
- 方法应该定义在`类当中`，但是不能在方法当中再定义方法。不能嵌套。
- 方法定义的前后顺序无所谓。
- 方法定义之后不会执行，如果希望执行，一定要调用：`单独调用`、`打印调用`、`赋值调用`。
- 如果**方法有返回值**，那么必须写上“return 返回值;”，不能没有。
- return后面的返回值数据，必须和方法的返回值类型，对应起来。
- 对于一个`void`没有返回值的方法，不能写return后面的返回值，只能写return自己
- 对于void方法当中最后一行的return可以省略不写。
- 一个方法当中可以有多个return语句，但是必须保证同时只有一个会被执行到，两个return不能连写。
```java
public class Demo04MethodNotice {
public static int method1() {
return 10;
}
public static void method2() {
// return 10; // 错误的写法！方法没有返回值，return后面就不能写返回值。
return; // 没有返回值，只是结束方法的执行而已。
}
public static void method3() {
System.out.println("AAA");
System.out.println("BBB");
// return; // 最后一行的return可以省略不写。
}
public static int getMax(int a, int b) {
/*int max;
if (a > b) {
max = a;
} else {
max = b;
}
return max;*/
if (a > b) {
return a;
} else {
return b;
}
}
}
方法之间相互调用
public class Method {
public static void main(String[] args) {
test01();
test02();
}
public static void test01(){
System.out.println("test01");
}
public static void test02(){
test01();
System.out.println("test02");
}}
方法的重载【重点】
规则：**同一个类中方法名相同，形参列表不同**。跟**方法返回值类型、修饰符等无关**
方法重载与下列因素相关
- 参数个数不同
- 参数类型不同
- 参数多类型顺序不同
方法重载与下列因素无关
- 与参数名称无关
- 方法的返回类型无关
- 与参数名称无关：定义一个xy，跟ab参数，那么方法调用时，不知道把参数传给谁
- 方法的返回类型无关：定义2个方法参数相同（int a，int b），但是类型不同，方法调用的时候不知道该传那个参数类型
重载的好处 ：
- 减轻了起名的麻烦
- 减轻了记名的麻烦
public int StudenClass() { int a; return a; } //方法重载 public int StudenClass(String name, int age) { this.name = name; this.age = age; return this.age; }
构造器【重点】
构造器作用
构造器，又叫构造方法，是类中定义的一种特殊方法，通过构造方法来实例化该类对象，也就是该类实例。
class Foo{
String name;
int age;
public Foo(){
System.out.println("Foo()");
}
public Foo(String name , int age){
this.name = name;
this.age = age;
}
}
总结 构造器作用 1. 创建对象 2.为对象属性赋值。
构造方法特点
构造方法有一下特点，需要记忆。
- 构造方法与类同名。
- 构造方法 没有返回值类型 ，也不可写void 。
- 构造方法 通过 new 调用
如果没有显示定义构造器，系统提供一个默认的无参构造，反之，一旦编写，系统不再提供。 ```java class Coder{ String name; int age; // 其他属性 …..
public void sayHello(){ System.out.println(“hello”); } // 其他行为 …… }
class TestCoder{ public static void main(String[] args){ Coder coder = new Coder(); coder.name = “张三”; coder.age = 30; coder.sayHello(); } }
<a name="CpLyR"></a>
##
<a name="CFOuu"></a>
### 构造方法重载
构造方法本质是方法，是方法就可以具备重载的特性， **一个类中之所以存在多个版本的构造器，是为了满足不同人对 对象属性初始化的要求**。
```java
/**
* 定义一个Java程序员类
*/
public class JavaCoder {
//实例属性
String name ;
int age ;
//构造方法，也是一个方法，和实例方法一样定义在类中，通常情况大部分人的习惯，定义在属性后
//无参数构造器
public JavaCoder(){
System.out.println("构造器执行");
}
//有参数构造器
public JavaCoder( String coderName ){
name=coderName;
}
//全参构造
public JavaCoder( String coderName, int coderAge ){
name = coderName;
age = coderAge;
}
//实例方法
public void writeCode(){
System.out.println( "我是"+name+"今年" +age+"岁，正在写hello world ");
}
}
可变参数
访问修饰符 返回类型 方法名(数据类型... 形参名) { }
public class Test03 {
public static void main(String[] args) {
HasMethod m = new HasMethod();
System.out.println(m.sum(2,4,67));
}}
class HasMethod {
public int sum(int... nums) {
int res = 0;
for (int i = 0; i < nums.length; i++) {
res += nums[i];
}
return res;
}
}
静态方法属于类本身，在类装载的时候被装载到内存中，不自动进行销毁，会一直存在内存中，直到JVM关闭。静态方法可以直接调用。需加static
非静态方法
又称实例化方法，属于实例对象，实例化之后才会分配内存，必须通过类的实例来引用，当实例对象被JVM回收之后，也跟着消失。 需要使用对象来调用
无参方法 有参方法
有参：小括号当中由内容，当一个方法需要数据条件，才能完成任务
例如：两个数字相乘，必须知道2个数字是多少，才能相乘
//两个数相乘
public class Test08 {
public static void main(String[] args) {
method1(10,20);
}
public static void method1(int a,int b){
int result = a * b;
System.out.println(result);
}
}
无参：小括号当中无内容，一个方法不需要任何数据条件，自己能独立完成任务
例如2：一个方法，固定打印10次hello world
public class Test09 {
public static void main(String[] args) {
method();
}
public static void method(){
for (int i = 0; i < 10; i++) {
System.out.println("hello world" + i);
}
}
}
形参和实参
形参 ：形参出现在方法定义中，在整个方法体内都可以使用， 离开该方法则不能使用。
实参： 实参出现在主调方法中，进入被调方法后，实参变量也不能使用。
注：**实际参数和形式参数的类型要对应**
递归
- 方法自己调用自己，递归一定要有出口
public class Method04 { public static void main(String[] args) { test1(3); } public static void test1(int n){ System.out.println("test1"); if(n==1){ return;//方法的出口 } test1(n-1);//递归：自己调用自己，递归一定要有出口 } }
练习：求1～之间的和
public class Method07 {
public static void main(String[] args) {
int sum = getSum(5);
System.out.println("1~5之间的和"+sum);
}
public static int getSum(int n){
if(n==1){
return 1;
}
return getSum(n-1)+n;
}
}
值传递和引用传递
值传递：
实参传递给形参的是值 形参和实参在内存上是两个独立的变量，对形参做任何修改不会影响实参
public class Demo1 {
public static void main(String[] args) {
int b =20;
change(b);// 实参 实际上的参数
System.out.println(b);//20
}
public static void change(int a){//形参 形式上的参数
a=100;
}
}
小明去餐厅吃饭，看见别人点的红烧肉挺好吃，把服务员叫过来，说我要一份红烧肉，服务员从后厨拿来一份红烧肉，小明吃完了，但是他吃的红烧肉跟旁边那个人吃的是一份吗？当然不是。
引用传递：
实参传递给形参的是堆内存上引用的地址，形参和实参在内存上指向的是同一地址，对形参的改变会影响实参
public class Demo1 {
public static void main(String[] args) {
int [] a={1,2,3};
System.out.println(a[0]); //1
change(a);
System.out.println(a[0]); //100
}
public static void change(int[] a ){
a[0]=100;
}
}
原来a[0]指向0x13地址，值是1，
后来在a[0] 指向的也是0x13地址，将值变成了100
所以，再查询a[0]的值的时候，值自然变成了100
通俗点的讲法就是： 小明回到家，他妻子说：冰箱二层有一只鸡，你去做了； 小明做好了，叫妻子过来吃饭。 这个时候，他妻子现在看见的鸡和她买回来的一样吗？ 当然不一样，都做熟了； 什么意思呢？ 鸡就是数据 冰箱二层就是存储数据的地址 把鸡做熟了就是相当于把值改变了 地方还是那个地方，就是鸡变了。
返回值和无返回值
在定义方法是需要加入返回值如：int，double，，，在调用的方法中需要有一个变量来接收这个返回值。
返回值的类型根据程序的需求来确定。
有返回值
/*
题目要求：定义一个方法，用来求出两个数字之和{（）你帮我算，算完之后把结果告诉我
*/
public class Test05 {
public static void main(String[] args) {
int num = getSum(10,20);
System.out.println("返回值"+num);
}
public static int getSum(int a,int b){
int result = a + b;
return result;
}
}
无返回值
/*
题目要求：定义一个方法，用来打印两个数字之和（你来计算，算完之后你自己负责显示结果，不用告诉我）
*/
public class Test06 {
public static void main(String[] args) {
getSum(10,20);
}
public static void getSum(int a ,int b){
int result = a+b;
System.out.println(result);
}
}
注意事项
- 对于有返回值的方法，可以使用
单独调用、打印调用、赋值调用 - 对于无返回值的方法，只能使用
单独调用
Java方法中通过传递参数改变变量的值：
基本数据类型，操作传递的是变量的值，改变一个变量的值不会影响另一个变量的值。引用数据类型（类、数组和接口），赋值是把原对象的引用（可理解为内存地址）传递给另一个引用
1、对于基本类型参数，在方法体内对参数进行重新赋值，并不会改变原有变量的值。
2、对于引用类型参数，在方法体内对参数进行重新赋予引用，并不会改变原有变量所持有的引用。
3、方法体内对参数进行运算，不影响原有变量的值。
4、方法体内对参数所指向对象的属性进行操作，将改变原有变量所指向对象的属性值。 
若有收获，就点个赞吧
0 人点赞
