黑马程序员---java基础之异常,线程,String与相关类

 

                                     ------- android培训、java培训、期待与您交流！ ----------

多看书,看好书,尽量充实自己,不要停止学习,不管学习什么,语言,厨艺,各种技能.

//今天的内容比较多

异常

异常就是我们程序中存在的问题，并且这种问题我们程序员是可以解决的.

 

在我们程序中问题分成两种

 所有的问题 Throwable

                            Exception(异常)    我们程序员处理的是异常

                            Error(错误)        我们不处理

例如:除数为0(异常)

                   ----------java ----------

                   Exceptionin thread "main" java.lang.ArithmeticException: / by zero

现在也出现了一个问题 创建数组时它占用的内存太大(错误)

---------- java ----------

                   Exceptionin thread "main" java.lang.OutOfMemoryError: Java heap space

 

对于异常,java中提供了方法可以来解决, 但是错误只能通过修改代码或其它途径.

 

解决异常的方式:

java中的异常解决方式是将逻辑代码与错误问题分离

java中异常处理方式有两种

                            1.捕获

                                     try    catch  finally

                            2.抛出                                 

                                     throws

使用异常处理问题的好处

                            1.使我们的逻辑代码与处理问题代码进行分离.程序更加清晰

                            2.通过异常对没有返回值的行为进行处理

异常处理第一种方式

                   捕获

                   try{

                            //有可能出现问题的代码

                   }catch(异常类型变量){

                            //处理问题的位置

                   }finally{

                            //强制执行语句

                   }

 

 

                   java中对于很多的异常，都有专门的类与之对应 

                            除数为0   ArithmeticException

                            空指针    NullPointerException

                            数组下标越界 ArrayIndexOutofBoundsException

也可以自己定义异常.

         专业的命名规则一般是XxxxxException 前面都是异常的名字后面是以父类为结束

异常中常用的方法

                            getMessage  错误信息

toString  显示的是  异常名  getMessage

                            printStackTrace  跟踪信息  toString 内容

注意：

                    如果try块中有多条语句，其中某一条出现了异常，

                    那么try块中的下面的语句就不会被执行，

                    而是直接执行catch中的内容

try-cath-finally

         无论try块中是否产生异常，finally中的内容永远会被执行到.

         finally块中在实际开发中一般完成关闭动作

 

例如:

         IO流  我们在操作文件时，会开辟通道与设备连接，这时比较消耗内存。使用完后

 需要关闭，那么我们就可以将关闭的动作放入到finally中完成。

         有一种情况，finally不会被执行到. system.exit(0);

         如果遇到了return,finally中的内容也会被执行

普通

                   try{

                   }catch(){

                   }finally{

                   }

 

没有catch

                   try{

                   }finally{

                   }

 

         多个catch

                   try{

                   }catch(){

                   }catch(){

                   }...

                   finally{

                   }

         以上三个里面，finally都不是必须的.

异常处理第二种方式             

                   异常的抛出  throws

                   了解异常分类

                            Exception

                                     ｜---- 编译异常   就是在javac 时就进行检测的异常

                                     ｜---- 运行异常   是程序在运行阶段才支检测的异常

Exception下面有一个RuntimeException 

                                     RuntimeException以及其所有子类都是运行异常

                                     除了RuntimeException及其子类外的所有类都是编译异常

无论是什么异常我们都可以使用上述两种行为人对其进行操作

                   但是对于编译异常，在代码上就强制要求必须对其进行处理.

                   而对于运行异常，我们在代码上没有强制要求，可以不用处理

 

throws 抛出异常throw  抛出异常

                   我们在开发中使用throw的作用就是将异常进行转型操作

                   自定义异常:   我们自己写异常类  我们只要做一个类继承自异常类就可以。

      throw与throws区别

                   throws它是用来标识一个方法是否抛出异常

                   throw它的作用是抛出一个异常对象

         1.throws写在方法的后面

                     throw 写在方法中

         2.throws后面写的异常类的名称

                     throw 后面写的是一个异常对象  new XxxException();

         3.throws后面可以加多个异常名称

                     throw后面只能有一个异常对象.

         throws后面可以跟多个异常名称

 

         方法的重写:子类中有一个与父类一样的方法  返回值类型  方法名参数列表一样

 注意 :

