day03【多态，内部类，常用API 1】.pptx
# 1 查看源码：ctrl+N # 2 查看某个类的成员结构：alt+7

一、多态

概述

面向对象语言三大特征：封装(private)、继承(extends)、多态。 多态：表示的是一个事物的多种表现形态。同一个事物，以不同的形态表现出来.**

:::info

使用多态的前提

  1. 继承(extends)或者实现(implements)【二选一】
  2. 方法的重写【意义体现：不重写，无意义】
  3. 父类引用指向子类对象【格式体现】 :::

    多态的体现

    1. 父类类型 变量名 = new 子类对象； 变量名.方法名();|
    小结：多态的好处是提高程序的灵活性，扩展性

    引用类型转换

    多态的转型分为向上转型与向下转型两种：

    • 向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

    当父类引用指向一个子类对象时，便是向上转型。

  1. 父类类型  变量名 = new 子类类型();
  2. 如：Animal a = new Cat();
  • 向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

  1. 子类类型 变量名 = (子类类型) 父类变量名;
  2. 如:Cat c =(Cat) a;
  1. abstract class Animal {  
  2.     abstract void eat();  
  3. }  
  5. class Cat extends Animal {  
  6.     public void eat() {  
  7.         System.out.println("吃鱼");  
  8.     }  
  9.     public void catchMouse() {  
  10.         System.out.println("抓老鼠");  
  11.     }  
  12. }  
  14. class Dog extends Animal {  
  15.     public void eat() {  
  16.         System.out.println("吃骨头");  
  17.     }  
  18.     public void watchHouse() {  
  19.         System.out.println("看家");  
  20.     }  
  21. }
  22. 测试类
  23. public class Test {
  24.     public static void main(String[] args) {
  25.         // 向上转型  
  26.         Animal a = new Cat();  
  27.         a.eat();                 // 调用的是 Cat 的 eat
  29.         // 向下转型  
  30.         Cat c = (Cat)a;       
  31.         c.catchMouse();         // 调用的是 Cat 的 catchMouse
  32.     }  
  33. }

转型的异常:ClassCastException类型转换异常

避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         // 向上转型  
  4.         Animal a = new Cat();  
  5.         a.eat();               // 调用的是 Cat 的 eat
  7.         // 向下转型  
  8.         if (a instanceof Cat){
  9.             Cat c = (Cat)a;       
  10.             c.catchMouse();        // 调用的是 Cat 的 catchMouse
  11.         } else if (a instanceof Dog){
  12.             Dog d = (Dog)a;       
  13.             d.watchHouse();       // 调用的是 Dog 的 watchHouse
  14.         }
  15.     }  
  16. }

二、内部类

概述

什么是内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。可以把内部类理解成寄生，外部类理解成宿主。 内部类是Java类的五大成员之一，也是我们最后一个需要学习的成员。

  1. 按定义的位置来分 
  3. 1. 成员内部类，类定义在了成员位置 (类中方法外称为成员位置)
  4. 2. 匿名内部类。定义在局部位置

