Java基础 day7 常用类

内部类

可以理解成：
成员内部类->实例方法
静态内部类->静态方法
局部内部类->方法内部，为方法添加内容
匿名内部类->实现接口

编译之后可生成独立的字节码文件
内部类可直接访问外部类的私有成员，而不破坏封装

成员内部类

与实例变量、实例方法同级别的类
必须要创建外部类的实例对象，才能使用成员内部类
创建
Outer out = new Outer();
Outer.Inner in = out.new Inner();
合并：
Outer.Inner in=new Outer().new Inner;
当外部类、内部类存在重名属性时，会优先访问内部类属性
内部类不能定义静态成员（但可以包含静态常量）

外部类的修饰符只能是public或者默认
内部类的修饰符任意
成员内部类可以访问外部类的属性或方法，不论私有不私有。
在内部类中当成员内部类属性与外部类重名使用 外部类名.this 访问外部类属性

class Outer {
    private String name="yanyan";
    private int age=18;
    public void show(){
        System.out.println("name = " + name);
        System.out.println("age = " + age);
    }
    class Inner{
        private String name="chichi";
        private int age=15;
        public void show(){
            System.out.println("name = " + Outer.this.name);
            System.out.println("age = " + age);
        }
    }
}

静态内部类

级别为外部类一样，作用是为外部类提供功能
不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
创建：Outer.Inner inner = new Outer.Inner();

public class TestOut{
    public static void main(String[] args) {
        Outer.Inner inner=new Outer.Inner();
        inner.show();
    }
}
class Outer {
    private String name="chichi";
    private int age=18;
    public void show(){
        System.out.println("name = " + name);
        System.out.println("age = " + age);

    }
    static class Inner{
        private String name="yan";
        private int age=11;
        public  void show(){
            System.out.println("name = " + name);
            System.out.println("age = " + age);
        }
    }
}

特点
静态内部类可以使用任意修饰符
不能访问外部类的实例属性和方法，可以访问外部类的静态属性和方法

局部内部类

级别与局部变量相同，使用范围只能当前方法中
不能使用任何修饰符
如果局部内部类所在方法是非静态方法，可以直接访问外部类的实例（或静态）属性和方法（外部类类名.this 属性）
若所在类是静态方法可以访问静态属性和方法，但可以通过创建外部类实例对象来访问外部类实例属性和方法。
局部内部类可以访问局部变量，但是局部变量必须是常量final，（jdk1.8后可以省略）对象的生命周期要长于局部变量

局部内部类不能声明静态成员，可以使用静态常量

public class aaa {
    public static void main(String[] args) {
        Outer outer=new Outer();
        outer.show();
    }
}
public void show(){
        final String phone="110";
        class Inner{
            private String name="chichi";
            private int age=11;
            public void print(){
                System.out.println("name = " + name);
                System.out.println("age = " + age);
                System.out.println("phone = " + Outer.this.phone);
            }
        }
        Inner inner=new Inner();
        inner.print();
    }

匿名内部类

一般和接口配合使用
必须继承一个父类或者实现一个接口
创建匿名内部类可以使用接口，抽象类，普通类，必须实现接口或抽象类中的方法
因为没有类名不能手动向其中添加构造方法（实际上本身是有的），不能包含静态成员
匿名内部类中不包含特有方法，不能直接访问，可以通过内部对象方法（特有方法要在重写方法中使用）

public interface Usb {
    void service();
}

public class aa {
    public static void main(String[] args) {
        Usb usb=new Usb() {
            @Override
            public void service() {
                System.out.println("chichi动了");
            }
        };
        usb.service();
        
    }
}

常用类

getClass（）
获取类的类对象

1.完整名 2.类名3.包名

hashCode（）
返回该对象的十进制的哈希码值。
哈希算法根据对象的地址或者字符串或者数字计算出来的int类型的数值
hash值并不唯一
对象.hashCode（）

toString（）
返回该对象的字符串表示（表现形式）
equals（）
重写步骤
finalize()
垃圾对象：没有有效引用指向此对象时，为垃圾对象
垃圾回收

包装类

默认值为null
包装类对应

手动装箱
手动拆箱

自动装箱拆箱

JDK 5.0之后，自动装箱、拆箱。基本数据类型和包装类自动转换

parseXXX()静态方法（除了Character）强制类型转换
valueOf()静态方法。
注意：需保证类型兼容，否则抛出NumberFormatException异常
基本类型转字符串

int n1=500;
String s1=n1+'';
String s2=String.valueOF(n1);
String S3=Integer.toString(n1)

字符串转基本类型

String s4="1111";
int n2=Interger.parseInt(s4);
int n2=Interger.parseInt(s4,16);//十六进制

布尔类型的字符串
只要字符串值不为"true",转成Boolean型，结果都是false

String

常量池在jdk1.6之前在永久代中，jdk1.7 堆中
字符串实际是存储在常量池中的字符数组
String s=“ssss”;ssss存储在常量池中；
字符串字面值是常量，创建之后不可改变。值得改变是因为在常量池中重新申请了空间，创建新对象，改变了栈中值的地址指向。

String s1=new String("xxx");
String s2=new String("xxx");

s1地址指向堆中对象，堆中对象地址指向常量池中的“xxx”;创建了两个对象，堆中一个，常量池中一个
s2创建时常量池中已经存在"xxx"，故地址直接指向常量池中地址

System.ou.println(s1==s2)

s1,s2地址不同，输出 false
但两者的最终指向是一样的，是同一个值

常用方法
范围含头不含尾

concat()拼接字符串
subString含有头，不含尾
compare() 比较字符串位置大小；在编码表中的位置
返回值是正数，负数，0；
s1.compare(s2) s1的位置减去s2的位置()，相同位置不比较，只比较第一个相同位置，就停下来

 String n1="abcd";
 String n2="abde";
 System.out.println(n1.compareTo(n2));

输入-1

String n1="abce";
        String n2="abcd";
        System.out.println(n1.compareTo(n2));

输出1
若字符串前边相同，就开始比长度s1的长度减去s2的长度

可变长字符串

可在内存中创建可变的缓冲空间，存储频繁改变的字符串
两者运行速度都比String快
StringBuilder速度快，线程不安全
含头不含尾
append（）追加数据
insert（）插入数据
replace（）替换数据
reverse（）反转
delete（）删除
StringBuffer速度慢，线程安全
方法同上

Arrays

常用方法






equals仅能比较一维数组，多维数组使用deepEquals

deepToString 用于打印多维数组