抽象类和接口

抽象类

抽象类的概念

一个类没有包含足够多的信息来描述一个具体的对象

抽象类语法

一个类被abstract修饰成为抽象类，抽象类中被abstrsct修饰的成员方法成为抽象方法，抽象方法不能有具体的实现体。

eg.

//抽象类：被abstract修饰的类
public abstract class Shape{
   abstract public void draw();
   abstract void make();
//抽象类中也可以有普通的方法和属性
   publlic int getArea(){
      return  area;
  }
  
}

注意：抽象类也是类，抽象类内部也可以包含普通方法和属性。

抽象类特性

1.抽象类不能直接实例化对象

Shape shape = new Shape();
//编译错误

2.抽象方法不能是private的。

3.抽象方法不能被final和static修饰，因为抽象方法要被子类重写

4.抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，不重写父类抽象方法的话子类也要是抽象类，要被abstract修饰，否则会报错

5.抽象类中不一定包含抽象方法，但是包含抽象方法的类一定是抽象类

6.抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

接口

接口的概念

在java中，接口可以看作是多个类的公共规范，是一种引用数据类型

语法规则

接口的定义格式

public interface IA{
//public abstract 是固定搭配默认就是这个可以省略不写
  public abstract void method();
  void method2();
}

创建接口时，接口的命名一般以I开头

接口的使用

使用接口时使用关键字implements实现

public class Shape implements IA{
  //.....
}

接口的特性

1.接口类型是一种引用类型，不能直接new一个接口对象。

public class TestUSB {
public static void main(String[] args) {
USB usb = new USB();
  }
}
//USB是抽象的，无法实例化

2.接口中的每一个方法都是public 的抽象方法，所以接口中的方法都会默认被public abstract 修饰

使用其他修饰符都会报错。

public interface USB {
// Error:(4, 18) java: 此处不允许使用修饰符private
private void openDevice();
void closeDevice();
}

3.接口中的方法不能再接口中实现，只能由实现接口的类来实现。

public interface USB {
void openDevice();
// 编译失败：因为接口中的方式默认为抽象方法
// Error:(5, 23) java: 接口抽象方法不能带有主体
void closeDevice(){
System.out.println("关闭USB设备");
  }
}

4.重写接口中的方法时，不能使用默认的访问权限

public interface USB {
void openDevice(); // 默认是public的
void closeDevice(); // 默认是public的
}
public class Mouse implements USB {
@Override
void openDevice() {
System.out.println("打开鼠标");
    }
// ...
}
// 编译报错，重写USB中openDevice方法时，不能使用默认修饰符
// 正在尝试分配更低的访问权限; 以前为public

5.接口中含有的变量默认是被public static final修饰

public interface USB {
double brand = 3.0; // 默认被：final public static修饰
void openDevice();
void closeDevice();
}
public class TestUSB {
public static void main(String[] args) {
System.out.println(USB.brand); // 可以直接通过接口名访问，说明是静态的
// 编译报错：Error:(12, 12) java: 无法为最终变量brand分配值
USB.brand = 2.0; // 说明brand具有final属性  不是变量而是一个常量
  }
}

6.接口中不能有静态代码块和构造方法。

7.如果类没有实现接口中的所有抽象方法，则类必须设置成抽象类

实现多个接口

在java中不能实现多继承，但是可以实现多个接口

注意：一个类在实现多个接口时，每个接口中的抽象方法都要重写，否则类必须设置成抽象类

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 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 + "正在蹬腿游泳");
}
}

一个类继承一个父类，同时实现多种接口

继承表达的含义是is  a语义，而接口表达的含义是具有xxx特性

接口间的继承

在java中，类与类之间是单继承，一个类可以实现多个接口，接口与接口之间可以多继承

用接口可以达到多继承的目的。

接口继承一个接口达到复用的效果，用extends关键字实现。

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

接口使用的实例

给对象数组排序

class Student implements Comparable{
    public String name;
    public int score;
   //提供构造方法
    public Student(String name, int sore) {
        this.name = name;
        this.score = sore;
    }

    @Override
    public String toString() {
        return "[" + this.name + ":" + this.score + "]";
    }

    @Override
    public int compareTo(Object o) {
        Student s=(Student)o;
        if(this.score>s.score)
         return -1;
        else if(this.score<s.score)
            return  1;
        else
            return 0;
    }
}

public class Test {
    //给定一个学生对象数组
    Student[] students = new Student[]{
            new Student("张三",95),
            new Student("李四",80),
            new Student("王五",97),
            new Student("大婷",100)

    };
}