成员内部类成员内部类特点：

  • 无static修饰的内部类，属于外部类对象的。
  • 宿主：外部类对象。 ```java 外部类.内部类。 // 访问内部类的类型都是用 外部类.内部类

外部类.内部类 变量 = new 外部类构造器.new 内部类构造器;
class Outer02{

  1. // 实例内部类，属于外部类对象的。
  2. // 拓展：实例内部类不能定义静态成员。
  3. public class Inner02{
  4.     // 这里面的东西与类是完全一样的。
  5.     private String name;
  7.     public Inner02(String name) {
  8.         this.name = name;
  9.     }
  11.     public void showName(){
  12.         System.out.println(this.name);
  13.     }
  14. }

}

public class InnerClassDemo02 { public static void main(String[] args) { // 宿主：外部类对象。 // Outer02 out = new Outer02(); // 创建内部类对象。 Outer02.Inner02 in = new Outer02().new Inner02(“张三”); in.showName(); } } Outer.Inner in=new Outer().new Inner();表示使用外部类的匿名对象new Outer()调用内部类的对象重新赋值给一个变量in。这里的in就表示内部类对象名。 注意：上述代码中，当外部类Outer.class被加载到内存中的时候，内部类Outer$Inner.class还没有被加载到内存中，仍然在硬盘中，只有当创建对象的时候使用内部类的时候，jvm才会将Outer$Inner.class加载到内存中。

  1. <a name="KjiUO"></a>
  2. ### 成员内部类面试题
  3. ```java
  4. // 身体
  5. class Body {    
  6.     private int weight = 30;
  7.     // 在成员位置定义一个类
  8.     class Heart {
  9.         private int weight = 20;
  10.         public void jump() {
  11.             System.out.println("局部内部类函数this="+this);
  12.             System.out.println("外部类this="+Body.this);
  13.             int weight = 10;
  14.             System.out.println("心脏在跳动 " + weight);    // 10
  15.             System.out.println("心脏在跳动 " + this.weight);    // 20
  16.             System.out.println("心脏在跳动 " + Body.this.weight);    // 30
  17.         }
  18.     }
  19. }
  20. public class Demo05 {
  21.     public static void main(String[] args) {
  22.         Body b = new Body();
  23.         System.out.println("b="+b);
  24.         Body.Heart heart = new Body().new Heart();
  25.         System.out.println("heart="+heart);
  26.         heart.jump();
  27.     }
  28. }

匿名内部类【重点】

概述

匿名内部类 ：是内部类的简化写法。它的本质是一个带具体实现的父类或者父接口的匿名的子类对象。开发中，最常用到的内部类就是匿名内部类了。

匿名内部类前提和格式

匿名内部类必须继承一个父类或者实现一个父接口。

  1. new 父类名或者接口名(){
  2.     // 方法重写
  3.     @Override 
  4.     public void method() {
  5.         // 执行语句
  6.     }
  7. };
  8. 说明：
  9.     1.其实上述整体格式是父类或者父接口的子类对象
  10.     2.
  11.         {
  12.             // 方法重写
  13.             @Override 
  14.             public void method() {
  15.                 // 执行语句
  16.             }
  17.         }
  18.     这些内容称为匿名内部类。但是不能单独书写，必须结合上述new 父类名或者接口名()一起。

匿名内部类的特点

  1. 定义一个没有名字的内部类
  2. 这个类实现了父类，或者父类接口
  3. 匿名内部类会创建这个没有名字的类的对象

    三、常用API

    Object类

    概述

    java.lang.Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。如果一个类没有特别指定父类， 那么默认则继承自Object类

equals方法

方法摘要

  • public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否是相同的。

查看源码： Object类中的equals()方法也是判断地址值是否相同 public boolean equals(Object obj) { return (this == obj); }

Objects类

  1. - 作用：
  2.   Objects的equals()是一个静态方法，可以使用类名直接调用，可以更完善的判断两个对象。
  3. - 源码：
  4. /*
  5. 源码的内部其实也是使用equals()方法在判断
  6. 只不过在判断之前做了一些更完善的操作：
  7.     1.先判断两个对象的地址值是否相同，如果相同就会短路，提高效率
  8.     2.判断a不等于null,避免空指针异常
  9. */
  11. public static boolean equals(Object a, Object b) {
  12.     return (a == b) || (a != null && a.equals(b));
  13. }
  14. 优点：
  15. 提高效率，避免了异常的产生。
  17. 代码演示：
  18. public class Test01 {
  19.     public static void main(String[] args) {
  20.         //定义一个字符串
  21.         String s1 = null;
  22.         String s2 = "abc";
  23.         //判断s1和s2是否相等 NullPointerException
  24. //        boolean boo = s1.equals(s2);
  25.         /*
  26.             防止空指针异常引入Objects类，从jdk1.7 真正是在jdk1.8开始使用
  27.             static boolean equals(Object a, Object b)
  28.          */
  29.         //使用Objects工具类中的静态方法比较上述s1和s2,目的是防止空指针异常
  30. //        boolean boo = Objects.equals(s1, s2);
  31.         /*
  32.             Object a= s2 --- "abc" 发生多态了
  33.             Object b = s1 --- null
  34.             public static boolean equals(Object a, Object b) {
  35.                                                 //a属于String类对象，调用Object的子类String类中的equals方法
  36.                 return (a == b) || (a != null && a.equals(b));
  37.             }
  39.          */
  40.         boolean boo = Objects.equals(s2, s1);
  41.         System.out.println("boo = " + boo);
  42.     }
  43. }

