【JavaSE基础】接口和抽象类

抽象

1、抽象类

在 Java 面向对象当中，所有的对象都是用过类进行描绘的，但是并不是所有的类都是用来描绘对象的，如果一 个类中没有包含足够的信息来描绘一个具体的对象，我们把这种类定义为抽象类。

抽象类的特征：

1、 不能用来实例化对象，所以抽象类必须被继承才能够被使用，其他的功能和普通类相同。

2、 一个类只能继承一个抽象类。

3、 抽象类的修饰符不能是 private。

2、抽象方法

如果想要设计一个类，该类包含一个特别的成员方法，该方法是根据子类的行为来确定的，那么在父类中将这个 方法声明为抽象方法。继而含有抽象方法的类称为抽象类。

抽象方法的注意点

1、 抽象类中不一定含有抽象方法，但是有抽象方法的类一定是抽象类。

2、 构造方法，类方法（static 修饰的方法）不能声明为抽象方法。

3、 抽象类的子类必须给出抽象类中抽象方法的实现，除非该子类也是一个抽象类。

4、 抽象方法的修饰符不能是 private。

一个类在被继承时某一个方法总要被重写，可将其设置为抽象方法，有抽象方法的类被称为抽象类，该类在被继承时抽象方法必须进行重写。

• 含有抽象方法的类一定是抽象类
• 抽象类中必定含有抽象方法

抽象类与普通类的区别

• 普通类：实例化new 抽象类不允许实例化对象
• 抽象类可以含有抽象方法

abstract class Employee{//抽象类
    private String name;
    private String address;
    private int number;
    public Employee(String name, String address, int number) {
        super();
        this.name = name;
        this.address = address;
        this.number = number;
    }
    public void mailCheck(){
        System.out.println("mailing a check to" + this.name+" "+this.address);
    }
    public void setAddress(String newaddress){
        address = new address;
    }
    public abstract void fun();//定义抽象方法
}
class ExtendsEmployee extends Employee {//继承抽象类必须实现抽象方法
    public ExtendsEmployee(String name, String address, int number) {
        super(name, address, number);
        // TODO Auto-generated constructor stub }
        @Override public void fun () {//抽象方法的实现
            // TODO Auto-generated method stub
        }
    }
    public class TestDemo {
        public static void main(String[] args) {
            Employee e = new Employee();//error 不能用抽象类实例化对象
        }
    }
}

接口

在抽象类中，可以包含一个或多个抽象方法，但是在接口中，所有的方法必须是抽象的，不能有方法体，他比 抽象类更加的抽象。接口规定一个类必须做什么而不规定他如何去做。

接口中生命的成员变量默认都是 public static final 的，必须显示的初始化。因而在常量声明时可以省略这些修饰 符。是若干常量和抽象方法的集合。

1、接口的特征

1、 接口中只定义抽象方法，这些方法默认都是 public abstract 的，在方法声明时可以省略这些修饰符。

2、 在接口中定义实例变量，非抽象实例方法以及静态方法都是不允许的。

3、 接口中没有构造方法，也不能被实例化。

4、 一个接口不能实现另一个接口，但是可以多继承其他接口。

2、接口的使用

1、 接口的使用与类的使用有些不同，在需要使用类的地方，会直接进行 new 关键字来创建一个类的实例，但是接口不行。

2、 接口必须通过类来实现他的抽象方法。

3、 如果一个类不能实现完接口中的抽象方法，那么这个类我们应该设计为抽象类。

4、不允许创建接口的实例，但是允许定义接口类型的引用变量引用实现该接口的类的实例。

interface InterfaceClass{
    int a=10;//只能是 public static final 进行修饰接口变量，必须初始化
    void fun();//默认的修饰符是 public abstract，不能用其他修饰符进行修饰操作
}
class AchieveInterface implements InterfaceClass{
    @Override public void fun() {
        // TODO Auto-generated method stub
    }
}

3、接口的应用

观察程序的代码：

Interface Fruit{
    Publicvoideat();
}
Class AppleimplementsFruit{
        Publicvoideat(){
            System.out.println(“吃苹果”);
        }
}
Public class TestDemo{
    Public static void main(String[]args){
        Fruitf = new Apple();
        f.eat();
    }
}

本程序在主类中通过 Apple 类实例化 Fruit 接口对象，通过接口对象调用 eat 方法，调用的是被重写过的方法。

本程序在接口的实例化中明确要调用的子类对象。但是，一个父类所派生出来的子类不止一个。Class Orange implements Fruit{ }. main: Fruit f = new Orange(); 难道每一次都要修改实例化接口的子类吗？

在 Java 中的 JVM 为了解决程序与操作系统之间的耦合问题，在程序与操作系统之间加了一个中间过渡层-JVM，由 JVM 匹配不同的操作系统，只要 JVM 核心不变，程序就可以在任意的操作系统间进行移植。

想办法只让用户看到接口而不必看到子类：

添加一个工厂类进行过渡

Class Factory{
    Public static FruitgetInstance(StringclassName){
        if(className.equals(“apple”)){
            ReturnnewApple();
        }
        if(className.equals(“orange”)){
            ReturnnewOrange();
        }
    }
}
Main: 
Fruit f = Fruit.getInstance(“apple”); 
f.eat();

接口里面只存在两项：

• 1、 常量 -> public static final -> 默认修饰符

• 2、 抽象方法 -> public abstract -> 默认修饰符

与类的关系：实现 -> class Name implements Name(interface)

接口和抽象类

接口和接口之间的关系：继承关系

interface A{
	void funA();
}
interface B extends A{
	void funB();//B接口中包含两个抽象方法
}

接口和类之间的关系：实现关系

class 类名 implements 接口{ }

类 -> 单一继承，多实现

既有实现又有继承

class 类名 extends 类名 implements 接口名，接口名{ }

接口和抽象类的区别

抽象类：一个类在被继承时某一个方法总要被重写

接口：给外界提供统一函数方法名