Java之学习笔记(19)-----------包装类和匿名类


包装类(Wrapper Class)

  包装类是针对于原生数据类型的包装

  因为有8个原生数据类型,所以对应有8个包装类。

  所有的包装类(8个)都位于java.lang下。

  Java中的8个包装类分别是:Byte, Short, Integer, Long, Float, Double, Character, Boolean,它们的使用方式都是一样的,可以实现原生数据类型与包装类型的双向转换。

 

 

  Java语言是一个面向对象的语言,但是Java中的基本数据类型却是不面向对象的,这在实际使用时存在很多的不便,为了解决这个不足,在设计类时为每个基本数据类型设计了一个对应的类进行代表,这样八个和基本数据类型对应的类统称为包装类(Wrapper Class),有些地方也翻译为外覆类或数据类型类。

         包装类均位于java.lang包,包装类和基本数据类型的对应关系如下表所示:

包装类对应表

基本数据类型

包装类

byte

Byte

boolean

Boolean

short

Short

char

Character

int

Integer

long

Long

float

Float

double

Double

         在这八个类名中,除了IntegerCharacter类以后,其它六个类的类名和基本数据类型一直,只是类名的第一个字母大写即可。

         对于包装类说,这些类的用途主要包含两种:

                   a、作为和基本数据类型对应的类类型存在,方便涉及到对象的操作。

                   b、包含每种基本数据类型的相关属性如最大值、最小值等,以及相关的操作方法。

         由于八个包装类的使用比较类似,下面以最常用的Integer类为例子介绍包装类的实际使用。

         1、实现intInteger类之间的转换

在实际转换时,使用Integer类的构造方法和Integer类内部的intValue方法实现这些类型之间的相互转换,实现的代码如下:

                   int n = 10;

                   Integer in = new Integer(100);

                   //int类型转换为Integer类型

                   Integer in1 = new Integer(n);

                   //Integer类型的对象转换为int类型

                   int m = in.intValue();

         2Integer类内部的常用方法

                  Integer类内部包含了一些和int操作有关的方法,下面介绍一些比较常用的方法:

                   aparseInt方法

                            public static int parseInt(String s)

该方法的作用是将数字字符串转换为int数值。在以后的界面编程中,将字符串转换为对应的int数字是一种比较常见的操作。使用示例如下:

                                     String s = “123”;

                                     int n = Integer.parseInt(s);

int变量n的值是123,该方法实际上实现了字符串和int之间的转换,如果字符串都包含的不是都是数字字符,则程序执行将出现异常。(说明:异常的概念将在下一章进行讲述)

另外一个parseInt方法:

         public static int parseInt(String s, int radix)

则实现将字符串按照参数radix指定的进制转换为int,使用示例如下:

         //将字符串”120”按照十进制转换为int,则结果为120

         int n = Integer.parseInt(“120”,10);

         //将字符串”12”按照十六进制转换为int,则结果为18

         int n = Integer.parseInt(“12”,16);

         //将字符串”ff”按照十六进制转换为int,则结果为255

         int n = Integer.parseInt(“ff”,16);

这样可以实现更灵活的转换。

                   btoString方法

                            public static String toString(int i)

                            该方法的作用是将int类型转换为对应的String类型。

                            使用示例代码如下:

                                     int m = 1000;

                                     String s = Integer.toString(m);

                            则字符串s的值是”1000”

                            另外一个toString方法则实现将int值转换为特定进制的字符串:

                                     public static int parseInt(String s, int radix)

                            使用示例代码如下:

                                     int m = 20;

                                     String s = Integer.toString(m);

                            则字符串s的值是”14”

         其实,JDK自从1.5(5.0)版本以后,就引入了自动拆装箱的语法,也就是在进行基本数据类型和对应的包装类转换时,系统将自动进行,这将大大方便程序员的代码书写。使用示例代码如下:

                   //int类型会自动转换为Integer类型

                   int m = 12;

                   Integer in = m;

                   //Integer类型会自动转换为int类型

                   int n = in;

         所以在实际使用时的类型转换将变得很简单,系统将自动实现对应的转换。

 

 

  下面以主要Integer类为例说明。

 