Date类

java.util.Date类 表示特定的瞬间，精确到毫秒。

  • public Date()：从运行程序的此时此刻到时间原点经历的毫秒值,转换成Date对象，分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
  • public Date(long date)：将指定参数的毫秒值date,转换成Date对象，分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。

tips: 由于中国处于东八区（GMT+08:00）是比世界协调时间/格林尼治时间（GMT）快8小时的时区，当格林尼治标准时间为0:00时，东八区的标准时间为08:00。

  1. - public long getTime() 把日期对象转换成对应的时间毫秒值。
  2. - public void setTime(long time) 把方法参数给定的毫秒值设置给日期对象
  3. public class DateDemo02 {
  4.     public static void main(String[] args) {
  5.         //创建日期对象
  6.         Date d = new Date();
  8.         //public long getTime():获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
  9.         //System.out.println(d.getTime());
  12.         //public void setTime(long time):设置时间，给的是毫秒值
  13.         long time = 1000*60*60;
  14.         d.setTime(time);
  16.         System.out.println(d);
  17.     }
  18. }

小结：Date表示特定的时间瞬间，我们可以使用Date对象对时间进行操作。

DateFormat类

概述

java.text.DateFormat 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

  • 格式化：按照指定的格式，把Date对象转换为String对象。
  • 解析：按照指定的格式，把String对象转换为Date对象。

    构造方法

    由于DateFormat为抽象类，不能直接使用，所以需要常用的子类java.text.SimpleDateFormat。这个类需要一个模式（格式）来指定格式化或解析的标准。构造方法为：
  • public SimpleDateFormat(String pattern)：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。参数pattern是一个字符串，代表日期时间的自定义格式。

    格式规则

标识字母（区分大小写） 含义
y 年
M 月
d 日
H 时
m 分
s 秒

备注：更详细的格式规则，可以参考SimpleDateFormat类的API文档。

  1. - public String format(Date date)：将Date对象格式化为字符串。
  2. - public Date parse(String source)：将字符串解析为Date对象。
  3. public class SimpleDateFormatDemo {
  4.     public static void main(String[] args) throws ParseException {
  5.         //格式化：从 Date 到 String
  6.         Date d = new Date();
  7.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
  8.         String s = sdf.format(d);
  9.         System.out.println(s);
  10.         System.out.println("--------");
  12.         //从 String 到 Date
  13.         String ss = "2048-08-09 11:11:11";
  14.         //ParseException
  15.         SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  16.         Date dd = sdf2.parse(ss);
  17.         System.out.println(dd);
  18.     }
  19. }

DateFormat可以将Date对象和字符串相互转换。

Calendar类