1. 重写的方法不能使用比被重写的方法更严格的修饰符

2. 在进行重写时异常的注意事项

         I   父类方法抛出异常，子类重写时没有抛出异常-----可以

         II  父类方法抛出异常,子类重写方法也抛出同样的异常 ---可以

         III父类方法抛出一个异常，而子类重写的方法抛出的是父类抛出异常的子异常.--可以

 

                   简单说对于重写的方法来说，父类中的方法如果抛出了异常，那么子类可以不抛出

                   如果要抛出只能与父类一样的异常或父类异常的子集.

                   如果父类中方法没有抛出异常，子类重写方法中产生了异常，

                   好么只能在重写的方法内捕获.而不能抛出.

包

包是用来管理类, 在说一个类的名字时，它的完整名称应该是包类.类名

包的作用

                   1.用来管理费用类

                   2.它用类提供了多层的命名空间

         包怎样定义

                   1.package来定义包的名称  package 包名;  包名一般都是小写的。

                   2.必须写在类的第一行，并且只能有一句

对于有包的类怎样编译

javac -d 包所在的路径类名.java

                   java包名.类名

         对于名的命名规则  所有包名小写，一般是将公司域名倒过来

         com.itheima.包中类的功能

         包也是一种封装形式.

访问权限

以前我们写的没包的代码，产生的.class文件都在同一目录下。

         如果一个类要访问带包的类，那么需要将它的全称写上

         包名.类名

         如果包与我们的.class文件没有在同一目录下，那么需要

         使用 set classpath去指定包所在的位置.

         我们在访问不同的包下的类时，要将这个类的全名写上，也就是包名.类名

         它有一种简化操作,我们可以在类上写上import 去将某一个不同的包下的类导入。

         导入后，在使用时直接使用类名就可以。

         注意：import它要写到package下边，import可以有多句

java中的四种访问权限

 

                     同一类中    同一包中   包外子类   不同的包

         public       ok         ok         ok         ok

         protected    ok          ok        ok         no

         默认         ok           ok         no        no

         private       ok         no        no         no

public 修饰的在所有范围内都可以访问

对于protected修饰的方法，我们要在子类中直接访问，是访问不了的。但是

         子类可以对父类中的protected方法进行重写，也就是说子类可以继承父类的protected方法.

         默认的是不写任何东西   只能在同一包内或同一类内访问.

例如：在模板方法模式中，我们就应该对抽象类中的所有的抽象方法声明成 protected

         abstract  calss Car{                

                   protectedabstract void fire();

                   protectedabstract void run();

                   protectedabstract void stop();

                   voiddrive(){

                            fire();

                            run();

                            stop();

                   }

         }

Jar文件

当前我们包中有很多.class文件，那么你将包给别人去用.

         jar简单理解成java的压缩文件

         jar文件怎样生成,使用jdk中jar.exe命令去生成.

         使用jar

         jar-cvf 压缩包名.jar 包名

                   c产生jar文件

                   v产生详细信息

                   f生成jar名字

                   t  列出归档目录

举例:

 

贪吃蛇游戏

                   cn.itcast.entity---->蛇类食物类

                   cn.itcast.view------>游戏界面类

                   cn.itcast.util------>这个包中定义了工具类

                   将这三个包封装到一个jar文件中

                   jar–cvfm  mypack.jar  mf.txt packa packb

                  将多个包封装到一个jar文件中时，需要指定

                   主方法所在的类是哪一个.

                   清单文件中就可以定义main方法所在的类.

         当生成jar文件后，我们要使用jar文件中的类，

         可以通过set classpath去设置jar文件路径

         那么在使用时，就可以直接使用jar中的类。

 

