常用类的基本认识（基础）

常用类：

内部类、Object类、Object类常用方法、包装类、String类、BigDecimal类 。

内部类

分类：成员内部类、静态内部类、局部内部类、匿名内部类。

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

特点：编译之后可生成独立的字节码文件；内部类可以直接访问外部类的私有成员，而不破坏封装；可以为外部类提供必要的内部功能组件。

成员内部类

在类的内部定义，与实例变量、实例方法同级别的类。

外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。

       //创建外部类的实例
       Outer outer = new Outer();
        //创建内部类的实例
      Outer.Inner inner=outer.new Inner();

当内部类与外部类存在重名属性时，会优先访问内部类属性。如若想访问外部类的属性时，可以采用外部类.this.属性的操作。

成员内部类不能定义静态成员。

静态内部类

不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。只有内部类可以使用static修饰。

局部内部类

定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。

局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。

限制类的使用范围。

匿名内部类

没有类名的局部内部类（一切特征都与局部内部类相同）。

必须继承一个父类或实现一个接口。

定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。

UserService接口：

public interface UserService {
    void service();
}

UserServiceImpl实现类：

public class UserServiceImpl implements UserService {
​
    @Override
    public void service() {
        System.out.println("UserServiceImpl==>实现");
    }
}

Test类：

public class Test {
    public static void main(String[] args) {
​
        //创建接口类型变量
        /*UserService userService = new UserServiceImpl();
        userService.service();*/
​
        //局部内部类
        class impl implements UserService{
​
            @Override
            public void service() {
                System.out.println("impl局部内部类==>实现");
            }
        }
        /*UserService impl = new impl();
        impl.service();*/
​
        //使用匿名内部类（相当于创建了一个局部内部类）
        UserService userService = new UserService() {
​
            @Override
            public void service() {
                System.out.println("匿名内部类==>实现");
            }
        };
        userService.service();
    }
}

优点：减少代码量

缺点：可读性差

Object类

超类、基类，所有类的直接或间接父类，位于继承树的最顶层。

任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承。

Object类中所定义的方法，时所有对象都具备的方法。

Object类型可以存储任何对象：作为参数，可以接受任何对象；作为返回值，可返回任何对象。

Object类常用方法

Student类

public class Student {
    private String name;
    private int age;
​
    public Student() {
    }
​
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
​
    @Override
    public boolean equals(Object o) {
        //1 判断两个对象是否是同一个引用
        if (this == o) return true;
        //2 判断o是否为null 判断是否同一个类型(也可以用o instanceOf Student)
        if (o == null || getClass() != o.getClass()) return false;
        //3 强制类型转换
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }
​
    @Override
    protected void finalize() throws Throwable {
        System.out.println(this.name+"对象被回收了");
    }
​
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
​
    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;
    }
}

TestStudent类

public class TestStudent {
    public static void main(String[] args) {
        //创建实例对象
        Student s1 = new Student("小花",12);
        Student s2 = new Student("小兰",12);
        //1 getClass方法
        System.out.println("------------1 getClass方法------------");
        //判断s1和s2是否为同一类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1==class2) {
            System.out.println("class1和class2属于同一个类型");
        }else{
            System.out.println("不属于同一个类型");
        }
        //2 hashCode方法
        System.out.println("------------2 hashCode方法------------");
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        Student s3=s1;
        System.out.println(s1.hashCode());
        //3 toString方法
        System.out.println("------------3 toString方法------------");
        System.out.println(s1.toString());
        System.out.println(s2.toString());
        //4 equals方法：判断两个对象是否相等
        System.out.println("------------4 equals方法------------");
        System.out.println(s1.equals(s2));
        Student s4 = new Student("小舞", 20);
        Student s5 = new Student("小舞", 20);
        System.out.println(s4.equals(s5));
    }
}

TestStudent2类

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

包装类

基本数据类型所对应的引用数据类型。

Object类可统一所有数据，包装类的默认值是null。

拆箱和装箱、基本类型和引用类型转换、Integer缓冲区

