传参

引用类型：
引用类型传递，形参的改变会影响实参属于引用传递，传递的是地址值。
当一个方法的形参是一个类 类型（引用类型），那么就传递一个该类的对象
抽象类型：
当一个方法的形参是一个 抽象类 类型，那么就传递一个该抽象类的子类对象。
接口类型：
当一个方法的形参是一个接口类型，那么就传递一个该接口的子类对象。

引用类型与抽象类型代码举例说明：

public class MyTest {
    public static void main(String[] args) {
        Cat cat = new Cat();//新new一个cat对象，初始化，num=100
        test(cat,30);//调用test方法，将数值30传过去，num=30;
        cat.setNum(cat,1000);//调用setNum方法，又将数值1000传过去，这时num数值已经被替换为1000，
        //因此输出的cat.num=1000;
        System.out.println(cat.num);//1000
        AA aa = new AA();//创建子类对象，a的初始值为30
        test1(aa,89);//调用test1方法，访问的是父类，将父类的a值替换为89
        System.out.println(aa.a);//输出结果访问的是子类的a=30；

    }

    public  static void test (Cat cat, int num) {
        cat.num=num;
    }
    public static void test1(MyClass myclass,int a){
        //多态的形式，因此访问的是父类的值，父类的值发生改变
        myclass.a=a;
    }
}
//类 类型  参数传递属于引用传递，形参色改变对实参有影响
class Cat{
    int num=100;
    public void setNum(Cat cat,int num){
        cat.num=num;
    }
}
//抽象类
abstract class MyClass{
    int a=1;
    public abstract void show(int a);
}
//抽象类子类
class  AA extends MyClass{
    int a=30;
    //方法重写
    @Override  

    public void show(int a) {
        this.a=a;
    }
}

接口类型代码举例说明：

public class MyTest {
    public static void main(String[] args) {
        AA aa = new AA();
        test(aa);
        aa.show();//200
        System.out.println(MyInterface.num); //200
        System.out.println(AA.num);
        aa.show();

        test(new BB());
    }
    public static void test(MyInterface myInterface){
        System.out.println(myInterface.num);//200
    }
}

interface MyInterface{
    public static final int num=200;//接口中定义的变量为常量200，不会发生改变
    void show();
}
class AA implements MyInterface{

    @Override
    public void show() {
        System.out.println(this.num);
    }
}

class BB implements MyInterface{

    @Override
    public void show() {

    }
}

返回值类型

引用类型
一个方法的返回值类型为类 类型，那么就返回一个该类的对象
代码举例说明：

public class MyTest {
    public static void main(String[] args) {
        Student student=test(100);//
        int num = student.num;
        System.out.println(num);
    }
    public static Student test(int num){
        Student student = new Student();//new对象，初始值为20
        student.num=num;//main方法中调用test方法，并输入num=100,因此这里num替换初始值，num=100
        return student;//返回对象
    }
}
class Student{
    int num=20;
}

抽象类型
一个方法的返回值类型是一个抽象类 类型，那么就返回一个该抽象类的子类对象
代码举例：

public class MyTest {
    public static void main(String[] args) {
        MyClass myClass = test(800);//调用test方法，num输入800；
        System.out.println(myClass.num); //在这里是父类引用调的num,因此输出为父类的200
        //向下转型
        MySon son= (MySon) myClass;
        System.out.println(son.num); //800
    }
    public static MyClass test(int num){
        MySon mySon = new MySon();//new子类对象，初始值为2
        mySon.num=num;//由于main方法 中调用test方法，因此num初始值2被覆盖为800
        return mySon;//返回对象
    }
}
abstract class MyClass {
    int num=200;
    public abstract void show(int num);
}

class MySon extends MyClass{
    int num=2;//被800覆盖
    @Override
    public void show(int num) {
        this.num=num;
    }
}

接口类型
一个方法的返回值类型是一个接口类型，那么就返回该接口的 子类对象
代码举例说明：

public class Mytest {
    public static void main(String[] args) {
        Son son = new Son();
        MyInterface myInterface=test(son);
        son.hehe();//调用方法，num初始值由600被覆盖为8000
        System.out.println(son.num);//8000
        System.out.println(MyInterface.num); //直接访问父接口的公共静态常量200
        System.out.println("=======================");
        System.out.println(myInterface.num); //200
        //向下转型
        Son s= (Son) myInterface;//将父接口类型向下转换为子类 类型，因此数据为6
        System.out.println(s.num); //6
    }
    public static MyInterface test(MyInterface myInterface){
        //System.out.println(myInterface.num);
        Son son = new Son();//初始值为600
        son.num=6;//覆盖之后为6
        return son;
    }
}
interface MyInterface{
   public static final int num=200;
    void hehe();
}

class Son implements MyInterface{
    int num=600;
    @Override
    public void hehe() {
        this.num=8000;
    }
}