目录
1、什么是接口?
接口就是一种公共的规范标准,只要符合规范标准,大家都可以通用。
Java中的接口更多的体现在对行为的抽象!
1.接口 用关键字interface 修饰
public interface 接口名{}
2.类实现接口用 implements 表示
public class 类 implements 接口 {}
3.接口不能够实例化
接口如何实例化呢?参照多态的方式,通过实现类对象实例化,这叫接口多态。
多态的形式:具体类多态,抽象类多态,接口多态。
4.多态的前提:有继承或者实现关系;有方法重写;有父(类/接口引用)指向(子/实现)类对象
5.接口的实现类,要么重写接口中所有的抽象方法、要么是抽象类
package jiekopudemo01;
public interface Animal {
//接口Animal
public abstract void eat();
}
package jiekopudemo01;
public class Catimpl implements Animal {
@Override
public void eat() {
System.out.println("我们是好人呀!");
//Catimpl是实现类 , 实现了我们的Anamil接口!
/**
* 实现类必须要重写接口中所有的方法!
*/
}
}
package jiekopudemo01;
public class Test {
public static void main(String[] args) {
//接口是不能进行实例化的
// Animal animal = new Animal();
//程序会提示报错!
Catimpl catimpl = new Catimpl();
catimpl.eat();
}
}
1、接口中成员变量的访问特点
2、接口中成员方法的访问特点
不需要写 public abstract 的
因为在接口处写方法默认就是抽象方法
如果想在接口中定义非抽象方法,那么就要嫁一个关键字-->default
但是此方法只限于jdk以后的版本,jdk8以前是不能使用这个方法的!
3、接口是没有构造方法的
在接口中,不能直接构造方法使用
接口中的抽象类是有抽象方法的!
4、猫和狗接口代码演示
接口
package jiekopudemo03;
public interface JumpInterface {
/**
* 跳高方法 -- 将publci abstract
*/
void jump();
}
Animal类
package jiekopudemo03;
public abstract class Animal implements JumpInterface {
private String name;//姓名!
private int age;//年龄!
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public Animal() {
}
/**
* 如果加上abstract -- 相当于有了一个jump抽象方法!
*/
public abstract void eat();
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
}
猫类
package jiekopudemo03;
import com.sun.xml.internal.stream.events.NamedEvent;
public class Cat extends Animal {
public Cat(String name, int age) {
//构造方法第一行默认调用父类中的午无参构造方法 -- super()
super(name, age);
}
@Override
public void jump() {
System.out.println("我是猫类!我在跳高!");
}
@Override
public void eat() {
System.out.println("我是猫咪!我在吃鱼!");
}
}
狗类
package jiekopudemo03;
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("我是狗类,我在干饭!");
}
@Override
public void jump() {
System.out.println("我是狗类,我在跳高!");
}
}
测试类
package jiekopudemo03;
public class AnimalDemo {
public static void main(String[] args) {
JumpInterface cat = new Cat("小猫", 2);
cat.jump();
//cat.eat // 报错! 编译看左边,JumpInterface接口中没有eat方法!
System.out.println("------------------");
Animal cat2 = new Cat("大猫", 5);
System.out.println(cat2.getName() + ", " + cat2.getAge());
cat2.eat();//不会报错是因为Animal类中有eat抽象方法!
cat2.jump();
System.out.println("--------------------");
Animal dog = new Dog();
dog.setName("我是小狗");
dog.setAge(12);
System.out.println(dog.getName() + ", " + dog.getAge());
dog.eat();
dog.jump();
}
}
5、接口和类的关系
小结:
1、类与类之间的关系:一个类只能单继承一个父类,不能同时继承n多个不同的父类! 可以多层继承父类,但不能同时继承多个父类!
2、类与接口之间的关系:一个类可以实现n多个不同的接口 也就是说,在一个类中可以加入多个接口!
3、接口与接口的关系:一个接口是可以继承n多个不同的接口的! 接口和接口之间是可以进行多继承的!
如果接口1继承接口2和接口3,那么接口1中就会继承接口2和接口3的方法!
小结
成员区别
1.1、在抽象类中的是有变量和常量的,有构造方法的,有抽象方法也有非抽象方法
1.2、在接口中,只有常量、抽象方法!但是在JDK8往后,在接口中就可以定义非抽象方法
关系区别
2.1、类与类只能进行单继承
2.2、类与接口可以实现单继承和多继承
设计区别
抽象类是对类进行抽象,包括属性的行为(对事物的抽象)
接口是对行为进行抽象,主要是对行为的抽象
我们可以通过接口的形式附加很多功能!
6、接口练习案例
抽象类
package jiekopudemo04;
public abstract class Door {
/**
* 开门的抽象方法
*/
public abstract void opendoor();
/**
* 关门的抽象方法
*/
public abstract void closedoor();
}
接口
package jiekopudemo04;
public interface FR {
void fr();//人脸识别功能!
}
package jiekopudemo04;
public interface Alarm {
void alarm();//报警功能!
}
door1类
package jiekopudemo04;
public class door1 extends Door implements Alarm {
@Override
public void opendoor() {
System.out.println("我是door1,我可以开门!");
}
@Override
public void closedoor() {
System.out.println("我是door1,我可以关门!");
}
@Override
public void alarm() {
System.out.println("我是door1,我可以报警!!!");
}
}
door2类
package jiekopudemo04;
public class door2 extends Door implements FR {
@Override
public void opendoor() {
System.out.println("我是door2,我可以开门!");
}
@Override
public void closedoor() {
System.out.println("我是door2,我可以关门!");
}
@Override
public void fr() {
System.out.println("我是door2,我有人脸识别功能!");
}
}
测试类
package jiekopudemo04;
public class Test {
public static void main(String[] args) {
Door door1 = new door1();
door1.opendoor();
door1.closedoor();
Alarm alarm = new door1();
alarm.alarm();
System.out.println("---------------------------");
Door door2 = new door2();
door2.closedoor();
door2.opendoor();
FR fr = new door2();
fr.fr();
}
}
2、什么是内部类
1、概念
在类的内部定义的类为内部类。
package AnimalParent05;
public class opop {
//外部类
private int age = 11;
public int code = 12;
//内部类
public class opop1 {
public void opop1() {
System.out.println("我是内部类");
System.out.println(age);
System.out.println(code);
}
}
public void opop() {
opop1 opop1 = new opop1();
opop1.opop1();
}
}
package AnimalParent05;
public class Test {
public static void main(String[] args) {
opop opop = new opop();
opop.opop();
}
}