Java SE--抽象类和接口-EW帮帮网

一.抽象类概念

一个类中没有包含足够的信息描述一个对象时，就可以作为抽象类

二.抽象类的语法

1.用关键字abstract进行修饰的类就是抽象类

2.用关键字abstract进行修饰的方法就是抽象方法（可有可无），抽象方法不用具体实现

3.抽象类也是类，可以增加普通方法、构造方法和成员变量

三.抽象类特性

1.抽象类不可以实例化,只能被继承，如果抽象类有抽象方法则子类必须重写父类的方法（不重写会报错），或者该子类也是抽象类

2.抽象方法不可以被prviate、final、static修饰（原因是必须满足重写的要求）

四.为何使用抽象类？

由上述共能可知抽象类的好处：

1.如之前写的Aminal、Shape中的一些方法被子类方法重写，不需要具体实现，就可以将这些类定义为抽象类，而抽象类可以有抽象方法，符合不需要具体实现的要求

2.可以对重写的方法进行验证

五.接口概念

接口可以看作公共的行为标准（能力），只要符合规范标准，就可以通用.如跑步的行为，狗能接受这个标准，而鱼就不能

六.接口语法

1.将关键字class换成关键字 interface,定义格式和继承一样

2.普通方法会默认加上public abstract，成员变量会默认加上public static final且得初始化

3.接口是引用类型，不是类，不能实例化，字节码文件后缀还是 .class 文件

七.接口使用

在类和类得继承中用 extends (单词意思为扩展)，在类和接口中用 implements (单词意思为实现)

八.接口和类中成员对比

成员类型	接（Interface）	类（Class）	原因
成员变量（实例变量）	❌ 不允许	✅ 允许	接口只定义行为契约，不维护状态，因此不能有实例变量。
常量（`public static final`）	✅ 允许（默认）	✅ 允许（需显式声明）	接口可以定义全局常量，但必须是 `public static final`（默认隐式）。
抽象方法（`public abstract`）	✅ 允许（默认）	✅ 允许（需显式 `abstract`）	接口的核心是定义方法规范，所有方法默认是 `public abstract`。
默认方法（`default`）	✅ 允许（Java 8+）	❌ 不允许（普通方法自带实现）	默认方法允许接口提供默认实现，避免破坏现有代码。
静态方法（`static`）	✅ 允许（Java 8+）	✅ 允许	静态方法属于类/接口级别，不依赖实例。
私有方法（`private`）	✅ 允许（Java 9+）	✅ 允许	私有方法用于接口内部代码复用，不暴露给实现类。
构造方法（Constructor）	❌ 不允许	✅ 允许	接口不能被实例化，因此不需要构造方法。
初始化块（`{}` / `static{}`）	❌ 不允许	✅ 允许	接口不能包含状态，因此不需要初始化逻辑。
嵌套类/接口	✅ 允许	✅ 允许	接口和类都可以包含嵌套类型。

接口应用举例：

九.多个接口使用和继承

在继承中不可以多继承，而一个类可以有多个接口例子如下：

十.接口继承接口

接口和接口之间的继承也用extends，用此可以达到多继承的效果

十一.Object类

Object是默认提供的一个类。所有类都会默认继承 Object 类，所有的类的对象都可以被 Object引用接收，Object 也定义了一些方法

1.对象比较equals方法

应用：

2.hashcode方法（了解）

功能：可以得出对象的位置，如果对象的成员变量相同则在同一位置

3.toString方法

十二.内部类(类和对象补充)

在Java中可以将一个类定义在另一个类中或方法中，在内部为内部类，外部为外部类

主要分为 静态内部类、实例内部类、匿名内部类

1.实例内部类

public class OutClass {
    private int a;
    static int b;
    int c;
    public void methodA{
    a=10;
    System.out.printin(a);
  }
public static void methodB(){
    System.out.printIn(b);
  }
//实例内部类:未被static修饰
class InnerClass{
    int c;
    public void methodinner(){
    // 在实例内部类中可以直接访问外部类中:任意访问限定符修饰的成员
    a=100;
    b =200;
    methodA();
    methodB();
//  如果外部类和实例内部类中具有相同名称成员时，优先访问的!
    部类自己的
    c=300;
    System.out.println(c);
//如果要访问外部类同名成员时候，必须外部类的名称.OutClass.this.c = 400;
System.out.println(OutClass.this.c)
     }
}
public static void main(String[] args)

// 外部类:对象创建 以及 成员访问
OutClass outClass = new OutClass(
System.out.println(outClass.a)
System.out.println(QutClass.b
System.out.printIn(outClass.c);
outClass.methodA()
outClass.methodB()

System.out.println("================实例内部类的访问=============")
// 要访问实例内部类中成员，必须要创建实例内部类的对象
//而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类
// 创建实例内部类对象
OutClass.InnerClass innerClass1 =new QutClass().new InnerClass();
// 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建实例内部类对象OutClass.InnerClass innerClass2 = outClass.new InnerClass();
innerClass2.methodinner();

2.静态内部类

public class OutClass {
       private int a;
       static int b;
       public void methodA(){
       a=10;
       System.out.println(a);
       public static void methodB(){
       System.out.println(b);
   }
}
// 静态内部类:被static修饰的成员内部类
static class InnerClass{
      public void methodinner(){
//    在内部类中只能访问外部类的静态成员
//    a=100; //编译失败，因为a不是类成员变量
      b =200;
//   methodA();  //编译失败，因为methodA()不是类成员方法
methodB;
   }
}
public static void main(String[] args) {
// 静态内部类对象创建 & 成员访问
OutClass.InnerClass innerClass =new OutClass.InnerClass();
innerClass.methodinner();
  }
}

3.匿名内部类（利用了接口）

十三.常用接口扩展

1.Comparable接口

俩对象的比较大小：

多对象比较大小：

目前结论：

只要是自定义类型，要比较实例化对象大小，就一定得实现Comparable接口

自己实现sort（利用冒泡排序）

该接口缺点：

每次运行都只能比较对象一个属性

2.Comparator接口

优点：

可以根据不同的属性创造不同的实现该接口的类重写compare方法来比较不同属性的对象

3.Cloneable接口

接口的源码：

作用：表示实现接口的类可以克隆

实现过程：

应用：

该实现过程没有将Money拷贝上属于浅拷贝，深拷贝得将Money也拷贝上

Java SE--抽象类和接口