day-14

常用类

内部类：在一个类的内部在定义一个完整的类

public class Body {
    private String name;
    class Header{
        public void show(){
            System.out.println(name);
        }

    }
}

特点;编译之后可生成独立的字节码文件；内部类可以直接访问外部类的私有成员而不破坏封装
成员内部类
在类的内部定义，与实例变量，实例方法同级别的类
package com.chapter;
//外部类
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象

当外部类和内部类存在重名属性时，会优先访问内部类属性

成员内部类里面不能定义静态成员，但是可以包含静态常量

package com.chapter;
//外部类
public class Outer {
    //实例变量
    private String name="张三";
    private int age=20;
    //内部类
    class Inner{
        private String address="北京";
        private String phone="110";
        private String name="李四";

    //方法
    public void show() {
        //打印外部类的属性,外部类和内部类属性相同时用Outer.this
        System.out.println(Outer.this.name);
        System.out.println(age);
        //打印内部类的属性
        System.out.println(address);
        System.out.println(phone);
    }
    }

}

package com.chapter;
import com.chapter.Outer.Inner;
public class Application {
    public static void main(String[] args) {
       //创建外部类对象
        Outer outer = new Outer();
        //创建内部类对象
       Inner inner = outer.new Inner();
        inner.show();
    }
}

静态内部类
不依赖外部对象，可直接创建或者通过类名访问，可声明静态成员

public class Outer {
    private String name="xxx";
    private  int age =18;
    //静态内部类，级别和外部类相同
    static class Inner{
        private String address="上海";
        private String phone="111";
        //静态成员
        private static int count=1000;
        public void show(){
            //调用外部类的属性
            Outer outer = new Outer();
            System.out.println(outer.name);
            System.out.println(outer.age);
            //调用静态内部类的属性和方法
            System.out.println(address);
            System.out.println(phone);
            //调用静态内部类的静态属性
            System.out.println(Inner.count);

        }
    }
}

public class Application {
    public static void main(String[] args) {
        //直接创建静态内部类对象
        Outer.Inner inner = new Outer.Inner();
        //调用方法
        inner.show();
    }
}

局部内部类
定义在外部类的方法中

public class Outer {
    private String name="刘德华";
    private int age=35;

    public void show(){
        //定义局部变量
        String address ="深圳";
        //局部内部类,不能加任何访问修饰符
        class Inner{
            private String phone="131321";
            private String email ="chengle@qq.com";
            public void show2(){
                //访问外部类的属性
                System.out.println(name);
                System.out.println(age);
                //访问内部类
                System.out.println(phone);
                System.out.println(email);
                System.out.println(address);
            }

        }
        //创建局部内部类对象
        Inner inner = new Inner();
        inner.show2();

    }
}

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();

    }
}

局部内部类访问外部类当前方法中的局部变量时，变量必须修饰为final
匿名内部类
没有类名的局部内部类
必须继承一个父类或者实现一个接口

public class TestUsb {
    public static void main(String[] args) {
        //创建接口类型的变量
        Usb usb = new Mouse();
        usb.service();
        
    }

}

public class Mouse implements Usb{

    @Override
    public void service() {
        System.out.println("链接电脑成功，鼠标开始工作");
    }
}

public interface Usb {
    void service();
}

第二个例子（和上个例子有联系）

public class TestUsb {
    public static void main(String[] args) {
        /**  //创建接口类型的变量
         Usb usb = new Mouse();
         usb.service();*/
        /**class Fan implements Usb{

        @Override public void service() {
        System.out.println("链接成功，风扇开时工作");

        }
        }
         //使用局部内部类创建对象
         Usb usb=new Fan();
         usb.service();
         */
        //使用匿名内部类优化(相当于创建一个局部内部类)
        Usb usb = new Usb() {
            public void service() {
                System.out.println("链接成功，风扇开时工作");
            }

        };
        usb.service();

    }
}

