java内部类、接口、集合框架、泛型、工具类、实现类

一、内部类

 1.成员内部类。

（1）成员内部类的实例化：

外部类名.内部类名   变量名=外部类对象.new 内部类名();

class Person{
  class Test{
   }
 }
 Person p=new Person();
 Person.Test t=p.new Test();

（2）在内部类中访问外部类属性或方法。

　　外部类名.this.属性名
　　 Person.this.name
（3）成员内部类声明的注意事项
  ①内部类不能与外部类重名。
  ②成员内部类中不能出现静态属性，静态方法和静态内部类。
     但是静态常量例外。
 private static final String name="1";//此情况可以使用

class Test{//成员内部类
        private  String  name;
        private int age;
        public void say(){
            System.out.println(Person.this.name);//访问外部类的
            System.out.println("Person中的Test的say方法");
        }
    }

2.静态内部类。

（1）使用static修饰的内部类，叫做静态内部类。

（2）实例化：外部类名.内部名 变量=new 外部类名.内部类名（）;

class Person{
     public String name="1";
     public Static int age="12";
         static class Test{
     } 
      }
      Person.Test t=new Person.Test();

　　 注意与成员内部类实例化的区别。

（3）静态内部类中不能访问外部类的非静态属性和方法。

　　 但可以访问外部类中的静态属性和方法，使用外部类名.属性名；
　　　　 Person.age;

（4）外部类不能访问静态内部类的非静态属性和方法，但可以访问静态内部类的的静态属性和方法，外部类名.属性名。

　　　　Test.age；

（5）【静态内部类和成员内部类的区别】

　　1.声明方式和实例化方式不同。成员内部类不带static
 　　  静态内部类实例化： Person.Test t=new Person.Test();
　　   成员内部类实例化： Person.Test t=p.new Test();
　　2.成员内部类中不能出现静态属性和方法，但静态内部类可以。
　　3.外部类和内部类的互相访问权限不同：
　　  ①静态内部类中不能访问外部类的非静态属性和方法。
　　  但可以访问外部类中的静态属性和方法，使用外部类名.属性名；
　　  ②成员内部类中不能出现静态属性，静态方法和静态内部类。
　　  但是静态常量例外。

static class Test1{
        public static String test="111";
        
        public void say(){
            System.out.println("Test1");
        }
    }

3.【局部内部类】（一般不用）。

（1）定义在某个类中的方法中的内部类，称为局部内部类。
（2）局部内部类是对外部完全隐藏的，只能在其作用域范围内被实例化。
（3）局部内部类可以访问外部类的属性和方法，使用外部类.this.属性名；
　　Person.this.name;
（4）局部内部类：不能访问其所在方法中的变量，只能访问常量。
（5）注意：局部内部类不能使用访问修饰符修饰，因为它不属于类的成员，它属于方法中的局部变量。

public void eat(){
//        final String name1="123";
        class Test2{
            public String name="123";
            public void test(){
                System.out.println(Person.this.name);
//                System.out.println(name1);
            }
        }
        Test2 t=new Test2();
        System.out.println(t.name);
    }
    
}

4.匿名内部类。

new Test1（）{

 };
（1）写法
（2）含义：相当于一个匿名类继承了Test1类，使用匿名内部类将直接返回当前子类的对象。
Test1 t=new Test1(){};
（3）相当于：①一个匿名内部类，继承了Test1类。
　　　　　　  ②匿名内部类返回一个子类对象，并付给父类引用。
　　  因此这一行代码用于向上转型。
（4）匿名内部类通常用于直接实例化抽象类或接口。
　　Test1 t=new Test1(){
　　　　 //重写抽象类Test1中的所有的抽象方法
　　　　//相当于一个匿名内部类，继承了Test1类，然后返回这个匿名内部类的对象。
};

Test1 t2=new Test1(){
            public int age=12;
            public void eat(){
                System.out.println(age);
                System.out.println("eat");
            }
            public void say(){
                System.out.println("匿名重写Test1类的say方法");
            }
        };
        //向上转型，会丢失掉子类特有的属性和方法，new Test1(){}.eat();
        t2.say();

5.使用内部类模拟多继承 。

class A{
    public void a() {
        System.out.println("a");
    }
}
class B{
    public void b(){
        System.out.println("b");
    }
}
class C{
    class A1 extends A{
        
    }
    class B1 extends B{
        
    }
    public  void a(){
        new A1().a();//不管A类是不是抽象类都可以，如果是A则要考虑是不是抽象类
    }
    public void b(){
        new B1().b();
    }
}

