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

时间：2023-01-07 09:28:39|栏目：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修饰，可以被继承