文章目录

• 一、内部类
• • 1.内部类是什么？
• 二、System类
• • 常用方法
• 三、String类
• 四、int型和String型转换
• • 1.int-->String
  • 2.String-->int
• 五、Date类
• • SimpleDateFormat类
• 六、Calendar类

一、内部类

1.内部类是什么？

简单的说，内部类就是在一个类的内部在定义一个类。

为什么要使用内部类？在《Think in java》中有这样一句话：使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。

在我们程序设计中有时候会存在一些使用接口很难解决的问题，这个时候我们可以利用内部类提供的、可以继承多个具体的或者抽象的类的能力来解决这些程序设计问题。可以这样说，接口只是解决了部分问题，而内部类使得多重继承的解决方案变得更加完整。

其实使用内部类最大的优点就在于它能够非常好的解决多重继承的问题，但是如果我们不需要解决多重继承问题，那么我们自然可以使用其他的编码方式，但是使用内部类还能够为我们带来如下特性（摘自《Think in java》）：

1、内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。

2、在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类。

3、创建内部类对象的时刻并不依赖于外围类对象的创建。

4、内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。

5、内部类提供了更好的封装，除了该外围类，其他类都不能访问。

外部类和成员内部类：
public class Outer {
    private int numo = 10;
       public class Inner{
           private int numi = 20;
           public void show(){
               System.out.println(numo);
           }
       }
    public void method(){
           Inner I = new Inner();  //不能直接show 要创建对象
           System.out.println(I.numi);
           I.show();
    }
}
主类：
    public static void main(String[] args) {
        Outer.Inner i = new Outer().new Inner(); //不能直接Inner i = new Inner();
    }

局部内部类：
public class Outer {
    private int numo = 10;

    public void method(){
        class Inner{
            private int numi = 20;
            public void show(){
                System.out.println(numo);//该类可直接访问外部类成员 也可以访问方法内的内部变量
                System.out.println(numi);
            }
        }
        Inner i = new Inner();//局部类是方法中定义的类 外界无法直接使用 要在方法内部创建使用
        i.show();
    }
}

匿名内部类：
public interface Inter {
    void show();
}

public class Outer {
    public void method(){
         Inter i = new Inter(){
             @Override
             public void show(){
                System.out.println("匿名内部类");
             }
         };
         i.show();
    }
}

二、System类

System类是系统类，主要用于获取系统的属性数据，没有构造方法。

常用方法

1.arraycopy——数组拷贝
System.arraycopy(arr1, 2, arr2, 0, 3);
参数分别为：被复制的数组，被复制的起始位置，复制到的数组，复制到这个数组的起始位置，复制到这个数组的结束位置

2.currentTimeMillis——返回毫秒数
和Date类中getTime方法一样。

3.exit——退出虚拟机
exit(int)方法终止当前正在运行的 Java 虚拟机，参数解释为状态码。根据惯例，非 0 的状态码表示异常终止。 而且，该方法永远不会正常返回。 这是唯一一个能够退出程序并不执行finally的情况。

三、String类

常见方法（只记录自己不懂的…）：

操作方法：

1. charAt(int index):获取指定索引处的字符
2. indexOf(String str,int fromIndex):获取str在字符串对象中第一次出现的索引（若添加fromIndex参数，则为对象与fromIndex的距离）
3. substring(int start):从start开始截取start后部分字符串
4. String substring(int start,int end):从start开始，到end结束截取字符串（包括start，不包括end）

判断方法：

1. equals(Object obj):比较字符串的内容是否相同（与==区别详见（三））
2. equalsIgnoreCase(String anotherString):比较字符串的内容是否相同,忽略大小写
3. startsWith(String prefix):判断字符串对象是否以指定的字符开头（区分大小写）
   4.endsWith(String str):判断字符串对象是否以指定的字符结尾

转化方法：

