导航：首页 > 开发技术 >

Java抽象类与接口怎么掌握

发表于：2025-01-16 作者：千家信息网编辑

千家信息网最后更新 2025年01月16日，本文小编为大家详细介绍"Java抽象类与接口怎么掌握"，内容详细，步骤清晰，细节处理妥当，希望这篇"Java抽象类与接口怎么掌握"文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧

千家信息网最后更新 2025年01月16日Java抽象类与接口怎么掌握

本文小编为大家详细介绍"Java抽象类与接口怎么掌握"，内容详细，步骤清晰，细节处理妥当，希望这篇"Java抽象类与接口怎么掌握"文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧。

abstract

abstract介绍:可以用于修饰：类（抽象类）、方法（抽象方法）

abstract修饰类：

①此类不能实例化（也就是不能创建这个类的对象)

②虽然自己不能实例化，但是子类会调用父类的构造器，所以抽象类中一定有构造器

abstract修饰方法

①抽象方法只有方法的声明没有方法体，所在的类一定是抽象类。因为如果类不是抽象的，那这个类就可以造对象，可以造对象就可以调用。反之抽象类中可以没有抽象方法。

② 若子类重写了子类重写了父类所有的抽象方法才能实例化，如果没有全部重写，那么子类也是抽象类，也需要用abstract修饰。

③abstract不能用来修饰私有方法、静态方法、final关键字修饰的方法、final关键字修饰的类。

final明确不能继承，但abstract需要子类继承所以不能用,因为如果两个方法都是static，不认为两个方法是重写或者覆盖，所以abstract用来修饰静态方法，就无法重写。

抽象的应用

模板方法设计模式。在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤在父类中写好，某些易变的和不确定的部分可以抽象出来给子类实现。

抽象类的匿名子类对象

public static void main(String[] args){    //匿名对象    eat(new son());    //非匿名类的非匿名对象    son John=new son();    eat(John);    //匿名子类对象    father f=new father(){//抽象类造对象必须要重写方法，了解看得懂就ok了。        @Override        public void work() {        }        @Override        public void info(father i) {        }    };}//普通方法public static void eat(father f){    System.out.println("吃饭");}//父类public abstract static class father{    String name;    int age;    public abstract void work();//抽象方法不能有方法体    public abstract void info(father i);}//子类public class son extends father{//继承    String name;    int age;    @Override    public void work(){        System.out.println("上学");    }    @Override    public void info(father i) {        System.out.println("name:"+i.name+" age:"+i.age);    }}//接口的匿名对象非匿名的对象可以被多次调用，匿名的对象只能使用一次Computer com=new Computer();//创建了接口的非匿名实现类（子类）的非匿名对象，类和对象都是有名的Flash flash = new Flash();//2.创建了接口的非匿名实现类的匿名对象，对象匿名了com.transferData(new Printer());//3创建了接口的匿名实现类的非匿名对象,就是类是匿名的，就不知道是接口中的哪个实现类，所以 需要重写方法进行说明USB  phone = new USB{    public void start(){        ...    }};//4.创建了接口的匿名实现类的匿名对象com.transferData(new USB(){    public void start(){        ...    }      });

final关键字

final修饰类：此类不能被其他类所继承，比如：String、System、StringBuffer

final修饰方法：此方法不能再被重写，比如：Object类中的getClass()

static final用来修饰属性：全局常量

final修饰变量：此时的变量就称为是一个常量

final修饰属性：可以考虑赋值的位置：显式初始化，代码块中初始化、构造器中初始化

final修饰局部变量：尤其是用final修饰形参时，表明此形参是一个常量，当调用此方法时，给常量形参赋实参，一旦赋值就只能在方法体内使用此形参，但不能重新赋值

接口

接口使用Interface来定义，和类是并列关系

接口的定义以及接口中的成员：

接口相关规则

1.接口中所有方法都是抽象的。

2.即使没有显式的将接口中的成员用public标示，也是public访问类型的

3.接口中变量默认用 public static final标示，所以接口中定义的变量就是全局静态常量。

4.可以定义一个新接口，用extends去继承一个已有的接口

5.可以定义一个类，用implements去实现一个接口中所有方法。

6.可以定义一个抽象类，用implements去实现一个接口中部分方法。

接口的特性

1.接口不可以被实例化

2.实现类必须实现接口的所有方法

3.实现类可以实现多个接口

4.接口中的变量都是静态常量

如果类覆盖了接口中所有的抽象方法，则可以创造实例；如果类没有覆盖接口中所有的抽象方法，则该类仍为抽象类。Java类可以实现多个接口——弥补了单继承性的缺陷

class AA extends BB implements CC,DD,EE

接口和接口之间可以继承，且可以多继承。接口的使用体现了多态性。接口是一种规范，面向接口编程。

抽象类和接口的异同

相同点：不能实例化，都可以包含抽象方法

不同点：

1. 把抽象类和接口（java7、java8)的定义、内部结构解释说明