C c=new C();  //结果a,b
c.a();
c.b();

二、接口

 1.【接口的定义】

（1）接口名/接口文件与类类似，接口也是使用.java文件编写。

（2）声明接口的关键字：interface，接口名命名规范与类名相同，习惯上，接口可以用I开头表示。

（3）接口的访问修饰符只能使用public和default修饰，不能使用protected和private（与外部类相同）。

（4）接口中的所有的属性，只能是公共的，静态的，常量。

　　 public static final int NAME=1；

　　而且，public/static/final都可以省略，省略后依然是公共的，静态的常量。

　　int NAME=1；

（5）接口中所有的方法必须是公共的抽象方法。

　　而且，接口中的抽象方法，也可以省略public/abstract关键字。

　　（public abstract） void say();

 2.【实现类实现接口】

（1）一个类实现接口使用implements关键字

（2）实现类实现一个接口，必须重写接口中的所有抽象方法，除非这个类是抽象类。

　　 一个类可以使用多个接口，多个接口之间，使用逗号隔开。

　　 class Desk implements IUsb2,3()

　　 一个类如果实现多个接口，必须重写所有接口中的所有方法。

（3）接口的引用可指向其实现类的对象（类似于父类引用指向子类对象）

　　IUsb2 usb=new UDesk();

　　因此可以使用接口实现多态。

 3.【接口继承接口】

（1）接口可以继承接口，使用extends关键字，接口继承与类的接口一样。

interface IUsb3 extends IUsb2{}

（2）接口可以多继承，多个父接口用逗号分隔，子接口继承多个父接口，将拥有所有父接口的抽象方法。

interface IUsb3 extends IUsb2，IUsb1{}

（接口不能被实例化）

4.【接口和抽象类的区别】 

 它们的本质区别：

　　抽象类是一个类，接口是一个接口，子类继承抽象类，要求子类必须和父类是同一类事物，必须符合is-a关系。

　　接口只是对功能的扩展。

　　多个实现类实现接口时，并不要求所有的实现类是一类事物。

　　接口符合like-a关系，理解为XXX具备一个XXX功能。比如人类狗类都具有吃饭功能，都具有吃饭接口，但是人类狗类的吃饭功能不能从同一个父类中继承。

（1）抽象类只能单继承，接口可以多继承，多实现。

（2）抽象类可以有自己的属性，接口中只能有静态常量。

（3）抽象类可以有非抽象方法，接口中的所有方法都必须是抽象方法（接口中的抽象方法可以省略abstract ）。

（4）抽象类是一个类，接口是一种规范。

　　子类继承抽象类，要求子类必须和父类是同一类事物。

　　接口并不要求多个实现类是同一类事物，只能进行设计与实现的分离。

interface IUsb2 {
/* public final static*/    int NAME=1;
//    public String name="1";//name是静态的，斜体的，接口的静态属性
    /*public abstract*/public void useUsb2();//在类中没有大括号必须加abstract修饰
}
    interface IUsb3 extends IUsb2{
        void useUsb3();
    }
     class UDesk implements IUsb2,IUsb3{

        @Override
        public void useUsb2() {
            // TODO Auto-generated method stub
            System.out.println("U盘使用useUsb2接口读取数据");
        }
        public void useUsb3() {
            // TODO Auto-generated method stub
            System.out.println("U盘使用useUsb3接口读取数据");
        }
        
    }
     class PC{
         private IUsb2 usb2 ;
         public PC(IUsb2 usb2){
             super();
             this.usb2=usb2;
         }
         public void useUsb(){
             usb2.useUsb2();
     }
     }
     public class Usb{
            public static void main(String[] args) {
                // TODO Auto-generated method stub
                
                System.out.println(IUsb2.NAME);
                IUsb2 usb=new UDesk();
                PC pc=new PC(new UDesk() );
                pc.useUsb();
            }
        }
     

三、集合框架

1.【java的集合框架】
 接口：
          collection                                                       map
      list                      set
 实现类：
 ArrayList              HashSet                                   HashMap
LinkList              LinkHashSet                          LinkHashMap
Vector                   TreeSet                                   TreeMap
                                                                           HashTable

StringBuffer：安全

StringBuild：不安全

ArrayList：线程不安全

Vector：线程安全

2.【四个接口的区别】