1. toCharArray():把字符串转换为字符数组
2. toLowerCase():把字符串转换为小写字符串
3. toUpperCase():把字符串转换为大写字符串

其他方法：

1. trim():去除字符串两端空格
2. split():去除字符串中指定的的字符，然后返回一个新的字符串
3. subSequence(int beginIndex,int endIndex )：截取字符串中指定位置的字符组成一个新的字符串
4. replace(char oldChar, char newChar)：将指定字符替换成另一个指定的字符
5. replaceAll(String regex,String replasement)：用新的内容替换全部旧内容

四、int型和String型转换

1.int–>String

	int num = 10;
	//方法一：空String+int型
	String s1=""+num;
	System.out.println(s1);
	//方法二：String型的valueOf方法
	String s2 =String.valueOf(num);
	System.out.println(s2);
    //方法三：int型-->Integer型-->String型
    Integer i =new Integer(num);
	String s3 =i.toString();
	System.out.println(s3);
	//方法四： Integer型-->String型
	String s4 =Integer.toString(i);
	System.out.println(s4);

2.String–>int

    String s="100";
    //方法一：intValue
	Integer i =new Integer(s);
	int x=i.intValue(); 
	System.out.println(x);
	//方法二：parseInt
	int y = Integer.parseInt(s);  
	System.out.println(y);

五、Date类

常见方法：

1. 获取当前时间：Date date = new Date();
2. 设置时间：date.setTime(long time); //按毫秒 从1970年开始算

以下为过时方法，Java API中将会把这些方法删除，不建议用：

4. 获得年份:int year = date.getYear() + 1900;
5. 获得月份:int month = date.getMonth() + 1;
6. 获得日期：int day = date.getDay();

        Date date = new Date();
        long time = System.currentTimeMillis();
        System.out.println(time);
        date.setTime(time);
        System.out.println(date);
        
输出结果：
1647336657888  //1970年距今时间（按毫秒算）
Tue Mar 15 17:30:57 CST 2022

SimpleDateFormat类

构造方法：

SimpleDateFormat();

SimpleDateFormat(String pattern); //用yyyyMMddHHmmss规定时间

格式化(Date变String)：SDF.format(Date date);

解析（String变Date）：SDF.parse(String pattern);//String要和SDF的pattern对应

    public static void main(String[] args) throws ParseException {
        Date date = new Date();
        SimpleDateFormat SDF = new SimpleDateFormat();
        String s1 = SDF.format(date);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String s2 = sdf.format(date);
        Date date1 = sdf.parse(s2); //给的模式要和字符串对应pattern才行
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(date1);
    }

输出结果：
22-3-15 下午6:07
2022-03-15 18:07:24
Tue Mar 15 18:07:24 CST 2022    

六、Calendar类

Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。

常见方法：

1. 构造方法

Calendar c = Calendar.getInstance();//默认是当前日期 
Calendar c1 = Calendar.getInstance();
c1.set(2009, 6 - 1, 12);//指定日期

Tips:getInstance()实际上是调用子类的重写方法返回Calendar子类 实现多态向上转型（抽象类不能直接实例化）

2. 获取年/月/日

Calendar c1 = Calendar.getInstance();
// 获得年份
int year = c1.get(Calendar.YEAR);
// 获得月份
int month = c1.get(Calendar.MONTH) + 1;
// 获得日期
int date = c1.get(Calendar.DATE);
// 获得小时
int hour = c1.get(Calendar.HOUR_OF_DAY);
// 获得分钟
int minute = c1.get(Calendar.MINUTE);
// 获得秒
int second = c1.get(Calendar.SECOND);
// 获得星期几（注意（这个与Date类是不同的）：1代表星期日、2代表星期1、3代表星期二，以此类推）
int day = c1.get(Calendar.DAY_OF_WEEK);

3. 添加/减少时间

c1.add(Calendar.DATE, 10);//10天后
c1.add(Calendar.DATE, -10);//10天前