java中的多线程

线程概念:

进程:简单理解成一个应用程序员.

         线程:是进程的一个单元片段.多个线程组成了一个进程.

         多线程:有多条通路可以执行我们的程序,它提高了我们程序的效率

jvm启动时启动了几个线程?

                            它在启动时启动了两个线程,

                            一个非守护线程(main线程)

                            第二个（守护线程）垃圾回收线程

                   java是面向对象的语言，java中的线程不是面向对象的。

                   它的处理线程操作时，与c相比它的缺点很明显.

                   java.lang包,对于这个包下的所有的类在使用时不需要导包

java中的线程的创建方式

java.lang.Thread类就是java中的线程类.

         我们电脑中打开多个程序时，哪一个程序被执行，是由于cpu它分配时间片来确定的。

那么对于我们的多个线程来说，理想状态下是多个线程都是一起执行，但是因为硬件的

原因，一次只能有一个线程获得时间片，获得时间片的线程才能真正被执行，没有获得

时间片的线程，它们排队等待，对于线程优先级高，它就会排在前面，当cpu在分配时间片时，它就会优先执行。

         java中的线程优先级一共有10个,默认的是5 最高的是10,最低的是1

java创建线程有两种方式(*)

         1.将我们自己的类声明成Thread类的子类  (extendsThread)

                  步骤

                            1.将当前类继承自Thread类

                            2.重写父类中的run方法

                            3.启动线程，调用Thread类中的start方法

         2.声明自己的类实现Runnable接口.       (implements Runnable)

                   步骤

                            1.创建一个类实现Runnable接口

                            2.将接口中的run方法重写

                            3.启动线程  调用Thread类中的start方法

                   问题:当实现Runnable接口时，怎样启动线程

                            将实现Runnable接口的类的对象做为参数传递给一个

                                     Thread类对象

                            newThread(实现了Runnable接口的对象).start()方法

 

java线程中的方法

run()方法:作用是用来定义我们自己的线程要执行的内容。

                            start()启动线程

                   java中启动线程start方法与直接调用run方法的区别?

                            start方法是jvm重新开辟一条通过，去调用线程类中的

                            run方法中的内容.

                            而我们直接调用run方法，这就是在main线程中执行run的内容。

                   java中线程的执行的无序性

                            多个线程在执行时，它的执行顺序是由cpu时间片来分配的，

                            我们控制不了，它的执行结果会产生无序性.

                   在实际开发中我们选择哪一种方式去创建线程?

                            首选接口

         原因:1.使用接口可以让我们程序扩展性更强

                                      一个类只能继承一个父类

                                      但是可以实现多个接口。

                    2. 使用extends Thread类是要想多个线程操作公共数据

                                   那么这个数据要是static，如果不是static,而是

                                     实例属性，那么代表的是每个线程操作的都是自己的属性。

                                     static属性的缺点:它的生命周期太长，所占用的内存一直得不到释放.

 

                                     使用implements Runnable接口时，多个线程在操作公共数据时

                                     这个属性可以是实例属性，因为只有一个实现了Runnable接口的对象，

                                     要想创建线程并启动它，是通过new Thread(Runnable runnable)这样的方式去创建线程对象的。

                   线程中常用的方法

                            start启动线程

                            run   用来定义线程的执行内容

 

                            设置线程优先级

                                     publicfinal void setPriority(int newPriority)更改线程的优先级。

                            设置线程的名称与获得线程的名称

                            setName(Stringname) 用来设置线程的名称 

                            StringgetName()   用来获得线程的名称

                            staticThread currentThread();

                                     功能:得到当前正在执行的线程的引用

                                     返回值:正在执行的线程的引用

                                     static方法可以直接通过类名调用

                            子线程的默认名称  Thread-编号

                            主线程的名称  main

                            默认的优先是   5

