Java抽象类与接口代码详解

自学JavaDay12

abstract关键字

package com.oop.demo09;

/*
abstract关键字的使用

1. abstract可以用来修饰的结构：类、方法

2. abstract修饰类：抽象类
    >此类不能实例化
    >抽象类中一定有构造器，子类实例化时调用
    >开发中会提供抽象类的子类，利用子类实例化完成操作

3. abstract修饰方法：抽象方法
    >只有方法的声明，没有方法体
    >包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法
    >子类需重写父类中所有抽象方法，方可实例化。若没有重写所有的抽象方法，则子类也声明为abstract

4. abstract使用上的注意点
    4.1 abstract不能用来修饰：属性、构造器等结构
    4.2 abstract不能用来修饰私有方法、静态方法、final的方法和类

5. 抽象类的匿名子类
 */

public class AbstractTest {

    public static void main(String[] args) {

//        一旦Person类声明为abstract，不能实例化
//        Person p1= new Person();
//        p1.eat();

        method(new Student());//匿名对象

        method1(new Student());//非匿名的类的匿名的对象

        //创建了一匿名子类的的对象，p
        Person p = new Person(){

            @Override
            public void breathe() {
                System.out.println("p呼吸");
            }

            @Override
            public void show() {
                System.out.println("p是人");
            }

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

            @Override
            public void walk() {
                System.out.println("p走路");
            }
        };

        method1(p);

        //创建匿名子类的匿名对象
        method1(new Person() {
            @Override
            public void show() {
                System.out.println("匿名子类的匿名对象是人");
            }

            @Override
            public void breathe() {
                System.out.println("匿名子类的匿名对象呼吸");
            }

            @Override
            public void eat() {
                System.out.println("匿名子类的匿名对象吃饭");
            }

            @Override
            public void walk() {
                System.out.println("匿名子类的匿名对象走路");
            }
        });

    }

    public static void method(Student s){

    }

    public static void method1(Person p){
        p.eat();
        p.walk();
    }
}

abstract class Creature{
    public abstract void breathe();
}

abstract class Person extends Creature{

    String name;
    int age;

    public Person(){

    }

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    public abstract void show();

    public void eat(){
        System.out.println("人吃饭");
    }

    public void walk(){
        System.out.println("人走路");
    }

}

class Student extends Person{

    public Student() {
    }

    public Student(String name, int age) {
        super(name, age);
    }

    @Override
    public void show() {
        System.out.println("我是一个学生");
    }

    @Override
    public void breathe() {
        System.out.println("呼吸新鲜空气");
    }

    @Override
    public void eat() {
        System.out.println("学生吃饭");
    }

    @Override
    public void walk() {
        System.out.println("学生走路");
    }
}

模板方法的设计模式（TemplateMethod）

package com.oop.demo09;

/*
抽象类的应用：模板方法的设计模式
 */

public class TemplateTest {

    public static void main(String[] args) {

        SubTemplate subTemplate = new SubTemplate();

        subTemplate.spendTime();

    }
}

abstract class Template{

    //计算某段代码所花费的时间
    public void spendTime(){

        long start = System.currentTimeMillis();

        this.code();//不确定的部分、易变的部分

        long end = System.currentTimeMillis();

        System.out.println("花费的时间为：" + (end - start));

    }

    public abstract void code();
    
}

class SubTemplate extends Template{

    @Override
    //输出100以内的质数
    public void code() {

        boolean isFlag = true;
        for (int i = 2; i <= 1000; i++) {
            for (int j = 2; j <= Math.sqrt(i); j++) {
                if(i % j == 0){
                    isFlag = false;
                    break;
                }
            }
            if(isFlag){
                System.out.print(i + "\t");
            }
            isFlag = true;//每次循环末尾重置isFlag
        }

    }
}

接口

package com.oop.demo10;

