java中接口返回类型不确定怎么办 接口返回的参数

接口

概述
接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。
Java中的接口更多的体现在对行为的抽象。

定义接口

public interface Jumpping {
   public abstract void jump();
}

类实现接口

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

接口如何实例化？

Jumpping j=new Jumpping();
//报错，不能直接实例化
//可以参照多态的形式
Jumpping j=new Cat();

要是接口实现类不想重写接口中的方法，那么这个类就要定义为抽象类。

接口的成员特点

1.接口中的成员变量默认是public static final int num=10;也就是说当定义时public int num=10，等价于前面的。
2.接口中的成员变量是静态变量，所以可以通过接口名.变量名直接访问，且是常量，不可重新赋值。
3.接口不能有构造方法。
4.接口中不能有非抽象方法

//接口
package myday;

public interface Inter {
	public abstract void eat();
}
//实现类
package myday;

public class InterImp implements Inter{
//这种写法相当于：
//public class InterImp extends Object implements Inter{}
//因为接口中没有构造方法，所以实现类中的super();其实调用的是Object中的无参构造方法（空的）
	public InterImp() {
		super();
	}
	public void eat() {
		System.out.println("啊啊啊");
	}
}

//接口中：
public void show(){};//报错，不能有非抽象方法
public abstract void show();//可以
void show();//可以，默认有修饰符public abstract

//接口
package myday;

public interface Inter {
	public abstract void jump();
}
//父类
package myday;

public abstract class Animal {
	public String name;
	public int age;
	
	public Animal() {
		
	}
	
	public Animal(String name,int age) {
		this.name=name;
		this.age=age;
	}
	

	public void setName(String name) {
		this.name=name;
	}
	
	public void setAge(int age) {
		this.age=age;
	}
	
	public String getName() {
		return this.name;
	}
	
	public int getAge() {
		return this.age;
	}
	
	public abstract void eat();
	
}
//子类
package myday;

public class Cat extends Animal implements Inter {
	public Cat() {
		
	}
	
	public Cat(String name,int age) {
		super(name,age);
	}
	
	public void jump() {
		System.out.println("猫跳高");
	}
	public void eat() {
		System.out.println("猫吃鱼");
	}
	public void Catch() {
		System.out.println("猫捉老鼠");
	}
}
//测试
package myday;

public class Demo {
	public static void main(String[] args) {
		Inter c1=new Cat();
		c1.jump();//只能调用接口的重写方法
		System.out.println("-----");
		Animal c2=new Cat();
		c2.setAge(15);//只能调用父类的重写方法
		c2.setName("aaa");
		System.out.println(c2.getAge()+","+c2.getName());
		Cat c3=(Cat) c2;
		c3.Catch();//强转，可以调用子类的特有方法
	}

}

接口引用的类只能调用接口中重写的方法，父类引用的子类只能调用父类重写的方法，这样做很麻烦。

由于子类继承了父类，同时也实现了接口，所以实际上是这样使用的：

又回到了最初创建对象的方法，这样无论是接口还是父类中的方法，还是子类特有的方法，都可以调用了。

类和接口的关系

类和类的关系：
继承关系，只能单继承，但是可以多层继承。
类和接口的关系：
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口。

一个类继承一个类、实现多个接口：

接口和接口的关系：

继承关系，可以单继承，也可以多继承。

抽象类和接口的区别

门有开关功能和报警功能。但并不需要所有门都有报警功能，所以如果把这三个功能都放在接口或者抽象类中，是不符合实际需求的。

解决方案为，开关门功能为所有门都有的功能，放在抽象类，报警功能放在接口，当门需要该功能时只需要实现接口即可。

类名作为形参和返回值

类名作为形参

//猫
package myday;

public class Cat {
	public void eat() {
		System.out.println("猫吃鱼");
	}
}
//猫操作类
package myday;

public class CatOp {
	public void useCat(Cat c) {
		c.eat();
	}
}
//猫测试类
package myday;

public class Demo {
	public static void main(String[] args) {
		Cat c=new Cat();
		CatOp op=new CatOp();
		op.useCat(c);
	}

}

类名作为返回值

public Cat getCat(){
   Cat c=new Cat();
   return c;
}

抽象类名作为形参

//抽象类
package myday;

public abstract class Animal {
	
	public abstract void eat();
	
}
//实现类
package myday;

public class Cat extends Animal{
	public void eat() {
		System.out.println("猫吃鱼");
	}
}
//操作类
package myday;

public class AnimalAll {
	public void useAnimal(Animal d) {
	//Animal类作为形参，也就是抽象类
		d.eat();
	}
}
//测试类
package myday;

public class Demo {
	public static void main(String[] args) {
		AnimalAll ao=new AnimalAll();
		Animal a=new Cat();
		//抽象类不能直接创建对象
		//所以要父类引用的方法创建对象传入方法
		ao.useAnimal(a);
	}

}

抽象类作为返回值

//抽象类
package myday;

public abstract class Animal {
	
	public abstract void eat();
	
}
//操作类
package myday;

public class AnimalAll {
	public void useAnimal(Animal d) {
		d.eat();
	}
	public Animal getAnimal() {
		Animal a=new Cat();
		return a;//返回的是Animal类（抽象类）
		//所以父类引用创建子类对象
	}
}
//子类
package myday;

public class Cat extends Animal{
	public void eat() {
		System.out.println("猫吃鱼");
	}
}
//测试类
package myday;

public class Demo {
	public static void main(String[] args) {
		AnimalAll ao=new AnimalAll();
		Animal a=ao.getAnimal();
		a.eat();
	}

}

接口名作为形参和返回值

//接口
package myday;

public interface Inter {
	void jump();
}
//接口实现类
package myday;

public class InterIm implements Inter{
	public void jump() {
		System.out.println("猫跳高");
	}
}
//操作类
package myday;

public class Interop {
	public void usejump(Inter j) {
	//形参为接口类
	//接口类不能直接定义对象
	//所以利用多态的形式创建对象
		j.jump();
	}
}
//测试类
package myday;

public class Demo {
	public static void main(String[] args) {
		Interop j=new Interop();
		Inter a=new InterIm();
		j.usejump(a);
	}

}

接口名作为返回值

//接口类
package myday;

public interface Inter {
	void jump();
}
//接口实现类
package myday;

public class InterIm implements Inter{
	public void jump() {
		System.out.println("猫跳高");
	}
}
//操作类
package myday;

public class Interop {
	public void usejump(Inter j) {
		j.jump();
	}
	public Inter getjump() {
		Inter j=new InterIm();
		return j;
	}
}
//测试类
package myday;

public class Demo {
	public static void main(String[] args) {
		Interop j=new Interop();
		Inter a=j.getjump();//new InterIm()
		a.jump();
	}
}