线程的状态

         创建  new 出一个线程对象

         运行  执行run的内容  其时就是cpu将时间片分配给某个线程,它就具有了执行权.

         销毁  线程执行结束 run结束  或  stop

         冻结  是线程遇到了sleep或wait时由运行变成冻结，当冻结状态结束后不一定回到运行状，有可能回到临时堵塞状态。

         临时堵塞  当前线程具有执行资格,但是没有执行权，也就说线程启动了，但是cpu没有分配给其时间片。只能排队等待.

 

同步线程(线程安全)           

         线程安全问题产生的原因:

                            多个线程通过多条语句去操作共享数据

         怎样解决线程的安全问题

                   当某一个线程在操作数据时，它没有操作完，其它的线程是不允许操作的。

                   只有当这个线程执行完成后，我们才允许其它线程操作。我们管这种机制叫锁的机制.

         线程同步的问题

                            两种解决方式

                                     1.使用synchronized 块

                                               synchronized(对象){

                                                        多条语句操作的数据

                                               }

                                               锁的对象可以是任意对象

                                     2.使用synchronized 方法

                   使用同步代码块解决安全问题注意事项

                             所有的线程在操作时，要保证线程是案例的，

                             必须保证所使用的锁是同一个.

                   同步方法

                   其时就是使用synchronized去修饰一个方法.

                            同步代码块与同步方法的原理是一样的，

                            区别在于它们所控制的范围不一样。

                            同步方法它是将整个方法都锁定。

                            线程没有执行完这个方法，其它线程是不能执行的。

                            而同步代码块我们可以控制只方法中的某一部分去锁。

                            在实际操作中建议使用同步代码块。

                   同步的弊端:

                            多线程的优点：提高效率

                            使用同步后就使的多线程程序的效率降低.

                   将同步方法详细分析

 

                            同步方法它其时也是使用同步代码块实现的。

                            那么同步方法它所使用的锁是什么时候？

                            非静态的同步方法所使用的锁对象就是this

                            静态的同步方法所使用的锁对象不是this，

                            当前静态同步方法所使用的锁对象就是线程类的.class文件对象.

                            java中的所有的类都有一个静态的属性叫做.class

                            它的作用是得到当前类的字节码对象.                

        

      死锁

                   死锁是怎样产生的?

                   死锁多个线程互相持有对方锁。

                   怎样避免产生死锁?

                            死锁一般出现的原因就是嵌套问题。

                            那么就容易出现死锁。

                            要想避免产生死锁，那么就尽量少去嵌套。

 

单实例（懒汉式） 线程安全问题解决

 

上次讲到的单实例问题解决方案,通过锁的方式来解决.

//单实例     懒汉式

                   classSingleTon{

                            privatestatic SingleTon s;

                            privateSingleTon(){}

                            publicsynchronized static SingleTon getInstance(){

                                     //synchronized(SinglTon.class){

//在这存在线程的安全问题,第一个线程执行到这里，

它将时间片分配给其它线程，这时就会new出多个对象

                                               if(s==null){.

                                                        s=newSingleTon();

                                               }

                                     //}

                                     returns;

                            }

                   }

String类

String类是final修饰的它不能被继承

         String是引用类型

         双引号引起怕内容都是字符串对象.

         所有的字符串字面值都做为String对象存在.String是常量，其值在创建后不能改变

String类的构造方法

1.构造方法

                   String(char[]value)  将字符数组中的所有字符拼成了一个字符串

                   2.构造方法

                            String(char[]value,int offset,int count)

                   将字符数组中从offset开始的count个字符拼成一个字符串

                   以上两个构造方法可以将char[] 转换成字符串

                  

                   3.构造方法

                            String(byte[]b) 将数值对应的字符拼成字符串

                   4.构造方法

                            String(byte[]b,int offset,int count)

                   以上两个构造方法可以将byte[]转换成字符串

 

                   5.构造方法

                            String()

                                     String类提供无参构造

                   6.构造方法

                            String(Strings)

                                     根据一个字符去实例化一个字符串

                   7.构造方法

                            String(int[]arr,int offset,int count)

                                     使用arr数据中从offset开始的count个数值对应的字符去构造字符串

