- 根据方法有没有参数,可分为:
- 1.无参方法
- 2.有参方法
- 根据有没有返回值，可分为：
- 1.无返回值方法
- 2.有返回值方法
示例如下：
public class Demo{
// 1. 最简单的无参方法
void sum1(){
System.out.println("加法操作");
}
// 2. 拥有修饰符的无参方法
public static void sum2(){
System.out.println("加法操作");
}
// 3. 拥有参数的方法
public static void sum3(int a,int b){
System.out.println("两数相加结果"+a+b);
}
// 4.拥有返回值的方法
public static int sum4(int a,int b){
return a+b;
}
// 5.声明一个无参数带返回值
public static int sum5(){
int x=20;
int y=28;
int z=x+y;
return z;
}
}
二.方法的调用格式
-
语法：方法名（实参列表）；
-
实参的数量和类型必须和形参的数量和类型保持完全一致。
-
方法和方法之间只能相互调用，不能在方法中声明方法。就目前而言声明的方法和main是并列的关系
-
如果声明的方法有返回值，那么返回值会返回给调用者，调用者必修创建变量来接收数据。
public class Demo{
public static void main(String[] args) {
//实参
int a = 10;
int b = 20;
swap(a,b);
System.out.println("main函数中的a=" + a);//10
System.out.println("main函数中的b=" + b);//20
}
//分析：需要参数（两个参数）
// 不需要返回值
// 形参：没有携带值的变量，多个变量之间使用逗号分隔
public static void swap(int a,int b){
int temp = 0;
temp = a;
a = b ;
b = temp ;
System.out.println("swap函数中的a=" + a); //20
System.out.println("swap函数中的b=" + b); //10
}
}
swap函数中的a=20 swap函数中的b=10 main函数中的a=10 main函数中的b=20 //无返回值故swap中的数据还在方法中而main的数据也没有被覆盖。有返回值的方法调用格式：
- 有返回值的要用到return关键字
- return关键字的作用：结束方法,返回结果。
情况1
public class Demo {
public static void main(String[] args) {
show();
}
public static void show() {
System.out.println("Hello World!");
int x = 10;
if (x > 5) {
return;//结束方法 }
}
// 不能执行
System.out.println("Hello World!========");
}
}
Hello World!
情况2
public class Demo {
public static void main(String[] args) {
int result = add(10,20);
System.out.println(result);
}
public static int add(int a ,int b) {
System.out.println("Hello World!");
int c = a+b;
return c;
}
}
30
情况3
public class Demo {
public static void main(String[] args) {
int result = compare(34,67);
System.out.println(result);
}
//
// 需求：比较两个变量的大小，返回较大的一个
public static int compare(int a,int b) {
if(a>b){
return a;
}
else if(a
return b;
}
else{
return 0;
}
}
}
67三.方法的重载
-
在同一个类中方法名相同，仅参数列表不同则是方法重载。
-
重载的方法与main方法是并行关系。
-
参数列表的不同：参数的数量，数据类型，参数的顺序。
-
方法的重载与修饰符和返回值没有任何关系。
- 类方法：使用static修饰，是属于当前整个类的而非属于某个实例。只能处理static域或者调用static方法。
- 实例方法（对象方法）：是属于对象的方法，用对象来调用。
- 类方法只能调用其他类方法，而实例方法则可以其他类方法和实例方法。
实例化对象： 例如存在类Dome，则有：Dome dome = new Dome（）；实例化一个对象dome。
五.方法的重写（extends）- 重写是子类对父类（必修满足非private，非static，非final）的方法块进行重写，而返回值和形参列表必须保持不变。
- 访问权限不能比父类中被重写的方法的访问权限更低。（不能更严厉）。
-
多态的前提1：是继承。
-
多态的前提2：要有方法的重写。
-
父类引用指向子类对象,如：Animal a = new Cat(); 创建父类对象，子类实例。
-
多态中，编译看左边，运行看右边 例：Animal a = new Cat（）；
-
方法的多态，属性没有多态。
创建包: cn.tedu.oop
创建类: TestDemo.java
package cn.tedu.oop2;
public class TestDemo {
public static void main(String[] args) {
//6.创建“纯纯的”对象用于测试
Animal a = new Animal();
Cat c = new Cat();
Dog d = new Dog();
a.eat();//小动物Animal吃啥都行~调用的是父类自己的功能
c.eat();//小猫爱吃小鱼干~调用的是子类重写后的功能
d.eat();//小狗爱吃肉骨头~调用的是子类重写后的功能
//a.jump();//报错，Animal类里并没有这个方法
//a.run();//报错，Animal类里并没有这个方法
c.jump();//小猫Cat跳的老高啦~,子类可以调用自己的功能
d.run();//小狗Dog跑的老快啦~,子类可以调用自己的功能
//7.创建多态对象进行测试
Animal a2 = new Cat();//Cat类对象的地址值交给父类型变量a2来保存
Animal a3 = new Dog();//Dog类对象的地址值交给父类型变量a3来保存
//8.测试多态对象
a2.eat();//小猫爱吃小鱼干~，多态对象使用的是父类的定义，子类的方法体
}
}
//1.创建父类
class Animal{
//3.创建父类的普通方法
public void eat(){
System.out.println("小动物Animal吃啥都行~");
}
}
//2.1创建子类1
class Cat extends Animal{
//4.1添加重写的方法
public void eat(){
System.out.println("小猫爱吃小鱼干~");
}
//5.1添加子类的特有功能
public void jump(){
System.out.println("小猫Cat跳的老高啦~");
}
}
//2.2创建子类2
class Dog extends Animal{
//4.2添加重写的方法
@Override
public void eat(){
System.out.println("小狗爱吃肉骨头~");
}
//5.2添加子类的特有功能
public void run(){
System.out.println("小狗Dog跑的老快啦~");
}
}