public class Demo01 {
    public static void main(String[] args) {
        //类型转换:装箱，把基本类型转换为引用类型
        //基本类型
        int num1=10;
        //Integer类型
        Integer integer1=new Integer(num1);
        Integer integer2=Integer.valueOf(num1);
        System.out.println("-----------------装箱-------------------");
        System.out.println(integer1);
        System.out.println(integer2);
        //类型转换：拆箱  把引用类型转换为基本类型
        Integer integer3=new Integer(100);
        int num2=integer3.intValue();
        System.out.println("-----------------拆箱-------------------");
        System.out.println(num2);
        System.out.println("-------------JDK1.5之后--------------");
​
        //JDK1.5后  提供自动装箱和开箱
        int age=20;
        //自动装箱
        Integer integer4=age;
        System.out.println(integer4);
        //自动拆箱
        int age2=integer4;
        System.out.println(age2);
​
        //基本类型和字符串之间的转换
        System.out.println("------------基本类型和字符串之间的转换--------------");
        //1 把基本类型转换为字符串
        int n1=100;
        //1.1 使用+
        String s1=n1+"";
        //1.2 使用Integer的toString方法
        String s2=Integer.toString(n1);
        System.out.println(s1);
        System.out.println(s2);
        //2 把字符串转换为基本类型
        String str="150";
        int n2=Integer.parseInt(str);
        System.out.println(n2);
        //3 把String类型转换为boolean类型
        String s3="false";
        boolean b1=Boolean.parseBoolean(s3);
        System.out.println(b1);
    }
}

public class Demo02 {
    public static void main(String[] args) {
        //面试题
        Integer integer1=new Integer(100);
        Integer integer2=new Integer(100);
        System.out.println(integer1==integer2);//false
​
        Integer integer3=Integer.valueOf(100);
        //自动装箱   Integer.valueOf()  Integer缓冲区有范围(-127,128)
        Integer integer4=Integer.valueOf(100);
        System.out.println(integer3==integer4);//true
​
        Integer integer5=Integer.valueOf(127);//自动装箱
        Integer integer6=Integer.valueOf(127);
        System.out.println(integer5==integer6);
    }
}

String类

String类是常类，创建之后不可以改变。

字符串字面值存储在字符串池中，可以共享。

产生一个对象，字符串中存储。例如：String s="hello";

产生两个对象，堆、池各存储一个。例如：String s=new String("hello");

public static void main(String[] args) {
    //产生一个对象
    String name="hello";//hello存储在字符串池中
    name="张三";//给字符串赋值，并没有修改它，而是将name(栈)与hello(方法区（字符串池）)的连接中断，去连接张三了
​
​
    //产生两个对象
    String s=new String("world");
    String s2=new String("world");
    System.out.println(s==s2);
    System.out.println(s.equals(s2));//两种对象之间的比较用equals
}