概述

  • java.util.Calendar类表示一个“日历类”，可以进行日期运算。
  • 日历类把和时间相关的所有值都定义为了字段，对时间的操作可以用字段的方式完成。
  • 它是一个抽象类，不能创建对象，我们可以使用它的子类：java.util.GregorianCalendar类。
  • 有两种方式可以获取GregorianCalendar对象：
    • 直接创建GregorianCalendar对象；子类构造方法：
    • GregorianCalendar()
    • 通过Calendar的静态方法getInstance()方法获取GregorianCalendar对象
  1. DAY_OF_WEEK的范围：1--7，分别表示："星期日","星期一","星期二",...,"星期六"。在java中,星期日是一周的第一天。
  2.   //  1  2  3  4  5  6  7
  3.   //  日 一 二 三 四  五  六
  4. public class Demo {
  5.     public static void main(String[] args) {
  6.         //1.获取一个GregorianCalendar对象
  7.         Calendar instance = Calendar.getInstance();//获取子类对象
  9.         //2.打印子类对象
  10.         System.out.println(instance);
  12.         //3.获取属性
  13.         int year = instance.get(Calendar.YEAR);
  14.         int month = instance.get(Calendar.MONTH) + 1;//Calendar的月份值是0-11
  15.         int day = instance.get(Calendar.DAY_OF_MONTH);
  17.         int hour = instance.get(Calendar.HOUR);
  18.         int minute = instance.get(Calendar.MINUTE);
  19.         int second = instance.get(Calendar.SECOND);
  22.         System.out.println(year + "年" + month + "月" + day + "日" + 
  23.                                hour + ":" + minute + ":" + second);
  25.         int week = instance.get(Calendar.DAY_OF_WEEK);//返回值范围：1--7，分别表示："星期日","星期一","星期二",...,"星期六"
  26.         // 在java中,星期日是一周的第一天
  27.         System.out.println("星期：" + method(week));
  29.         //  1  2  3  4  5  6  7
  30.         //  日 一 二 三 四  五  六
  31.     }
  33.     //把Calendar中的星期转成我们中国习惯的星期
  34.     public static String method(int week){
  35.         //创建数组
  36.         String[] arr = {"","日","一","二","三","四","五","六"};
  38.         //返回元素
  39.         return arr[week];
  40.     }
  41. }
  1. package com.itheima.sh.k_date_11;
  3. import java.util.Calendar;
  5. /*
  6.     Calendar类中的set add方法演示
  7.  */
  8. public class CalendarDemo07 {
  9.     public static void main(String[] args) {
  10.         //1.创建Calendar类的对象
  11.         Calendar c = Calendar.getInstance();
  12.         //2.修改年
  13. //        c.set(Calendar.YEAR,1999);
  14. //        //获取 1999
  15. //        System.out.println(c.get(Calendar.YEAR));
  17.         //3.将当前的年-100
  18. //        c.add(Calendar.YEAR,-100);
  19. //        System.out.println(c.get(Calendar.YEAR));//1921
  21.         //4.设置月份的值为4
  22. //        c.set(Calendar.MONTH,4);
  23. //        System.out.println(c.get(Calendar.MONTH));
  25.         //5.给月份+1
  26.         /*c.add(Calendar.MONTH,1);
  27.         System.out.println(c.get(Calendar.MONTH)+1);//目前是3月份，+1后就是4月份*/
  29.         /*
  30.             扩展：
  31.             如果月份超过范围修改年份，天数超过范围修改月份
  32.          */
  33.         c.add(Calendar.MONTH,-3);
  34.         System.out.println(c.get(Calendar.YEAR)+"---"+(c.get(Calendar.MONTH)+1));//
  35.     }
  36. }
  1. /*
  2.     void setTime(Date date) 使用给定的 Date 设置此 Calendar 的时间。
  3.  */
  4. public class Test02 {
  5.     public static void main(String[] args) {
  6.           //创建日历
  7.         Calendar c = Calendar.getInstance();
  9.         //获取年
  10.         int year = c.get(Calendar.YEAR);
  11.         //没有更改c表示的内容，获取的是当前时间
  12.         System.out.println(year);   //2020
  14.         //创建日期对象
  15.         Date d = new Date(3181277292010L);
  16.         System.out.println(d);
  18.         //把Date所表示的时间赋值给Calender
  19.         //void setTime(Date date) 使用给定的 Date 设置此 Calendar 的时间。
  20.         c.setTime(d);
  21.         //获取年
  22.         int year2 = c.get(Calendar.YEAR);
  23.         //更改之后c表示的内容，获取的是当前时间
  24.         System.out.println(year2);   //2070
  25.     }
  26. }

Math类

  • java.lang.Math(类): Math包含执行基本数字运算的方法。
  • 它不能创建对象，它的构造方法被“私有”了。因为他内部都是“静态方法”，通过“类名”直接调用即可。
方法名 说明
public static int abs(int a) 获取参数a的绝对值：
public static double ceil(double a) 向上取整
public static double floor(double a) 向下取整
public static double pow(double a, double b) 获取a的b次幂
public static long round(double a) 四舍五入取整 
  1. public class Demo {
  2.     public static void main(String[] args) {
  3.         System.out.println("-5的绝对值：" + Math.abs(-5));//5
  4.         System.out.println("3.4向上取整：" + Math.ceil(3.4));//4.0
  5.         System.out.println("3.4向下取整：" + Math.floor(3.4));//3.0
  6.         System.out.println("2的8次幂：" + Math.pow(2, 8));//256.0
  7.         System.out.println("3.2四舍五入：" + Math.round(3.2));//3
  8.         System.out.println("3.5四舍五入：" + Math.round(3.5));//4
  10.     }
  11. }

