文章目录
- 一、抽象类
- 1. 抽象类定义
- 2. 抽象类成员特点
- 二、接口
- 1. 接口概述
- 2. 接口成员特点
- 3. 类和接口的关系
- 4. 抽象类和接口的区别
- 5. 接口案例
- 三、形参和返回值
一、抽象类
1. 抽象类定义
在 Java 中,一个没有方法体的方法应该定义为抽象方法,而类中如果有抽象方法,则该类必须定义为抽象类。
抽象类关键字:abstract
public abstract class Animal {
public abstract void eat();
}
public class Cat extends Animal {
//重写抽象方法
public void eat() {
System.out.println("猫吃鱼!");
}
}
抽象类不是具体的,所以不能直接创建对象!
抽象类的特点:
① 抽象类和抽象方法必须使用 abstract 关键字修饰;
② 抽象类中不一定有抽象方法,但有抽象方法的类一定是抽象类;
③ 抽象类不能直接实例化,要想实例化,参照多态的方式,通过子类对象实现实例化,这叫抽象类多态;
④ 抽象类的子类要么重写抽象类中的所有抽象方法,要么自己就是抽象类。
2. 抽象类成员特点
① 抽象类中的成员变量可以是变量,也可以是常量;
② 抽象类有构造方法,但是不能实例化,此处构造方法用于子类访问父类数据的初始化;
③ 可以有抽象方法,限定子类必须完成某些动作,也可以有非抽象方法,提高代码的复用性。
分析问题要从具体到抽象!
二、接口
1. 接口概述
接口就是一种公共的规范标准,只要符合规范标准,大家都可以通用,Java 中的接口更多的体现在对行为的抽象。
接口关键字:Interface
//Jumpping.java,接口
package com.zxe;
public interface Jumpping {
public abstract void jump();
}
//Cat.java,接口的实现类
package com.zxe;
public class Cat implements Jumpping {
public void jump() {
System.out.println("喵喵喵跳起来!");
}
}
//Test.java
package com.zxe;
public class Test {
public static void main(String[] args) {
Jumpping c = new Cat();
c.jump();
Jumpping d = new Dog();
d.jump();
}
}
Dog 的实现类与 Cat 同理,实例化的过程依然采用多态的方法!
接口的特点:
① 接口用关键字 interface 修饰;
② 接口不能实例化,参照多态的方式,通过实现类对象进行实例化,这叫接口多态;
③ 接口的实现类,要么重写接口中的所有抽象方法,要么自身就是抽象类。
2. 接口成员特点
① 成员变量默认是常量,且只能是常量,默认被 static 修饰;
② 接口没有构造方法,因为接口主要是对行为进行抽象的,是没有具体存在的;
③ 一个类如果没有父类,默认继承 Object 类,访问其无参构造方法;
④ 成员方法只能是抽象方法。
3. 类和接口的关系
(1)类和类是继承关系,只能单继承,但可以多层继承;
(2)类和接口是实现关系,可以单实现,也可以多实现,还可以在继承一个类的同时实现多个接口;
(3)接口和接口是继承关系,可以单继承,也可以多继承。
public class InterImpl implements Inter1, Inter2, Inter3 {
}
4. 抽象类和接口的区别
抽象类 | 接口 |
---|---|
可以是常量也可以是变量,有构造方法,有抽象方法,也有非抽象方法,对类抽象,包括属性、行为 | 只能是常量,只有抽象方法,主要是对行为抽象 |
抽象类是对 Door 这一事物的抽象,而接口是对 Alram 报警行为的抽象!
5. 接口案例
//Animal.java
package com.zxe;
public 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();
}
//Jumpping.java
package com.zxe;
public interface Jumpping {
public abstract void jump();
}
//Cat.java
package com.zxe;
public class Cat extends Animal implements Jumpping {
public Cat() {
}
public Cat(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("猫爱吃鱼!");
}
@Override
public void jump() {
System.out.println("喵喵喵跳起来!");
}
}
//Dog.java
package com.zxe;
public class Dog extends Animal implements Jumpping {
public Dog() {
}
public Dog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("狗爱吃骨头!");
}
@Override
public void jump() {
System.out.println("汪汪汪跳起来!");
}
}
//Test.java
package com.zxe;
public class Test {
public static void main(String[] args) {
Cat c = new Cat("加菲猫", 12);
System.out.println(c.getName() + ", " + c.getAge());
c.eat();
c.jump();
Dog d = new Dog();
d.setName("舔狗");
d.setAge(21);
System.out.println(d.getName() + ", " + d.getAge());
d.eat();
d.jump();
}
}
在实际开发中,既会有接口的出现,也会有抽象类的出现,在使用的时候我们应使用具体的子类,因为它里面的方法最多。
三、形参和返回值
① 类名作为形参和返回值
方法的形参是类名,其实需要的是该类的对象,方法的返回值是类名,其实返回的是该类的对象。
//Cat是普通类
public void useCat(Cat c) {
c.eat();
}
public Cat getCat() {
Cat c = new Cat();
return c;
}
② 抽象类名作为形参和返回值
方法的形参是抽象类名,其实需要的是该抽象类的子类对象,方法的返回值是抽象类名,其实返回的是该抽象类的子类对象。
//Animal是抽象类
public class AnimalOperator{
public void useAnimal(Animal a) {
a.eat();
}
public Animal getAnimal() {
Animal a = new Cat();
return a;
}
}
//Test.java
AnimalOperator ao = new AnimalOperator();
Animal a = new Cat();
ao.useAnimal(a);
Animal a2 = ao.getAnimal();
a2.eat();
因为要传的参数是一个 Animal 对象,而 Animal 类是一个抽象类,它不能直接实例化,所以我们还是通过多态的方式创建它的子类对象,然后作为参数传递进来。
③ 接口名作为参数和返回值
方法的形参是接口名,其实需要的是该接口的实现类对象,方法的返回值是接口名,其实返回的是该接口的实现类对象。
//Jumpping是接口
public void useJumpping(Jumpping j) {
j.jump();
}
public Jumpping getJumpping() {
Jumpping j = new Cat();
return j;
}
接口与抽象类一样也需借助多态来实现对象的实例化!