面向对象-接口

接口的特点：

/*
	接口的特点：
		A:接口用关键字interface表示	
			interface 接口名 {}
		B:类实现接口用implements表示
			class 类名 implements 接口名 {}
		C:接口不能实例化
			那么，接口如何实例化呢?
			按照多态的方式来实例化。
		D:接口的子类
			a:可以是抽象类。但是意义不大。
			b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
	
	由此可见：
		A:具体类多态(几乎没有)
		B:抽象类多态(常用)
		C:接口多态(最常用)
*/
//定义动物培训接口
interface AnimalTrain {
	public abstract void jump();
}

//抽象类实现接口，但是意义不大
abstract class Dog implements AnimalTrain {
}

//具体类实现接口，推荐方案
class Cat implements AnimalTrain {
	public void jump() {
		System.out.println("猫可以跳高了");
	}
}

class InterfaceDemo {
	public static void main(String[] args) {
		//AnimalTrain是抽象的; 无法实例化
		//AnimalTrain at = new AnimalTrain();
		//at.jump();
		
		AnimalTrain at = new Cat();
		at.jump();
	}
}

接口的成员特点：

A:成员变量：只能是常量，并且是静态的。

                      默认修饰符：public static final

                      建议：自己手动给出。

public interface Inter {
	public int num = 10;
	public final int num2 = 20;
	//完整版的接口中的变量，不写public static final，也默认是这样的
	public static final int num3 = 30;
}

//接口名+Impl这种格式是接口的实现类格式
public class InterImpl implements Inter {
    
}

public class InterfaceDemo2 {
	
	public static void main(String[] args) {
		//创建对象
		Inter i = new InterImpl();
		System.out.println(i.num); //10
		System.out.println(i.num2);//20
		
		/*i.num = 100;
		i.num2 = 200;
		System.out.println(i.num); //报错:无法为最终变量num分配值
		System.out.println(i.num2);//报错:无法为最终变量num2分配值*/	
	
		System.out.println(Inter.num); //10
		System.out.println(Inter.num2);//20
	}

}

B:构造方法：接口没有构造方法。

所有的类都默认继承自一个类：Object。

类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。

所以接口没有构造方法不影响

C:成员方法：只能是抽象方法。

                      默认修饰符：public abstract

                      建议：自己手动给出。

------------------------------------------------------------------------------------------------------------------------------------------------------------

类与类,类与接口,接口与接口的关系：

/*
	类与类：
		继承关系,只能单继承,可以多层继承。
	类与接口：
		实现关系,可以单实现,也可以多实现。
		并且还可以在继承一个类的同时实现多个接口。
	接口与接口：
		继承关系,可以单继承,也可以多继承。
*/
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(); //报错
		//要想用show2(),向下转型
		Son s = (Son)f;
		s.show2();
	
		Mother m = new Son();
		//m.show(); //报错
		//要想用show(),向下转型
		Son ss = (Son)m;
		ss.show(); 
		m.show2();
	}
}

抽象类和接口的区别：开发中一般不记它，但是面试中经常会问到

A:成员区别

    抽象类：

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

        构造方法：有

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

    接口：

        成员变量：只可以常量

        成员方法：只可以抽象

B:关系区别

    类与类

        继承，单继承

    类与接口

        实现，单实现，多实现

    接口与接口

        继承，单继承，多继承       

C:设计理念区别

    抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。

    接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。

--------------------------------------------------------------------------------------------------------------------------------------------------------------

猫狗案例加入跳高功能分析：

/*
	猫狗案例,加入跳高的额外功能
	
	分析：从具体到抽象
		猫：
			姓名,年龄
			吃饭，睡觉
		狗：
			姓名,年龄
			吃饭，睡觉
			
		由于有共性功能，所以，我们抽取出一个父类：
		动物：
			姓名,年龄
			吃饭();
			睡觉(){}
			
		猫：继承自动物
		狗：继承自动物
		
		跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口
		接口：
			跳高
			
		部分猫：实现跳高
		部分狗：实现跳高
	实现；
		从抽象到具体
		
	使用：
		使用具体类
*/
//定义跳高接口
interface Jumpping {
	//跳高功能
	public abstract void jump();
}

//定义抽象类
abstract class Animal {
	//姓名
	private String name;
	//年龄
	private int age;
	
	public Animal() {}
	
	public Animal(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 Cat extends Animal {
	public Cat(){}
	
	public Cat(String name,int age) {
		super(name,age);
	}
	
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

//具体狗类
class Dog extends Animal {
	public Dog(){}
	
	public Dog(String name,int age) {
		super(name,age);
	}
	
	public void eat() {
		System.out.println("狗吃肉");
	}
}

//有跳高功能的猫
class JumpCat extends Cat implements Jumpping {
	public JumpCat() {}
	
	public JumpCat(String name,int age) {
		super(name,age);
	}

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

//有跳高功能的狗
class JumpDog extends Dog implements Jumpping {
	public JumpDog() {}
	
	public JumpDog(String name,int age) {
		super(name,age);
	}

	public void jump() {
		System.out.println("跳高狗");
	}
}

class InterfaceTest {
	public static void main(String[] args) {
		//定义跳高猫并测试
		JumpCat jc = new JumpCat();
		jc.setName("哆啦A梦");
		jc.setAge(3);
		System.out.println(jc.getName()+"---"+jc.getAge());
		jc.eat();
		jc.sleep();
		jc.jump();
		System.out.println("-----------------");
		
		JumpCat jc2 = new JumpCat("加菲猫",2);
		System.out.println(jc2.getName()+"---"+jc2.getAge());
		jc2.eat();
		jc2.sleep();
		jc2.jump();

		
		//定义跳高狗并进行测试的事情自己完成。
	}
}

老师学生案例加入抽烟功能分析及代码实现：

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

		部分老师抽烟：实现抽烟接口
		部分学生抽烟：实现抽烟接口
		
	实现：从抽象到具体
		
	使用：具体
*/
//定义抽烟接口
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();
		
		//测试老师留给自己练习
	}
}