System

概述

java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作

常用方法

方法名 说明
public static void exit(int status) 终止当前运行的 Java 虚拟机，非零表示异常终止
public static long currentTimeMillis() 返回当前时间(以毫秒为单位)
static void arrayCopy() 数组中元素的复制 
  1. public class Demo02{
  2.     public static void main(String[] args) {
  4.         //退出虚拟机
  5.         //System.exit(0);
  7.         //获取当前时间的毫秒值
  8.         long time1 = System.currentTimeMillis();
  9.         System.out.println(time1);
  11.         //Date
  12.         Date d = new Date();
  13.         long time2 = d.getTime();
  14.         System.out.println(time2);
  17.         //数组中元素的复制
  18.         int[] arr = {11,22,33,44,55,66};
  19.         int[] brr = {0,0,0,0,0,0};
  21.         /*
  22.         复制数组的方法：
  23.         static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)  
  24.             参数：
  25.                 src - 源数组。
  26.                 srcPos - 源数组中的起始位置。
  27.                 dest - 目标数组。
  28.                 destPos - 目标数据中的起始位置。
  29.                 length - 要复制的数组元素的数量。 
  30.          */
  31.         System.arraycopy(arr,2,brr,0,3);
  33.         //打印数组查看结果
  34.         for (int i = 0; i < brr.length; i++) {
  35.             System.out.print(brr[i] + " ");
  36.         }
  37.         // brr :  33 44 55 0 0 0 
  38.         System.out.println();
  39.         System.out.println("------------------------------");
  40.         //练习
  41.         System.arraycopy(brr,0,brr,2,2);
  43.         //打印数组查看结果
  44.         for (int i = 0; i < brr.length; i++) {
  45.             System.out.print(brr[i] + " ");
  46.         }
  47.         // 33 44 33 44 0 0 
  48.     }
  49. }

BigInteger类

概述

java.math.BigInteger 类，不可变的任意精度的整数。如果运算中，数据的范围超过了long类型后，可以使用BigInteger类实现，该类的计算整数是不限制长度的。

构造方法

方法 说明
BigInteger(String value) 可以把字符串整数变成对象

BigInteger(String value) 将 BigInteger 的十进制字符串表示形式转换为 BigInteger。超过long类型的范围，已经不能称为数字了，因此构造方法中采用字符串的形式来表示超大整数，将超大整数封装成BigInteger对象。

成员方法

BigInteger类提供了对很大的整数进行加、减、乘、除的方法，注意：都是与另一个BigInteger对象进行运算。

方法声明 描述
add(BigInteger value) 返回其值为 (this + val) 的 BigInteger，超大整数加法运算
subtract(BigInteger value) 返回其值为 (this - val) 的 BigInteger，超大整数减法运算
multiply(BigInteger value) 返回其值为 (this * val) 的 BigInteger，超大整数乘法运算
divide(BigInteger value) 返回其值为 (this / val) 的 BigInteger，超大整数除法运算，除不尽取整数部分

BigDecimal类

概述

表示无限大的小数类型,使用基本类型做浮点数运算精度问题.对于浮点运算，不要使用基本类型，而使用BigDecimal类类型不会损失精度

构造方法

方法 说明
BigDecimal(double val) 把小数数值变成BigDecimal对象
BigDecimal(String val) 把字符串值变成BigDecimal对象(建议使用)

常用方法

方法 说明
BigDecimal add(BigDecimal value) 加法运算
BigDecimal subtract(BigDecimal value) 减法运算
BigDecimal multiply(BigDecimal value) 乘法运算
BigDecimal divide(BigDecimal value) 除法运算
BigDecimal divide(BigDecimal divisor, int scale, int roundingMode) 除法运算

注意：

