抽象，接口，内部类

一、抽象（abstract）

只能修饰类和方法

抽象类

抽象类可以有任意成员
一般来说抽象类会被继承
抽象类不能被实例化

抽象方法

抽象方法一定要在抽象类中
就是没有实现的方法：没有方法体

二、接口（interface）

接口只能用public和默认修饰
接口就是给出一些没有实现的方法，封装到一起
接口中的属性都是public final static的（必须初始化）
接口可以继承多个接口（extends）

接口中的方法

接口中的所有方法都是public方法
接口中的抽象方法可以省略abstract
接口中的默认方法需要加default
一个普通类实现接口就要重写接口中的所有方法
抽象类实现接口可以不实现接口的方法

类实现接口（implements）

一个类可以实现多个接口（implements）
接口可以继承多个接口（extends）
接口主要在于扩展类的功能性，继承主要在于解决代码的复用性和可维护性

三、内部类

一个类的内部又完整的嵌套了另一个类结构
内部类最大的特点就是可以直接访问外部类的私有属性

局部内部类

一般定义在方法或者代码块中，地位相当于局部变量，但是不能使用修饰符（final除外）
可以调用外部类的所有成员
只能作用在定义他的方法或者代码块中
外部类其他成员和内部类成员重名时，采用就近原则

class Outer01{
    private int n1 = 100;
    public void m1(){
        class Inner01{
            public void f1(){
            	private int ni = 200;
                System.out.println("n1=" + n1);//200//可以直接访问私有属性
                System.out.println("外部类的n1" + Outer01.this.n1);//100
            }
        }
        class Inner02 extends Inner01{//可以被其他类所继承
        }
        Inner01 inner01 = new Inner01();
        inner01.f1();//可以创建对象然后调用
    }
}

匿名内部类

匿名内部类定义在外部类的局部位置
基本语法：

new 类或接口（参数列表）{
		类体
};

接口匿名内部类

class Outer01{//外部类
   //1.本质是类2.内部类3.不定义名字4.还是一个对象
    public void method(){//方法
        A tiger = new A() {//只使用一次//编译类型A//运行类型是匿名内部类（jdk底层创建 的名字Outer01$1)
            @Override
            public void cry() {
                System.out.println("调用接口中的cry方法");
            }
        };
        tiger.cry;
    }
}
interface A{//接口
    public void cry();
}

相当于

class Outer01{//外部类
    public void method(){//方法
       A tiger = new Tiger();
       tiger.cry();
    }
}
interface A{//接口
    public void cry();
}
class Tiger implements A {
    @Override
    public void cry() {
        System.out.println("叫");
    }
}

类的匿名内部类

Father father = new Father("jack"){
            @Override
            public void test() {
                System.out.println("类的匿名内部类");
            }
        };
        father.test;

class Father {
    public Father(String name) {
    }
    public void test(){
    }
}

抽象类的匿名内部类

 Animal animal = new Animal(){
            @Override
            void eat() {
            System.out.println("抽象类的匿名内部类");
            }
        };
        animal.eat;

abstract class Animal{
    abstract void eat();
}

实际运用

public class InnerClass01 {
    public static void main(String[] args) {
        f1(new AAA() {//匿名内部类当作实参传递//只能使用一次//灵活
            @Override
            public void eat() {
                System.out.println("xp吃屎");
            }
        });
       // f1(new cat());
    }
    public static void f1(AAA aaa){//形参是接口类型
        aaa.eat();
    }
}
interface AAA{
    public void eat();
}
//class cat implements AAA{//硬编码//可以反复使用//不够灵活一动全动
//	@Override
//	public void eat() {
//  	System.out.println("xp吃屎");
//      }
//}

成员内部类

定义在外部类的成员位置，没有static修饰
可以使用修饰符修饰
作用在整个类
可以调用外部类的所有成员
外部类其他成员和内部类成员重名时，采用就近原则

public class LocalInnerClass02 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.f1();
        //Outer.Inner inner = new Outer().new Inner();//2
        //inner.say();
        //outer.getInner().say();//3
    }
}
class Outer{
    private int n1 = 10;
    public String name = "xp";
    class Inner {
        public void say(){
            System.out.println(n1 + name);
        }
    }
    public void f1(){
        Inner inner = new Inner();
        inner.say();
    }
//    public Inner getInner(){//3
//    return new Inner();
//}

静态内部类

外部类的成员位置，可以添加修饰符
有static修饰，只能访问外部类的静态成员