一、概述
方法,也称函数,如果想要重复一段或者多段代码块的使用,可以将这些代码封装成一个方法,方法具体表现为某种行为,使用方法可以提高代码的复用性。
二、方法的声明
1.组成
访问权限符 返回值 方法名(参数列表){
方法体
}
public viod method(){
System.out.println(“Hello World!!!”);
}
2.访问权限符
表示该方法被访问的权限,主要有以下几种
2.1 public
- (1)定义:public是公共的,被public所修饰的成员可以在任何类中都能被访问到。
- (2)作用域:public能用来修饰类,在一个java源文件中只能有一个类被声明为public,而且一旦有一个类为public,那这个java源文件的文件名就必须要和这个被public所修饰的类的类名相同,否则编译不能通过。public用来修饰类中成员(变量和方法),被public所修饰的成员可以在任何类中都能被访问到。通过操作该类的对象能随意访问public成员。public在类的继承上的体现,被public所修饰的成员能被所有的子类继承下来。
2.2 protected
- (1)定义:protected是受保护的,受到该类所在的包所保护。
- (2)作用域:被protected所修饰的成员会被位于同一package中的所有类访问到。同时,被protected所修饰的成员也能被该类的所有子类继承下来。(注意:这里是指同一个package或者不同的package中的子类都能访问)
2.3 default
- (1)定义:default是默认,缺省的,即在成员的前面不写任何的访问修饰符的时候,默认就是友好的。所谓友好的,是对同一package的类友好。
- (2)作用域:同一package中的所有类都能访问。被friendly所修饰的成员只能被该类所在同一个package中的子类所继承下来。(也就是说只有在同一个package中的子类才能访问到父类中friendly修饰的成员)
2.4 private
- (1)定义:private是私有的,即只能在当前类中被访问到,它的作用域最小。
- (2)作用域:private可以修饰数据成员,构造方法,方法成员,不能修饰类(此处指外部类,不考虑内部类)。被private修饰的成员,只能在定义它们的类中使用,在其他类中不能调用。
3. 返回值:
表示方法(函数)要返回的数据类型,int ,double,String等等·,void表示无返回值
4. 方法名:
方法的名称,避免使用到java关键字,并且首字母小写,命名时使用驼峰命名法
骆驼式命名法(Camel-Case)又称驼峰式命名法,是电脑程式编写时的一套命名规则(惯例)。正如它的名称CamelCase所表示的那样,是指混合使用大小写字母来构成变量和函数的名字。程序员们为了自己的代码能更容易的在同行之间交流,所以多采取统一的可读性比较好的命名方式。
5. 参数列表:
方法声明时可以定义参数列表,调用时需要传入实参
5.1 形参
也叫形式参数,方法声明时候的参数称为形参,如add(int a)
5.2 实参
也叫实际参数,方法调用时传入的参数,如add(1)
public class Text {
public static void main(String[] args) {
method("字符参数");//括号中为实参
}
private static void method(String str) {//括号中为形参
System.out.println(str);//将传入的参数打印输出
}
}
运行结果
5.3 可变参数
- 当参数的个数不定时,可以使用可变参数
- 可变参数的写法:int…a 前面为参数类型,中间加三个点,后面为参数名
- 使用规则:
- 可变参数只能位于参数列表的最后一个
- 可变参数有且只有一个
- 可变参数的原理为数组,传入参数时,根据传入的参数自动生成匹配的数组类型,数组长度等于传入的参数个数,数组元素为传入的实参
public class Text2 {
public static void main(String[] args) {
int sum = addSum(1,2,3,4,5,6,7,8,9);
System.out.println(sum);
}
private static int addSum(int ...a) {
int add = 0;
//将数组元素(即传入的参数)求和
for (int i = 0; i < a.length; i++) {
add += a[i];
}
return add;
}
}
7. 方法体:
方法的主体内容,具体要使用的代码块,位于{}中
private static void fun() {
System.out.println("fun方法体");
}
三、方法的声明与调用
public class Text3 {
//定义4种方法
private static void method1() {
System.out.println("无参无返回值的方法");
}
private static int method2() {
System.out.println("无参有返回值的方法");
return 1;
}
private static int method3(String str) {
System.out.println("有参有返回值的方法");
return 1;
}
private static void method4(String str) {
System.out.println("有参无返回值的方法");
}
public static void main(String[] args) {
//调用方法
method1();
method2();
method3("我");
method4("你");
}
}
运行结果
四、方法的种类
1.构造方法
也称构造器,构造函数,构造方法的名称和类名一样,并且没有返回值,通过new加上构造方法可以创建一个对象,每个类都有一个默认的构造方法,如果重新声明了构造方法,则系统默认的构造方法将不再使用。
Text1 t1 = new Text1();//引用无参构造函数创建对象
Text1 t2 = new Text1("张三",18);//引用有参构造函数创建对象
2.静态方法
- 2.1 关键字static修饰的方法称为静态方法,也叫类方法,静态方法不属于对象,而是属于类,随着类的加载而加载,优先于构造方法执行。
- 2.2 静态方法可以直接使用类名.方法直接调用,如果静态方法位于本类中可以直接省略类名直接调用
- 2.3 在静态方法中,可以访问静态方法,可以引用类变量(被static修饰的变量),不能访问非静态方法与变量,不能使用super和this关键字
3.非静态方法
- 3.1是不含有static关键字修饰的普通方法,又称为实例方法,成员方法。属于对象的,不属于类的。(成员属性,成员方法是属于对象的,必须通过new关键字创建对象后,再通过对象调用)。
- 3.2在非静态方法中,即可以调用非静态方法,也可以调用静态方法,可以引用类变量和成员变量,可以使用关键字super和this
public class Text3 {
int age = 18;//成员变量
static String name = "迪丽热巴";//类变量
public static void main(String[] args) {
Text3 t1 = new Text3();
method();//本类中调用静态方法,直接省略类名
t1.method1();//调用成员方法
}
//静态方法
static void method() {
System.out.println("静态方法");
//访问属性
System.out.println(name);
//System.out.println(age);//报错,静态不能访问非静态
//t1.method();//报错
}
//非静态方法,也叫成员方法
void method1() {
System.out.println("非静态方法1");
method();//既可以调用静态方法
new Text3().method2();//又可以调用非静态方法
System.out.println(name);//既可以访问静态属性
System.out.println(age);//又可以访问非静态属性
}
void method2() {
System.out.println("非静态方法2");
}
}
运行结果
注:静态方法和非静态方法的区别(生命周期不同)
- 静态方法的生命周期跟相应的类一样长,静态方法和静态变量会随着类的定义而被分配和装载入内存中。一直到线程结束,静态属性和方法才会被销毁。(也就是静态方法属于类)
- 非静态方法的生命周期和类的实例化对象一样长,只有当类实例化了一个对象,非静态方法才会被创建,而当这个对象被销毁时,非静态方法也马上被销毁。(也就是非静态方法属于对象)
4.抽象方法
关键字abstract修饰的方法称为抽象方法,抽象方法必须定义在抽象类(abstract修饰的类称为抽象类)中,抽象类中既有抽象方法,也有非抽象方法,但是抽象方法必须定义在抽象类中,并且抽象方法没有方法体
public class Text3 {
public static void main(String[] args) {
Cat cat = new Cat();
cat.cry();
}
}
// 定义一个抽象类
abstract class Animal {
String name;
int age;
// 抽象方法
public abstract void cry(); // 不确定动物怎么叫的。定义成抽象方法,来解决父类方法的不确定性。
//抽象方法在父类中不能实现,所以没有方法体。但在后续在继承时,要具体实现此方法。
}
// 抽象类可以被继承
// 当继承的父类是抽象类时,需要将抽象类中的所有抽象方法全部实现。
class Cat extends Animal {
// 实现父类的cry抽象方法
public void cry() {
System.out.println("猫叫:苗苗苗");
}
}
五、方法的重载与重写
1.重载(overload)
是指方法名相同,参数列表不同(无关返回值类型)的方法造成了方法的重载,通常发生在类的成员方法中,方法的重载提高了程序的强壮性
1.1 重载规则:
- 被重载的方法必须改变参数列表(参数个数或类型不一样);
- 被重载的方法可以改变返回类型;
- 被重载的方法可以改变访问修饰符;
- 方法能够在同一个类中或者在一个子类中被重载
- 无法以返回值类型作为重载函数的区分标准
public class Text {
public static void main(String[] args) {
add(1,2);//两个数的相加
add(1,2,3);//三个数的相加
add(1,2,3,4);//四个数的相加
add(1,2,3,4,5);//五个数的相加
}
//方法名相同,参数列表不同造成重载
private static void add(int a,int b) {
int sum = a + b;
System.out.println("两个数的相加和为"+sum);
}
private static void add(int a,int b,int c) {
int sum = a + b + c;
System.out.println("三个数的相加和为"+sum);
}
private static void add(int a,int b,int c,int d) {
int sum = a + b + c +d;
System.out.println("四个数的相加和为"+sum);
}
private static void add(int a,int b,int c,int d,int e) {
int sum = a + b + c + d +e;
System.out.println("五个数的相加和为"+sum);
}
}
运行结果
2.重写(override)
发生在子父类的继承关系中,指父类的方法与子类的方法相同(方法名和参数列表完全一致)造成了重写,也叫覆写
2.1 重写规则
- 参数列表与被重写方法的参数列表必须完全相同。
- 访问权限不能比父类中被重写的方法的访问权限更低。例如:如果父类的一个方法被声明为 public,那么在子类中重写该方法就不能声明为 protected。
- 声明为 final 的方法不能被重写。
- 声明为 static 的方法不能被重写,但是能够被再次声明。
- 重写的方法能够抛出任何非强制异常,无论被重写的方法是否抛出异常。但是,重写的方法不能抛出新的强制性异常,或者比被重写方法声明的更广泛的强制性异常,反之则可以。
- 构造方法不能被重写。
- 如果不能继承一个类,则不能重写该类的方法。
package cn.tedu.day06;
//父类
class Parent {
int age;
String name;
void eat() {
System.out.println("parent吃饭");
}
}
//子类
class Son extends Parent{
//子类方法和父类一样(方法名称和参数列表一样),方法体不同造成方法的重写,
void eat() {
System.out.println("son吃饭");//重写提高了方法的扩展性,
//当子类不满足从父类继承到的方法时,可以使用方法的重写
}
}
public class Text4 {
public static void main(String[] args) {
new Son().eat();//调用时看new的是什么对象,new Son()则使用子类中的方法
}
}
运行结果