对于divide方法来说，如果除不尽的话，就会出现java.lang.ArithmeticException异常。此时可以使用divide方法的另一个重载方法； BigDecimal divide(BigDecimal divisor, int scale, int roundingMode): 参数说明：divisor：除数对应的BigDecimal对象；scale:精确的位数；roundingMode取舍模式，表示舍入方式 RoundingMode.HALF_UP四舍五入

  1. private static void method_2() {
  2.     /*
  3.     底层原理：例如将0.09*100变为整数9  0.01*100变为整数1然后整数进行运算 ---》9+1=10然后除以100.0---0.10
  4.     */
  5.     //1.创建BigDecimal类的对象
  6.     BigDecimal b1 = new BigDecimal("0.09");
  7.     BigDecimal b2 = new BigDecimal("0.01");
  8.     //2.使用对象调用方法进行运算
  9.     //加法
  10.     BigDecimal b3 = b1.add(b2);
  11.     System.out.println("b3 = " + b3);
  12.     //减法
  13.     System.out.println(b1.subtract(b2));
  14.     //乘法
  15.     System.out.println(b1.multiply(b2));
  16.     //除法 divide 如果除不尽就会报异常 b1/b2--可以除尽
  17.     System.out.println(b1.divide(b2));
  19.     //创建对象
  20.     BigDecimal b4 = new BigDecimal("10.0");
  21.     BigDecimal b5 = new BigDecimal("3");
  22.     //这里b4/b5是无法除尽的，所以该方法会报异常
  23.     //        System.out.println(b4.divide(b5));
  24.     //我们对于除不尽使用如下方法
  25.     // 第二个参数2表示保留小数2位，RoundingMode.HALF_UP 表示四舍五入
  26.     BigDecimal b6 = b4.divide(b5, 2, RoundingMode.HALF_UP);
  27.     System.out.println("b6 = " + b6);
  28. }
  29.       //ctrl+alt+M 抽取方法

Arrays类

Arrays类概述

java.util.Arrays类：该类包含用于操作数组的各种方法（如排序和搜索）。Arrays本身也是一个工具类。工具类不能创建对象(构造方法被private修饰了)，所有的方法都是静态的。

Arrays类常用方法

  1. public static void sort(int[] a)：按照数字顺序排列指定的数组
  2. public static String toString(int[] a)：返回指定数组的内容的字符串表示形式
    1. public static void main(String[] args) {
    2.    int[] arr = {432, 53, 6, 323, 765, 7, 254, 37, 698, 97, 64, 7};
    3.    //将数组排序
    4.    Arrays.sort(arr);
    5.    //打印数组
    6.    System.out.println(Arrays.toString(arr));
    7. }

    包装类

    概述

    Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型 对应的包装类（位于java.lang包中）
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

Integer类

概述

包装一个对象中的原始类型 int 的值

Integer类构造方法及静态方法

方法名 说明
public Integer(int value) 根据 int 值创建 Integer 对象(过时)
public Integer(String s) 根据 String 值创建 Integer 对象(过时)
public static Integer valueOf(int i) 返回表示指定的 int 值的 Integer 实例
public static Integer valueOf(String s) 返回保存指定String值的 Integer 对象 
  1. public class IntegerDemo {
  2.     public static void main(String[] args) {
  3.         //public Integer(int value)：根据 int 值创建 Integer 对象(过时)
  4.         Integer i1 = new Integer(100);
  5.         System.out.println(i1);
  7.         //public Integer(String s)：根据 String 值创建 Integer 对象(过时)
  8.         Integer i2 = new Integer("100");
  9.         //Integer i2 = new Integer("abc"); //NumberFormatException
  10.         System.out.println(i2);
  11.         System.out.println("--------");
  13.         //public static Integer valueOf(int i)：返回表示指定的 int 值的 Integer 实例
  14.         Integer i3 = Integer.valueOf(100);
  15.         System.out.println(i3);
  17.         //public static Integer valueOf(String s)：返回保存指定String值的Integer对象 
  18.         Integer i4 = Integer.valueOf("100");
  19.         System.out.println(i4);
  20.     }
  21. }

装箱与拆箱

概述：

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“： 装箱：从基本类型转换为对应的包装类对象。 用Integer与 int（基本数值——>包装对象）

  1. Integer i = new Integer(4);//使用构造函数函数
  2. Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法

拆箱：从包装类对象转换为对应的基本类型。

自动装箱与自动拆箱

由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成

基本类型转换为String

