文章目录

• 抽象类
• • 什么是抽象类
  • • 抽象类不能进行实例化
    • 继承了抽象类，需要重写里面的所有抽象方法，不重写会报错
    • 有抽象方法的就一定是抽象类
    • 有final，private，static修饰的不能被重写
    • 接口
    • • 接口的应用
      • interface关键字
      • 注意事项
      • • public default
        • 接口中的静态方法
        • 总结
        • Object类
        • 内部类
        • • 局部内部类
          • 实例内部类
          • 静态内部类
          • 匿名内部类（掌握）
          • • 使用场景
            • 总结

              抽象类

              什么是抽象类

              被abstract修饰的类就是抽象类

              抽象类不能进行实例化

              继承了抽象类，需要重写里面的所有抽象方法，不重写会报错

              public abstract class Person {
                  public static void eat(){
                      System.out.println("我饿了，想吃点好的");
                  }
                  public abstract void sleep(); 
              }
              

              public class Student extends Person{
                  @Override
                  public void sleep() {
                  }
              }
              

              有抽象方法的就一定是抽象类

              有final，private，static修饰的不能被重写

              抽象类的出现就是为了被继承，多了一层编译器的校验

              接口

              想要让某个对象去拥有对应的行为就可以定义成接口

              接口的应用

              比如说，定义了运动员和教练的类，运动员和教练中都有会说英语的，那么说英语这个行为，可以由运动员和教练中的任意一个完成都行，所以就可以写成接口，只要实现了接口就是可以完成某种行为

              interface关键字

              通过interface关键字就可以去创建某个接口了

              注意事项

              1. 接口中的成员变量默认是由public static final所修饰的

              2. 接口里的抽象方法默认都是public abstract 所修饰的

                 4. 如果接口中的方法被default 或者static 修饰可以有具体实现

                 也就是接口中的默认方法和静态方法

              public default

              注意事项：

              默认方法不是抽象方法，所以不强制被重写，但是如果要重写，需要去掉default关键字

              public可以省略，default不能省略

              接口中的静态方法

              格式：public static 返回值类型 方法名(参数列表){

              }

              注意事项：

              静态方法只能通过接口调用，不能实例化

              public interface Inter {
              	public static void swim(){}
              	public static void play(){
                 		swim();
              	}
              }
              

              不能被重写(子类把从父类继承下来的虚方法表里的方法进行了覆盖才是重写)，而静态方法是没有被被到虚添加方法表里的

              4.接口比抽象类还抽象不可以进行实例化

              5.作为父类对象还是可以引用对象的，也就是new子类的对象

              public class Student extends Person implements Inter{
              }
              

              public class Test {
                  public static void main(String[] args) {
                     Person person=new Student();
                     person.sleep();
                  }
              }
              

              6.类和接口之间可以使用关键字implements实现接口

              7.一个接口对应一个.class文件

              8.如果一个类不想实现接口中的方法，可以使用抽象类

              但是抽象类再被继承就得重写接口中的方法和抽象方法

              总结

              一个类可以实现多个接口，解决类只能单继承问题

              对于接口可以用对象来接收实现了多态，同样需要重写方法，然后可以进行调用

              Object类

              是所有类默认的父类

              内部类

              局部内部类

              方法里写一个内部类
              相当于方法里得局部变量
              很少这样写
              

              实例内部类

              如何是实例化成员内部类对象？

              直接创建

              格式：外部类类名.内部类名=外部类对象.内部类对象

              public class Outer {
                  String name;
                  class Inner {
                      static int a = 10;
                  }
              }
              

                 Outer.Inner oi=new Outer().new Inner();
              

              由private修饰的方法

              通过外部类编写方法，对外提供内部类方法

               public static void main(String[] args) {
                    Outer o=new Outer();
                    System.out.println(o.getInstance());
                }
              

              public class Outer {
                  String name;
                  private class Inner{
                      static int a=10;
                  }
                  public Inner getInstance(){
                      return  new Inner();
                      }
                  }
              

              访问同名成员变量

              首先就近原则

              如果要引用外部类的成员变量

              就需要引用外部类引用.this.去引用

              也可以外部名.this.去引用

              静态内部类

              在类里面再定义一个

              语法是static class 类名{

              里面可以有成员变量和成员方法

              }

              如何是实例化静态内部类对象？

              只要是静态的，都可以直接用类名直接调用

              实例化要把内部类和外部类看成整体Out.inner

              匿名内部类（掌握）

              理解:

              隐藏了名字的内部类，可以写在成员位置，也可以写在局部位置

              是new出来的对象，真正的匿名体是大括号
              继承或实现关系
              方法的重写
              创建对象
              

              调用方法：

              new 外部类类名(){

              重写方法

              }.方法；

              public abstract class Outer {
                  public void eat(){
                      System.out.println("哈哈");
                  }
              }
              

              public class Inner extends Outer {
                  public static void main(String[] args) {
                      new Outer(){
                          @Override
                          public void eat() {
                              System.out.println("嘿嘿");
                          }
                      }.eat();
                  }
              }
              

              使用场景

              作为方法参数，没有名字的类继承了Animal这个类

              作为Animal的子类对象传递给method时就构成了多态

              public abstract class Animal {
                  abstract void eat();
              }
              

              public class Test1 {
                  public static void main(String[] args) {
                      method(
                          new Animal() {
                              @Override
                              void eat() {
                                  System.out.println("狗不爱吃骨头");
                              }
                          }
                      );
                  }
                  public static void method(Animal a){//Animal a=子类对象——多态
                      a.eat();
                  }
              }
              

              总结

              相信小伙伴看到这已经对抽象类和接口有了一定了解，一起加油啊