String类的成员方法

比较的方法

                   1.equals

                            这个方法是从Object类继承的，String类对其进行了重写

                            声明  public boolean equals(Objectobj)

                            作用: 它是将两个字符串中的所有字符进行比较

                            我们在对字符串进行比较时使用equals而不使用==

                   2.equalsIgnoreCase

                            声明   public booleanequalsIgnoreCase(String s);

                            作用   与equals方法一样，只是它不区分大小写.

                   3.contains  (了解)

                            声明  public booleancontains(CharSequence c)

                            作用  判断字符串是否包含c这样的子串，包含返回true,不包含返回false

"abc".contains("a")  //"a"它的类型是String，String实现了CharSequence

                                                                          

                   4.startsWithendsWith  (了解)

                            4.1startwWith

                                     声明  public booleanstartsWith(String s);

                                     作用  是判断一个字符串是否以s开头,如果是返回true,不是返回false;

                            4.2endsWith

                                     声明  public booleanendsWith(String s)

                                     作用  是判断一个字符串是否以s结尾.如果是返回true,不是返回false;

                   5.isEmpty(JDK1.6版本)  (了解)

                                     声明 public boolean isEmpty();

                                     作用判断一个字符串是否为空。

                            其时它就是判断字符串的长度是否为0,如果为0，返回true,

                            不为0返回false;

                            如果一个字符串中是空格 " " ,它也不代表为空.

                            只有""才代表为空.

转换的方法

                            1.getBytes(重点)

                                     声明  public byte[] getBytes();

                                     作用  是将一个字符串转换成byte数组

                            2.toCharArray(重点)

                                     声明 public char[] toCharArray();

                                     作用是将一具字符串转换成char数组

                            3.staticString copyValueOf();(了解)

                                     通过查看源码发现copyValueOf()底层实现与valueOf一样

                                     所以在使用时，我们可以与其valueOf方法一样去使用

                                               3.1  声明  public static StringcopyValueOf(char[] ch);

                                               3.2  声明  public static StringcopyValueOf(char[] ch,int offset,int count)

                            4.valueOf();(重点)

                                     声明  public static StringvalueOf(参数)

                   这个方法的参数基本上包含这么三部分  1.基本数据类型  2.char[] 3.Object

                                     作用：将参数指定的数据变成String

                            5.toLowerCase()    toUpperCase() （了解）

5.1 toLowerCase

                                              声明  public String toLowerCase()

                                             作用  将字符串转换成小写

                                      5.2toUpperCase

                                      声明  public String toUpperCase()

                                      作用  将字符串转换成大写

                                     char[]--------->String

                                               1.newString(char[] ch)

                                               2.valueOf(char[]ch)

                                               3.copyValueOf(char[]ch);

                                     String---------->char[]

                                               1.toCharArray()

                                     byte[]---------->String

                                               1.newString(byte[] b);

                                     String----------->byte[]

                                               1.getBytes()