Integer

  Integer类将int类型的值包装到一个对象中。

  Integer通过下面这个构造方法构造相应的整型数的对象:

  public Integer(int value);

  public int intValue()方法则返回这个包装类所包装的整型值。

 

自动装箱/拆箱(Autoboxing/unboxing)

  JDK5.0的一个新特性是自动装箱和自动拆箱。

  自动装箱/拆箱大大方便了基本类型数据和它们包装类的使用。

  自动装箱:基本类型自动转为包装类(int >> Integer)

  自动拆箱:包装类自动转为基本类型(Integer >> int)

 

  比如下面的例子:

 

import java.util.ArrayList;
import java.util.Collection;

public class BoxTest
{
    public static void main(String[] args)
    {
        Collection c = new ArrayList();
    
        c.add(3);//将int类型的3转换为Integer类型并放到集合当中        
    }
}
 
 
包装类型     : Byte,Integer,Short,Long,Boolean,Character,Float,Double等

基本类型(primitive type)
不用new来创建变量,而是创建一个并非是“引用”的“自动”变量。这个变量拥有它的“值”,并置于堆

栈中,因此更加高效。要确定每种基本类型所占存储空间的大小。
基本类型            大小           最小值             最大值         包装器类型
boolean                -             -                   -         Boolean
char              6bit              Unicode 0      Unic ode 2(16)-1   Character
byte                       8bit                  -128                +127               Byte
short                      16bit                   -2(15)             2(15)-1           Short
int                          32bit                  -2(31)              2(31)-1           Integer
long                       64bit                 -2(63)              2(63)-1           Long
float                       32bit                 IEEE754           IEEE754          Float
double                   64bit               IEEE754            IEEE754          Double
void                        -                       -                        -                 Void

Java整型

int 4字节(32位) -2147483648 ~ 2147483647   (正好超过20亿)
short 2字节(16位) -32768 ~ 32767
long 8字节(64位) -9223372036854775808 ~ 9223372036854774807
byte 1字节(8位) -128 ~ 127



       浮点类型

float 4字节(32位) 大约±3.40282347E+38F (有效位数为6-7位)
double 8字节(64位) 大约±1.79769313486231570E+308 (有效位数为15位)

一些需要注意:

1if(x == Double.NaN)  // is never true


1if(Double.isNaN(x))  // check whether is "not a number"


       浮点数值不适合用于禁止出现舍入误差的金融计算中。例如System.out.println( 2.0 - 1.1);将打印0.899999999999999,而不是0.9。因为浮点数值采用二进制系统表示,而二进制无法精确表示分数1/10,就像十进制无法精确表示1/3一样。如果需要在数值计算中不含有舍入误差,就应该使用BigDecimal类。


一、 包装类(Wrapper Class)共同的方法

值得说明的是,java是可以直接处理基本类型的,但是在有些情况下我们需要将其作为对象来处理,这时就需要将其转化为包装类了.所有的包装类(Wrapper Class)都有共同的方法,他们是:

(1)带有基本值参数并创建包装类对象的构造函数.如可以利用Integer包装类创建对象,Integer obj=new Integer(145);

(2)带有字符串参数并创建包装类对象的构造函数.如new Integer("-45.36");

(3)可生成对象基本值的typeValue方法,如obj.intValue();

(4)将字符串转换为基本值的 parseType方法,如Integer.parseInt(args[0]);

(5)生成哈稀表代码的hashCode方法,如obj.hasCode();

(6)对同一个类的两个对象进行比较的equals()方法,如obj1.eauqls(obj2);

(7)生成字符串表示法的toString()方法,如obj.toString().

转换关系:

