接口是功能的集合
这点可以让我们将接口看做是一种只包含了功能声明的特殊类。
定义格式：
public interface 接口名 {
抽象方法1;
抽象方法2;
抽象方法3;
}
- 接口中的方法均为公共访问的抽象方法
- 接口中无法定义普通的成员变量
类与接口的关系为实现关系，即类实现接口。实现的动作类似继承，只是关键字不同，实现使用implements。
重写方法以实现具体的功能。
格式：
class 类 implements 接口 {
重写接口中方法
}
在类实现接口后，该类就会将接口中的抽象方法继承过来，此时该类需要重写该抽象方法，完成具体的逻辑。
接口中成员的特点
1、接口中可以定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量，其值不能改变。后面我们会讲解static与final关键字
2、接口中可以定义方法，方法也有固定的修饰符，public abstract
3、接口不可以创建对象。
4、子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。
interface Demo { ///定义一个名称为Demo的接口。
public static final int NUM = 3;// NUM的值不能改变
public abstract void show1();
public abstract void show2();
}
//定义子类去覆盖接口中的方法。类与接口之间的关系是 实现。通过 关键字 implements
class DemoImpl implements Demo { //子类实现Demo接口。
//重写接口中的方法。
public void show1(){}
public void show2(){}
}
接口最重要的体现：解决多继承的弊端。将多继承这种机制在java中通过多实现完成了。
interface Fu1
{
void show1();
}
interface Fu2
{
void show2();
}
class Zi implements Fu1,Fu2// 多实现。同时实现多个接口。
{
public void show1(){}
public void show2(){}
}
类继承类同时实现接口
接口和类之间可以通过实现产生关系，同时也学习了类与类之间可以通过继承产生关系。当一个类已经继承了一个父类，它又需要扩展额外的功能，这时接口就派上用场了。
子类通过继承父类扩展功能，通过继承扩展的功能都是子类应该具备的基础功能。如果子类想要继续扩展其他类中的功能呢？这时通过实现接口来完成。
class Fu {
public void show(){}
}
interface Inter {
pulbic abstract void show1();
}
class Zi extends Fu implements Inter {
public void show1() {
}
}
最终多态体现为父类引用变量可以指向子类对象。
在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法，而不是父类方法。
多态是继封装、继承之后，面向对象的第三大特性。
多态的定义格式：就是父类的引用变量指向子类对象
父类类型 变量名 = new 子类类型();
变量名.方法名();
- 普通类多态定义的格式
父类 变量名 = new 子类();
如： class Fu {}
class Zi extends Fu {}
//类的多态使用
Fu f = new Zi();
- 抽象类多态定义的格式
抽象类 变量名 = new 抽象类子类();
如： abstract class Fu {
public abstract void method();
}
class Zi extends Fu {
public void method(){
System.out.println(“重写父类抽象方法”);
}
}
//类的多态使用
Fu fu= new Zi();
- 接口多态定义的格式
接口 变量名 = new 接口实现类();
如： interface Fu {
public abstract void method();
}
class Zi implements Fu {
public void method(){
System.out.println(“重写接口抽象方法”);
}
}
//接口的多态使用
Fu fu = new Zi();
- 注意事项
同一个父类的方法会被不同的子类重写。在调用方法时，调用的为各个子类重写后的方法。
如 Person p1 = new Student();
Person p2 = new Teacher();
p1.work(); //p1会调用Student类中重写的work方法
p2.work(); //p2会调用Teacher类中重写的work方法
多态-成员变量的特点：
class Fu {
int num = 4;
}
class Zi extends Fu {
int num = 5;
}
编译运行全看父类
输入：4
多态-成员方法的特点：
class Fu {
int num = 4;
void show() {
System.out.println("Fu show num");
}
}
class Zi extends Fu {
int num = 5;
void show() {
System.out.println("Zi show num");
}
}
输出：f.show()=zi show num
所以编译看父类，运行看子类 子类方法被注释则运行父类
instanceof关键字（比较引用数据类型的运算符 只用与继承类比较）
我们可以通过instanceof关键字来判断某个对象是否属于某种数据类型。如学生的对象属于学生类，学生的对象也属于人类。
使用格式：
boolean b = 对象 instanceof 数据类型;
如
Person p1 = new Student(); // 前提条件，学生类已经继承了人类
boolean flag = p1 instanceof Student; //flag结果为true
boolean flag2 = p2 instanceof Teacher; //flag结果为false
多态的转型分为向上转型与向下转型两种：
- 向上转型：当有子类对象赋值给一个父类引用时，便是向上转型，多态本身就是向上转型的过程。
使用格式：
父类类型 变量名 = new 子类类型();
如：Person p = new Student();
- 向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用转为子类引用，这个过程是向下转型。如果是直接创建父类对象，是无法向下转型的！
使用格式：
子类类型 变量名 = (子类类型) 父类类型的变量;
如:Student stu = (Student) p; //变量p 实际上指向Student对象
例子：public class demo {
public static void main(String[] args) {
Animal a = new Dog();
a.eat();
Dog d=(Dog) a;（因为编译方法看父类，又因为父类没有，所以需要转型）
d.lookHome();
}
static abstract class Animal{
abstract void eat();
}
static class Dog extends Animal{
void eat(){
System.out.println("坑骨头");
}
void lookHome(){
System.out.println("看家");
}
}
}
学习到这里，面向对象的三大特征学习完了。
总结下封装、继承、多态的作用：
- 封装：把对象的属性与方法的实现细节隐藏，仅对外提供一些公共的访问方式
- 继承：子类会自动拥有父类所有可继承的属性和方法。
- 多态：配合继承与方法重写提高了代码的复用性与扩展性；如果没有方法重写，则多态同样没有意义。
- 多态使用的前提：
1，有继承或者实现关系
2，要方法重写
-
-
- 类的多态
-
abstract class Fu {
public abstract void method();
}
class Zi extends Fu {
public void method(){
System.out.println(“重写父类抽象方法”);
}
}
//类的多态使用
Fu fu= new Zi();
-
-
- 接口的多态
-
interface Fu {
public abstract void method();
}
class Zi implements Fu {
public void method(){
System.out.println(“重写接口抽象方法”);
}
}
//接口的多态使用
Fu fu = new Zi();