（1）Collection：存储不唯一，无序的数据。
（2）List：存储有序的，不唯一的数据。
（3）Set：存储无序的，唯一的数据。
（4）Map：以键值对的形式存储数据，以键取值，键不能重复，值能重复。

3.【List 接口】

（1）常用方法：
 ①add()在列表的最后添加元素
 ②add(index.obj)在列表的指定位置插入元素
 ③size();返回当前列表的元素个数
 ④get(int index);返回下标为index的元素
 如果没有泛型约束，返回Object类型，需要强转，如果有泛型约束，返回约束类型，无需强转。
 ⑤clear();清除列表中的所有数据
 isEmpty();检测列表是否为空
 ⑥contains()方法，传入一个对象，检测列表中是否包含该对象。
 如果传入的是String和基本数据类型，可以直接对比。
 如果传入的是实体类对象，则默认只比对两个对象的地址，因此，需要在实体类重写equals()方法。
 ⑦indexof()传入一个对象，返回在该对象在列表中首次出现的地址。
 lastindexof()返回最后一次的地址。
 ⑧传入一个下标，或者一个对象，删除指定元素
 如果传入下标，返回被删除的元素对象，如果下标大于size(),显示越界异常。
 如果传入对象，则要求重写equals方法，返回true或false显示删除是否成功。
 ⑨set(index,obj)用新传入的对象，将指定位置的元素替换掉，返回被替换掉的元素对象。
 sublist()截取一个子列表返回list类型
 toArray()将列表转成数组，返回一个Object[]类型
 （2）ArrayList（例如新闻列表）
 是实现了长度可变的数组，在内存空间中开辟一串连续的空间，长度可以随时修改，这种存储结构再循环
 遍历和随机访问元素的速度比较快。
 （3）LinkedList
 使用链表结构存储数据，再插入和删除元素师速度比较快。
 LinkedList的特有方法：
.addfirst();开头插入元素
.addlast();结尾插入元素
 removefirst()删除第一个元素
 removelast()删除最后一个元素。返回被删除的元素
 peekfirst();检索但不删除第一个元素
 peeklast();检索但不删除最后一个元素
 pullfirst()检索删除第一个元素
 getfirst()检索但不删除第一个元素
 getlast()检索但不删除最后一个元素

//ArrayList是实现类，实现List接口。
ArrayList list=new ArrayList();
list.add("list1");
        list.add("list2");
        list.add("list3");
        list.add("list4");
        list.add(2,"list0");
        System.out.println(list.contains("list1"));//返回true
        System.out.println(list);        //返回数组类型的
                /**
         * 使用for循环遍历列表
         */
        for(int i=0;i<list.size();i++){
            if(list.get(i) instanceof String){
                String s=(String)list.get(i);//向下转型，强转      Integer强转会出现转换异常。
                System.out.println(s);
            }else{
                Integer s=(Integer) list.get(i);
                System.out.println(s);
            }

        }//返回字符串的形式

1.【set接口】
（1）常用方法：与list接口基本相同。
 但是由于Set接口中的元素是无序的，因此没有用下标方法。
 例如get(index),remove(index)add(index,obj)
（2）Set的特点：无序，唯一
（3）HashSet，底层是调用HashMap的相关方法，传入数据后，根据数据的hashcode进行散列运算，得到一个散列值后在进行运算，
 确定元素在序列中存储的位置。
 HashSet如何确定两个对象是否相等：
 ①先判断对象的HashCode()，如果HashCode不同，肯定不是一个对象。
 如果HashCode相同，继续判断equals方法
 ②重写equals()方法。
 所以使用HashSet存储实体对象时，必须重写对象的HashCode()和equals()两个方法；
（4）LinkedHashSet,在HashSet的基础上，新增了一个链表，
  用链表来记录HashSet元素存放的顺序，因此使用迭代器遍历时，可以按照放入的顺序一次独处。
（5）TreeSet将存入的元素进行排序，然后再进行输出，如果存入的是实体对象，那么实体类必须实现comparable接口，并重写compareTo方法。
 或者也可以在实例化TreeSet的同时，通过构造函数传入一个比较器（一个实现了comparator接口并重写了compare的方法的对象）
 //使用匿名内部类拿到一个比较器对象

 Set<Person> set=new TreeSet<Person>(new Comparator(){
 public int compare(Person p1,Person p2){
 return p1.getId()-p2.getId();
 }
 });

 //自定义一个比较类，实现Comparator接口。