基本类型------>包装器类
Integer obj=new Integer(145);

包装器类------>基本类型
int num=obj.intValue();

字符串------>包装器类
Integer obj=new Integer("-45.36");

包装器类------>字符串包装器类

String str=obj.toString();

字符串------>基本类型
int num=Integer.parseInt("-45.36");

基本类型------>字符串包装器类

String str=String.valueOf(5);


        在一定的场合,运用java包装类来解决问题,能大大提高编程效率.

二、JDK1.5的新特性:自动装包/拆包(Autoboxing/unboxing)

  自动装包/拆包大大方便了基本类型数据和它们包装类地使用。

  自动装包:基本类型自动转为包装类.(int >> Integer)

  自动拆包:包装类自动转为基本类型.(Integer >> int)

  在JDK1.5之前,我们总是对集合不能存放基本类型而耿耿于怀,现在自动转换机制
解决了我们的问题。

int a = 3;
Collection c = new ArrayList();
c.add(a);//自动转换成Integer.

Integer b = new Integer(2);
c.add(b + 2);

  这里Integer先自动转换为int进行加法运算,然后int再次转换为Integer.

 
在学习包装类时,找了几个比较有意思的类进行了学习!
 
[java]  view plain copy
  1. "font-size:18px;">Integer i=3;  
  2. //上述语句毫无疑问,是进行一个类的创建!但通过Java Decompiler进行反编译后,发现这条语句被编译器优化成了Integer integer = Integer.valueOf(1);比较有意思,于是就看看valueOf中是什么  
  3.  public static Integer valueOf(int i) {  
  4.     final int offset = 128;  
  5.     if (i >= -128 && i <= 127) { // must cache   
  6.         return IntegerCache.cache[i + offset];  
  7.     }  
  8.         return new Integer(i);  
  9.     }  
  10. IntegerCache是什么  
  11.    private static class IntegerCache {  
  12.     private IntegerCache(){}  
  13.     static final Integer cache[] = new Integer[-(-128) + 127 + 1];  
  14.     static {  
  15.         for(int i = 0; i < cache.length; i++)  
  16.         cache[i] = new Integer(i - 128);  
  17.     }  
  18.     }  
  19. 原来当创建Integer时,-128-127范围内的数据已经以static final的形式预先创建了,放在堆中。当用户声明该范围的Integer类型的变量时,直接从IntegerCache中读取。  
  20. 可以做一个试验:  
  21.     Integer integer=1;  
  22.     Integer integer2=1;  
  23.     if (integer==integer2){  
  24.             System.out.println("ok");  
  25.     }  
  26. 结论是:integer与integer2所指的内存都是一致的,所以打印ok!  
  27. (在Java版经常看到很多人对堆与栈搞得很糊涂)  
[java]  view plain copy
  1. "font-size:18px;">   
[java]  view plain copy
  1. "font-size:18px;">Boolean:  
[java]  view plain copy
  1. "font-size:18px;"> Boolean boolean1=true;  
  2. //这个代码与上述的Integer integer=1的做法类似,编译器对此进行优化(大家可以下载一个java Decompiler)。优化后的语句为Boolean boolean1 = Boolean.valueOf(true);这时可以看看valueOf的代码  
  3.  public static Boolean valueOf(boolean b) {  
  4.         return (b ? TRUE : FALSE);  
  5.     }  
  6.  再看看TRUE与FALSE是什么?  
  7.  public static final Boolean TRUE = new Boolean(true);  
  8.    
  9.  public static final Boolean FALSE = new Boolean(false);  
  10. 原来Boolean在创建时已经创建了二个static final的Boolean对象,True与False。这时做个实验:  
  11. Boolean boolean1=true;  
  12.          Boolean boolean2=true;  
  13.          if (boolean1==boolean2){  
  14.              System.out.println("ok");  
  15.          }  
  16. 结果:boolean1与boolean2指向同一个堆地址。  
  17. 这里想说明一下==与equal,很难想像为什么每个博客都介绍这个的区别。对于对象类型==肯定是栈指针地址的对比,而equal,可以点开源码看一下  
  18. public boolean equals(Object anObject) {  
  19.     if (this == anObject) {  
  20.         return true;  
  21.     }  
  22.     if (anObject instanceof String) {  
  23.         String anotherString = (String)anObject;  
  24.         int n = count;  
  25.         if (n == anotherString.count) {  
  26.         char v1[] = value;  
  27.         char v2[] = anotherString.value;  
  28.         int i = offset;  
  29.         int j = anotherString.offset;  
  30.         while (n-- != 0) {  
  31.             if (v1[i++] != v2[j++])  
  32.             return false;  
  33.         }  
  34.         return true;  
  35.         }  
  36.     }  
  37.     return false;  
  38.     }  


