『JavaSE』抽象类与接口

抽象类

抽象类概念：只给出方法定义而不具体实现的方法被称为抽象方法（子类会根据具体需求来具体实现，即方法的声名相同，但是方法功能主体不同）。包含一个或多个抽象方法的类称为抽象类。

注意事项

a.抽象方法不能是private的.
b.方法前加上 abstract 关键字, 表示这是一个抽象方法，抽象方法是没有方法体的，在代码的表达上就是没有“{}”.
c.抽象类中可以包含其他的非抽象方法，也可以包含字段。这个非抽象方法和普通方法的规则都是一样的，可以被重写，也可以被子类直接调用.
d.抽象类不能直接实例化.

抽象类的作用

a.抽象类存在的最大意义就是为了被继承。
b.抽象类本身不能被实例化，要想使用，只能创建该抽象类的子类。然后让子类重写抽象类中的抽象方法。
c.虽然说普通类也可以被继承，普通的方法也可以被重写。但是使用抽象类和抽象方法相当于多了一重编译器检查。
d.使用抽象类的场景就如上面的代码，实际工作不应该由父类完成，而应由子类完成。那么此时如果不小心误用成父类了，使用普通类编译器是不会报错的。但是父类是抽象类就会在实例化的时候提示错误，让我们尽早发现问题。
e.很多语法存在的意义都是为了“预防出错”，例如我们曾经用过的final也是类似。创建的变量用户不去修改，不就相当于常量嘛？但是加上final能够在不小心误修改的时候，让编译器及时提醒我们。
f.充分利用编译器的校验，在实际开发中是非常有意义的。

//抽象类
abstract class People{
//抽象方法
public abstract void work();
}
class Doctor extends People{
private String work;
public Doctor(String work) {
this.work=work;
}
//重写方法
@Override
public void work() {
System.out.println("我的职业是"+this.work);
}
}
class Lawyer extends People {
private String work;
public Lawyer(String work) {
this.work = work;
}
@Override
public void work() {
System.out.println("我的职业是" + this.work);
}
}
public class Solution {
public static void main(String[] args) {
Doctor doctor=new Doctor("医生");
doctor.work();
Lawyer lawyer=new Lawyer("律师");
lawyer.work();
}
}

接口

接口是抽象类的更进一步. 抽象类中还可以包含非抽象方法和字段. 而接口中包含的方法都是抽象方法, 字段只能包含静态常量.

interface IShape {
void draw();
}
class Cycle implements IShape {
@Override
public void draw() {
System.out.println("○");
}
}
public class Test {
public static void main(String[] args) {
IShape shape = new Rect();
shape.draw();
}
}

注意事项

a.使用 interface 定义一个接口
b.接口中的方法一定是抽象方法, 因此可以省略 abstract
c.接口中的方法一定是 public, 因此可以省略 public
d.Cycle 使用 implements 继承接口. 此时表达的含义不再是 “扩展”, 而是 “实现”
e.在调用的时候同样可以创建一个接口的引用, 对应到一个子类的实例.
f.接口不能单独被实例化

实现多个接口

有的时候我们需要让一个类同时继承自多个父类. 这件事情在有些编程语言通过多继承的方式来实现的.然而 Java 中只支持单继承, 一个类只能 extends 一个父类. 但是可以同时实现多个接口, 也能达到多继承类似的效果.

现在我们通过类来表示一组动物。

class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
}
//提供一组接口, 分别表示 "会飞的", "会跑的", "会游泳的"
interface IFlying {
void fly();
}
interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
//创建几个具体的动物
//猫跑
class Cat extends Animal implements IRunning {
public Cat(String name) {
super(name);
}
@Override
public void run() {
System.out.println(this.name + "正在用四条腿跑");
}
}
//鱼游
class Fish extends Animal implements ISwimming {
public Fish(String name) {
super(name);
}
@Override
public void swim() {
System.out.println(this.name + "正在用尾巴游泳");
}
}
//青蛙跑和游
class Frog extends Animal implements IRunning, ISwimming {
public Frog(String name) {
super(name);
}
@Override
public void run() {
System.out.println(this.name + "正在往前跳");
}
@Override
public void swim() {
System.out.println(this.name + "正在蹬腿游泳");
}
}
//鸭子跑、飞、游
class Duck extends Animal implements IRunning, ISwimming, IFlying {
public Duck(String name) {
super(name);
}
@Override
public void fly() {
System.out.println(this.name + "正在用翅膀飞");
}
@Override
public void run() {
System.out.println(this.name + "正在用两条腿跑");
}
@Override
public void swim() {
System.out.println(this.name + "正在漂在水上");
}
}
public class Solution {
public static void main(String[] args) {
Cat cat = new Cat("小猫");
cat.run();
Fish fish = new Fish("小鱼");
fish.swim();
Frog frog = new Frog("青蛙");
frog.run();
frog.swim();
Duck duck = new Duck("鸭子");
duck.run();
duck.swim();
duck.fly();
}
}

时刻牢记多态的好处, 忘记类型. 有了接口之后, 类的使用者就不必关注具体类型, 而只关注某个类是否具备某种能力。

接口间的继承

接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字.

interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
}
class Frog implements IAmphibious {
...
}

通过接口继承创建一个新的接口 IAmphibious 表示 “两栖的”. 此时实现接口创建的 Frog 类, 就继续要实现 run 方法,也需要实现 swim 方法。

总结

核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法.

如之前写的 Animal 例子. 此处的 Animal 中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此此处的 Animal 只能作为一个抽象类, 而不应该成为一个接口.

class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
}

抽象类和接口的区别

最后

以上就是专注小兔子为你收集整理的『JavaSE』抽象类与接口的全部内容，希望文章能够帮你解决『JavaSE』抽象类与接口所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。