Set<Person> set=new TreeSet<Person>(new Compare());
 class Compare implements Comparator(){
 //重写compare方法
}

（5）[comparable 接口和comparator的区别]
①Comparable由实体类实现，重写ComparaTo()方法
　实体类实现Comparable接口以后，TreeSet使用空参构造即可。
②Comparator需要单独一个单独比较类进行实践，重写compare方法。
　实例化TreeSet的时候，需要传入一个比较类的对象。
2.【Map】

（1）Map接口特点：以键值对的形式存储数据，以键取值键不能重复，值不能重复。

（2）Map接口的常用方法：       

　　.clear()　

　 replace(key,value)①put(key,value);向map的最后追加一个键值对

　　map1.put("001", "小红");
②get(key);通过建，收到值
　　System.out.println(map1.get("001"));
③.clear();清除Map中的所有数据
④containsValue(obj)检测是否包含指定的值
 　　containsKey(obj)检测是否包含指定的键,如果传入对象，需要重写equals方法。
（3）【HashTable和HashMap的区别】
 ①HashTable是线程安全的（线程同步），HashMap是线程不安全的（线程不同步）
 ②HashTable的键不能为null，HashMap的键可以为null
 ③HashMap的初始容量为16，Hashtable初始容量为11，两者的填充因子默认都是0.75。
 ④HashMap扩容时是当前容量翻倍即:capacity*2，Hashtable扩容时是容量翻倍+1即:capacity*2+1。
 ⑤HashMap继承了AbstractMap，HashTable继承Dictionary抽象类，两者均实现Map接口。
 ⑥在HashMap 中不能用get()方法来判断HashMap 中是否存在某个键，而应该用containsKey()，方法来判断。Hashtable 的键值都不能 为null，所以可以用get()方法来判断是否含有某个键。
（4）【LinkedHashMap】（无序）
 可以使用链表，记录数据放入的次序，进入让读出的顺序和放入的顺序一致，与LinkedHashSet一致
 　　Map<String,String> map1=new LinkedHashMap<String,String>();
（5）【TreeMap】
 根据键的顺序，进行排序后，输出。如果传入的是实体对象，必须重写比较函数，详见TreeSet
　　 Map<String,String> map1=new TreeMap<String,String>();

Map<String,String> map1=new Hashtable<String,String>();
        map1.put("001", "小红");
        map1.put("002", "小王");
        map1.put("003", "小绿");
        map1.put("004", "小黄");
        map1.put(null, "小和");
        map1.replace("001", "小哈");//更改
        System.out.println(map1);
        System.out.println("****************");
        System.out.println(map1.get("001"));
        
        System.out.println("****************");
        System.out.println(map1.containsKey("001"));
        System.out.println(map1.containsValue("小绿"));//

Map<String,String> map1=new HashMap<String,String>();
        map1.put("001", "小红");
        map1.put("002", "小王");
        map1.put("003", "小绿");
        map1.put("004", "小黄");
        map1.put(null, "小和");
        map1.replace("001", "小哈");//更改
        System.out.println(map1);
        System.out.println("****************");
        System.out.println(map1.get("001"));
        
        System.out.println("****************");
        System.out.println(map1.containsKey("001"));
        System.out.println(map1.containsValue("小绿"));//

（6）遍历Map的方式

①遍历Map的方式1：KeySet

System.out.println("****************");
        Set<String> keys=map1.keySet();
        Iterator<String> it=keys.iterator();
        while(it.hasNext()){
            String key=it.next();
            System.out.println(key+"*******"+map1.get(key));
        }

② 遍历Map的方式2：values

System.out.println("****************");
        Collection<String> values=map1.values();
        Iterator<String>it1=values.iterator();
        while(it1.hasNext()){
            System.out.println(it1.next());//可以以键取值，不能以值取键
        }

③遍历Map的方式3：entrySet

System.out.println("****************");
        Set<Map.Entry<String,String>> set2=map1.entrySet();
        /*foreach*/
        for(Map.Entry<String, String> entry:set2){
                System.out.println(entry.getKey()+"****"+entry.getValue());
        }

/*Entry*/
        System.out.println("****************");
        Iterator<Map.Entry<String, String>> it3=set2.iterator();
        while(it3.hasNext()){
            Map.Entry<String, String>entry =it3.next();
            //entry 是Java给我们提供的一种特殊的数据类型其实是一个数据对。
            //键就是这条记录的键，使用getkey()去到
            //值就是这条记录的值，使用getValue()取到
            System.out.println(entry.getKey()+"****"+entry.getValue());
        }

