Java常用类，一次性帮你总结好啦

• 常用类概述
• 内部类
  • 内部类的分类：
  • 1.成员内部类（非静态内部类）
  • 2.局部内部类
  • 4.匿名内部类
• Object类
  • Object类常用方法：
  • 1.equals方法
  • 2.hashCode方法
  • 3.toString方法
  • 4.finzlize方法
• 包装类
  • 「1.基本数据类型以及对应的包装类：」
  • 「2.包装类的意义：」
  • 3.包装类常用方法：
• 数学类
• 时间类
  • Java常用时间类：
  • 1.Date 日期
  • 2.Calendar 日历
  • 3.SimpleDateFormat格式化时间
  • 4.计算时间差
• String类
  • 字符串类常用方法
• String Builder和StringBuffer
• DecimalFormat
• 总结

---

常用类概述

1. 内部类
2. Object类
3. 包装类
4. 数学类
5. 时间类
6. 字符串
7. String Builder和StringBuffer
8. DecimalFormat

内部类

「概念」 ：在一个类内部再定义一个完整的类。

一般情况下类与类之间是相互独立的，内部类的意思就是打破这种独立思想，让一个类成为另一个类的内部信息，和成员变量、成员方法同等级别。

「内部类的好处：」

把一个类写在外面和写在里面最终达到的结果都一样，那我们为什么还要使用内部类，岂不是多此一举吗？

「采用内部类这种技术，可以隐藏细节和内部结构，封装性更好，让程序的结构更加合理！如果类很多且都暴露在外面，那么类与类之间的调用就会十分繁琐！」

内部类的分类：

1.成员内部类（非静态内部类）

参考代码如下：

package NeiBuLei;
public class OuterClass {
    //成员变量
    private String OuterName;
    //成员方法
    public void display(){
        System.out.println("这是外部类方法！");
        System.out.println(OuterName);
    }
    //内部类
    public class InnerClass{
        //成员变量
        private String InnerNme;
        //构造方法
        public InnerClass() {
            InnerNme = "Inner Class";
        }
        //成员方法
        public void display(){
            System.out.println("这是内部类方法！");
            System.out.println(InnerNme);
        }
    }
    // 主方法
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();//这是外部类方法！null

        // 这个类是内部类，已经不是独立的类了，因此不能像外部类一样直接创建！
        //InnerClass innerClass = new InnerClass(); 行不通
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();// 同成员方法/变量 只是加了个前缀
        innerClass.display();// 这是内部类方法！
    }
}

输出结果：
这是外部类方法！null 这是内部类方法！Inner Class

「总结：成员内部类（非静态内部类）的使用就是将内部类作为外部类的的一个成员变量/成员方法来使用，所以必须依赖于外部类的对象才能调用，用法和成员变量/成员方法一致！」

2.局部内部类

局部内部类：基本的内部类还可以在一个方法体中定义。

package NeiBuLei;
public class OuterClass {
    //成员变量
    private String OuterName;
    //成员方法
    public void display(){
        class InnerClass {
            public void print(){
                System.out.println("这是一个局部内部类方法！");
            }
        }
        InnerClass innerClass = new InnerClass();
        innerClass.print();
    }

    // 主方法
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();
    }
}

1. 静态内部类

静态内部类的构造不需要依赖于外部类对象，类中的静态组件都不需要依赖于任何对象，可以直接通过「类本身」 进行构造。

package NeiBuLei;
public class OuterClass {
    //成员变量
    private String OuterName;
    //成员方法
    public void display(){
        System.out.println("这是外部类方法！");
        System.out.println(OuterName);
    }
    //静态内部类
    public static class InnerClass{
        private String InnerName;
        public InnerClass() {
            InnerName = "Inner Class";
        }

        //成员方法
        public void display(){
            System.out.println("这是静态内部类方法！");
            System.out.println(InnerName);
        }
    }

    // 主方法
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();
        // 静态内部类的构造不依赖与外部类，可以直接通过类本身进行构造！
        InnerClass innerClass = new InnerClass();
        innerClass.display();
    }
}

输出结果：
这是外部类方法！null 这是静态内部类方法！Inner Class

4.匿名内部类

匿名内部类：没有名字的内部类。

匿名内部类「主要应用与接口的实现！」

接口：

package NeiBuLei;
public interface MyInterface {
    public void test();
}

实现类：

package NeiBuLei;
public class MyImplement implements MyInterface{
    @Override
    public void test() {
        System.out.println("test");
    }
}

匿名内部类的使用：

package NeiBuLei;
public class MyImplement implements MyInterface{
    @Override
    public void test() {
        System.out.println("test");
    }
}

「匿名内部类的好处：」

我们定义接口之后，「它的实现类不需要去单独创建一个文件去写它的实现」 ，我们可以把这个实现类的操作写到我们调用的地方就可以了！写起来更加简洁、方便。

「匿名内部类的缺点：」

耦合度太高了！

总结

万变不离其宗，Java 的其他类和功能，都离不开这些基础。java基础牢记基础，成长的更稳！