Java基础之形参、返回值

1 形参、返回值

1.0 形参和实参的区别

• 形参 ：就是形式参数，用于定义方法的时候使用的参数，是用来接收调用者传递的参数的。 形参只有在方法被调用的时候，虚拟机才会分配内存单元，在方法调用结束之后便会释放所分配的内存单元。 因此,形参只在方法内部有效，所以针对引用对象的改动也无法影响到方法外。

• 实参 ：就是实际参数，用于调用时传递给方法的参数。实参在传递给别的方法之前是要被预先赋值的。

• 注意：在值传递调用过程中，只能把实参传递给形参，而不能把形参的值反向作用到实参上。在函数调用过程中，形参的值发生改变，而实参的值不会发生改变。而在引用传递调用的机制中，实际上是将实参引用的地址传递给了形参，所以任何发生在形参上的改变也会发生在实参变量上。

1.1 类名作为形参和返回值

• 类名作为形参，需要的是该类的对象
• 类名作为返回值，返回值的是该类的对象
• Cat类

package ceshi;

public class Cat{

    public void eat() {
        System.out.println("猫吃鱼");
    }

}

• Cat操作类

package ceshi;

public class CatOperator {

    public void useCat(Cat c) { //类名作为形参需要的是一个Cat对象，Cat c = new Cat();
        c.eat();
    }
    //Cat作为返回值
    public Cat getCat() {
        Cat c = new Cat();
        return c;
    }
}

• 测试类

package ceshi;

public class Demo {
    public static void main(String[] args) {
        //创建操作类对象，调用方法
        CatOperator co = new CatOperator();
        Cat c1 = new Cat();
        co.useCat(c1); //需要一个Cat对象，上面创建Cat对象；猫吃鱼

        Cat c2 = co.getCat(); //调用getCat方法，把new Cat()赋值给c2
        c2.eat(); //猫吃鱼
    }
}

1.2 抽象类名作为形参和返回值

• 抽象类名作为形参，需要的是该类的 子类对象
• 抽象类名作为返回值，返回值的是该类的 子类对象
• 父类

package ceshi;

public abstract class Animal {
    public abstract void eat();
}

• 子类

package ceshi;

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

• 操作类

package ceshi;

public class AnimalOperator {

    public void useAnimal(Animal a) { //需要的是Animal的子类对象 Animal a = new Cat();
        a.eat();
    }

    public Animal getAnimal() {
        Animal a = new Cat();
        return a;
    }

}

1.3 接口名作为形参和返回值

• 接口名作为形参，需要的是该类的 实现类对象
• 接口名作为返回值，返回值的是该类的 实现类对象
• 接口

package ceshi;

public interface Jumpping {

    void jump();
}

• 实现类

package ceshi;

public class Cat implements Jumpping{
    @Override
    public void jump() {
        System.out.println("猫可以跳高");
    }
}

• 接口操作类

package ceshi;

public class JumppingOperator {
    public void useJumpping(Jumpping j) { //需要的是接口实现类，Jumpping j = new Cat();
        j.jump();
    }

    public Jumpping getJumpping() {
        Jumpping j = new Cat();
        return j;
    }

}

• 测试类

package ceshi;

public class Demo {
    public static void main(String[] args) {
        //创建操作类对象，调用方法
        JumppingOperator jo = new JumppingOperator();
        Jumpping j = new Cat();
        jo.useJumpping(j); //猫可以跳高

        Jumpping j2 = jo.getJumpping();
        j2.jump(); //猫可以跳高

    }
}

2 内部类

2.1 内部类的概述

• 1、内部类就是在 一个类中定义的类

• 2、格式

public class 类名 {
	修饰符 class 类名 {
	}
}

• 3、内部类访问特点
  1，内部类可以直击访问外部的成员，包括私有
  2，外部内访问内部类的成员必须创建内部类对象，通过对象来调用内部类成员

package ceshi;

public class Outer {

    private int num = 20;

    public class Inter {
        public void show() {
            System.out.println(num); //可以访问外部类私有
        }
    }

    public void method() {
//        show(); 报错，不能直接访问需要创建内部类对象
        Inter i = new Inter();
        i.show();
    }
}

• 4、内部类的分类
  1.成员内部类 (实例内部类)
  2.局部内部类（类方法中定义的类）
  3. 匿名内部类 (重点)
• 5、为什么需要内部类？
  • 内部类继承自某个类或实现某个接口，内部类的代码操作可以创建其外部类的对象。所以可以将其入围是进入外部类的门窗
  • 每个内部类都可独立的继承一个接口的实现，所以不管外部类是否已经集成某个接口的实现。对于内部类是没有影响的，而且内部类提供的使得外部类具有了类似多重继承的效果，解决了一些设计与变成的问题，使得。接口解决部分，内部类也有效的解决一部分"多重继承"的问题。

2.2 成员内部类（了解）

• 成员内部类外界如何创建对象使用？
• 格式：外部类名.内部类名 对象名 = new 外部类对象.内部类对象()；
• 范例：

Outer.Inter oi = new Outer(). new Inter();

• 思路
  1、内部类通常用private修饰
  2、通过外部类创建内部类对象，调用内部类方法
  3、其他类创建外部类对象调用method方法

2.3 局部内部类（了解）

• 局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用
• 该类可以直接访问外部类的成员，也可以访问方法内的局部变量
• 范例

package ceshi;

public class Outer {

    private int num1 = 10;

    public void method() {
        int num2 = 20;
        //局部内部类
        class Inter {
            public void show() {
                System.out.println(num1);
                System.out.println(num2);
            }
        }
        //需要在方法中创建局部内部类对象，调用方法，否则没法访问
        Inter i = new Inter();
        i.show();
    }
}

• 测试

package ceshi;

public class InterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method(); //10
                    //20
    }
}

2.4 匿名内部类（重点）

• 前提：存在一个类或者接口，这里的类可以是抽象类、具体类
• 好处：可以少写接口实现类
• 格式

new 类名或者接口名() {
	重写方法
};

• 本质是继承了该类或实现该接口的 子类匿名对象