/*
接口的使用

1. 接口使用interface定义

2. Java中，接口和类是并列的两个结构

3. 如何定义接口：定义接口中的成员

    3.1 JDK7及以前：只能定义全局常量和抽象方法
        >全局常量：public static final，书写时可以省略接口
        >抽象方法：public abstract

    3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法

4. 接口中不能定义构造器，意味着接口不可以实例化

5. Java开发中，接口通过让类去实现的方式来使用（implements）
   如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
   如果实现类没有覆盖接口中所有的抽象方法，则此实现类必须声明为abstract

6. Java类可以实现多个接口--->弥补了Java单继承性的局限性
    格式：class AA extends BB implements CC,DD,EE

7. 接口与接口之间可以继承，而且可以多继承

8. 接口的使用体现了多态性

9. 接口实际上可以看作是一种规范

面试题：抽象类与接口有哪些异同？
 */

import javax.net.ssl.SSLProtocolException;

public class InterfaceTest {

    public static void main(String[] args) {

        System.out.println(Flyable.MAX_SPEED);

//        Flyable.MIN_SPEED = 2;

        Plane plane = new Plane();
        plane.fly();

    }
}

interface Flyable{

    //全局常量
    public static final int MAX_SPEED = 7900;
    int MIN_SPEED = 1;//省略 public static final

    //抽象方法
    public abstract void fly();

    void stop();//省略 public abstract

}

interface Attackable{

    void attack();

}

class Plane implements Flyable{

    @Override
    public void fly() {
        System.out.println("芜湖起飞");
    }

    @Override
    public void stop() {
        System.out.println("肉蛋葱鸡");
    }
}

abstract class Kite implements Flyable{

    @Override
    public void fly() {

    }
}

class Bullet extends Object implements Flyable,Attackable,CC{

    @Override
    public void fly() {

    }

    @Override
    public void stop() {

    }

    @Override
    public void attack() {

    }

    @Override
    public void methodA() {

    }

    @Override
    public void methodB() {

    }
}

//**************************************************************

interface AA{
    void methodA();
}

interface BB{
    void methodB();
}

interface CC extends AA,BB{

}

JDK8中新特性

package com.oop.demo10.newinjdk8;

/*
JDK8中的新特性
 */

public class SubClassTest {

    public static void main(String[] args) {

        SubClass s = new SubClass();

        //知识点1：接口中定义的静态方法，只能通过接口来调用
//        s.method1();

        //知识点2：通过实现类的对象，可以调用接口中的默认方法
        CompareA.method1();
        s.method2();

        //如果实现类重写了接口中的默认方法，调用时调用的是实现类中重写的方法
        s.method3();

        //知识点3：如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法，
        //那么子类在没有重写此方法的情况下，默认调用的是父类中的方法--类优先原则
        //知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法
        //那么实现类没有重写此方法的情况下，报错-->接口冲突
        s.method4();
    }

}

class SubClass extends SuperClass implements CompareA,CompareB{

    public void method3(){
        System.out.println("compareA：默认方法2SubClass重写");
    }

    @Override
    public void method4() {
        System.out.println("SubClass：方法");
    }

    //知识点5：如何在子类（或实现类）的方法中调用父类、接口中被重写的方法
    public void myMethod(){
        method4();//调用的自定义重写方法
        super.method4();//调用父类中声明的方法
        //调用接口中的默认方法
        CompareA.super.method4();
        CompareB.super.method4();
    }
}

interface CompareA {

    public static void method1(){
        System.out.println("compareA：静态方法");
    }

    public default void method2(){
        System.out.println("compareA：默认方法1");
    }

    default void method3(){
        System.out.println("compareA：默认方法2");
    }

    default void method4(){
        System.out.println("compareA：默认方法3");
    }
}

interface CompareB{

    default void method4(){
        System.out.println("compareB：默认方法3");
    }
}

class SuperClass{

    public void method4(){
        System.out.println("SuperClass：方法");
    }
}