黑马程序员-抽象类、接口、内部类

---------------------- ASP.Net+Android+IOS开发</a>、 .Net培训、期待与您交流！ ----------------------

抽象类和抽象方法

使用abstract关键字修饰的类就是抽象类，抽象类里可以包含抽象方法

抽象类的作用就是做一个模版，无法创建实例

除了抽象方法外，正常类中有的元素，抽象类中都可以包含

抽象类中为什么不能定义抽象构造函数？

因为定义抽象构造函数就无法初始化抽象类

抽象方法被abstract修饰，没有方法体，所以必须被子类实现后才可以调用

抽象方法和空方法体的区别？

抽象方法没有花括号，空方法体有花括号，但没方法体

当abstract修饰类时，表明这个类只能被继承，当abstract修饰方法时，表明这个方法必须由子类实现（重写）。
而final修饰的类不能被继承，final修饰的方法不能被重写
因此final和abstract不能同时使用

abstract只能修饰类和方法（不能修饰构造函数）
抽象类里定义的构造器只能是普通构造器

当使用static来修饰一个方法时，表明这个方法属于当前类，即可以通过类来调用
如果该方法被定义成抽象方法，则通过类调用时会出错（因为没有方法体）
因此static和abstract不能同时修饰某个方法

abstract关键字修饰的方法必须被其子类重写才有意义，否则着个方法将永远不会有方法体
因此abstract方法不能定义为private访问权限，private和abstra不能同时使用

接口

抽象类是从多个类中抽象出来的模版，而接口体现的是一种规范，作为规范，接口里的所有方法都是抽象方法，接口不需要初始化，所以没有构造函数，没有初始化代码块

让规范和实现分离正是接口的好处，让软件系统的各模块之间面向接口耦合，从而尽量降低各模块之间耦合，为系统提供更好的可扩展性和可维护性，接口体现的是规范和实现分离的设计哲学

接口作为一种规范，接口内的元素（字段、方法、内部类等）必须能够被访问，所以接口里的所有元素都是public修饰
字段只能是静态常量（public static final）
方法只能是抽象（public abstract）
内部类、枚举类都是静态（public static）

修饰符 interface 接口名 extends 父接口1, 父接口2...
{
    零个到多个常量定义...
    零个到多个抽象方法定义...
}

修饰符可以是public或者省略，如果省略了修饰符，默认采用protected修饰符

一个接口可以有多个直接父接口（可以多继承），但接口只能继承接口，不能继承类

接口和抽象类

接口体现的是一种规范，是多个模块间的耦合标准
抽象类则不一样，抽象类作为系统中多个子类的共同父类，它所体现的是一种模版式设计

内部类

将一个类定义在另一个类的里面，里面那个类就称为内部类（内置类，嵌套类）

访问特点：
内部类可以直接访问外部类中的成员，包括私有成员，而外部类要访问内部类中的成员必须要建立内部类的对象

/**
内部类
*/

class Outer
{
    private int num = 3;

    //定义内部类
    class Inner
    {
        void function()
        {
            System.out.println("inner:"+num);
        }
    }

    void method()
    {
        //外部类访问内部类要创建内部类对象
        Inner in = new Inner();
        in.function();
    }
}

class InnerTest
{
    public static void main(String[] args)
    {
        Outer out = new Outer();
        out.method();

        //直接创建内部类对象(不常用，因为内部类一般会被private修饰)
        Outer.Inner in = new Outer().new Inner();
        in.function();
    }
}

静态内部类

当内部类在成员位置上，就可以被成员修饰符所修饰
比如private：将内部类在外部类中进行封装
比如static：内部类具备static特性
当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限

在外部其他类中，如何直接访问内部类的非静态成员呢？
new Outer.Inner().function();

在外部其他类中，如何直接访问内部类的静态成员呢？
Outer.Inner.function();

注意：
当内部类中定义了静态成员，该内部类必须被静态修饰
当外部类中的静态方法访问内部类时，该内部类也必须被静态修饰

局部内部类

把一个类定义在方法上，位于局部位置，称为局部内部类

特点：
不可以被成员修饰符修饰（如：private static）
仍然可以直接访问外部类中的成员，当访问所在方法的局部变量时，局部变量要使用final修饰

/**
局部内部类
*/
 
class Demo
{
    public static void main(String[] args)
    {
        new Outer().method();
    }
}
 
class Outer
{
    int x = 1;    //外部类成员
    void method()
    {
        final int y = 2;    //final修饰的局部变量
        class Inner
        {
            void innerMethod()
            {
                System.out.println(x);    //直接访问外部类成员
                System.out.println(y);    //只能访问final修饰的局部变量
            }
        }
 
        new Inner().innerMethod();    //局部内部类只能在所在方法内创建实例
    }
}

匿名内部类

匿名内部类其实就是内部类的简写格式，定义匿名内部类的前提是内部类必须是继承一个类或者实现接口

其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖

/**
匿名内部类
*/
 
class AnonymousTest
{
    public static void main(String[] args)
    {
        new Outer().method();
    }
}
 
abstract class AbsDemo
{
    abstract void function();
}
 
class Outer
{
    void method()
    {
        //匿名内部类
        new AbsDemo()
        {
            public void function()
            {
                System.out.println("run");
            }
        }.function();
    }
}

---------------------- ASP.Net+Android+IOS开发</a>、 .Net培训、期待与您交流！ ----------------------