public static void main(String[] args) {
    //产生一个对象
    String name="hello";//hello存储在字符串池中
    name="张三";//给字符串赋值，并没有修改它，而是将name(栈)与hello(方法区（字符串池）)的连接中断，去连接张三了
​
​
    //产生两个对象
    String s=new String("world");
    String s2=new String("world");
    System.out.println(s==s2);
    System.out.println(s.equals(s2));//两种对象之间的比较用equals
​
    //字符串方法的使用
    System.out.println("------------字符串方法的使用1---------------");
    //1 length();返回字符串长度
    //2 charAt(int index);返回某个字符的长度
    //3 contains()判断是否包含某个字符串
​
    String content="     JAVA是最好的编程语言,JAVA真香      ";
    System.out.println(content.length());
    System.out.println(content.charAt(content.length()-1));
    System.out.println(content.contains("JAVA"));
​
    System.out.println("------------字符串方法的使用2---------------");
​
    //4 toCharArray()返回字符串对应的数组
    //5 indexOf() 返回子字符串首次出现的位置
    //6 lastIndexOf()返回字符串最后一次出现的位置
    System.out.println(Arrays.toString(content.toCharArray()));
    System.out.println(content.indexOf("JAVA"));
    System.out.println(content.lastIndexOf("JAVA"));
​
​
    System.out.println("------------字符串方法的使用3---------------");
​
    //7 trim()去掉字符串前后的空格
    //8 toUpperCase()把小写转成大写  toLowerCase()把大写转成小写
    //9 endsWith(str) 判断是否以str结尾 startsWith(str) 判断是否以str结尾
    System.out.println(content.trim());
    System.out.println(content.toLowerCase());
    String fileName="demo01.java";
    System.out.println(fileName.startsWith("demo01"));//开头或结尾的字符串含有开头结尾字符皆为true，除非deo01这种情况为false
    System.out.println(fileName.endsWith("a"));
​
​
    System.out.println("------------字符串方法的使用4---------------");
    //10 replace(char old;char new);用新的字符或字符串来替换旧的字符串
    //11 split();对字符串进行拆分
​
    System.out.println(content.replace("JAVA","c++"));
    String saying="JAVA is the best         programing language,you are respecting";
    String[] arr=saying.split("[ ,]+");
    for(String string : arr){
        System.out.println(string);
    }
    System.out.println(arr.length);
​
    //补充两个方法  equals         compareTo();比较大小
    System.out.println("------------另外两种方法---------------");
    String s3="hello";
    String s4="HELLO";
    System.out.println(s3.equals(s4));
    System.out.println(s3.equalsIgnoreCase(s4));//equalsIgnoreCase忽略大小写的比较
    String s5="abc";
    String s6="agz";
    System.out.println(s5.compareTo(s6));
}

/**
 * StringBuffer和StringBuilder的使用
 * 区别  效率比String高    比String节省内存
 *
 */
public class Demo05 {
​
    public static void main(String[] args) {
//        StringBuffer sb=new StringBuffer();
        StringBuilder sb=new StringBuilder();
        //1  append()追加
        System.out.println("----------------1 append()追加-----------------");
        sb.append("java世界第一");
        System.out.println(sb.toString());
        sb.append("java对象");
        System.out.println(sb.toString());
        sb.append("java不错");
        System.out.println(sb.toString());
        //2   insert()插入
        System.out.println("----------------2 insert()插入-----------------");
        sb.insert(0,"我在前面了");
        System.out.println(sb.toString());
        //3   replace()替换
        System.out.println("----------------3 replace()替换-----------------");
        sb.replace(0,5,"hello");
        System.out.println(sb.toString());
        //4    delete()删除
        System.out.println("----------------4 delete()删除-----------------");
        sb.delete(0,5);
        System.out.println(sb.toString());
        //5    清空
        System.out.println("----------------5 清空-----------------");
        sb.delete(0,sb.length());
        System.out.println(sb.toString());
    }
}

/**
 * 验证 StringBuilder效率高于String
 * @author Ambition
 */
public class demo06 {
    public static void main(String[] args) {
        //开始时间
      long start=System.currentTimeMillis();
//      String string="";
//      for(int i=0;i<99999;i++){
//          string+=i;
//      }
//        System.out.println(string);
        StringBuilder sb=new StringBuilder();
        for(int i=0;i<99999;i++){
            sb.append(i);
        }
        System.out.println(sb.toString());
        long end=System.currentTimeMillis();
        System.out.println("用时:"+(end-start));
    }
}

BigDecimal类

位置：java.math包中。

作用：精确计算浮点数。

创建方式：BigDecimal bd=new BigDecimal("1.0");

方法：

public static void main(String[] args) {
    //double 是近似值存储
    double d1=1.0;
    double d2=0.9;
    System.out.println(d1-d2);
​
    double result=(1.4-0.5)/0.9;
    System.out.println(result);
​
    //BigDecimal,大的浮点数精确计算
    BigDecimal bd1=new BigDecimal("1.0");
    BigDecimal bd2 = new BigDecimal("0.9");
    //subtract减法操作
    BigDecimal r1 = bd1.subtract(bd2);
    System.out.println(r1);
​
    //加法  add
    BigDecimal r2 = bd1.add(bd2);
    System.out.println(r2);
​
    //乘法  multiply
    BigDecimal r3 = bd1.multiply(bd2);
    System.out.println(r3);
​
    //除法  divide
    BigDecimal r4 = new BigDecimal("1.4")
            .subtract(new BigDecimal("0.5"))
            .divide(new BigDecimal("0.9"));
    System.out.println(r4);
​
    //divide(数值，余数，BigDecimal.ROUND_HALF_UP)
    BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);
    System.out.println(r5);
}

