Java抽象类接口内部类(详细知识点)

最新推荐文章于 2023-08-06 22:17:54 发布

嘟嘟嘟的小火车

最新推荐文章于 2023-08-06 22:17:54 发布

阅读量743

点赞数 29

分类专栏： # 《javaSE从0到1》文章标签： java eclipse intellij-idea 后端

本文链接：https://blog.csdn.net/weixin_51140943/article/details/124240741

版权

《javaSE从0到1》专栏收录该内容

8 篇文章 5 订阅

订阅专栏

本文详细介绍了Java中的抽象类、接口和内部类。抽象类用于定义规范，不能实例化；接口则更纯粹地定义规范，JDK8后支持默认和静态方法；内部类包括成员、静态、局部和匿名内部类，提供了类的嵌套使用方式。此外，还讨论了static关键字的用法，包括静态属性、方法和代码块。

摘要由CSDN通过智能技术生成

👨‍💻作者简介: 大家好,我是小火车~~,在校大二学生一枚
🛳️个人主页: 嘟嘟嘟的小火车的博客
📗系列专栏: 本文写在《java从0到1》专栏
✉️如果文章知识点有错误的地方,请指正! 和大家一起学习一起进步🎈
🔥如果觉得博主的文章还不错的话,请👍三连支持👍一下博主哦

java抽象类,接口,内部类

一.🥧 抽象类

abstract修饰符可以用来修饰方法也可以修饰类,修饰方法就是抽象方法,修饰类就是抽象类.

package oop.demo12;
//抽象类
public abstract class Action {

    //约束
    //抽象方法 只有方法名字 没有方法实现
    public abstract void doSomething();
}
package oop.demo12;
//继承抽象类的子类必须实现抽象类中的抽象方法
public class A extends Action{
    @Override
    public void doSomething() {

    }
}

抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类.
抽象类,不能使用new关键字来创造对象,它是用来让子类继承的
抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的.
子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类.

二. 🍦接口

2.1🍝约束和实现

普通类:只有具体的实现

抽象类:具体的实现和规范(抽象方法)

接口:只有规范,自己不能写方法约束和实现分离

2.2🍨接口的定义

老版本的定义

接口是一种特殊的抽象类，它不能包含普通方法，其内部的所有方法都是抽象方法，它将抽象进行的更为彻底。

JDK 8接口定义

接口中除了抽象方法外，还可以有默认方法和静态方法（也叫类方法），默认方法使用default修饰，静态方法使用static修改，并且这两种方法都允许有方法体。

2.3🍬接口的实现

[修饰符] interface 接口名 [extends 父接口1,父接口2,…] {

[public] [static] [final] 常量类型常量名 = 常量值;

[public] [abstract] 方法返回值类型方法名([参数列表]);

[public] default 方法返回值类型方法名([参数列表]){

// 默认方法的方法体

}

[public] static 方法返回值类型方法名([参数列表]){

// 类方法的方法体

}

}

package oop.demo13;
//interface 接口定义的关键字,接口都需要有实现类
public interface UserService {
    //接口中的所有属性都是常量public static final
    //不建议使用
    int AGE = 10;

    //接口中的所有定义方法其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

}
package oop.demo13;

public interface TimeService {
    void time();
}
package oop.demo13;
//implements 类实现接口
//利用接口实现伪多继承
//实现了接口的类,就需要实现接口中的方法
public class UserServiceImpl implements UserService,TimeService{

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void time() {

    }
}

修饰符可以使用public或直接省略（省略时默认采用包权限访问控制符）。

在接口内部可以定义多个常量和抽象方法，定义常量时必须进行初始化赋值，定义默认方法和静态方法时，可以有方法体。

在接口中定义常量时，可以省略“public static final”修饰符，接口会默认为常量添加“public static final”修饰符。

与此类似，在接口中定义抽象方法时，也可以省略“public abstract”修饰符，定义default默认方法和static静态方法时，可以省略“public”修饰符，这些修饰符系统都会默认进行添加。

2.4🥧接口中的类

接口中可以包含三类方法:抽象方法、默认方法、静态方法。

静态方法可以通过“接口名.方法名”的形式来调用。

抽象方法和默认方法只能通过接口实现类的实例对象来调用。

接口的实现类，必须实现接口中的所有抽象方法。

[修饰符] class 类名 [extends 父类名] [implements 接口1,接口2,…] {

…

}

package oop.demo13;
//implements 类实现接口
//利用接口实现伪多继承
//实现了接口的类,就需要实现接口中的方法
public class UserServiceImpl implements UserService,TimeService{

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void time() {

    }
}

2.5🍡接口的注意点

从JDK 8开始，接口中的方法除了包含抽象方法外，还包含默认方法和静态方法，默认方法和静态方法都可以有方法体，并且静态方法可以直接通过“接口.方法名”来调用。

