接口
当一个抽象类中的方法都是抽象的时候 可以将该抽象类用另一种方式表示 即接口
定义接口的关键字是 Interface
例如
abstract class Demo1
{
abstract void show1(){};
abstract boid show2(){};
}
interface Demo
{
abstract void show1()；
abstract boid show2();
}
接口中常见的成员:
1.全局常量--->pubic static final
2.抽象方法--->public abstract
接口中的成员都是公共的权限~
interface Demo
{
public static final int Num = 1;
public abstract void show1();
public abstract void show2();
}
//类与类之间是继承关系 类与接口直接是实现过程
/*
1.接口不可以实例化 只能由实现了接口的子类并覆盖了接口中的所有抽象方法后
该子类才可以实例化，否则这个字类就是一个抽象类
*/
class DemoImpl implements Demo
{
public void show1(){}
public void show2(){}
}
interface Demo
{
public static final int Num = 1;
public abstract void show1();
public abstract void show2();
}
class InterfaceDemo
{
public static void main(String[] arr){
DemoImpl d = new DemoImpl();
System.out.println(d.Num);
System.out.println(DemoImpl.Num);
System.out.println(Demo.Num);
}
}
在Java中不直接支持多继承，会出现调用的不确定性
所以Java将多继承机制进行了改良 变成了多实现--↓
↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
一个类可以实现多个接口。
interface A
{
public void show();
}
interface B
{
public void show();
}
class C
{
public void method()
{}
}
class Test implements A,B//多实现
{
public void show()
{
}
}
class Test extends C implements A,B
{
}
class InterfaceDemo
{
public static void main(String[] arr)
{
Test t = new Test();
t.show();
}
}
一个类在继承另一个类的同时 才可以实现多个接口
class Test extends C implements A,B
{
}
接口的出现避免了单继承的局限性
接口可以多继承
interface A{}
interface B{}
interface C extends A,B{}
接口的特点
抽象类和接口的异同点:
相同点:都是不断向上抽取而来的
不同点:
1.抽象类需要给继承，，而且只能单继承
接口需要被实现，而且可以多实现
2.抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法
接口中只能定义抽象方法，必须由子类去实现
3.抽象类的继承是所有的关系，在定义该体系的基本共性内容
接口的实现是'like'即'像'的关系，在定义体系额外功能
多态
定义:某一类事物的多种存在形态
对象的多态性
class Animal
{}
class Cat extends Animal
{}
class Dog extends Animal
{}
Cat x = new Cat();
Animal x = new Cat();//父类型指向子对象 一个对象两种形态
//Cat这类事物既具备了Cat的形态，也具备了Animal的形态，这就是对象的多态性
简单说:就是一个对象对应着不同的类型
多态在代码中的体现:
父类或者接口的引用指向其子类的对象
多态示例:
class Animal
{
abstract void eat();
}
class Dog extends Animal
{
void eat()
{
syso;
}
void look()
{
syso;
}
}
class Cat extends Animal
{
void eat()
{
syso;
}
void Catch()
{
syso;
}
}
class Pig extends Animal
{
void eat()
{
syso;
}
void pigWork
{
syso;
}
}
class DuoTaiDemo
{
public static void main(String[] arr)
{
Cat c = new Cat();
Dog d = new Dog();
//c.eat();
method(c);
method(d);
method(new Pig());
}
/*
public static void method(Cat c)
{
c.eat();
}
public static void method(Dog c)
{
d.eat();
}
public static void method(Pig p)
{
p.eat();
}*/
public static void method(Animal a)
{
a.eat();
}
}
由上可见,多态的好处:
提高了代码的扩展性，前期定义的代码可以使用后期的内容
多态的局限性:
前期定义的内容不能调用后期子类的特有功能
多态的前提:
1.必须有关系，继承，实现
2.要有覆盖
Animal a = new Cat();
//自动类型提升，Cat对象提升了Aniaml类型，但是Cat特有功能无法访问
//作用就是限制特有功能访问--->向上转型
Cat c = (Cat)a;//向下转型是为了使用子类特有功能
//向下转型 可以访问特有功能