String获取方法

                            1.length(重点)

                                     声明:public int length()

                                     作用:得到字符串的长度

                                     关于length有笔试题

                                               问：数组有length方法还是属性,字符串有length方法还是属性?

                                               答:   数组有length属性而字符串有length方法

                            2.charAt(重点)

                                     声明: public char charAt(int index);

                                     作用:得到指宝index位置上的字符，字符串的位置值叫索引，它是从0开始到length()-1

                            3.indexOf(重点)                        

                                     3.1

                                               声明：public int indexOf(int code);

                                               作用: 得到code代表的字符第一次出现在字符串中的索引，如果不存在返回-1

                                     3.2

                                               声明: public int indexOf(int code,int fromIndex)

                                               作用: 从fromIndex位置开始查找code代表的字符第一次出现的位置，如果不存在返回-1

                                     3.3

                                               声明: public int indexOf(String substring)

                                               作用: 查找字符串中第一次出现substring子串的位置，如果不存在返回-1

                                     3.4

                                               声明: public int indexOf(String substring,int fromIndex)

                                               作用: 从fromIndex位置开始查找substring子串第一次出现在字符串中位置，不存在返回-1  

                                               如果fromIndex的值为负 从0开始查找,如果值大于length()，那么它相当从length()位置开始,返回的是-1;

                            4.lastIndexOf

                                      它与indexOf方法功能基本相同，区别在于它是从后向前查找

                                      当fromIndex的值

                                               如果它大于等于此字符串的长度，则与它小于此字符串长度减 1 的效果相同：将搜索整个字符串。

                                               如果它为负，则与它为 -1 的效果相同：返回 -1。

                            5.substring(重点)

                                     5.1  

                                               声明 :public String substring(int start);

                                               作用: 从字符串的start位置开始截取字符串，一直截取到末尾

                                               注意 start值中能从0-length()之间取  包信0与length()的值.如果是length()的值

                                                    得到的就是一个空串

                                                         如果超过length()的值，会产生 StringIndexOutOfBoundsException异常.

                                     5.2

                                               声明：public String substring(int start,int end);

                                               作用:  截取字符串start开始到end之间的字符串

                                               注意: 包含开始不包含结束.

                                                          如果 start 为负，或 end 大于此 String 对象的长度，或 start 大于 end都是会产生

                                                          StringIndexOutOfBoundsException异常

String 其它方法

                            1.replace替换(了解)

                                     1.1

                                                声明 public Stringreplace(char oldchar,char newchar)

                                                作用 使用newchar将字符串中所有的oldchar替换.这个方法的返回值是替换后的字符串

                                     1.2

                                               声明 public String replace(CharSequence oldString,CharSequencenewString);

                                               作用:将字符串中的所有oldString用newString替换.

                            2.split切割(了解)

                                     声明： public String[] split(String s)

                                     作用:  将字符串按照s进行切割，切割后的每一部分做为String数组的一个元素。(在使用时注意正则的问题)

                            3.trim去空格(重点)

                                     声明: public String trim();

                                     作用:去掉字符串前后两边的空格.

                            4.compareTo比较字符串unicode (了解)

                                               这个方法就是比较字符串的大小的。

                                               声明 public int compareTo(String s)

                                               作用:比较两个字符串大小

                                                    如果返回的是0，代表这两个字符串相同  返回正数,代表在字典顺序中在后  返回负数代表大字典顺序中在前是按照字符串的"自然顺序" 比较

 

关于StringBuffer与StringBuilder

StringBuffer与String的区别

                   String它的对象表示的是一个常量,它的值创建后不能改变。

                   StringBuffer是一个字符串缓冲区,它的底层是一个数组，

                   它可以将所有的字符串都保存到这个数组中。

StringBuffer的构造方法

                            1.

                                     StringBuffer();

                                     构造一个默念长度为16个字符的字符串缓冲区

                            2.

                                     StringBuffer(intlen)

                                     构造一个指定长度的字符串缓冲区

                            3.

                                     StringBuffer(Strings);

                                     构造一个具有指定内容的StringBuffer

      StringBuffer成员方法

1.append方法

         声明:public StringBuffer append(参数 c)

         参数类型可以是:1.基本类型   2.char[] 3.Object 4.String或StringBuffer

         返回值是StringBuffer

         作用:向StringBuffer上添加内容

                   对于字符串连接时我们建议使用append方法,而不要使用+操作。

                   在实际开发中append方法什么时候应用的比较多?

                   2.在ajax开发,经常会从服务器向客户端返回一个字符串信息，这个字符串是

          一些相关信息的组合，那么在组合这些信息时会使用到append方法.

                                    