当一个类实现接口时，如果这个类是抽象类，只需实现接口中的部分抽象方法即可，否则需要实现接口中的所有抽象方法。

一个类可以通过implements关键字同时实现多个接口，被实现的多个接口之间要用英文逗号（,）隔开。

接口之间可以通过extends关键字实现继承，并且一个接口可以同时继承多个接口，接口之间用英文逗号（,）隔开。

一个类在继承一个类的同时还可以实现接口，此时，extends关键字必须位于implements关键字之前。

三.🫕内部类

3.1🍪什么是内部类？

在Java中，允许在一个类的内部定义类，这样的类称作内部类，这个内部类所在的类称作外部类。

3.2🎂成员内部类

在一个类中除了可以定义成员变量、成员方法，还可以定义类，这样的类被称作成员内部类。说明：在成员内部类中，可以访问外部类的所有成员，包括成员变量和成员方法；在外部类中，同样可以访问成员内部类的变量和方法。

package oop.demo14;

public class Outer {

    private int id = 10;
    public void out(){
        System.out.println("这是外部类方法");

    }
    //定义内部类
    class Inner{
        public void in(){
            System.out.println("这是内部类方法");
        }
        //成员的访问
        public void getId(){
            System.out.println(id);
        }
    }
    
}
package oop.demo14;

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //实例化
        Outer.Inner inner =outer.new Inner();
        inner.in();
    }
}

3.3🍰静态内部类

所谓静态内部类，就是使用static关键字修饰的成员内部类。

静态内部类在成员内部类前增加了static关键字，在功能上，静态内部类中只能访问外部类的静态成员，同时通过外部类访问静态内部类成员时，可以跳过外部类从而直接通过内部类访问静态内部类成员。

package oop.demo14;

public class Outer2 {
    private static int id = 10;
    public void out(){
        System.out.println("这是外部类方法");

    }
    static class Inner2{
        public  void in(){
            System.out.println("这是内部类方法");
        }
        public void getId(){
            System.out.println(id);
        }
    }
}
package oop.demo14;

public class Application {

    public static void main(String[] args) {
        Outer2.Inner2 inner2 =new Outer2.Inner2();
    }

}

3.4🍧局部内部类

局部内部类，也叫做方法内部类，就是定义在某个局部范围中的类，它和局部变量一样，都是在方法中定义的，其有效范围只限于方法内部。

在局部内部类中，局部内部类可以访问外部类的所有成员变量和方法，而局部内部类中的变量和方法却只能在创建该局部内部类的方法中进行访问。

package oop.demo14;

public class Outer3 {
    public void method(){
        //局部变量类
        class Inner3{
            public void in(){
                
            }
        }
    }
}

3.5🥣匿名内部类

匿名内部类其实就是没有名称的内部类。

在调用包含有接口类型参数的方法时，通常为了简化代码，可以直接通过匿名内部类的形式传入一个接口类型参数，在匿名内部类中直接完成方法的实现。

从JDK 8开始，允许在局部内部类、匿名内部类中访问非final修饰的局部变量，而在JDK 8之前，局部变量前必须加final修饰符，否则程序编译报错。

package oop.demo14;

public abstract class Transport {
    public abstract void run();

}
package oop.demo14;

public class Outer4 {
    public static void main(String[] args) {
        //匿名内部类
        Transport transport = new Transport() {
            @Override
            public void run() {
                System.out.println("小火车在跑");
            }
        };
    }
}

四.🥮static关键字

4.1🥖静态属性

package oop.demo11;

public class Student {
    private static int age;//静态的变量
    private double score;//非静态的变量

    public static void main(String[] args) {
        Student s1 = new Student();

        System.out.println(Student.age);
        System.out.println(s1.age);
        System.out.println(s1.score);
    }
}

4.2🍞静态方法

package oop.demo11;

public class Student {
    private static int age;//静态的变量
    private double score;//非静态的变量

    public static void main(String[] args) {
        Student s1 = new Student();
        run();//静态方法直接调用
        s1.go();//非静态方法通过创建对象调用
        
    }

    public static void run(){
        System.out.println("run");
    }
    public void go(){
        System.out.println("go");
    }

}

4.3🍔静态代码块

package oop.demo11;

public class Person {
    //2.赋初始值
    {
        //代码块(匿名代码块)
        //在对象创建时执行,在构造器之前
        System.out.println("匿名代码块");
    }
    //1.
    static {
        //静态代码块
        //和类同时进行 只被执行一次
        System.out.println("静态代码块");
    }
    //3.
    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("=================");
        Person person1 = new Person();
    }
}

4.4🥣静态导入包

package oop.demo11;

import static java.lang.Math.PI;

public class Application {
    public static void main(String[] args) {
        System.out.println(Math.random());
        System.out.println(PI);
    }
}