四、Collections工具类

 Collections是Java中专门用于操作集合的工具类。

Collection是一个接口。

1.向集合中添加多个数据

（1）传入数据

ArrayList<String> list = new ArrayList<String>();
        list.add("test04");
        list.add("test09");
        list.add("test03");
        list.add("test02");
        list.add("test01");
        list.add("test07");
Collections.addAll(list, "01","02","test01");
System.out.println(list);

（2）传入对象

List<PersonDemo> list1 = new ArrayList<PersonDemo>();
        list1.add(new PersonDemo(1,"zhangsan"));
        list1.add(new PersonDemo(5,"lisi"));
        list1.add(new PersonDemo(2,"wanger"));
        list1.add(new PersonDemo(6,"zhaowu"));
        list1.add(new PersonDemo(3,"liergou"));
Collections.addAll(list1, new PersonDemo(10,"zhngsan"),new PersonDemo(8,"wangr"));
                System.out.println(list1);

 

2.将集合中的所有元素，全部替换为指定元素。把list里的内容替换成呵呵哒。

Collections.fill(list, "呵呵哒！");
System.out.println(list);

3.排序。

（1）sort方法: 对集合中的数据进行排序。

    Collections.sort(list1);
        System.out.println(list1);    

（2）如果集合存储的是一个实体对象，那么：

 ① 实体类实现comparable接口，并重写CompareTo方法；
 ② 在sort的第二个参数，传入比较器。 比较器需实现comparator接口，并重写compare方法。

Collections.sort(list1, new Comparator<PersonDemo>() {
            @Override
            public int compare(PersonDemo o1, PersonDemo o2) {
                // TODO Auto-generated method stub
                return o1.getId() - o2.getId();
            }
        });
        System.out.println(list1);

4.使用binarySearch，那么集合必须先排序。
同样，如果比较的是实体对象，依然需要通过两种方式实现比较器。

①

Collections.sort(list1);

System.out.println(Collections.binarySearch(list1, new PersonDemo(6,"zhaowu")));

 ②匿名内部类比较器

System.out.println(Collections.binarySearch(list1, new PersonDemo(6,"zhaowu"),
            //匿名内部类    
        new Comparator<PersonDemo>() {
                    @Override
                    public int compare(PersonDemo o1, PersonDemo o2) {
                        // TODO Auto-generated method stub
                        return o1.getId() - o2.getId();
                    }
                }
        ));

（4）拿到集合中最大、最小的值。

System.out.println(Collections.max(list1));
System.out.println(Collections.min(list1));

5..replaceAll(): 将列表的指定值，用新值替换。

如果是实体对象，需要在实体类中重写 equals()方法。

System.out.println(Collections.replaceAll(list1, new PersonDemo(1,"zhangsan"),
                new PersonDemo(1,"zhangsansan")));//后面返回前面，返回boolean类型
        System.out.println(list1);//返回替换后的列表

6.反转列表中的所有元素。（前后交换）

Collections.reverse(list1);
System.out.println(list1);

7.对集合的元素，进行随机排序。

Collections.shuffle(list1);
        System.out.println(list1);

8.将集合中指定的元素位置，进行交换。（把第三个和第0个交换）

Collections.swap(list1, 0, 3);
        System.out.println(list1);

五、泛型

1、 [泛型]
（1） 泛型就是“参数化类型”。 
在定义类型时，不将类型定死，而是采用泛型参数的形式进行定义。调用时传入具体的泛型参数。
2、[泛型类的特点]
 在声明类的时候，进行泛型约束，这样的类，称为泛型类。

 class Test<T>{ // <T> 可以理解为泛型声明是的形参。可以用任何字母代替。 常用T N E
 // 在泛型类中，T就可以当做特殊的数据类型进行使用
 private T arg;
 }
 // 泛型调用时，需要将实际的数据类型进行传入。
Test<String> test1 = new Test<String>("姜浩真帅！");
Test<Integer> test2 = new Test<Integer>(123);

（1） 泛型只在编译阶段生效。 同一个类通过不同泛型拿到的对象，使用getClass()判断是属于同一个类的。

 System.out.println(test1.getClass() == test2.getClass());
 // 取到的test1的类为 Test类，而不是Test<String>

（2）同一个类，通过不同泛型拿到的对象，相互不兼容。 不能互相赋值。

 test2 = test1; // test1与test2不兼容。

 即便，声明的泛型数据类型有父子类关系，那么用这两个数据类型声明的泛型类，还是不兼容。