2.insert方法

         声明:public StringBuffer insert(int offset,参数 c)

                   将c插入到offset这个位置

         作用：是将指定的数据插入到指定的位置

        

         3.delete

                   1.声明 public StringBuffer delete(int start,int end)

                            作用  删除StringBuffer中从start开始到end结束的字符,不包含end

                   2.声明  public StringBufferdeleteCharAt(int index);

                            作用  删除StringBuffer中index位置上的字符.

         4.reverse

                   声明 public StringBuffer reverse();

                   作用将StringBuffer反转

         5.其它方法

                   setCharAt方法

                            声明 public void setCharAt(int index,char c);

                            作用 使用c替换index位置上的字符

                   trimToSize();

                            当我们使用StringBuffer进行操作时，底层数组会越来越大，

                            这个方法可以将数组中没有使用的空间清理掉，它可以提高空间的利用率;

                            String类中提供的大部分方法我们在StringBuffer中也可以找到。

StringBuffer与StringBuilder区别                     

StringBuffer与StringBuilder功能相似，StringBuffer中提供的方法在StringBuilder中也有。

         StringBuffer是线程的安全的(同步)，它的效率比较低.

         StringBuilder是线程不安全(异步),它的效率比较高

                            String与StringBuffer转换

                                     String----->StringBuffer

                                              newStringBuffer(String s);

                                     StringBuffer--->String

                                               toString()

                                               newString(StringBuffer buff);

包装类

                   作用:

                            1.它可以将基本数据类型包装成对象

                            2.它可以在基本数据类型与String之间转换

                   java中的基本数据类型与其包装类

                            整型

                                     byte--------->Byte

                                     short-------->Short

                                     int  --------->Integer

                                     long--------->Long

                            浮点

                                     float-------->Float

                                     double------->Double

                            字符

                                     char---------->Character

                            布尔

                                     boolean------->Boolean

                   基本类型的转换:double float long int short(char) byte

                   引用类型转换:前提  必须存在extends implements(继承||实现)关系

                   基本<------>引用

                            使用包装类

                   1.基本类型------>引用

                            使用构造方法.例如:Integer    构造  Integer(int value)

                   Integer类中的方法

                            intValue

                            声明:public int intValue();

                            作用:就是得到Integer对象中的包装的int属性值

                   在基本数据类型与String之间做转换 使用包装类

                   以Integer类为例:

                            基本类型---->String

                                     toString方法

                                               声明 public static String toString(int value);

                                               作用将一个int类型的值转换成String

                            String------>基本类型

                                     parseInt方法(重点)

                                               声明 public static int parseInt(String s)

                                               作用将一个String类型的数据转换成int

                   了解Integer类中的其它方法

                            toBinaryString

                                      声明: publicstatic String toBinaryString(int i)

                                      作用: 将一个数字转换成二进制.

                            toOctalString

                                      声明: publicstatic String toOctalString(int i)

                                      作用: 将一个数字转换成八进制

                            toHexString

                                      声明: publicstatic String toHexString(int i)

                                      作用: 将一个数字转换成十六进制

jdk1.5 新特性

/自动装箱

                            Integerin=10; //底层自动将来10包装成对象  new Integer(10)

                            //自动拆箱

                            inti=in+100; //底层将in的intValue的返回值取出操作

                            关于Integer的自动装箱笔试题

                                     Integer in1=127;

                                     Integerin2=127;

                                     System.out.println(in1==in2);//true

                                     Integerin1=128;

                                     Integerin2=128;

                                     System.out.println(in1==in2);//false

                                     //如果全都是new出来的，那么他们在内存空间中都有自己的空间。

                                     //如果作用了自动装箱,它的值如果是在byte的范围内，不会重新创建，

                                     //如果超出范围会重新创建创建

 

温故而知新,每天看看以前学过的知识点,会学到很多.

 

------- android培训、java培训、期待与您交流！ ----------