java(4)-深入理解java嵌套类、内部类以及内部类builder构建构造函数

(71) 2024-07-14 21:01:01

一、什么是嵌套类及内部类


  可以在一个类的内部定义另一个类,这种类称为嵌套类(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"); } }); } }

D、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表达式传递给以函数式接口作为参数的方法。

六、静态成员类优于非静态成员类


       这四种嵌套类都有自己的用途。

匿名类使用:假设这个嵌套类属于一个方法的内部,如果只需要在一个地方创建实例,并且已经有了一个预置的类型可以说明这个类的特征,就要把它做成匿名类。通常用于创建函数对象和过程对象,不过现在会优先考虑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();

 

THE END

发表回复