抽象类和接口

抽象类

什么是抽象类

被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();
    }

}

总结

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