Java深入数据结构理解掌握抽象类与接口

2022-05-12 14:57:09 作者：crisp制药

在类中没有包含足够的信息来描绘一个具体的对象，这样的类称为抽象类，接口是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();
    }
}
//问题：编译期不知道是要输出哪个x
System.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修饰，可以被继承

this.name//内部类的属性

Person.this.name//外部类的属性

总结

今天学习了抽象类，final关键字的使用，接口的概念，特点，以及使用方式，内部类。

到此这篇关于Java深入数据结构理解掌握抽象类与接口的文章就介绍到这了,更多相关Java抽象类与接口内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！