Java Util包

内部类

• 以前：一个类是不能去访问另一个类的私有成员
• 现在：内部类的作用：可以直接访问外部类的私有成员
  1：成员内部类

 package com.example;

import java.net.StandardSocketOptions;

/**
* Created by JiaYuanFa on 2017/7/11.
*/

/*
   成员内部类：当做是外部类的一个成员变量
   总结：成员内部类可以访问外部类的所有属性和方法
   成员内部类不能定义静态变量和静态方法，因为成员内部类是由外部的类对象创建的
*/
public class MemberInnerClass {
   // 成员变量
   private String st1 = "member variable";
   // 静态变量
   private static String st2 = "static varivale";
   // 成员方法
   public void test1() {
       System.out.println("member function");
   }
   // 静态方法
   public static void test2() {
       System.out.println("static function");
   }
   // 成员内部类：可以使用左右的作用域关键字
   // public > protected > 缺省 > private
   class InnerClass {
       // 静态方法 报错 所以 内部类不能有静态的变量和方法 因为成员内部类需要有对象才能初始化
//        public static void test3() {
//
//        }
       // 成员方法
       public void test4() {
           System.out.println(st1);    // 访问成员变量
           test1();
           System.out.println(st2);
           test2();
       }
   }
   // 程序入口
   public static void main(String[] args) {
       // 如果使用内部类对象？首先创建外部类对象
       // 成员内部类必须要有外部类对象才能创建内部类对象，为什么呢？
       MemberInnerClass out = new MemberInnerClass();
       InnerClass inner = out.new InnerClass();
       inner.test4();
   }
}

2：静态内部类

package com.example;

/**
 * Created by JiaYuanFa on 2017/7/11.
 */
/*
    静态内部类：相当于外部类的一个静态变量
    1：静态内部类可以定义静态方法和成员方法
    2：静态内部类不能访问外部类的成员方法和属性
    3：静态内部类只能访问外部类的静态成员变量和静态方法
 */
public class StaticInnerClass {

    // 成员变量
    private String st1 = "member variable";
    // 静态变量
    private static String st2 = "static varivale";
    // 成员方法
    public void test1() {
        System.out.println("member function");
    }
    // 静态方法
    public static void test2() {
        System.out.println("static function");
    }

    // 静态内部类：可以使用所有的作用域关键字
    static class InnerClass {
        // 静态方法
        public static void test3() {
            // 只能使用外部类中的静态属性和静态方法
            System.out.println(st2);
            test2();
        }

        // 成员方法
        public void test4() {
//            System.out.println(str1); // 静态内部类的成员方法不能访问外部类的动态变量
        }
    }
    public static void main(String[] args) {
        // 直接使用外部类的类名.出来静态内部类并调用内部静态类的静态方法
        StaticInnerClass.InnerClass.test3();

        // 成员方法 必须要用内部类来调用
        InnerClass innerClass = new StaticInnerClass.InnerClass();
        innerClass.test4();
    }
}

3：局部内部类

package com.example;

/**
 * Created by JiaYuanFa on 2017/7/11.
 */
/*
    局部内部类
    1：局部内部类中，不能定义静态的属性和方法
    2：局部内部类访问局部变量必须是final类型 即最终的
 */
public class PartInnerClass {
    public void test() {
        // 局部变量
        final String str1 = "part variable";
        // 局部内部类：不能使用我们的作用域关键字 已经被限制在了方法内部
        class InnerClass {
            // 不能定义静态的方法
//            public static void test3() {
//            }

            // 成员方法
            public void test2() {
                System.out.println(str1);
            }
        }

        InnerClass inner = new InnerClass();
        inner.test2();
    }
    public static void main(String[] args) {
        PartInnerClass out = new PartInnerClass();
        out.test();
    }
}

4：匿名内部类

package com.example;

/**
 * Created by JiaYuanFa on 2017/7/11.
 */
/*
    匿名内部类：没有类名的类
    匿名内部类的优点：可以少定义一个类
    缺点：无法重复使用该类，该类只能使用一次
    什么情况下用？

 */
public class AnonInnerClass {

    public static void test(CustomService cs) {
        cs.logout();
    }

    public static void main(String[] args) {
        // 使用实现类的方法：多定义一个类
        test(new CustomerServiceImp());

        // 使用匿名内部类的方式 少定义一个类 来实现匿名类的方法
//        test(new CustomService() {
//            @Override
//            public void logout() {
//                // 实现接口中的方法
//                System.out.println("匿名内部类的方法被调用");
//            }
//        });
    }
}

// 接口
interface CustomService {
    // 退出系统
    void logout();
}

// 实现接口方法
class CustomerServiceImp implements CustomService {
    public void logout() {
        System.out.println("匿名内部类的方法被调用");
    }
}

Java日期类

package com.example;

/**
 * Created by JiaYuanFa on 2017/7/12.
 */

import java.lang.*;
import java.text.SimpleDateFormat;
import java.util.Calendar;  // 导入日历包
import java.util.Date;  // 导入日期包
import java.util.SimpleTimeZone;

public class JavaDate1 {
    public static void main(String[] args) throws java.lang.Exception{
        Date date = new Date();
        System.out.println(date.toString());

        Date date2 = new Date(2014-1999,12-1,1,12,12,12);
        System.out.println(date2.toLocaleString());

        // 一：日期变为格式化字符串
        // xxxx年xx月xx日xx时xx分xx秒 HH大写表示24小时制

        // 死循环打印时间
//        while (true) {
//            // 每次重写取得系统时间
//            date = new Date();
//            // 转换为字符串时间
//            SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日hh时mm分ss秒");
//            // Date---->转换
//            System.out.println(sdf.format(date));
//            // 打印一次时间 休息一秒
//            Thread.sleep(1000);
//        }

        // 获取系统日历 这个类是一个抽象类 要使用单例模式获得
        Calendar c = Calendar.getInstance();    // 使用这样的方式初始化
        // 今天是星期几？老外是星期天是一个礼拜的第一天
        int i = c.get(Calendar.DAY_OF_WEEK);
        System.out.println(i);
        System.out.println(c.get(Calendar.DAY_OF_MONTH));

        // 2015年6月25号是星期几？
        Date date3 = new Date(2015-1900,6-1,25);
        c.setTime(date3);
        System.out.println(c.get(Calendar.DAY_OF_WEEK) - 1);

        //2: 计算2012-3-5到今天相隔多少天
        Date date4 = new Date(2012-1900,3-1,5);
        Date dateToday = new Date();
        long old = date4.getTime();    // 算出2012-3-5到1970-1-1相隔的毫秒数
        long now = dateToday.getTime();
        // 两者相减 得出日期差
        long days = (now - old) / (1000*60*60*24);
        System.out.println("Days相差：" + days);
    }
}

Java数学类

package com.example;

/**
 * Created by JiaYuanFa on 2017/7/12.
 */

/*
    数学类
 */
public class JavaUtilMath {
    public static void main(String[] args) {
        // PI
        System.out.println(Math.PI);
        // 求绝对值
        System.out.println(Math.abs(-2));
        // 向上取整 求>=1.000001的最小整数
        System.out.println(Math.ceil(1.00001));
        // 向下取整 求<=1.99999的最大整数
        System.out.println(Math.floor(1.9999));
        // 四舍五入
        System.out.println(Math.round(3.45));
        // 随机产生[0 1）小数
        System.out.println(Math.random());
        // pow: 求幂
        System.out.println(Math.pow(2,3));  // 求2的3次方
        // sqrt:求正平方根
        System.out.println(Math.sqrt(4));   // 求4的平方根
    }
}