目录
一、成员方法
- 提高代码的复用性
- 可以将实现的细节封装起来，然后供其他用户来调用即可
- 成员方法的定义：
访问修饰符 返回数据类型 方法名（形参列表 .. ） {// 方法体语句；return 返回值 ;}
- 访问修饰符 (作用是控制方法使用的范围)
- 如果不写默认访问，[有四种: public, protected, 默认, private],
- 返回数据类型：表示成员方法输出, void 表示没有返回值
- 一个方法最多有一个返回值
- 返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
- 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值; 而且要求返回值类型必须和 return 的 值类型一致或兼容；如果方法是 void，则方法体中可以没有 return 语句，或者 只写 return ;
- 方法名
- 遵循驼峰命名法，最好见名知义，表达出该功能的意思即可
- 形参列表：表示成员方法输入
- 一个方法可以有0个参数也可以有多个参数，中间用逗号隔开, 比如 getSum(int n1,int n2)
- 参数类型可以为任意类型，包含基本类型或引用类型，比如 printArr(intDl map)
- 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型 的参数!etSum
- 方法定义时的参数称为形式参数，简称形参:方法调用时的传入参数称为实际参数，简称实参实参和形参的类型要一致或兼容个数、顺序必须一致!
- 方法主体：表示为了实现某一功能代码块
- 里面写完成功能的具体的语句，可以为输入，输出、变量、运算、分支、循环、方法调用，但里面不能再定义方法!
- return 语句不是必须的。
二、成员方法使用细节
- 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型 的参数
- 实参和形参的类型要一致或兼容、个数、顺序必须一致
- 一个方法最多有一个返回值
- 返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
三、方法的调用
- 同一个类中的方法调用：直接调用即可。
- 跨类中的方法A类调用B类方法: 需要通过对象名调用。
- 特别说明一下: 跨类的方法调用和方法的访问修饰符相关
class A {
//同一个类中的方法调用：直接调用即可
public void aa(int n) {
System.out.println("aa()方法被调用");
}
public void bb() { //bb 调用 aa(直接调用即可)
aa(10);
System.out.println("继续执行");
}
//跨类中的方法 A 类调用 B 类方法：需要通过对象名调用
public void m1() {
B b = new B();//创建 B 对象
b.hi();//再调用方法即可
}
}
class B {
public void hi() {
System.out.println("B 类中的 hi()被调用");
}
}- 方法调用过程：
- 当程序执行到方法时，就会开辟一个独立的空间(栈空间)
- 当方法执行完毕，或者执行到return语句时，就会返回
- 返回到调用方法的地方
- 返回后继续执行方法后面的代码当main方法(栈) 执行完毕，整个程序退出
四、成员方法传参机制
1.基本数据类型的传参机制
- 基本数据类型传递的是值（值拷贝），形参的任何改变不影响实参
/**
*基本数据类型的传参机制
*/
public class MethodParameter01 {
public static void main(String[] args) {
int a = 10;
int b = 20;
//创建 AA 对象
M1 m1 = new M1();
m1.swap(a, b); //调用 swap 将a b 传入swap方法中
System.out.println("main 方法 a=" + a + " b=" + b);//a=10 b=20
/*
m1.swap(a, b);调用时开辟一个新的栈
新的栈中改变值 而原来栈的值并不变
*/
}
}
class M1 {
public void swap(int a, int b) {
System.out.println("a 和 b 交换前的值 a=" + a + "\tb=" + b);//a=10 b=20
// a 和 b 交换
int tmp = a;
a = b;
b = tmp;
System.out.println("a 和 b 交换后的值 a=" + a + "\tb=" + b);//a=20 b=10
}
}2.引用数据类型的传参机制
- 引用数据类型 = 类、数组、接口
- 引用数据类型传递的是地址（传递的值是地址），可以通过形参影响实参！
/**
*引用数据类型的传参机制 数组
*/
public class MethodParameter02 {
public static void main(String[] args) {
//创建对象
M2 m2 = new M2();
//定义数组
int arr[] = {1, 2, 3};
//调用方法
m2.test(arr);
System.out.println("main 的数组");
//for循环输出数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i] + "\t");
}//输出 111 2 3
}
}
class M2 {
public void test(int[] arr) {
//将数组下标为0的元素改为 111
arr[0] = 111;
System.out.println("test100的arr数组");
//for循环输出数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i] + "\t");
}//输出 111 2 3
}
}/**
* 引用数据类型的传参机制 类
*/
public class MethodParameter03 {
public static void main(String[] args) {
M4 m4 = new M4();
M3 m3 = new M3();
m3.name = "dd";
m3.age = 11;
m4.temp(m3);//将m3 传入m4 中
//第一种情况 输出22
System.out.println("main的age=" + m3.age);
//第二种情况 输出11
System.out.println("main的age=" + m3.age);
//第三种情况 new一个新对象 输出11
System.out.println("main的age=" + m3.age);
}
}
class M3 {
String name;
int age;
}
class M4 {
public void temp(M3 m3) {
//第一种情况 输出22
m3.age = 22;
System.out.println("改变之后的age=" + m3.age);
//第二种情况 main的age不改变 m4调用为空是自己指向地址的断开 并不影响原本m3地址的指向
m3 = null;
//第三种情况 new一个新对象 输出33
M3 m31 = new M3();
m31.age = 33;
System.out.println(m31.age);
}
}五、方法重载
- java 中允许同一个类中，多个同名方法的存在，但要求形参列表不一致！
- 方法名 : 必须相同(形参类型或个数或顺序，至少有一样不同，参数名无要求)
- 返回类型: 无要求
/**
* 方法重载
*/
public class OverLoad {
public static void main(String[] args) {
MyCalculator mc = new MyCalculator();
System.out.println(mc.calculate(1, 2));//找参数为 两个整数
System.out.println(mc.calculate(1, 2.1));//找参数为 一个整数，一个double
System.out.println(mc.calculate(1, 2, 3));//找参数为 三个整数
}
}
class MyCalculator {
//两个整数的和
public int calculate(int n1, int n2) {
System.out.println("calculate(int n1, int n2) 被调用");
return n1 + n2;
}
//没有构成方法重载, 因为int n1, int n2 形参完全相同
// public void calculate(int n1, int n2) {
// System.out.println("calculate(int n1, int n2) 被调用");
// int res = n1 + n2;
// }
//没有构成方法重载，因为不看参数名
// public int calculate(int a1, int a2) {
// System.out.println("calculate(int n1, int n2) 被调用");
// return a1 + a2;
// }
//一个整数，一个 double 的和
public double calculate(int n1, double n2) {
System.out.println("calculate(int n1, double n2) 被调用");
return n1 + n2;
}
//三个 int 的和
public int calculate(int n1, int n2, int n3) {
System.out.println("calculate(int n1, int n2, int n3) 被调用");
return n1 + n2 + n2;
}
}六、可变参数
- 基本语法
访问修饰符 返回类型 方法名 ( 数据类型 ... 形参名 ) {}
- java 允许将同一个类中，多个同名同功能，但参数个数不同的方法，封装成一个方法。
- 可变参数的实参可以为0个或任意多个
- 可变参数的实参可以为数组
- 可变参数的本质就是数组
- 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
- 一个形参列表中只能出现一个可变参数
/**
* 可变参数
*/
public class VarParameter {
public static void main(String[] args) {
V v = new V();
System.out.println(v.sum(1, 2));
//可变参数的实参可以为数组
int[] arr = {1, 3};
System.out.println(v.sum(arr));
}
}
class V {
//接收 类型为int 的多个元素
public int sum(int... nums) {
int res = 0;
for (int i = 0; i < nums.length; i++) {
res += nums[i];
}
return res;
}
//可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
public void v1(String str, int... nums) {
}
}七、构造方法/构造器
- 基本语法：[修饰符] 方法名 (形参列表 ){ 方法体; }
- 构造器的修饰符可以默认，也可以是public protected private
- 构造器没有返回值
- 构造方法名 和 类名 必须一样
- 参数列表 和 成员方法一样的规则
- 构造器是完成对象的初始化,并不是创建对象，在创建对象时,系统自动的调用该类的构造方法完成对对象的初始化
- 一个类可以定义多个不同的构造器，即构造器重载
- 构造器没有返回值!
/**
* 构造方法/构造器
*/
public class Constructor {
public static void main(String[] args) {
C1 c1 = new C1("aaa", 11);
System.out.println(c1.age + c1.name);
//c1.C1;//错误 （构造器由 系统调用）
C1 c2 = new C1("bbb");
System.out.println(c2.name);
}
}
class C1 {
String name;
int age;
public C1(String name, int age) {
System.out.println("构造器一被调用");
this.name = name;//哪个对象调用，this就代表哪个对象
this.age = age;
}
//构造器重载
public C1(String name) {
System.out.println("构造器二被调用");
this.name = name;
}
//一旦定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器,除非显式的定义
C1() {//无指定构造器 有默认构造器
}
}
8554
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
