接口和形式参数

(一)接口
1.概述:是一系列方法的声明,是一些方法特征的集合.一个接口只有方法的特征没有方法的实现,因此这些特征可以再不同的地方被不同的类实现.
2.特点:
接口里面定义的方法只能是抽象方法,接口中没有构造方法
接口的子类和接口之间是实现关系:implements  
子类  implements 接口{
  }
  抽象的子实现类,因为不能实例化,所以没意义.非抽象的子实现类,是可以实例化的.
  接口实例化需要使用接口的子实现类进行实例化.
例:
package 接口2;
//定义一个猫会跳高的接口
interface Jumpping{
public abstract void jump();
}
//定义一个会跳高的猫类
class JumpCat implements Jumpping{


@Override
public void jump() {
System.out.println("猫咪会跳高");
}

}
//测试类
public class InterfaceDemo {
public static void main(String[] args) {
//创建子实现类
//以接口多态的形式进行实例化
Jumpping j = new JumpCat();
j.jump();
System.out.println("--------------");
//通过接口的子实现类进行实例化
JumpCat jc = new JumpCat();
jc.jump();
}
}
3.成员特点:
  成员变量:默认的修饰符:public static final ,只能是常量(同时被final和static修饰)
  成员方法:默认的修饰符:public abstract ,只能是抽象的方法
  构造方法:接口中没有构造方法
例:
package 接口2;


//定义一个接口
interface Inter{
// public Inter(){}//Interfaces cannot have constructors
//成员变量
int num = 10;
public final int num2 = 20;
public static final int num3 = 30;

//成员方法
// public void show(){}  //Abstract methods do not specify a body
public abstract void show();
}
//接口的子实现类
class InterImpl implements Inter{


@Override
public void show() {
System.out.println(num);
}
}
//测试类
public class InterfaceDemo2 {
public static void main(String[] args) {
//创建对象
Inter i = new InterImpl();

i.show();//10
// i.num = 1;//The final field Inter.num cannot be assigned
System.out.println(Inter.num);//10
System.out.println(Inter.num2);//20
System.out.println(Inter.num3);//30
}
}
4.案例:
package 接口;
/*
* 猫狗案例,加入跳高的额外功能
* */
//定义跳高的接口
interface Jumpping{
//定义抽象方法
public abstract void jump();
}


//定义抽象动物类
abstract class Animal{
//成员变量
private String name;
private int age;
private String color;

//无参/有参
public Animal() {

}
public Animal(String name, int age, String color) {
super();
this.name = name;
this.age = age;
this.color = color;
}

//get()/set()方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}

public void sleep(){
System.out.println("sleep");
}
public abstract void eat();
}
//具体的猫类
class Cat extends Animal{
//无参/有参
public Cat() {

}
public Cat(String name, int age, String color) {
super(name, age, color);
}


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

}
//定义具体的狗类
class Dog extends Animal{


public Dog() {

}


public Dog(String name, int age, String color) {
super(name, age, color);
}

@Override
public void eat(){
System.out.println("狗吃骨头");
}
}


//定义部分具有跳高功能的猫类和狗类
class JumpCat extends Cat implements Jumpping{
//无参/有参
public JumpCat() {

}
public JumpCat(String name, int age, String color) {
super(name, age, color);
}


@Override
public void jump() {
System.out.println("猫咪会跳高");
}
}
class JumpDog extends Dog implements Jumpping{


public JumpDog() {

}


public JumpDog(String name, int age, String color) {
super(name, age, color);
}


@Override
public void jump() {
System.out.println("狗狗会跳高");
}
}
//测试类
public class InterfaceDemo {
public static void main(String[] args) {
//测试猫类
JumpCat jc = new JumpCat();

jc.setName("折耳猫");
jc.setAge(2);
jc.setColor("白色");

System.out.println("这是一只"+jc.getAge()+"岁的"+jc.getColor()+jc.getName());
jc.eat();
jc.sleep();
jc.jump();
System.out.println("----------------");
//测试狗类
JumpDog jd = new JumpDog("哈士奇", 3, "灰色");

System.out.println("这是一只"+jd.getAge()+"岁的"+jd.getColor()+jd.getName());
jd.eat();
jd.sleep();
jd.jump();
}
}
(二)形式参数与返回值问题
1)形式参数
引用类型
  1.类:返回的是该类对象
  2.抽象类:返回的是该抽象类的子类对象
  3.接口:需要返回的是接口的子实现类对象
例1:
package 形式参数;
//形式参数是类的情况
class Student{
public void show(){
System.out.println("show");
}
}


class StudentDemo{
public void method(Student s){
s.show(); 
}
}


//测试类
public class StudentTest {
public static void main(String[] args) {
//1)创建StudentDemo对象
StudentDemo sd = new StudentDemo() ;
//2)创建Student类的对象
Student s = new Student() ;
//3)将对象名作为参数进行传递
sd.method(s);

//匿名对象
new StudentDemo().method(new Student());
}
}
例2:
package 形式参数;
//形式参数是抽象类的情况
//定义一个抽象类
abstract class Teacher{
public abstract void show();
}
class TeacherDemo{
public void method(Teacher t){
t.show();
}
}
//子类
class BasicTeacher extends Teacher{


@Override
public void show() {
System.out.println("show");
}
}
//测试类
public class TeacherTest {
public static void main(String[] args) {
//创建对象,通过子类进行实例化
TeacherDemo td = new TeacherDemo() ;
//抽象类多态:
Teacher t = new BasicTeacher() ;
td.method(t);
}
}
例3:


2)返回值类型
引用类型
1.类:返回的是该类对象
  2.抽象类:返回的不应该是该抽象类的对象(不能实例化),返回的是抽象类的子类对象
例1:
package 形式参数;
//返回值是类的情况
class Student2{
public void show(){
System.out.println("show");
}
}


class StudentDemo2{
public Student2 method(){
// Student2 s = new Student2();
// return s;
return new Student2();//匿名对象
}
}
//测试类
public class StudentTest2 {
public static void main(String[] args) {
//创建对象
StudentDemo2 sd = new StudentDemo2() ;
Student2 s = sd.method() ;
s.show();


//链式编程:
new StudentDemo2().method().show();
}
}
例2:
package 形式参数;
//返回值类型是抽象类的情况
abstract class Teacher2{
public abstract void show() ;
}


class TeacherDemo2{
public Teacher2 method(){
// return new Teacher2();//错误 Cannot instantiate the type Teacher2
return new WorkTeacher();
}
}
//定义子类
class WorkTeacher extends Teacher2{


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

}
//测试类
public class TeacherTest2 {
public static void main(String[] args) {
//创建TeacherDemo2对象
TeacherDemo2 td = new TeacherDemo2() ;
Teacher2 t= td.method() ;
t.show();

//链式编程
new TeacherDemo2().method().show();
}
}