抽象类和接口

文章目录

• 抽象类
• • 什么是抽象类
  • • 抽象类不能进行实例化
    • 继承了抽象类，需要重写里面的所有抽象方法，不重写会报错
    • 有抽象方法的就一定是抽象类
    • 有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();    }}

              总结

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