java-深入理解java嵌套类内部类以及内部类builder构建构造函数
Posted hguisu
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java-深入理解java嵌套类内部类以及内部类builder构建构造函数相关的知识，希望对你有一定的参考价值。
一、什么是嵌套类及内部类
可以在一个类的内部定义另一个类，这种类称为嵌套类（nested classes），它有两种类型：静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类（inner）。嵌套类从JDK1.1开始引入。其中inner类又可分为三种：
其一、在一个类（外部类）中直接定义的内部类；
其二、在一个方法（外部类的方法）中定义的内部类；
其三、匿名内部类。
使用嵌套类的好处：
- 嵌套类可以访问外部类的所有数据成员和方法，即使它是私有的。
- 提高可读性和可维护性：因为如果一个类只对另外一个类可用，那么将它们放在一起，这更便于理解和维护。
- 提高封装性：给定两个类A和B，如果需要访问A类中的私有成员，则可以将B类封装在A类中，这样不仅可以使得B类可以访问A类中的私有成员，并且可以在外部隐藏B类本身。
- 减少代码的编写量。
二、静态嵌套类
如下所示代码为定义一个静态嵌套类，
public class StaticTest
private static String name = "javaJohn";
private String id = "X001";
static class Person
private String address = "swjtu,chenDu,China";
public String mail = "josserchai@yahoo.com";//内部类公有成员
public void display()
//System.out.println(id);//不能直接访问外部类的非静态成员
System.out.println(name);//只能直接访问外部类的静态成员
System.out.println("Inner "+address);//访问本内部类成员。
public void printInfo()
Person person = new Person();
person.display();
//System.out.println(mail);//不可访问
//System.out.println(address);//不可访问
System.out.println(person.address);//可以访问内部类的私有成员
System.out.println(person.mail);//可以访问内部类的公有成员
public static void main(String[] args)
StaticTest staticTest = new StaticTest();
staticTest.printInfo();
在静态嵌套类内部，不能访问外部类的非静态成员，这是由Java语法中"静态方法不能直接访问非静态成员"所限定。若想访问外部类的变量，必须通过其它方法解决，由于这个原因，静态嵌套类使用很少。注意，外部类访问内部类的的成员有些特别，不能直接访问，但可以通过内部类来访问，这是因为静态嵌套内的所有成员和方法默认为静态的了。同时注意，内部静态类Person只在类StaticTest 范围内可见，若在其它类中引用或初始化，均是错误的。
三、在外部类中定义内部类
1、内部类分为成员内部类、静态嵌套类、方法内部类、匿名内部类。
几种内部类的共性：
A、内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类命和$符号。
B、内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的。
如下所示代码为在外部类中定义两个内部类及它们的调用关系：
public class Outer
int outer_x = 100;
class Inner
public int y = 10;
private int z = 9;
int m = 5;
public void display()
System.out.println("display outer_x:"+ outer_x);
private void display2()
System.out.println("display outer_x:"+ outer_x);
void test()
Inner inner = new Inner();
inner.display();
inner.display2();
//System.out.println("Inner y:" + y);//不能访问内部内变量
System.out.println("Inner y:" + inner.y);//可以访问
System.out.println("Inner z:" + inner.z);//可以访问
System.out.println("Inner m:" + inner.m);//可以访问
InnerTwo innerTwo = new InnerTwo();
innerTwo.show();
class InnerTwo
Inner innerx = new Inner();
public void show()
//System.out.println(y);//不可访问Innter的y成员
//System.out.println(Inner.y);//不可直接访问Inner的任何成员和方法
innerx.display();//可以访问
innerx.display2();//可以访问
System.out.println(innerx.y);//可以访问
System.out.println(innerx.z);//可以访问
System.out.println(innerx.m);//可以访问
public static void main(String args[])
Outer outer = new Outer();
outer.test();
总结：
1、对于内部类，通常在定义类的class关键字前不加public 或 private等限制符，若加了没有任何影响。
2、内部类中可以直接访问外部类的数据成员和方法。
3、另外，就是要注意，内部类Inner及InnterTwo只在类Outer的作用域内是可知的，如果类Outer外的任何代码尝试初始化类Inner或使用它，编译就不会通过。同时，内部类的变量成员只在内部内内部可见，若外部类或同层次的内部类需要访问，需采用示例程序中的方法，不可直接访问内部类的变量。
四、方法内部类
顾名思义，把类放在方法内。
class Outer
public void doSomething()
class Inner
public void seeOuter()
A、方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。
B、方法内部类对象不能使用该内部类所在方法的非final局部变量。
因为方法的局部变量位于栈上，只存在于该方法的生命期内。当一个方法结束，其栈结构被删除，局部变量成为历史。但是该方法结束之后，
在方法内创建的内部类对象可能仍然存在于堆中！例如，如果对它的引用被传递到其他某些代码，并存储在一个成员变量内。
正因为不能保证局部变量的存活期和方法内部类对象的一样长，所以内部类对象不能使用它们。
下面是完整的例子：
class Outer
public void doSomething()
final int a =10;
class Inner
public void seeOuter()
System.out.println(a);
Inner in = new Inner();
in.seeOuter();
public static void main(String[] args)
Outer out = new Outer();
out.doSomething();
五、匿名内部类
没有名字的内部类。表面上看起来它们似乎有名字，实际那不是它们的名字。
匿名内部类即没有名字的内部类，如我们在临时创建新的线程时,经常会这么写:
new Thread(new Runnable()
@Override
public void run()
// do something
);本来应该传给new Thread()构造函数一个实现了Runnable接口的类，但是如果这个类只用到一次，那么还要给他命名岂不是很麻烦，所以就省略了名字，即用匿名内部类来代替。但我们可以发现，即使省略了类名，上面的代码看上去还是废话很多，因为其实我们只关心run方法里面的内容，其他都是没用的废话。
A、继承式的匿名内部类。
class Car
public void drive()
System.out.println("Driving a car!");
class Test
public static void main(String[] args)
Car car = new Car()
public void drive()
System.out.println("Driving another car!");
;
car.drive();
结果输出了：Driving another car! Car引用变量不是引用Car对象，而是Car匿名子类的对象。
B、接口式的匿名内部类。
interface Vehicle
public void drive();
class Test
public static void main(String[] args)
Vehicle v = new Vehicle()
public void drive()
System.out.println("Driving a car!");
;
v.drive();
上面的代码很怪，好像是在实例化一个接口。事实并非如此，接口式的匿名内部类是实现了一个接口的匿名类。而且只能实现一个接口。
C、参数式的匿名内部类。
class Bar
void doStuff(Foo f)
interface Foo
void foo();
class Test
static void go()
Bar b = new Bar();
b.doStuff(new Foo()
public void foo()
System.out.println("foofy");
);
4、lambda表达式
lambda表达式与匿名内部类在JVM层面有本质不同，但有的人将lambda看做匿名内部类的语法糖，主要用途就是简化代码和增加代码的可读性。
lambda表达式即匿名表达式，也被称为闭包。lambda 表达式的语法格式如下：
(parameters) -> expression 或 (parameters) -> statements;
以下是lambda表达式的重要特征:
可选类型声明parameters：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。
// 举例如下：
() -> System.out.println(x);
str -> System.out.println(str);
(int x, int y) -> x+y;
(int x, int y) ->
int temp1 = x+y;
int temp2 = x-y;
return temp1*temp2;
有了lambda表达式之后，我们可以大大简化上面创建线程的代码
new Thread(() -> doSomething())
函数式接口
lambda表达式能够良好工作还离不开一个函数式接口。函数式接口是指有且仅有一个抽象方法的接口，如上面的Runnable只具有一个抽象方法void run(),就是一个函数式接口，所以函数式接口本质上和普通接口没有什么区别。
函数式接口可以使用@FunctionalInterface注解标识，被该注解标注的接口具有多个非抽象方法时，则会编译报错。
lambda表达式可以直接赋值给对应函数式接口声明的引用，如：
Runnable runnable = () -> System.out.println("I am running");
runnable.run() // 输出 I am running
new Thread(runnable).start(); // 输出 I am running因此，我们可以直接将lambda表达式传递给以函数式接口作为参数的方法。
六、使用 builder 模式解决构造方法参数过多的情况
静态工厂和构造方法都有一个限制：它们不能很好地扩展到很多可选参数的情景。
请考虑一个代表包装食品上的营养成分标签的例子。这些标签有几个必需的属性——每次建议的摄入量，每罐的份量和每份卡路里 ，以及超过 20个可选的属性——总脂肪、饱和脂肪、反式脂肪、胆固醇、钠等等。大多数产品都有非零值，只有少数几个可选属性。应该为这样的类编写什么样的构造方法或静态工厂？传统上，程序员使用了可伸缩（telescoping constructor）构造方法模式，在这种模式中，只提供了一个只所需参数的构造函数，另一个只有一个可选参数，第三个有两个可选参数，等等，最终在构造函数中包含所有可选参数。这就是它在实践中的样子。为了简便起见，只显示了四个可选属性：
public class NutritionFacts
private final int servingSize; // (mL) required
private final int servings; // (per container) required
private final int calories; // (per serving) optional
private final int fat; // (g/serving) optional
private final int sodium; // (mg/serving) optional
private final int carbohydrate; // (g/serving) optional
public NutritionFacts(int servingSize, int servings)
this(servingSize, servings, 0);
public NutritionFacts(int servingSize, int servings,
int calories)
this(servingSize, servings, calories, 0);
public NutritionFacts(int servingSize, int servings,
int calories, int fat)
this(servingSize, servings, calories, fat, 0);
public NutritionFacts(int servingSize, int servings,
int calories, int fat, int sodium)
this(servingSize, servings, calories, fat, sodium, 0);
public NutritionFacts(int servingSize, int servings,
int calories, int fat, int sodium, int carbohydrate)
this.servingSize = servingSize;
this.servings = servings;
this.calories = calories;
this.fat = fat;
this.sodium = sodium;
this.carbohydrate = carbohydrate;
当想要创建一个实例时，可以使用包含所有要设置的参数的最短参数列表的构造方法：
NutritionFacts cocaCola = new NutritionFacts(240, 8, 100, 0, 35, 27);
通常情况下，这个构造方法的调用需要许多你不想设置的参数，但是你不得不为它们传递一个值。 在这种情况下，我们为 fat 属性传递了 0 值。「只有」六个参数可能看起来并不那么糟糕，但随着参数数量的增加，它会很快失控。
简而言之，可伸缩构造方法模式是有效的，但是当有很多参数时，很难编写客户端代码，而且很难读懂它。读者不知道这些值是什么意思，并且必须仔细地计算参数才能找到答案。一长串相同类型的参数可能会导致一些细微的bug。如果客户端意外地反转了两个这样的参数，编译器并不会抱怨，但是程序在运行时会出现错误行为
当在构造方法中遇到许多可选参数时，另一种选择是 JavaBeans 模式，在这种模式中，调用一个无参数的构造函数来创建对象，然后调用 setter 方法来设置每个必需的参数和可选参数：
public class NutritionFacts
// Parameters initialized to default values (if any)
private int servingSize = -1; // Required; no default value
private int servings = -1; // Required; no default value
private int calories = 0;
private int fat = 0;
private int sodium = 0;
private int carbohydrate = 0;
public NutritionFacts()
// Setters
public void setServingSize(int val) servingSize = val;
public void setServings(int val) servings = val;
public void setCalories(int val) calories = val;
public void setFat(int val) fat = val;
public void setSodium(int val) sodium = val;
public void setCarbohydrate(int val) carbohydrate = val;
这种模式没有伸缩构造方法模式的缺点。有点冗长，但创建实例很容易，并且易于阅读所生成的代码:
NutritionFacts cocaCola = new NutritionFacts();
cocaCola.setServingSize(240);
cocaCola.setServings(8);
cocaCola.setCalories(100);
cocaCola.setSodium(35);
cocaCola.setCarbohydrate(27);
不幸的是，JavaBeans 模式本身有严重的缺陷。由于构造方法在多次调用中被分割，所以在构造过程中
JavaBean 可能处于不一致的状态。该类没有通过检查构造参数参数的有效性来执行一致性的选项。在不一致的状态下尝试使用对象可能会导致与包含 bug 的代码大相径庭的错误，因此很难调试。一个相关的缺点是，JavaBeans 模式排除了让类不可变的可能性，并且需要在程序员的部分增加工作以确保线程安全。
通过在对象构建完成时手动「冻结」对象，并且不允许它在解冻之前使用，可以减少这些缺点，但是这种变体在实践中很难使用并且很少使用。 而且，在运行时会导致错误，因为编译器无法确保程序员在使用对象之前调用freeze 方法。
幸运的是，还有第三种选择，它结合了可伸缩构造方法模式的安全性和 JavaBean 模式的可读性。 它是 Builder模式 的一种形式。客户端不直接调用所需的对象，而是调用构造方法 (或静态工厂)，并使用所有必需的参数，并获得一个 builder 对象。然后，客户端调用 builder 对象的 setter 相似方法来设置每个可选参数。最后，客户端调用一个无参的 build 方法来生成对象，该对象通常是不可变的。Builder 通常是它所构建的类的一个静态成员类。以下是它在实践中的示例：
//Builder Pattern
public class NutritionFacts
public final int servingSize;
public final int servings;
public final int calories;
public final int fat;
public final int sodium;
public final int carbohydrate;
//静态内部类Builder
public static class Builder
//必选变量
private final int servingSize;
private final int servings;
//可选变量
private final int calories = 0;
private final int fat = 0;
private final int sodium= 0;
private final int carbohydrate= 0;
//Builder的构造函数
public Builder(int servingSize, int servings)
this. servingSize = servingSize;
this.servings = servings;
//Builder的成员方法返回其自身，所以可以链式调用
//类似于setter()方法
public Builder calories(int val)
calories = val;
return this;
public Builder fat(int val)
fat = val;
return this;
public Builder sodium(int val)
sodium = val;
return this;
public Builder carbohydrate(int val)
carbohydrate = val;
return this;
//Builder的build方法，返回外部类的实例
public NutritionFacts build()
return new NutritionFacts(this);
//外部类的构造函数
private NutritionFacts(Builder build)
servingSize = build.servingSize;
servings = build.servings;
calories = build.calories;
fat = build.fat;
sodium = build.sodium;
carbohydrate = build.carbohydrate;
NutritionFacts 类是不可变的，所有的参数默认值都在一个地方。builder 的 setter 方法返回 builder 本身，这样调用就可以被链接起来，从而生成一个流畅的 API。下面是客户端代码的示例：
NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8)
.calories(100).sodium(35).carbohydrate(27).build();
以上是关于java-深入理解java嵌套类内部类以及内部类builder构建构造函数的主要内容，如果未能解决你的问题，请参考以下文章