包装类和内部类--简单讲解

最新推荐文章于 2021-02-01 16:47:58 发布

苦修的木鱼

最新推荐文章于 2021-02-01 16:47:58 发布

阅读量527

点赞数

分类专栏： JAVA基础文章标签：包装类和内部类

本文链接：https://blog.csdn.net/L_Jun0112/article/details/76063821

版权

JAVA基础专栏收录该内容

11 篇文章 0 订阅

订阅专栏

- 包装类
- 内部类

包装类

这里写图片描述

包装类的转换

这里写图片描述

包装类的层次结构

除了Boolean和Character外，其他的包装类都有valueOf()和parseXXX()方法，并且还具有 byteValue()、shortValue()、intValue()、longValue()、floatValue()、doubleValue()方法，这些方法时最常见的方法。

包装类的转换

    int转换为Integer
    int i=10;
    Integer I=new Integer(i);
    //这样更好，会利用缓存
    Integer  I = Integer.valueOf(i); 
    Integer转换为int
    Integer i=new Integer(10);
    int i=I.intValue();

    String转换为Integer
    String s="12";
    Integer I=new Integer(s);
    Integer I = Integer.valueOf(s); //更好
    Integer转换为String
    Integer I=new Integer(23);
    String s=I.toString();

    String转换为int
    String s="20";
    int i=Integer.parseInt(s);
    int转换为String
    int i=20;
    String s1=String.valueOf(i);
    String s2=""+i;

自动装箱和自动拆箱

java5.0开始支持自动装箱和自动拆箱，包装类的变量可以被赋值为一个基本类型—装箱；基本类型的变量可以被赋值为一个包装类
```
//自动装箱
Integer itg = 123；
//自动拆箱
Int i = Integer.valueOf(111);
```

注意：

程序中少量的自动拆箱和装箱可以，但是大量的拆箱和装箱会对效率影响较大，所以尽量需要什么类型就声明什么类型。
Integer类的自动转换

 /**
  *实际上，程序运行时，系统为我们执行了下面一条语句
  * Integer number = new Integer(290);
  */
    Integer number = 290;
    System.out.println(number); 

/*
 * 实际上，程序运行时，系统为我们执行了下面语句
 * int number2 = number.intValue();
 */
Integer number = 290;
int number2 = number;
System.out.println(number2);

内部类

在类的内部定义一个类
内部类是一种编译时语法
内部类分为四种
- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类

成员内部类

内部类的作用
- 内部类可以访问外部类的私有成员
类似于成员变量，可以使用访问修饰符
构造一个成员内部类对象必须先够近啊一个外部类对象，然后通过外部类对象的引用“.new”构造内部类对象。

Outer out1 = new Outer(200);
Outer.Inner in = out1.new Inner();
在内部类中访问外部类的成员变量，并不会破坏封装
```
Outer.this.index
```
成员内部类中不能有静态的变量

成员内部类代码

class Outer {
    private int index;
    public Outer(int index) {
      this.index = index;
    }
    class Inner {
      private int index = 100;
      public void print() {
          System.out.println(this.index);
          System.out.println(Outer.this.index);
      }
    }
}
// 测试的main方法
public static void main(String args[]) {
        Outer out1 = new Outer(200);
        Outer.Inner in = out1.new Inner();
        in.print();
}

内部类的作用

配合接口，抽象类实现多继承，这是使用内部类的主要原因

 public abstract class Person {
   public abstract void run();
}

public interface Machine {
   void run();
}

public class Robot extends Person {
   class RobotHeart implements Machine {
      public void run() {
        System.out.println("机器人发动机开动");
      }
   }
   public void run() {
     System.out.println("人在跑");
   }
}

静态内部类

用static修饰的内部类称为静态内部类
在静态内部类中可以有静态的成员
静态内部类只能访问外部类的静态成员，但是不能访问外部类的非静态成员
构造静态内部类对象时不需要外部类对象
```
 Outer.Inner in = new Outer,Inner();
```

静态内部类代码

class Outer {
    private int index;
    private static int a = 200;
    static class Inner {
        private static int b = 300;
        public  void print() {
            System.out.println(a + " " + b);
        }
    }
}
// 测试的main方法
public static void main(String args[]){
   Outer.Inner in = new Outer.Inner();
   in.print();
}