包装类和内部类

1、包装类

包装类可以把基本类型包装为对象类型。
共有8种包装类

• int Integer
• long Long
• byte Byte
• short Short
• float Float
• double Double
• boolean Boolean
• char Character**

1、Integer常用方法
Integer的缓存为-128~127，在这个值范围内的Integer对象只要值相等，相当于地址相等。
Byte Short Long 一样的原理

        Integer a = new Integer(10);//自动装箱
        Integer b = new Integer("20");//自动将字符串转换为整数
        System.out.println(a.toString());//将整形转换为字符串
        System.out.println(Integer.parseInt("2000"));//字符串转换成int
        System.out.println(Integer.toHexString(100));//10进制转16进制
        System.out.println(Integer.toBinaryString(100));//10进制转2进制
        System.out.println(Integer.toOctalString(100));//10进制转8进制

		//Integer 转换为 int
		int aa  = a.intValue();
		int aaa = a;//自动拆箱 把包装对象给基本类型
		//int 转换为 Integer
		Integer bb = 30; //自动装箱  直接把基本类型赋值给包装对象

包装类都相似，具有自动拆装箱功能。

2、局部内部类

1、局部内部类 定义在方法中 可看成局部变量 局部变量能使用的修饰符其都能使用 final
2、public private protected static 等修饰符不能用
3、把类声明在方法中，就是局部内部类，作用域 ，类似局部变量，可以访问该作用域下的变量。
4、使用方法，在方法中创建该局部类对象来调用；
5、外界无法使用该成员内部类

public class LocalOutClass {
    private String name = "out";
    private String uid = "1455";

    public void outShow() {
        System.out.println("外部show" + name);
    }
    public void inner() {
        String name = "张三";//局部变量必须初始化  全局变量可以初始化
        //成员内部类
        class InnerClass {
            private String name = "局部类";
            public void show() {
                outShow();
                System.out.println("局部类" + name);
            }
        }
        InnerClass innerClass = new InnerClass();
        innerClass.show();

    }
}
局部类调用

```java
    public static void main(String[] args) {
        //调用局部类
        LocalOutClass localOutClass = new LocalOutClass();
        localOutClass.outShow();
        localOutClass.inner();
    }

3、静态内部类

1、使用static修饰，声明在类体中 （每个类需要创建一次静态内部类）
2、静态内部类中可以访问外部类的静态成员
3、静态内部类需要实例化才能使用
4、静态内部类只能访问外部的静态属性和静态方法 或者通过对象访问
5、静态内部类可以使用任何修饰符

静态内部类创建

public class StaticOutClass {
    private static String name;

    public void show(){
        System.out.println("外部");
        InnerClass innerClass = new InnerClass();
        innerClass.show();
    }

    static class InnerClass{//只能访问外部的静态属性和静态方法  或者通过对象访问
        private String name="inner";
        public void show(){
            System.out.println("静态内部类"+name);
            StaticOutClass staticOutClass = new StaticOutClass();
            staticOutClass.show();
        }

    }
}

静态内部类对象创建

public class TT {
    public static void main(String[] args) {
        StaticOutClass staticOutClass = new StaticOutClass();
        staticOutClass.show();
        //静态内部类创建
        StaticOutClass.InnerClass innerClass = new StaticOutClass.InnerClass();
        innerClass.show();
    }
}

成员内部类

可访问的成员

1. 局部成员变量可访问不可修改
2. 全局成员变量可以访问和修改
3. 可以访问其他成员函数

1、声明在类体中，不使用static，具有类的成员特征，也就是，必须有类的实例才能使用
2、创建内部类实例 内部类实例可以访问共享外部类的成员变量（很常用）

成员内部类的创建

    /**
     * 成员内部类 看作成员外部类的成员方法
     * 可用 public protected private final abstract
     */
public class OutClass {

    private String  name;
    InnerClass innerClass = new InnerClass();


    public void show(){
        System.out.println(name+"姓名");
        innerClass.innerShow();
        B b = new B();
        b.show();

    }
    /**
     * 成员内部类 看作成员外部类的成员方法
     * 可用 public protected private final abstract
     */
  public  class InnerClass{
        private String name;
        public  void innerShow(){
            System.out.println("内部类");
            OutClass outClass = new OutClass();
        }

    }

}
final class B{
    public void show(){
        System.out.println("外部类");
    }
}

内部类对象创建

public class TT {
    public static void main(String[] args) {
        OutClass outClass = new OutClass();
        outClass.show();
        //内部类声明
        OutClass.InnerClass innerClass = new OutClass().new InnerClass();
        innerClass.innerShow();
    }
}

匿名内部类

可访问的成员

1. 局部成员变量可访问不可修改
2. 全局成员变量可以访问和修改
3. 可以访问其他成员函数

类内属性要求
（1）类没有名字
（2）必须在声明类的同时创建唯一的对象
（3）匿名内部类没有任何修饰符

• 没有权限修饰符
• 没有static
• 没有abstract
• 没有final

（4）不能声明自己的静态成员，除非是static final,或者是从父类继承的

匿名内部类
. 匿名类，非常常见，可以写在任何地方,就像一般的语句
. 语法更象是创建对象：Date d = new Date(){//…};
. 匿名类是对原类的一个继承，同时创建了实例，{} 就是继承以后的类体
类体中可使用所有类的语法
. 匿名类不能写构造器
. 匿名类可以从抽象类或者接口继承，必须提供抽象方法的实现

相当于父类引用指向子类对象

父类

public class Animal {
    public void eat(){
        System.out.println("动物吃东西");
    }
}

匿名内部类创建

public class TT {
    public static void main(String[] args) {
        Animal dog = new Animal(){
            private String name;
            @Override
            public void eat() {
                System.out.println("狗吃骨头");
            }
        };
        dog.eat();
    }
}

匿名内部类接口形式

可访问的成员

1. 局部成员变量可访问不可修改
2. 全局成员变量可以访问和修改
3. 可以访问其他成员函数
   接口
   如果一个接口只有一个抽象方法 这种接口成为函数式接口 jdk1.8 lambda来表示

public interface Pet {
    void listen(String name);
}

生成函数式接口

    Pet cat = (name)->{//lambda表达式实现匿名内部类 接口只有一个方法  方法体只有一条语句花括号可以省略
            System.out.println("lambda表达式");
        };
        cat.listen("猫");

        Pet cat2 = (name)-> System.out.println("狗蛋");//如果方法体只有一条语句花括号可以省略
        cat2.listen("猫2");

		Pet cat3= name-> System.out.println("猫三")//接口中该方法只有一个参数可以省略括号，多个参数或则没有参数不能省略括号

        Pet duck = getPet();
        duck.listen("鸭子");
    }

    public static Pet getPet() {//只有一个参数可以省略括号
        return name-> System.out.println("嘎嘎嘎"+name);
    }

总结

1. 任何内部类都编译成独立的class 文件
2. 最大的作用：封装！
3. 注意内部类可以访问外部类的权限
4. ！！！局部内部类和匿名内部类可以访问局部变量但是不能修改局部变量，可以修改全局的变量。