内部类

一个类的定义放在另一个类的内部，这个类就叫做内部类

  • 10.1创建内部类

public class First {
public class Contents{
public void f(){
System.out.println("In Class First's inner Class Contents method f()");
}
}
}
这样的类就叫内部类，内部类了解外部类，并能与之通信

  • 10.2 链接到外部类

package cn.zlb.innerclass;
interface Selector{
boolean end();
int current();
void next();
}
public class Sequence {
private Object[] items = null;
int next = 0;
public Sequence(int size){
items = new Object[size];
}
public void add(int i){
items[next++] = i;
}
private class SequenceSelector implements Selector{
private int i = 0;
@Override
public boolean end() {
return i==items.length;
}
@Override
public int current() {
// TODO Auto-generated method stub
return (int) items[i];
}
@Override
public void next() {
// TODO Auto-generated method stub
if(i < items.length){ i++;}
}
}
public Selector getSelector(){
return new SequenceSelector();
}
public static void main(String[] args) {
}
}

内部类自动拥有对其外围类的所有成员的访问权，因为当某个外围类创建一个内部类时，次内部类必定会秘密捕获一个指向外部类的引用用那个引用来访问外部成员

  • 10.3 使用.this 和 .new
    内部类中得到当前外围类对象的引用，可以使用.this关键字，.new关键字 如果想直接创建一个内部类对象，而不是通过外围类对象的方法来得到，可以使用.new关键字 注意与new的区别

private int num ;
public Test2(){
}
public Test2(int num){
this.num = num;
}
private class Inner{
public Test2 getTest2(){
return Test2.this;
}
public Test2 newTest2(){
return new Test2();
}
}
public static void main(String [] args){
Test2 test = new Test2(5);
Test2.Inner inner = test.new Inner();
Test2 test2 = inner.getTest2();
Test2 test3 = inner.newTest2();
System.out.println(test2.num);
System.out.println(test3.num);
}

  • 10.4 内部类与向上转型
    将内部类上转型为基类时，尤其是转型为一个接口时，内部类就有了用武之地
public interface Shape {

public void paint();
}
public class Painter {
private class InnerShape implements Shape{
public void paint(){
System.out.println("painter paint() method");
}
}
public Shape getShape(){
return new InnerShape();
}
public static void main(String []args){
Painter painter = new Painter();
Shape shape = painter. getShape();
shape.paint();
}
}
此时，内部类是private的，可以它的外围类Painter以外，没人能访问。 这样,private内部类给累的设计者提供了一种途径，通过这种方式可以完全阻止任何依赖于类型的编码，并完全隐藏实现的细节。

  • 10.5在方法和作用域内的内部类
  • 10.6匿名内部类

public interface Shape {
public void paint();
}
public class Painter {
public Shape getShape(){
return new Shape(){
public void paint(){
System.out.println("painter paint() method");
}
};
public static void main(String [] args){
Painter painter = new Painter();
Shape shape = painter.getShape();
shape.paint();
}
}

注意匿名内部类一定要以分号结束 在这个匿名内部类中使用了默认的构造器来生成Shape()，如果你的基类需要一个有参数的构造器呢?
如果在这个内部类中需要用到这个参数那么这个参数一定的是final类型的

public class B {
public A getA(int num){
return new A(num){
};
}
}
public class A {
private int num;
public A(int num){
this.num = num;
}
public A(){
}
}

另外，还可以在匿名内部类里定义属性 由于类是匿名的，自然没有构造器，如果想模仿构造器，可以采用实例初始化({})

public A getA(){
return new A(){
int num = 0;
String str;
{
str = "javaeye";
System.out.println("hello robbin");
}
};
}

  • 10.6.1 使用匿名内部类改造工厂方法

package cn.zlb.factory;
interface Service{
void method1();
void methid2();
}
interface ServiceFactory{
Service getService();
}
class ImplementService1 implements Service{
@Override
public void method1() {
// TODO Auto-generated method stub
System.out.println("ImplementService1 method1");
}
@Override
public void methid2() {
// TODO Auto-generated method stub
System.out.println("ImplementService1 method2");
}
//使用匿名内部类
private ServiceFactory serviceFactory = new ServiceFactory() {
@Override
public Service getService() {
// TODO Auto-generated method stub
return new ImplementService1();
}
};
}
class ImplementServiceFactory1 implements ServiceFactory{
@Override
public Service getService() {
// TODO Auto-generated method stub
return new ImplementService1();
}
}
class ImplementServiceFactory2 implements ServiceFactory{
@Override
public Service getService() {
// TODO Auto-generated method stub
return new ImplementService2();
}
}
class ImplementService2 implements Service{
@Override
public void method1() {
// TODO Auto-generated method stub
System.out.println("ImplementService2 method1");
}
@Override
public void methid2() {
// TODO Auto-generated method stub
System.out.println("ImplementService2 method2");
}
private ServiceFactory serviceFactory = new ServiceFactory() {
@Override
public Service getService() {
// TODO Auto-generated method stub
return new ImplementService2();
}
};
}
public class factory {
public static void method(ServiceFactory sf){
Service s = sf.getService();
s.methid2();
s.method1();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
method(new ImplementServiceFactory1());
method(new ImplementServiceFactory2());
}
}

  • 10.7 嵌套类
    static的内部类就叫做嵌套类 前面提到了很多次，嵌套类是个例外 使用嵌套类时有两点需要注意：
    a、创建嵌套类对象时，不需要外围类
    b、在嵌套类中，不能像普通内部类一样访问外围类的非static成员
    另外，嵌套类还有特殊之处，就是嵌套类中可以有static方法，static字段与嵌套类，而普通内部类中不能有这些
  • 10.8为何需要内部类
    a、内部类提供了某种进入外围类的窗户。
    b、也是最吸引人的原因，每个内部类都能独立地继承一个接口，而无论外围类是否已经继承了某个接口。 因此，内部类使多重继承的解决方案变得更加完整。 在项目中，需要多重继承，如果是两个接口，那么好办，接口支持多重继承。 如果是两个类呢？这时只有使用内部类了。
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • Spring Cloud
    Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智...
    卡卡罗2017阅读 135,099评论 19赞 139
  • JavaSE知识点14java内部类详解
    内部类基础 1 定义将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。 2 分类广泛意义上的内部类一...
    paulpaullong阅读 357评论 0赞 1
  • Java的多态、（成员、局部、匿名）内部类
    多态 概述：某一个事物，在不同时刻表现出来的不同状态。我们来举例说明： 猫是猫，狗是狗，猫和狗都是动物。 水在不同...
    清风沐沐阅读 568评论 0赞 0
  • Java内部类
    Java 内部类 分四种：成员内部类、局部内部类、静态内部类和匿名内部类。 1、成员内部类： 即作为外部类的一个成...
    ikaroskun阅读 1,269评论 0赞 13
  • Java 静态变量、方法、快，（非）静态内部类
    静态对象 静态对象的数据是全局唯一的，一改全改。 引用方便。直接用 类名. 静态方法名 或者 类名 . 静态变量名...
    Yanci516阅读 2,023评论 1赞 6