内部类，抽象类和接口(一)

目录：

一.抽象类

二.接口

三内部类

一.抽象类：

1 抽象类概念 ：在 面向对象的概念中，不是所有的类都是用来描绘对象的， 如果 一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

2. 抽象类语法： 在 Java 中，一个类如果 被 abstract 修饰称 为抽象类，抽象类中被 abstract 修饰方法称为 抽象方法 ，抽象方法不用 给出 具体的 实现体。

代码图：

3. 抽象类特性 ： (1)抽象类不能直接实例化对象

(2)抽象方法不能是 private 的

(3)抽象方法不能被final和static修饰，因为抽象方法要被子类重写

(4) 抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类必须要使用abstract 修饰

(5)抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类 (关系，和第四条，如出辙)

(6)抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

4 抽象类的作用 :抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法. 这样就相当于，多了一层校验器，帮你检查错误

二.接口：

1.概念理解：接口就是公共的行为规范标准（更抽象），大家在实现时，只要符合规范标准，就可以通用。在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

2.语法规则：接口的定义格式与定义类的格式基本相同，将 class 关键字换成 interface 关键字 ，就定义了一个接口。

定义格式提醒：（接口也可以继承）

1. 创建接口时, 接口的命名一般以大写字母 I 开头.

2. 接口的命名一般使用 "形容词" 词性的单词.

3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性

3.接口特性：

(1) 接口类型是一种引用类型，但是不能直接new接口的对象

(2)接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错)

(3)接口中的方法是不能在接口中实现的，只能由实现接口的类来实

(4)重写接口中方法时，不能使用默认的访问权限

(5)接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量

(6)接口中不能有静态代码块和构造方法,实例代码块也不能有：

  (7) 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class

(8) 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类

(9)jdk8中：接口中还可以包含default方法。  

4.实现多个接口:

在 Java 中，类和类之间是 单继承 的，一个类只能有一个父类，即 Java 中不支持多继承 ，但是 一个类可以实现多个接 口.

三内部类：

1.概念：可以将一个类定义在另一个类或者一个方法的内部， 前者称为内部类，后者称为外部类 。内部类也是封装的一种体现。

public class OutClass {
class InnerClass{
}
}
// OutClass是外部类
// InnerClass是内部类

注： 内部类和外部类共用同一个 java 源文件，但是经过编译之后，内部类会形成 单独的字节码文件

定义在 class 类名 {} 花括号外部的，即使是在一个文件里，都不能称为内部类

1. 内部类的分类：1. 成员内部类，成员内部类又分为，没有 被static修饰的成员内部类 和 被static修饰的成员内部类。

2. 局部内部类( 不谈修饰符 )

3.匿名内部类

被static修饰的成员内部类（静态内部类）：

静态内部类里不可以，访问外部非静态成员变量,需要访问就得实例化对象，来访问

public class OutClass {
    public static int a = 10;
    public int b = 2;
    private int c = 3;
    public int g = 0;

    //静态内部类
      static class InnerClass {
        public int d = 1;
        private int e = 6;
        private static int f = 0;

        //静态内部类里不可以，访问外部非静态成员变量,需要访问就得实例化对象，来访问
        public void print() {
            System.out.println(a);
        }
    }

    public static void main(String[] args) {
        OutClass.InnerClass innerClass = new OutClass.InnerClass();
        innerClass.print();
    }

}

没有被static修饰的成员内部类（ 实例内部类）：

public class OutClass1 {
    public int a = 10;

    //实例内部类
     class Innerclass1 {
         int a = 100;
        int c;
        public void test() {
            System.out.println(OutClass1.this.a);
        }
    }

    public static void main(String[] args) {
        //实例化，实例内部类

        //先实例化，外部类
        OutClass1 outClass1 = new OutClass1();
        //再借助，外部类实例化，实例内部类
        OutClass1.Innerclass1 innerclass1 = outClass1.new Innerclass1();
        innerclass1.test();

    }

}

2. 局部内部类：定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用，一般使用的非常少，此处简单了解下语法格式。

class Out{
    public void test() {
        //局部内部类，只能在次方法里使用
        class Innerclass {
            int a = 1;
            public void test2() {
                System.out.println(a);
            }
        }
        //实例化局部内部类
        Innerclass innerclass = new Innerclass();
        innerclass.test2();
    }
}

public class Test {
    public static void main(String[] args) {
        //err
        OutClass.Innerclass innerclass = new Innerclass;
    }
}

注意：1. 局部内部类只能在所定义的方法体内部使用

2. 不能被 public 、 static 等修饰符修饰

3.匿名内部类：可以简单理解为继承关系，的体现

class out{
    public void test() {
        System.out.println("haha");
    }
}
public class OutClass2 {
    public static void main(String[] args) {
        //可以理解，为继承关系
        new out(){
            @Override
            public void test() {
                //调用了out类（父类）的方法
                super.test();
            }
        }.test();
}

用接口来体现：

interface IA{
    void test1();

    }

public class OutClass2 {
    public static void main(String[] args) {

//接口举例,ia这个类实现了，IA接口，并且重写了test1方法
        IA ia =  new IA() {
            @Override
            public void test1() {
                System.out.println("实现了这个方法");
            }
        };
        ia.test1();

}