2. 类：单继承性，接口：多继承性。

抽象类与接口的练习

 abstract class Door {    //开门    public abstract void openDoor();    //关门    public abstract void closeDoor();} interface Lock {    public static final int num = 200;    //开锁    public abstract void openLock();    //上锁    public abstract void closeLock();}class LockDoor extends Door implements Lock {    public void openDoor() {        System.out.println("开门");    }    public void closeDoor() {        System.out.println("关门");    }    public void openLock() {        System.out.println("开锁");    }    public void closeLock() {        System.out.println("上锁");    }  }public class TestLockDoor {    public static void main(String[] args) {        LockDoor lockDoor = new LockDoor();        lockDoor.openLock();        lockDoor.openDoor();        lockDoor.closeDoor();        lockDoor.closeLock();    }}

接口的应用

两种设计模式

- 代理模式

代理设计就是为其他对象提供一张代理以控制对这个对象的访问

应用场景：安全代理、远程代理、延迟加载

分类：静态代理、动态代理

- 工厂模式

实现创建者和调用者的分离

interface A{    int x=0;}class B{    int x=1;}class C extends B implements A{    public void pX(){        System.out.println(x);    }    public static void main(String[] args){        new C().pX();    }}//问题：编译期不知道是要输出哪个xSystem.out.println(super.x);//这个调用的是父类中的System.out.println(A.x);//这个调用的是接口中的

java8中接口新特性

JDK8：除了全局常量和抽象方法，还可以定义静态方法和默认方法（default关键字修饰）

public interface CompareA{    public static void method1(){  //静态方法          System.out.println("CompareA:北京");      }       public default void method2(){    //默认方法            System.out.println("CompareA:上海");        }  }

接口中定义的静态方法只能通过接口来调用，接口.方法。

通过实现类的对象，可以调用接口中的默认方法，对象.方法。

如果实现类重写了接口中的默认方法，调用时仍然调用的是重写以后的方法

如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法，子类在没有重写此方法的情况下调用的是父类中的方法——类优先原则

如果实现类实现了多个接口，而这个多个接口中定义了同名同参数的默认方法，在实现类没有重写方法的情况下会报"接口冲突"错误，此时需要重写。

如何在子类（或者实现类）调用父类、接口中被重写的方法？接口.super.方法。

内部类

需要关注的问题：如何实例化成员内部类的对象：外部类Person，静态内部类Brain，非静态内部类Lungs，静态成员内部类：new 外部类.内部类()

Person.Brain brain=new Person.Brain();

非静态成员内部类：先造对象，对象.new 内部类()

Person p=new Person();p.Lungs lungs=p.new Lungs();

如何在成员内部类中区分调用外部类的结构

形参直接调，所在类的用this.结构，外部类的用外部类.this.结构

成员内部类和局部内部类在编译以后都会生成字节码文件

成员内部类：外部类.内部类名.class

局部内部类：外部类.数字内部类名.class

在局部内部类的方法中，如果调用局部内部类所在的方法中的局部变量，该局部变量必须用final关键字修饰(JAVA8之后可以不写出来，但仍然还是final的)

public void Person(){    int num=10;    class AA{//局部内部类        public void show(){//局部内部类的方法            num=20;//试图修改会报错            System.out.println(num);//调用局部内部类所在的方法中的局部变量        }    }}

开发中局部内部类的使用

常用的局部内部类：

//方式一public Comparable getCompareble(){    class MyComparable implements Comparable{//局部内部类        public int compareTo(Object o){            return 0;        }    }    return new MyComparable();}//方式二public Comparable getCompareble(){    return new Comparable(){        public int CompareTo(Object o){            return 0;        }    };}

Java允许将一个类A声明在另一个类B中，A为内部类，B为外部类

内部类的分类：成员内部类、局部内部类（方法内，代码块内，构造器内）

成员内部类

作为外部类的成员：可以调用外部类的结构，可以被static修饰

作为一个类：可以定义属性、方法、构造器，可以用final、abstract修饰，可以被继承