Test<Integer> test2 = new Test<Integer>(123);
 Test<Number> test3 = new Test<Number>(123);
 test3 = test2; // 依然不兼容。

（3） 泛型类，在实例化的时候，可以不传入泛型。 类中的数据类型，以赋值时传入的变量类型为主。

 Test test3 = new Test(); // 实例化泛型类，没有传入泛型实参
test3.setArg("123"); // 类中的泛型变为String
 test3.setArg(456); // 类中的泛型被修改为Integer

（4） 实例化泛型时，只能传入类名，可以是系统类也可以是自定义的实体类，但不能传入基本数据类型。

Test<int> test1 = new Test<int>(); // × 

（5）泛型约束时，可以同时约束多个泛型： 

class Test1<T1,T2>{
 public T1 arg1;
 public T2 arg2;
 }
Test1<String,Integer> test4 = new Test1<String,Integer>();

（6）不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错。

 test2 instanceof Test2<Integer>; // ×
 test2 instanceof Test2; // √

3.[泛型通配符与上下边界]
（1） 为了解决，同一个类的多个不同泛型对象，相互不兼容的问题。 可以使用泛型通配符：?

 Test<?> test2 = new Test<String>();
// ? 表示可以兼容所有类的数据类型。

（2） 泛型通配符上边界： 使用? extends 类名,表示通配符只支持指定类及指定类的子类。

Test<? extends Number> test5 = new Test<Number>(); // √
Test<? extends Number> test5 = new Test<Integer>(); // √
 Test<? extends Number> test5 = new Test<String>(); // ×

（3） 泛型通配符下边界： 使用 ? super 类名,表示通配符只支持指定类及其超类。

Test<? super Integer> test6 = new Test<Integer>(); // √
Test<? super Integer> test6 = new Test<Number>(); // √
Test<? super Integer> test6 = new Test<String>(); // ×

4. [泛型接口]
（1） 声明泛型接口：

 interface inter<T>{
void Test(T t);
 }

（2）实现类，如果实现泛型接口，那么不能直接使用接口的泛型，需要重新声明：

class Test3<T> implements inter<T>{
@Override
 public void Test(T t) {}
 }

（3）如果实现类，不想作为泛型类。 那么，可以在实现接口时，直接给接口的泛型赋值:

 class Test3 implements inter<String>{
@Override
public void Test(String t) {}
 }

5. [泛型方法]
（1） 泛型方法可以独立于泛型类，在任何类中都可以单独使用：

 class Test{
 public static <T> void test(T t){
 }
 } 
//调用：
 Test.test("String");
Test.test(int);

（2） 使用泛型方法，可以实现可变参数的方法：

class Test{
 // 使用T... 表示可以接受N个 任意类型的参数； 也可以接受数组
public static <T> void test(T... t){
 }
}

 调用： Test.test("String","String2",123,true);
Test.test(new int[]{123,456,789});
（3）只有在方法中声明了<T>的方法，才叫泛型方法。
而如果在方法中，使用了类的泛型，这不能称为泛型方法。

 class Test<T>{
 // 这个不是泛型方法
 public void test(T t){}
}

 注意： 静态方法不能使用类泛型。 只能将静态方法，单独声明为泛型方法。

六、实现类

Math类 

 Math类位于java.lang包，不需要导包。

1.返回圆周率。

System.out.println(Math.PI);

2.返回绝对值。

System.out.println(Math.abs(-10));//绝对值，返回10

3.立方根。

System.out.println(Math.cbrt(27));//返回3

4.平方根。

System.out.println(Math.sqrt(9));//返回3

5.最大最小值。

System.out.println(Math.max(20, 19));
        System.out.println(Math.min(20, 19));

6.求a的b次方幂。

System.out.println(Math.pow(a, b));

7.floor返回一个小于指定浮点数的第一个整数，返回的是double类型，10.0。

System.out.println(Math.floor(10.5));//10.0
        System.out.println(Math.floor(-10.5));//-11.0

8.ceil返回一个大于指定浮点数的第一个整数，返回的是double类型，11.0。

System.out.println(Math.ceil(10.5));//11.0
        System.out.println(Math.ceil(-10.5));//-10.0

9.进行四舍五入，返回一个整数类型，若果传入double返回long，如果float返回int。

System.out.println(Math.round(10.5f));//11
        System.out.println(Math.round(10.3d));//10

