java包装类与内部类

java包装类与内部类

包装类

包装类：把数据类型封装成类的形式，所以是一个类，可以存储null，提供了自动装箱与自动拆箱的功能
（1）自动装箱：是指系统自动将基本数据类型转换成为包装类对象
（2）自动拆箱：是指系统自动将包装类对象转换成为基本数据类型

• byte->Byte
• short ->Short
• int->Integer
• long->Long
• double->Double
• float->Float
• boolean->Boolean

/**
 * java的包装类
 */
public class Test01 {

    public static void main(String[] args) {
        try {
            Integer i1=new Integer(123);
            String s="135";

            //字符串转换为包装类  String to Integer
            Integer i2=new Integer(s);
            //Integer->int
            int i=i2.intValue();
            //int->Integer
            i2=new Integer(i);

            //int -> String
            s=i+"";
            s=String.valueOf(i);

            //String -> int
            i=Integer.parseInt(s);//容易出现转换异常

            /**
             * i1=123  i2=135
             * i1>i2 --> 1
             * i1=i2 --> 0
             * i1<i2 --> -1
             */
            System.out.println(i1.compareTo(i2));

            System.out.println(Integer.max(i1,i2));


        }catch (IllegalArgumentException e){
            System.out.println("出现数据转换异常！");
        }

    }

}

内部类

内部类：在某个类中再声明一个类的操作

作用：

• 内部类方法可以访问该类定义所在的作用域的数据，包括私有数据
• 内部类可以隐藏起来，可以起到保护作用
• 当想要定义一个回调函数的时候而又不想写大量繁多的代码时，匿名内部类是个不错的选择，比较方便快捷

成员内部类

1）成员内部类：最普通的内部类，定义在一个类的内部，与方法是同一个级别位置，它是一个依赖外部类而存在，所以要创建内部类是，先要存在一个外部类对象
2） 局部内部类：

  是定义在一个方法或者一个作用域里面的类。它与成员内部类的区别在于局部内部类的访问仅在于方法内或者作用域内

• 不能用public,private,protected或static修饰符，类似于局部变量
• 只能外部类的方法或作用域中定义
• 只有当前方法才可以使用这个类，出了这个方法就不行了
• 如果想要访问当前方法的变量，那么该变量必须是由有效的final修饰的（从java 8+开始，只要局部变量事实不变，那么final关键字可以省略）
  原因：

public class Test02 {
    public static void main(String[] args) {
        method01();
    }
    public static void method01(){
        Outer01 o01=new Outer01();
        o01.method01();

        //创建内部类对象，由外部类的new才能创建
        Outer01.Inner01 inner01=o01.new Inner01();
        inner01.method02();
    }
}

/**
 * 成员内部类
 */
class Outer01{
    private Integer age=20;
    public static String name="不高兴";
    public Double height=170.12;

    public void method01(){
        System.out.println("姓名："+name);
        //外部类想要使用内部类，要先创建对象才能使用内部类的属性与方法
        //会创建Outer01.Inner01对象
        Inner01 i01=new Inner01();
        System.out.println("体重："+i01.weight+",分数："+i01.score);
    }
    //成员内部类,不能存在static,没办法共享调用
    //可以使用外部类的所以属性
    //内部类是对外部类的某些内容的一种补充，成员方法可以被访问，但内部类不一能能被访问，
    // 同时有隐藏与保护作用
    class Inner01{
        private Integer score=100;
        public Double weight=120.90;
//        public static String address="宏桂217";//不能写静态
        public void method02(){
            System.out.println("分数:"+score);
            System.out.println("身高："+height);//内部类可以使用外部类的东西
            System.out.println("年龄;"+age+",名字："+name);//可以使用外部类的私有化
        }
    }
}

匿名内部类

• 匿名内部类： 是平时使用比较多的内部类，专门对接口与抽象类进行操作类（唯一性，不可重用）

public class Test03 {
    public static void main(String[] args) {
        //实现类
        ICar c=new Audi();
        c.start();
        Audi a=new Audi();

        Outer02 o=new Outer02();
        o.method01().start();
    }
}
class Outer02{

    private String address="一汽";

    public ICar method01(){
        //匿名内部类
        ICar c=new ICar() {
            @Override
            public void start() {
                System.out.println(address+"指纹启动");
            }
        };
        return c;
    }
    public void method02(){
        method01();
    }

}

静态内部类

• 静态内部类：在类中有一个static修饰的类

public class Test04 {
    public static void main(String[] args) {
        Outer03 o03=new Outer03();
        o03.method01();
        //静态内部类的创建方式
        Outer03.Inner o=new Outer03.Inner();
        o.method01();
    }
}
class Outer03{
    private String name="没头脑";
    private Integer age=21;
    public static Double height=172.98;
    public void method01(){
        System.out.println("姓名:"+name);

    }
    static class Inner{
        private  Integer score=109;
        public Double weight=45.45;

        public void method01(){
            System.out.println("分数："+score);
            //静态的内部类不能访问非静态的外部类的东西
//            System.out.println("身高："+height+"，姓名："+name);//不可用

            //创建Outer03对象才可以用
            Outer03 o03=new Outer03();
            System.out.println("身高："+height+"，姓名："+o03.name);
        }

    }
}