匿名类:
 
 
 
java 匿名类(不能被忽略 (new+接口)是定义匿名类的一个形式)
 

匿名内部类 ( 明白了匿名类就理解了函数回调,(此处与线程无关))有位老兄说:(匿名一是为了简化代码,而是告诉GC我这个对象只用一次,用完给我回收了)

关于JAVA内部类:一个内部类的定义是定义在另一个类内部的类。

  存在它的原因是:

  1.一个内部类的对象能够访问创建它的对象的实现,包括私有数据。即内部类实例对包含它的哪个类的实例来说,是特权的。

  2.对于同一个包中的其他类来说,内部类能够隐藏起来,换句话说,内部类不管方法的可见性如何,那怕是public,除了包容类,其他类都无法使用它。

  3.匿名内部类可以很方便的定义回调。

  4.使用内部类可以非常方便的编写事件驱动程序。


其实它真正的目的仅仅为了定义回调--进一步就是事件驱动。

接口和回调:编程一个常用的模式是回调模式,在这种模式中你可以指定当一个特定时间发生时回调对象上的方法。


java的匿名内部类的语法规则看上去有些古怪,不过如同匿名数组一样,当你只需要创建一个类的对象而且用不上它的名字时,使用内部类可以使代码看上去简洁清楚。它的语法规则是这样的: 

new interfacename(){......}; 或 new superclassname(){......}; 

下面接着前面继续举例子: 