10.保留三位小数。

public static double rounds(double num,int count){
         return Math.round(num*Math.pow(10, count))/Math.pow(10, count);
         } 
         System.out.println(rounds(10.354546,3));//diao用

System.out.println(Math.round(10.354546*Math.pow(10, 3))/Math.pow(10, 3));//10.355

11.返回最接近参数的一个整数，如果是10.5与10和11同时接近，那么返回偶数10。

System.out.println(Math.rint(10.5));//10   

12.返回【0,6）的int（左闭右开）随机一个。

System.out.println((int)(Math.random()*6));//  强转成int返回【1,6）的

13.返回ASCII码值。

System.out.println(Arrays.toString("abcdef".getBytes()));//返回数组97 98 99 100 101 102 103

14.判断是否有.java返回boolean。

System.out.println("abc.java".endsWith(".java"));

15.把0替换成o，把I替换成i。

String s="43434344250000000ooooooooooIIIIIIIIIi";
        System.out.println(s.replace("0", "o"));//4343434425oooooooooooooooooIIIIIIIIIi
        System.out.println(s.replace("I", "1"));//43434344250000000oooooooooo111111111i

 Date类

1.date空参构造： 取到当前时间。

Date date = new Date();
System.out.println(date);

2.setTime(): 传入一个长整型，重新设置date时间。

Date date = new Date();

date.setTime(1000*60*60*24);//计算机元年

System.out.println(date);

3.传入一个long类型的时间戳，取到指定时间。

date.getTime()： 取到一个时间的时间戳： 从0时区，1970年1月1日0:0:0 到当前时间的毫秒数。

Date date = new Date();
        date.setTime(1000*60*60*24);
System.out.println(date.getTime());

4.compareTo(): 前面>参数 返回 1 前面<参数 返回 -1 前面=参数 返回 0

　equals(): 比对两个时间是否相等。
   before(): 检测一个时间是不是在指定时间之前
   after(): 检测一个时间是不是在指定时间之后

System.out.println("3******************");
        System.out.println(date.before(date2));
        System.out.println(date.after(date2));
        System.out.println(date.compareTo(date2));
        System.out.println(date.equals(date2));

5.求出从95年到现在的年数。

Date date = new Date();
        System.out.println(date);//当前时间
Date date3  = new Date(95, 11, 23);
        System.out.println((date.getTime() - date3.getTime())/1000/60/60/24/365);//求出从95年到现在的年数

6.日期。

.

7.format(): 用于传入一个Date类型的参数，并返回格式化之后的字符串。

parse(): 将字符串格式的时间，转成Date类型。 要求传入的字符串格式，必须与实例化时的模式，保持完全一致
toPattern(): 返回当前格式化的模式字符串。

SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E");
        String dateFormat = sf.format(new Date());

