面向对象-接口

4:接口(掌握)

(1)回顾猫狗案例，它们仅仅提供一些基本功能。

    比如：猫钻火圈，狗跳高等功能，不是动物本身就具备的，

    是在后面的培养中训练出来的，这种额外的功能，java提供了接口表示。

(2)接口的特点：

A:接口用关键字interface修饰

interface 接口名 {}

B:类实现接口用implements修饰

class 类名 implements 接口名 {}

C:接口不能实例化

D:接口的实现类

a:是一个抽象类。可以不必重写接口中的方法。

b:是一个具体类，这个类必须重写接口中的所有抽象方法。

(3)接口的成员特点：

A:成员变量，只能是常量

默认修饰符：public static final

B:构造方法

没有构造方法

C:成员方法，只能是抽象的

默认修饰符：public abstract

(4)类与类,类与接口,接口与接口

A:类与类

继承关系，只能单继承，可以多层继承

B:类与接口

实现关系，可以单实现，也可以多实现。

还可以在继承一个类的同时，实现多个接口

C:接口与接口

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

 

interface Father {
	public abstract void show();
}

interface Mother {
	public abstract void show2();
}

interface Sister extends Father,Mother {

}

//class Son implements Father,Mother //多实现
class Son extends Object implements Father,Mother {
	public void show() {
		System.out.println("show son");
	}
	
	public void show2() {
		System.out.println("show2 son");
	}
}

class InterfaceDemo3 {
	public static void main(String[] args) {
		//创建对象
		Father f = new Son();
		f.show();
		//f.show2(); //报错：Father没有show2()方法
	
		Mother m = new Son();
		//m.show(); //报错:Mother没有show()方法
		m.show2();
	}
}

(5)抽象类和接口的区别(自己补齐)?

A:成员区别

抽象类：

成员变量：可以变量，也可以常量

构造方法：有

成员方法：可以抽象，也可以非抽象

接口：

成员变量：只可以常量

成员方法：只可以抽象

B:关系区别:

类与类：

类与接口：

接口与接口：

C:设计理念不同

抽象类：is a，抽象类中定义的是共性功能。

接口：like a，接口中定义的是扩展功能。

(6)练习：

A:猫狗案例，加入跳高功能

B:老师和学生案例，加入抽烟功能0

多态的实现方式：

A:具体类多态(几乎没有)

B:抽象类多态(常用)

C:接口多态(最常用)

/*
	老师和学生案例,加入抽烟的额外功能
	
	分析：从具体到抽象
		老师：姓名，年龄，吃饭，睡觉
		学生：姓名，年龄，吃饭，睡觉
		
		由于有共性功能，我们提取出一个父类，人类。
		
		人类：
			姓名，年龄
			吃饭();
			睡觉(){}
			
		抽烟的额外功能不是人或者老师，或者学生一开始就应该具备的，所以，我们把它定义为接口
		
		抽烟接口。

		部分老师抽烟：实现抽烟接口
		部分学生抽烟：实现抽烟接口
		
	实现：从抽象到具体
		
	使用：具体
*/
//定义抽烟接口
interface Smoking {
	//抽烟的抽象方法
	public abstract void smoke();
}

//定义抽象人类
abstract class Person {
	//姓名
	private String name;
	//年龄
	private int age;
	
	public Person() {}
	
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	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 abstract void eat();
	
	//睡觉(){}
	public void sleep() {
		System.out.println("睡觉觉了");
	}
}

//具体老师类
class Teacher extends Person {
	public Teacher() {}
	
	public Teacher(String name,int age) {
		super(name,age);
	}
	
	public void eat() {
		System.out.println("吃大白菜");
	}
}

//具体学生类
class Student extends Person {
	public Student() {}
	
	public Student(String name,int age) {
		super(name,age);
	}
	
	public void eat() {
		System.out.println("吃红烧肉");
	}
}

//抽烟的老师
class SmokingTeacher extends Teacher implements Smoking {
	public SmokingTeacher() {}
	
	public SmokingTeacher(String name,int age) {
		super(name,age);
	}

	public void smoke() {
		System.out.println("抽烟的老师");
	}
}

//抽烟的学生
class SmokingStudent extends Student implements Smoking {
	public SmokingStudent() {}
	
	public SmokingStudent(String name,int age) {
		super(name,age);
	}

	public void smoke() {
		System.out.println("抽烟的学生");
	}
}

class InterfaceTest2 {
	public static void main(String[] args) {
		//测试学生
		SmokingStudent ss = new SmokingStudent();
		ss.setName("林青霞");
		ss.setAge(27);
		System.out.println(ss.getName()+"---"+ss.getAge());
		ss.eat();
		ss.sleep();
		ss.smoke();
		System.out.println("-------------------");
		
		SmokingStudent ss2 = new SmokingStudent("刘意",30);
		System.out.println(ss2.getName()+"---"+ss2.getAge());
		ss2.eat();
		ss2.sleep();
		ss2.smoke();
		
		//测试老师留给自己练习
	}
}