JavaSE_11_抽象类、接口、内部类

柳絮，曾轻语

于 2023-06-14 10:20:58 发布

阅读量56

点赞数 1

文章标签： java jvm 数据库

本文链接：https://blog.csdn.net/weixin_42788897/article/details/131189263

版权

《抽象类、接口、内部类》

一、抽象类

abstract修饰的类称之为抽象类，abstract修饰的方法称之为抽象方法，其有以下特点：

抽象类必须被继承（因此不能与final同用），且不能被直接实例化；
抽象方法只有方法主干，但没有方法体（即只定义业务需求，但没有实现过程）。

案例一

package com.hpr.entity;

public abstract class Animal {

    public String name;
    public int age;

    public void speak() {
        System.out.println("动物讲话方式");
    }

    //抽象方法：只有方法主干，没有方法体
    public abstract void sleep();
}

子类继承抽象类后，必须重写抽象方法

package com.hpr.child;

import com.hpr.entity.Animal;

public class Cat extends Animal {

    @Override
    public void sleep() {
        System.out.println("猫咪正在打瞌睡...");
    }
}

二、接口

接口（interface）在Java编程语言中是一个抽象类型，是抽象方法和常量值的集合。继承讲求“是不是”，注重父子类关系，而接口讲求“有没有”，注重是否具备某些功能。

Java中类为单继承，但接口可多实现；
接口中的变量全部为常量（public static final）；
接口与接口之间可多继承。

请添加图片描述

案例二

Action接口

package com.hpr.infc;

public interface Action {

    int AGE_RANGE = 10;

    void run();

    void speak();

    void fly();

}

Bird类

package com.hpr.entity;

import com.hpr.infc.Action;

public class Bird extends Animal implements Action {

    @Override
    public void sleep() {
        System.out.println("小鸟正在休息...");
    }

    @Override
    public void run() {
        System.out.println("小鸟正在奔跑...");
    }

    @Override
    public void fly() {
        System.out.println("小鸟正在飞翔...");
    }
}

测试类

package com.hpr.test;

import com.hpr.entity.Bird;
import com.hpr.infc.Action;

public class Test {
    public static void main(String[] args) {
        //多态写法
        Action a = new Bird();
        a.fly();
    }
}

执行结果

请添加图片描述

概念小结

类：全具体；
抽象类：半具体半抽象；
接口：近乎全抽象（Java8新增了static方法和default方法）。

三、内部类

内部类即“类中类”，主要作用是实现只有类才能实现的部分功能。

常规内部类（需先实例化外部类，再使用外部类对象实例化内部类）

package com.hpr.inner;

public class CommonInner {

    class Inner {
        int x = 1;
        int y = 2;

        public void test() {
            System.out.println("常规内部类...");
        }
    }

    public static void main(String[] args) {
        CommonInner out = new CommonInner();
        Inner inner = out.new Inner();
        inner.test();
    }
}

静态内部类（不用先实例化外部类，可直接实例化内部类）

package com.hpr.inner;

public class StaticInner {

    static class Inner {
        int x = 1;
        int y = 2;

        public void test() {
            System.out.println("静态内部类...");
        }
    }

    public static void main(String[] args) {
        StaticInner.Inner inner = new Inner();
        inner.test();
    }
}

方法局部内部类（只能在该方法中实例化，同时对所在方法的变量只能访问，不能修改）

package com.hpr.inner;

public class MethodInner {

    public void aa() {
        int x = 1;

        class Inner {
            int y = 2;

            public void test() {
                System.out.println(x + y);
//                x=3;      //报错，方法局部内部类只能使用所在方法变量，但不能改变其变量值
                y = 4;
            }
        }
        //在当前方法中实例化
        new Inner().test();
    }
}

匿名内部类（将接口或抽象类间接实例化）

package com.hpr.test;

import com.hpr.entity.Animal;

public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal() {
            @Override
            public void sleep() {
                System.out.println("匿名内部类实现...");
            }
        };
        animal.sleep();
    }
}