特点：减少代码量，可读性较差
Object类
超类，基类，所有的类的直接或者间接父类，位与继承树的最顶层
任何类如果没有书写extends显示继承的类，都默认继承Object类
getClass（）方法：返回引用中存储的实际对象类型，通常用于判断两个引用中世纪存储类型是否一致
hashCode（）方法：返回该对象的哈希码值
哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的值
一般情况下相同对象返回相同的哈希码

toString（）方法；返回该对象的字符串表示，可根据程序需求覆盖该方法
equal（）方法：比较两个对象地址是否相同，可进行覆盖
finalize（）方法;当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列

import java.util.Objects;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        //判断两个对象是否 是同一个引用
        if (this == o) return true;
        //判断o是否为null以及是否为同一个类型
        if (o == null || getClass() != o.getClass()) return false;
        //强制类型转换
        Student student = (Student) o;
        //比较属性
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println(this.name+"对象被回收了");
    }
}

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();
        //判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1==class2){
            System.out.println("s1和s2属于同一个类型");
        }else {
            System.out.println("s1和s2不属于同一个类型");
        }
        System.out.println("===========================");
        //hashCode方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());

        Student s3=s1;
        System.out.println(s3.hashCode());
        System.out.println("===========================");

        System.out.println(s1.toString());
        System.out.println(s2.toString());
        System.out.println("==============================");

        System.out.println(s1.equals(s2));
        Student s4=new Student("小明",17);
        Student s5=new Student("小明",17);
        System.out.println(s4.equals(s5));
        System.out.println("===========================");

    }

}

public class TestStudent2 {
    public static void main(String[] args) {
        Student s1 = new Student("aaa",20);
        Student s2 = new Student("bbb",20);
        Student s3 = new Student("ddd",20);
        Student s4 = new Student("eee",20);
        Student s5 = new Student("ccc",20);
        //回收垃圾
        System.gc();
        System.out.println("回收垃圾");

    }
}

包装类
包装类的默认值是null
类型转换，装箱和拆箱

public class Demo01 {
    public static void main(String[] args) {
        int num1 =18;
        //使用integer创建对象
        Integer integer1 = new Integer(num1);
        Integer integer2 =Integer.valueOf(num1);
        System.out.println(integer1);
        System.out.println(integer2);
        //拆箱，引用类型转换成基本类型
        Integer integer3 = new Integer(100);
        int num2 =integer3.intValue();
        System.out.println(num2);

        //JDK1.5之后提供了自动装箱和拆箱
        int age =30;
        //自动装箱
        Integer integer4=age;
        //自动拆箱
        int age2=integer4;
        System.out.println(integer4);
        System.out.println(age2);

    }
}

类型转换

//基本类型转成字符串
        int n1=15;
        //方法1，使用+号
        String s1=n1+"";
        //方法2，使用integer中的toString（）方法,radix是进制的意思
        String s2=Integer.toString(n1,16);
        System.out.println(s1);
        System.out.println(s2);

        //字符串转成基本类型
        String str="150";
        //使用integer.parsexxx(）
        int n2=Integer.parseInt(str);
        System.out.println(n2);

        //boolean
        String str2="true";
        int n3=Integer.parseInt(str2);
        System.out.println(n3);

整数缓冲区
java预先创建了256个常用的整数包装类型对象
在实际应用中，对已创建的对象进行复用

public class Demo02 {
    public static void main(String[] args) {
        Integer integer1 = new Integer(1000);
        Integer integer2 = new Integer(1000);
        System.out.println(integer1==integer2);//false

        Integer integer3=Integer.valueOf(100);//自动装箱
        Integer integer4=Integer.valueOf(100);
        System.out.println(integer3==integer4);//true

        Integer integer5=Integer.valueOf(200);//自动装箱
        Integer integer6=Integer.valueOf(200);
        System.out.println(integer3==integer4);//false
        //看不明白就看valueOf的源码
    }
}