抽象类&接口

1.抽象类

抽象类: 若一个类没有足够的信息来描绘一个具体对象,这样的类称为抽象类
一般用在体系结构的顶层用来进行功能的定义声明

package Test.abstractdemo;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

/*
    抽象方法:只有声明,没有实现(没有方法体):
    形如  public abstract void display();

注意:
    抽象类中可以没有抽象方法
    但抽象方法必须在抽象类中
 */
public abstract class People {
    //属性
    String name;//名字
    int age;//年龄

    /*
    抽象方法:
    abstract [返回值类型] 方法名(参数列表);
     */
    abstract String travelMode(String travel);//出行方式
    abstract String restTime(String rest);//休息时间

    /*
    构造方法
    抽象类可以拥有构造方法,但不能实例化对象
     */

    public People(){
        System.out.println("父类无参构造");
    }

    public People(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("父类有参构造");
    }

    void commonMethod(){
        System.out.println("普通父类方法");
    }
}

/*Class 'Student' must either be declared abstract or implement abstract method 'travelMode(String)' in 'People'
    若一个类继承了抽象类,则
    要么重写抽象类的所有抽象方法
    要么该类需定义为抽象类
    */
//学生类
class Student extends People{

    //重写抽象方法
    @Override
    String travelMode(String travel) {
        return name+"的出行方式: "+travel;
    }

    @Override
    String restTime(String rest) {
        return name+"休息时间: "+rest;
    }

    //重写构造方法
    public Student() {
        super();
        System.out.println("子类无参构造");
    }

    public Student(String name, int age) {
        super(name, age);
        System.out.println("子类有参构造");
    }

    //重写普通方法
    @Override
    void commonMethod() {
        System.out.println("子类普通方法");
    }
}
//工人类
class Worker extends People{

    @Override
    String travelMode(String travel) {
        return "工人出行方式: "+travel;
    }

    @Override
    String restTime(String rest) {
        return "工人休息时间: "+rest;
    }
}

package Test.abstractdemo;
//测试例
import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        //People p=new People();
        //报错:'People' is abstract; cannot be instantiated People是抽象的 ,不能实例化

        Student s = new Student("张一",21);
        System.out.println(s.restTime("23:30"));
        System.out.println(s.travelMode("步行"));

        Worker w = new Worker();
        System.out.println(w.restTime("打车"));
        System.out.println(w.travelMode("22;00"));

    }
}

运行结果:

package Test.abstractdemo;
public class Test1 {
    public static void main(String[] args) {
        Test1 t = new Test1();
        People student = new Student("张三",20);
        People worker = new Worker();//没有继承构造方法,默认调用父类无参构造方法

        t.restTime(student,"23:00");
        t.restTime(worker,"22:00");

        student.commonMethod();
        worker.commonMethod();//先在子类里寻找此方法,子类没有重写此方法,在父类调用此方法
    }

    //多态优点,提高程序扩展性
    public void restTime(People p,String s){//使People的引用都能使用这个方法
        System.out.println(p.restTime(s));

    }
}

2.接口

接口: 是一个抽象类型，是抽象方法的集合 .

类描述对象的属性和方法。接口则包含类要实现的方法.

属性:默认 public static final 数据类型 变量名;(此处的变量值必须直接赋值)

抽象方法:默认 public abstract 返回值 方法名(参数列表);

接口中的属性全为常量,必须声明时就赋值初始化,因为接口没有构造方法

接口中的方法只有抽象方法,默认方法,静态方法

四个接口:

package Test.interfacedemo;
/*
    接口: 一个抽象类型，是抽象方法的集合
    接口中的属性默认public final static修饰
          方法默认public abstract修饰
 */
public interface InterfaceA {
    //接口中的属性都是静态常量,方法只有抽象方法,默认方法,静态方法
    //public final static String s = "InterfaceA";
    String s = "InterfaceA";

    //抽象方法
    //public abstract void eat();
    void eat();
}

interface InterfaceB{

    void sleep();

}

interface InterfaceC extends InterfaceA,InterfaceB{
	//接口可同时继承多个接口,同时继承父接口抽象方法
    
    //通过子类调用default方法,子类可重写它也可不重写
    default void defaultMethod(){
        System.out.println("默认方法");
    }
    //静态方法可直接接口名调用
    static void staticMethod(){
        System.out.println("静态方法");
    }

}

interface InterfaceD{
    void run();//抽象方法
}

package Test.interfacedemo;
/*
    一个类要实现接口
    要么实现所有接口的所有抽象方法
    要么将该类定义为抽象类
 */
public class ImplementsDemo extends Object implements InterfaceC,InterfaceD{
	//一个类可直接继承一个类,但可以同时实现多个接口
    
    //重写抽象方法
    @Override
    public void eat() {
        System.out.println("接口A:吃东西");
    }

    @Override
    public void sleep() {
        System.out.println("接口B:睡觉");
    }

    @Override
    public void run() {
        System.out.println("接口D:run");
    }
}

package Test.interfacedemo;
public class Test {
    public static void main(String[] args) {
        ImplementsDemo i = new ImplementsDemo();
        i.eat();
        i.sleep();
        i.run();
        i.defaultMethod();
        InterfaceC.staticMethod();//接口名调用静态方法
        System.out.println(InterfaceA.s);//接口名调用静态常量
    }
}

运行结果:

package Test.interfacedemo;
//People接口
public interface People {
    //抽象方法
    void eat();
    void play();
}
//Child类
class Child implements People{

    @Override
    public void eat() {
        System.out.println("吃一点");
    }

    @Override
    public void play() {
        System.out.println("多玩点");
    }
}
//Adult类
class Adult implements People{

    @Override
    public void eat() {
        System.out.println("吃多点");
    }

    @Override
    public void play() {
        System.out.println("晚一点");
    }
}

测试

package Test.interfacedemo;

public class PeopleTest {
    //接口的多态性
    People p = new Child();
    People p1 = new Adult();
}

3.接口与抽象类的异同

注意:Extension methods can only be used within an interface

默认方法只存与接口中,与静态方法是Java 8 以后新增的特性