Date date3 = null;
        try {//捕获异常
            date3 = sf.parse("2018年04月13日 14:09:47 星期五");
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        System.out.println(dateFormat);
        System.out.println(date3);
        System.out.println(sf.toPattern());

Calendar 日历类

1. Calendar日历类是一个抽象类，不能直接通过new拿到对象，必须使用 Calendar.getInstance();拿到。

Calendar calendar = Calendar.getInstance();
        System.out.println(calendar);

2.在原来的基础上减了两天。

calendar.add(Calendar.DAY_OF_MONTH, -2);
        System.out.println(calendar);

3.getTime 返回一个日期对象。

Date date4 = calendar.getTime();
        System.out.println(sf.format(date4));

4.根据calendar提供的常量，获得指定字段。

System.out.println(calendar.get(calendar.MONTH));
        System.out.println(calendar.get(calendar.DAY_OF_WEEK));

5.计算当前为星期几。

String[] arr = {"星期天","星期一","星期二","星期三","星期四","星期五","星期六"};
        int week = calendar.get(calendar.DAY_OF_WEEK)-1;
        System.out.println(arr[week]);

Random类

Random()类：取随机数
两种构造：
①空参构造
②传入一个种子数
③传入一个种子数，只要种子数相同，那么在相同次数(Random)取到的随机数肯定相同，这是伪随机数。

1.随机输出一个整数。

Random ran=new Random();//随机输出正负均可
        System.out.println(ran.nextInt());

2.nextInt()随机获得一个整数

　nextInt(n)随机获得从0到n的随机数
    nextDouble();

Random ran1=new Random(10);
        System.out.println(ran1.nextInt(10));//10以内随机
        System.out.println(ran1.nextInt(10));//10以内随机
        System.out.println(ran1.nextInt(10));//10以内随机
        System.out.println(ran1.nextInt(10));//10以内随机

3.返回毫秒数。

Date date=new Date();
        System.out.println(date.getTime()/1000/60/60/24);
        System.out.println(System.currentTimeMillis());

4.随机返回[95,103）。

Random ran=new Random();
System.out.println(ran.nextInt(8)+95);

Enum枚举类

枚举类是一种特殊的类，里面的值全部都是静态常量。
每个枚举值都相当于一个本类对象，只不过（对象的值就是对象的名）调用对象的toString方法打印的是对象名。

enum Color{
        /**
         * 每一个枚举值都是一个本类对象。
         * 、所以声明一个枚举值，相当于执行下列代码
         * public static final BLUE=new Color();
         *  public static final PINK=new Color();
         *   public static final YELLOW=new Color();
         */
        /**
         * 在枚举类中，枚举值必须要放在第一行，其他所有代码只能放在枚举值的后面。
         * 
         * 枚举类中的构造函数，只能是私有化的，在声明枚举值时，自动调用。
         */
        BULE,RED,YELLOW,GREEN,PINK;//本类对象   
        private Color(){//构造函数在常见对象使用
            System.out.println("hahahahahah");//输出5次，枚举值的个数。                
        }
    }
    

System.out.println(Color.BULE);

1.toString方法自动调用。

System.out.println(Color.BULE.toString());

调用对象的toString方法打印的是对象名。

返回BULE。

2.取到枚举类中所有枚举值。

Color [] colors=Color.values();
        for(Color color:colors){
            System.out.println(color.toString());
        }

3.声明一个Person枚举类型的类。

enum Person{

        Person1 ("张",12),Person2 ("li",22),Person3 ("chen",22),Person4 ("liu",13),Person0;
        private String name;
        private int age;
        private Person(String name,int age){
            this.name=name;
            this.age=age;
        }
        private Person(){
            this.name="默认";
            this.age=0;
        }
        public String toString(){
            return name+"------"+age;
            
        }
    }

System.out.println(Person.Person0);
        System.out.println(Person.Person1);//写toString方法

单例模式

单例模式：确保某一个类只能产生一个实例。

1.设计思路：

①将构造函数私有化，确保类外部不能使用new关键字自己创建对象。
②在类内部实例化一个对象，并通过静态方法返回。

private static Singleton sing =new Singleton();
    //如果这局部是静态的，public static Singleton getInstance()方法不能调用
    private Singleton(){//1
        System.out.println("单例模式");
    }

2. 恶汉式单例模式，在类加载的时候，就创建了一个对象。

缺点：在类加载的时候就实例化对象，提前占用系统资源
优点：线程安全。

private static Singleton sing =new Singleton();
public static Singleton getInstance(){
        return sing;
        
    }

3.懒汉式单例模式。

优点：解决了恶汉式单例，一加载就提前占用资源的问题。
 缺点：线程不安全。

private static Singleton sing =null;
    public static  Singleton getInstance(){
        if(sing==null){
            sing =new Singleton();
        }
        return sing;
        
    }

4.synchronized同步锁。

使用synchronized同步锁，对方法进行加锁，确保懒汉式单利可以线程安全。
将一个方法或者是代码块进行加锁，同一时间只允许一个线程访问。
 缺点：每次都需要锁住方法，每一个方法或代码块 ，效率低下。

private static Singleton sing =null;
    public static synchronized Singleton getInstance(){//线程锁synchronized
        if(sing==null){
            sing =new Singleton();
        }
        return sing;
        
    }

5.双重加锁的懒汉模式。

只有第一个Sing为null时，才进行线程锁，
当后续sing不为null时，就无需线程锁，可以允许多个线程同时拿走sing。

private static Singleton sing =null;
    public static synchronized Singleton getInstance(){//锁住哪个类的对象
        if(sing==null){
            synchronized (Singleton.class) {
                if(sing==null){
                    sing =new Singleton();
                }
        }    
        }
        return sing;
        }

6.静态内部类实现单例：

优点：解决了恶汉式提前占用资源的问题，解决了懒汉式线程不安全的问题。

    private static class Singleton1{//不能是public外面可以直接实例化，每次都调用，不能实现单例
        private static Singleton sing =new Singleton();
    }
    public static Singleton getInstance(){
        return Singleton1.sing;
        
    }