java 内部类声明 抽象类_java的抽象类、内部类、接口

抽象方法

1.由abstract修饰的方法(在方法最前面加)只有声明，没有方法体，连{ }都没有。定义的是一种规范，就是告诉子类必须要去给这个方法提供具体的实现

2.有抽象方法的的类必须是抽象类。

设计规则：

将派生类所共有的属性和行为，抽到超类中-----抽共性

所有派生类的行为都一样，则在父类中设计为普通的方法。 //如飞机游戏超类的loadImage方法

所有派生类的行为都不一样，则在父类中设计为抽象方法。 //如飞机游戏超类的step方法

抽象类

包含抽象方法的类就是抽象类。(不完整的)抽象类一定是作为超类的，要不然没意义。

1.通过abstract修饰类，要求子类必须定义具体实现。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。

2.有抽象方法的类一定是抽象类，抽象类可以没有抽象方法。

3.抽象类不能被实例化即不能被new、但可以向上造型。

4.抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用。

5.抽象类需要被继承，不被继承的抽象类是没有意义的

6.继承抽象类的时候必须重写抽象类中的所有抽象方法。或者声明为抽象类(一般不这么做)。

抽象类意义：

封装共有的属性和行为，但不同的子类的行为又都不一样---------代码的复用。

为所有派生类提供统一的类型--------向上造型。

内部类

Java内部类指 一个类中可以嵌套另外一个类。广泛意义上的内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。

内部类作为外部类的一个成员，并且依附于外部类而存在的。

内部类可为静态，可用protected和private修饰(而外部类只能使用public和缺省的包访问权限)。

成员内部类(应用率不高，了解)

1)类中套类，外面的类称为Outer外部类，里面的称为Inner内部类。

2)内部类只服务于外部类，对外不具备可见性。

3)内部类对象通常是在外部类中创建的。

4)内部类中可以直接访问外部成员(是隐式的    外部类.this.成员)。

5)内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。外部类只能被public和包访问两种权限修饰。我个人是这么理解的，由于成员内部类看起来像是外部类的一个成员，所以可以像类的成员一样拥有多种权限修饰。

局部内部类

局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

匿名内部类(最最最最最常用的)

匿名内部类就是没有名字的内部类。没有名字的子类。

语法：创建类对象时后面加{ };

匿名内部类也是不能有访问修饰符和static修饰符的。

匿名内部类是唯一一种没有构造器的类。正因为其没有构造器，所以匿名内部类的使用范围非常有限，大部分匿名内部类用于接口回调。匿名内部类在编译的时候由系统自动起名为Outter$1.class。一般来说，匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。

若想创建一个类(派生类)的对象，且对象只被创建一次，即若想继承一个类或实现一个类的接口的时候，且这个类的实例只用一次的时候此时该类不必命名，称为匿名内部类。

Aoo a = new Aoo(){ //创建了Aoo的一个没有名字的派生类， a为派生类的对象。

};

Boo b = new Boo();//假设Boo是继承了Aoo的派生类的活  这种写法与上面效果一样 只不过派生类是有名字的Boo。

用匿名内部类时，要记住以下几个原则：

1.匿名内部类不能有构造方法。

2.匿名内部类不能定义任何静态成员、方法和类。

3.匿名内部类不能是public,protected,private,static。

4.只能创建匿名内部类的一个实例。

5.一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。

6.java8以前。若一个方法中，如果匿名内部类想使用这个方法中的局部变量，那么这个局部变量因该用final修饰

静态内部类

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法，这点很好理解，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。

为什么需要内部类？

1.内部类方法可以访问该类定义所在的作用域的数据，包括私有的数据

2.内部类可以对同一个包中的其他类隐藏起来,一般的非内部类，是不允许有 private 与protected权限的，但成员内部类可以

3.可以实现多重继承

4.当想要定义一个回调函数且不想编写大量代码时，使用匿名内部类比较便捷。

使用内部类最吸引人的原因是：

每个内部类都能独立地继承自一个(接口的)实现，所以无论外围类是否已经继承了某个(接口的)实现，对于内部类都没有影响。大家都知道Java只能继承一个类，它的多重继承在我们没有学习内部类之前是用接口来实现的。但使用接口有时候有很多不方便的地方。比如我们实现一个接口就必须实现它里面的所有方法。而有了内部类就不一样了。它可以使我们的类继承多个具体类或抽象类。

接口

接口可以看成时特殊的抽象类，是只有抽象相方法的类。变相的可以实现多继承。

用于将部分派生类所共有的行为抽到接口中(因为若写到超类中 很多派生类没有此行为却还是要重写)

接口是完全面向规范的，规定了一批类具有的公共方法规范。

从接口的实现者角度看，接口定义了可以向外部提供的服务。

从接口的调用者角度看，接口定义了实现者能提供那些服务。

接口是两个模块之间通信的标准，通信的规范。如果能把你要设计的模块之间的接口定义好，就相当于完成了系统的设计大纲，剩下的就是添砖加瓦的具体实现了。大家在工作以后，做系统时往往就是使用“面向接口”的思想来设计系统。

接口和实现类很想但不是父子关系，是实现规则的关系。比如：我定义一个接口Runnable，Car实现它就能在地上跑，Train实现它也能在地上跑，飞机实现它也能在地上跑。就是说，如果它是交通工具，就一定能跑，但是一定要实现Runnable接口。

面向对象的精髓，是对对象的抽象，最能体现这一点的就是接口。

定义接口

1)由interface定义 (不是修饰)且生命的常量和方法一般都用public修饰。

2)接口中只能包含常量和抽象方法。

int CSA = 5; //默认为public static final 修饰，注：常量必须声明同时初始化。

void say(); //默认为public abstract

3)不能被实例化。

4)接口是需要被实现(继承)的，实现(派生)类必须重写接口中的所有抽象方法。

5)一个类可以实现(继承)多个接口 在实现(派生)类implements时 用逗号分隔。(类实现接口)

6)接口可以实现一个或多个接口 用extends关键字 逗号分隔。(接口继承接口)

抽象类和接口的区别与联系。

接口和抽象类的概念不一样。接口是对动作的抽象，抽象类是对根源的抽象。

抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类(如果是类的话……)，他们的抽象类是人。说明，他们都是人。

人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它.

所以，在高级语言上，一个类只能继承一个类(抽象类)(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)。

当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。

抽象类和接口的区别：

1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。

2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。

3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。

4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。