转换方式

  • 方式一：直接在数字后加一个空字符串
  • 方式二：通过String类静态方法valueOf()
  3. public class IntegerDemo {
  4.     public static void main(String[] args) {
  5.         //int --- String
  6.         int number = 100;
  7.         //方式1
  8.         String s1 = number + "";
  9.         System.out.println(s1);
  10.         //方式2
  11.         //public static String valueOf(int i)
  12.         String s2 = String.valueOf(number);
  13.         System.out.println(s2);
  14.         System.out.println("--------");
  15.     }
  16. }

String转换成基本类型

除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

  • public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
  • public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
  • public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
  • public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
  • public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
  • public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。

  • public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。

    1. package com.itheima.sh.d_integer_04;
    2. /*
    3.   fftf
    4. */
    5. public class IntegerDemo02 {
    6.   public static void main(String[] args) {
    7.       //1.创建包装类对象
    8.       Integer i1 = new Integer(50);
    9.       Integer i2 = new Integer(50);
    10.       System.out.println(i1==i2);//f
    12.       Integer i3 = new Integer(500);
    13.       Integer i4 = new Integer(500);
    14.       System.out.println(i3==i4);//f
    16.       //自动装箱原理：底层执行Integer.valueOf(50);
    17.       /*
    18.           public static Integer valueOf(int i) {
    19.           IntegerCache.low 的值是-128 ，IntegerCache.high 127
    20.           if (i >= IntegerCache.low && i <= IntegerCache.high)
    21.           //满足if条件到cache数组中获取数据，这里i是50，所以索引是50+128
    22.               return IntegerCache.cache[i + (-IntegerCache.low)];
    23.           return new Integer(i);
    24.       }
    25.        */
    26.       Integer i5 = 50;
    27.       Integer i6 = 50;
    28.       //底层都会去数组的同一个空间获取数据，所以比较的结果是true
    29.       System.out.println(i5==i6);//t
    31.       Integer i7 = 500;
    32.       Integer i8 = 500;
    33.       /*
    34.           由于i7的值是500不在-128到127之间，所以执行  return new Integer(i); 创建一个新的对象
    35.           由于i8的值是500不在-128到127之间，所以执行  return new Integer(i); 创建一个新的对象
    36.           由于创建两个对象，地址值肯定不相等，所以i7==i8的结果是false
    38.        */
    39.       System.out.println(i7==i8);//f
    40.   }
    41. }

    String类常用方法

    concat

    ```java 方法原型：public String concat (String str) 功能：将当前字符串与参数字符串进行”拼接”，返回一个新字符串。 String s1 = “Hello”; String s2 = “World”; String result = s1.concat(s2); System.out.println(“result = “ + result); System.out.println(“s1 = “ + s1); System.out.println(“s2 = “ + s2);

  1. > concat的作用和+符号的不同：
  2. >     1). concat只能拼接String类型，不能拼接其它类型。+符号可以拼接任何类型。
  3. >     2). concat的效率要高于+符号。
  5. <a name="CRLo2"></a>
  6. ###  contains
  7. ```java
  8. 方法原型：public boolean contains (CharSequence s)
  9.   CharSequence是一个接口，String类是它的实现类。
  10. 功能：判断参数字符串在当前字符串中是否存在(区分大小写)。存在，返回true，否则，返回false
  11. String s = "我爱Java，我爱学习！";
  12. System.out.println("字符串中是否包含Java：" + s.contains("Java"));//true
  13. System.out.println("字符串中是否包含java：" + s.contains("java"))//false

endsWith

  1. 方法原型：public boolean endsWith(String suffix)
  2. 功能：测试此字符串是否以指定的后缀结尾(区分大小写)。 String name = "Test.java"; System.out.println("判断name是否以java结尾：" + name.endsWith("java"));//true System.out.println("判断name是否以Java结尾：" + name.endsWith("Java"));//false

startsWith

  1. 方法原型：public boolean startsWith(String prefix)
  2. 功能：测试此字符串是否以指定的前缀开始(区分大小写) String name = "我爱Java"; System.out.println("字符串是否以‘我’开头：" + name.startsWith("我"));//true

indexOf

  1. - 方法原型：public int indexOf(String str)
  2. - 功能：返回指定子字符串第一次出现的字符串内的索引。如果不包含，则返回-1.
  3. String str = "我爱Java，我爱学习！";
  4. System.out.println("在字符串中，Java第一次出现的位置：" + str.indexOf("Java"));//2
  5. System.out.println("在字符串中，java第一次出现的位置：" + str.indexOf("java"));//-1