Date

Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代。

public static void main(String[] args) {
    //1 创建Calendar对象
    Calendar calendar = Calendar.getInstance();
    System.out.println(calendar.getTime().toLocaleString());
    //2 获取时间信息
    //获取年
    int year = calendar.get(calendar.YEAR);
    //获取月
    int month=calendar.get(calendar.MONTH);
    //获取日   DAY_OF_MONTH
    int day=calendar.get(calendar.DATE);
    //获取小时  HOUR12小时    HOUR_OF_DAY24小时
    int hour=calendar.get(calendar.HOUR_OF_DAY);
    //获取分钟
    int minute=calendar.get(calendar.MINUTE);
    //获取秒
    int second=calendar.get(calendar.SECOND);
    System.out.println(year+"年-"+(month+1)+"月-"+day+"日-"+hour+"小时-"+minute+"分钟-"+second+"秒");
    Calendar calendar1=Calendar.getInstance();
    //3 修改时间 set(修改的属性 修改后数值)
    calendar1.set(Calendar.DATE,6);
    System.out.println(calendar1.getTime().toLocaleString());
    //4  add添加多少时间  负值代表减少  正值代表增加
    calendar1.add(calendar.HOUR_OF_DAY,-1);
    System.out.println(calendar1.getTime().toLocaleString());
    //5   补充方法
    int max=calendar1.getActualMaximum(calendar.HOUR_OF_DAY);
    int min=calendar1.getActualMinimum(calendar.HOUR_OF_DAY);
    System.out.println(max);
    System.out.println(min);
       //创建SimpleDateFormat对象
//        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy年mm月dd日hh时:mm分:ss秒");
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy/mm/dd");
        //创建Date
        Date date = new Date();
        //格式化date(把日期转换为字符串)
        String str=simpleDateFormat.format(date);
        System.out.println(str);
        //解析 （把字符串解析为日期）
        Date date2 = simpleDateFormat.parse("1990/05/20");
        System.out.println(date2);
}

System类

System系统类，主要用于获取系统的属性数据和其它操作，构造方法私有的。

 //arrayCopy：实现数组复制
        System.out.println("-----------------arrayCopy方法----------------");
        //src 原数组 srcPos 从那个位置开始复制0 dest 目标数组 destPos 目标数组位置 length长度
        int[] arr={20,18,34,60,78,15,13,45};
        int[] dest=new int[8];
        System.arraycopy(arr,0,dest,0,arr.length);
        for(int i=0;i<dest.length;i++){
            System.out.println(dest[i]);
        }
        //currentTimeMillis方法
        System.out.println("------------currentTimeMillis方法--------------");
        long start=System.currentTimeMillis();
        for (int i=0;i<99999999;i++){
            for (int j=0;j<99999999;j++){
                int result= i+j;
            }
        }
        long end=System.currentTimeMillis();
        System.out.println(end-start);
        //垃圾回收
        System.out.println("------------gc垃圾回收方法--------------");
//        Student s1=new Student("小花",12);
//        Student s2=new Student("小三",13);
//        Student s3=new Student("小四",14);
//        Student s4=new Student("小兰",15);
//        Student s5=new Student("小妹",16);
//        Student s6=new Student("小武",17);
//        Student s7=new Student("小舞",18);
        new Student("小花",12);
        new Student("小三",13);
       new Student("小四",14);
      new Student("小兰",15);
       new Student("小妹",16);
       new Student("小武",17);
       new Student("小舞",18);
        System.gc();
       //退出jvm
        System.out.println("------------exit退出jvm方法--------------");
        System.exit(0);
        System.out.println("程序结束");
    }