public class Goods3 { 
public Contents cont(){ 
return new Contents(){ 
private int i = 11; 
public int value() { 
return i; 

}; 



这里方法cont()使用匿名内部类直接返回了一个实现了接口Contents的类的对象,看上去的确十分简洁。 

在java的事件处理的匿名适配器中,匿名内部类被大量的使用。例如在想关闭窗口时加上这样一句代码: 

frame.addWindowListener(new WindowAdapter(){ 
public void windowClosing(WindowEvent e){ 
System.exit(0); 

}); 

有一点需要注意的是,匿名内部类由于没有名字,所以它没有构造函数(但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类,创建它的时候必须带上这些参数,并在实现的过程中使用super关键字调用相应的内容)。如果你想要初始化它的成员变量,有下面几种方法: 

如果是在一个方法的匿名内部类,可以利用这个方法传进你想要的参数,不过记住,这些参数必须被声明为final。 
将匿名内部类改造成有名字的局部内部类,这样它就可以拥有构造函数了。 
在这个匿名内部类中使用初始化代码块。 
为什么需要内部类? 
java内部类有什么好处?为什么需要内部类? 

首先举一个简单的例子,如果你想实现一个接口,但是这个接口中的一个方法和你构想的这个类中的一个方法的名称,参数相同,你应该怎么办?这时候,你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的,所以这样做可以完成所有你直接实现这个接口的功能。 

不过你可能要质疑,更改一下方法的不就行了吗? 

的确,以此作为设计内部类的理由,实在没有说服力。 

真正的原因是这样的,java中的内部类和接口加在一起,可以的解决常被C++程序员抱怨java中存在的一个问题——没有多继承。实际上,C++的多继承设计起来很复杂,而java通过内部类加上接口,可以很好的实现多继承的效果。

————————————————————————————————————

Java 1.1通过对Java语言规范进行修改,显著简化了一些实用结构的实现。在那些修改中,最引人注目的就是内部类和匿名类。如运用得当,它们可使程序更易理解和维护。下面来看看这些特性具体是如何工作的,如何正确使用它们,以及如何避免一些常见的错误。

    内部类
    简单地说,“内部类”是在另一个类的内部声明的类。从Java 1.1开始,你可在一个类中声明另一个类,这与声明字段和方法非常相似。包装了内部类声明的类就称为“外部类”。
    实际上,Java语言规范还允许你做更多的事情,包括:
    在另一个类或者一个接口中声明一个类。 
    在另一个接口或者一个类中声明一个接口。 
    在一个方法中声明一个类。 
    类和接口声明可嵌套任意深度。 
    清单A是类和接口的一些空白声明,它演示了这些可能性。
    使用一个import语句,你可像使用其他任何标准类那样省略package名称。此外,在外部类中,可利用简单名称来引用所有内部类和接口(参见清单A中的new语句)。注意从Method1中引用Inner2仍需指定Interface1,因为Inner2在一个不同的级别上。
    表A总结了清单A中声明的每个内部类和接口的完全限定名称。用了import语句之后,就可采用较短的形式。当然,在外部类中,你还可省略外部类的名称。
    名称 
    类/接口 
Inner1 mypackage.Inner1 
Interface1 mypackage.Interface1 
Inner2 mypackage.Interface1.Inner2 
Interface2 mypackage.Interface1.Interface2 
Inner3 Inner3对于Method1来说是local的,所以它不可在方法外部访问

    引用内部类
    内部类最自然的一种应用就是声明只在另一个类的内部使用的类,或者声明与另一个类密切相关的类。如清单B所示,它是一个链表的简单实现。由于Node类通常只在LinkedList的范围内使用,所以最好将Node声明为LinkedList的一个内部类。
    适用于类成员的访问控制修改符也适用于内部类;也就是说,内部类可以具有package、protected、private和public访问权限,它们的语义和正常的语义没有什么不同。由于Node要在LinkedList的外部使用,所以把它声明为public。
    然而,修饰符static具有不同的含义。应用于内部类时,它声明的类具有与其他类相同的语义,也就是可进行实例化,并像一个标准类那样使用。惟一的区别就是它拥有对外部类的所有静态成员的完全访问权限。清单C展示了一个简单的程序,它创建一个链表,并将它打印到标准输出设备。

    非静态内部类
    如果内部类没有指定static修饰符,就拥有对外部类的所有成员的完全访问权限,包括实例字段和方法。为实现这一行为,非静态内部类存储着对外部类的实例的一个隐式引用。
    所以,对一个非静态内部类进行实例化需要采用不同语法的new语句: 
.new 
这种形式的new语句要求外部类的一个实例,使内部类能在那个实例的上下文中创建。注意清单A声明了几个非静态内部类,并用标准的new语句在Method1中实例化它们。
之所以能那样做,是因为Method1是外部类的一个实例方法,所以new语句会在外部类的一个实例的上下文中隐式地执行。只有在外部类的外部或者在其他对象的上下文中实例化一个非静态内部类时,才需要使用修改过的语法。
    但是,非静态内部类具有一些限制。尤其是,它们不能声明静态初始化列表和静态成员,除非是在常量字段中。此外,方法内部声明的内部类不能访问方法的局部变量和参数,除非它们被初始化成final。

    匿名类
    匿名类是不能有名称的类,所以没办法引用它们。必须在创建时,作为new语句的一部分来声明它们。
    这就要采用另一种形式的new语句,如下所示: 
new <类或接口> <类的主体>
这种形式的new语句声明一个新的匿名类,它对一个给定的类进行扩展,或者实现一个给定的接口。它还创建那个类的一个新实例,并把它作为语句的结果而返回。要扩展的类和要实现的接口是new语句的操作数,后跟匿名类的主体。
    如果匿名类对另一个类进行扩展,它的主体可以访问类的成员、覆盖它的方法等等,这和其他任何标准的类都是一样的。如果匿名类实现了一个接口,它的主体必须实现接口的方法。
    注意匿名类的声明是在编译时进行的,实例化在运行时进行。这意味着for循环中的一个new语句会创建相同匿名类的几个实例,而不是创建几个不同匿名类的一个实例。
    从技术上说,匿名类可被视为非静态的内部类,所以它们具有和方法内部声明的非静态内部类一样的权限和限制。
    如果要执行的任务需要一个对象,但却不值得创建全新的对象(原因可能是所需的类过于简单,或者是由于它只在一个方法内部使用),匿名类就显得非常有用。匿名类尤其适合在Swing应用程序中快速创建事件处理程序。 
    清单D就是一个非常简单的Swing应用程序,它展示了与匿名类有关的几个概念。这个例子创建了两个匿名类。第一个对java.awt.event.WindowAdapter进行扩展,并在应用程序窗口关闭时调用应用程序的onClose方法。
    即使onClose声明为private,匿名类也能调用它,因为匿名类本质上是应用程序类的一个内部类。第二个匿名类实现了java.awt.ActionListener接口,它在一个按钮被按下后关闭应用程序窗口。注意匿名类可以访问本地变量frame。这是由于匿名类在与frame相同的方法内部声明。然而,frame要被声明为final,否则会生成编译错误。

    更优化的代码
    内部和匿名类是Java 1.1为我们提供的两个出色的工具。它们提供了更好的封装,结果就是使代码更容易理解和维护,使相关的类都能存在于同一个源代码文件中(这要归功于内部类),并能避免一个程序产生大量非常小的类(这要归功于匿名类)。

java中的匿名内部类总结

匿名内部类也就是没有名字的内部类

正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写

但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口

 

实例1:不使用匿名内部类来实现抽象方法
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
abstract class Person {
    public abstract void eat();
}
 
class Child extends Person {
    public void eat() {
        System.out.println("eat something");
    }
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Child();
        p.eat();
    }
}

运行结果:eat something

可以看到,我们用Child继承了Person类,然后实现了Child的一个实例,将其向上转型为Person类的引用

但是,如果此处的Child类只使用一次,那么将其编写为独立的一个类岂不是很麻烦?

这个时候就引入了匿名内部类

 

实例2:匿名内部类的基本实现
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
abstract class Person {
    public abstract void eat();
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

运行结果:eat something

可以看到,我们直接将抽象类Person中的方法在大括号中实现了

这样便可以省略一个类的书写

并且,匿名内部类还能用于接口上

 
实例3:在接口上使用匿名内部类
?
interface Person {
    public void eat();
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

运行结果:eat something

 

由上面的例子可以看出,只要一个类是抽象的或是一个接口,那么其子类中的方法都可以使用匿名内部类来实现

最常用的情况就是在多线程的实现上,因为要实现多线程必须继承Thread类或是继承Runnable接口

 

实例4:Thread类的匿名内部类实现
?
public class Demo {
    public static void main(String[] args) {
        Thread t = new Thread() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        t.start();
    }
}

运行结果:1 2 3 4 5

 

实例5:Runnable接口的匿名内部类实现
?
1
2
3
4
5
6
7
8
9
10
11
12
13
public class Demo {
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        Thread t = new Thread(r);
        t.start();
    }
}

运行结果:1 2 3 4 5

 

 

大功告成!!!

良心的公众号,更多精品文章,不要忘记关注哈

《Android和Java技术栈》


你可能感兴趣的:(Java学习路程,java,jvm)