lastIndexOf

  1. - 方法原型：public int lastIndexOf(String str)
  2. - 功能：返回指定子字符串最后一次出现的字符串中的索引。 如果不包含，则返回-1.
  3. String str = "我爱Java，我爱学习！";
  4. System.out.println("在字符串中，'我'最后一次出现的位置：" + str.lastIndexOf("我"));//7

replace

  1. - 方法原型：public String replace(CharSequence target,CharSequence replacement)
  2. - 功能：将与字面目标序列匹配的字符串的每个子字符串替换为指定的文字替换序列。 替换从字符串开始到结束，例如，在字符串“aaa”中用“b”替换“aa”将导致“ba”而不是“ab”。 
  3. String str = "我爱吃红烧鲤鱼，我太想吃红烧鲤鱼了！";
  4. System.out.println("将'红烧鲤鱼'替换为'咸水鸡'：" + str.replace("红烧鲤鱼","咸水鸡"));
  5. System.out.println("原字符串：" + str);//我爱吃咸水鸡，我太想吃咸水鸡了！

substring

  1. - 方法原型：public String substring(int beginIndex)：将当前字符串从beginIndex开始截取到末尾。
  2. - 方法原型：public String substring(int beginIndex, int endIndex)：将当前字符串从beginIndex开始截取到endIndex - 1处。
  4. String str = "我爱Java";
  5. System.out.println("截取'Java'：" + str.substring(2));//Java
  6. System.out.println("截取'我爱'：" + str.substring(0,2))//我爱

toCharArray

  1. - 方法原型：public char[] toCharArray()
  2. - 功能：将当前字符串转换为char[]数组。
  4.  String str = "I Love Java, I Love Heima";
  5. //计算字符 a 出现的次数（要求使用toCharArray）
  6. char[] chars = str.toCharArray();
  7. int count = 0;
  8. for (char ch : chars) {
  9.     if (ch == 'a') {
  10.         count++;
  11.     }
  12. }
  13. System.out.println("count = " + count);

charAt

  1. - 方法原型：public char charAt(int index)
  2. - 功能：将字符串中指定索引的字符获取
  4. private static void method_1() {
  5.         String str = "I Love Java, I Love Heima";
  6.         //计算字符 a 出现的次数（要求使用charAt）
  7.         int count = 0;
  8.         for (int i = 0; i < str.length(); i++) {
  9.             char ch = str.charAt(i);
  10.             if (ch == 'a') {
  11.                 count++;
  12.             }
  13.         }
  14.         System.out.println("count = " + count);
  15.   }

toLowerCase

  1. - 方法原型： public String toLowerCase()
  2. - 功能：将当前字符串中的所有英文字符转换为小写，并返回一个转换后的新字符串，原字符串不变。
  4. String str = "我爱Java";System.out.println("转换为小写：" + str.toLowerCase());//我爱javaSystem.out.println("原字符串：" + str);//我爱Java

toUpperCase

  1. - 方法原型：public String toUpperCase()
  2. - 功能：将当前字符串中的所有英文字符转换为大写，并返回一个转换后的新字符串，原字符串不变。
  4. String str = "我爱Java";
  5. System.out.println("转换为大写：" + str.toUpperCase());//我爱JAVA
  6. System.out.println("原字符串：" + str);//我爱Java

trim

  1. - 方法原型：public String trim()
  2. - 功能：去掉当前字符串的前后空格，并返回一个新字符串，原字符串不变。
  4. String str = "  ad  min     ";
  5. System.out.println("去掉前后空格后|" + str.trim() + "|");//去掉前后空格后|ad  min|
  6. System.out.println("原字符串|" + str + "|");//原字符串|  ad  min     |

split

  1. - 方法原型：public String[] split(String regex)
  2. - 功能：切割字符串——将字符串以regex作为分隔符进行切割。
  3. String str = "张三,20,男,13513153355";
  4. String[] arr = str.split(",");
  5. for(int i = 0;i < arr.length ; i++){
  6.     System.out.println(arr[i]);
  7. }