“黑马程序员”学习笔记六

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ---------- 
/*
  * 开启线程有两种方式：
  * 一.继承Thread类：
  * 1.用Person类继承Thread类，复写其run()方法
  * 2.在主函数中建立对象：Person p=new Person()
  * 3.调用对象的start()开启线程,实现run()方法：p.start()
  * 二.实现runnable接口：
  * 1.用Person类实现runnable接口，复写其run（）方法
  * 2.在主函数中建立对象：Person p=new Person()
  * 3.建立Thread对象,并把p传入Thread（）中：Thread t=new Thread(p)
  * 4.用线程对象开启线程，实现run()方法、：t.start()
  * 同步存在的前提是：1.存在两个或两个以上的线程，2.这连个线程有共享数据
  * 同步的作用是保证共享内容在同一时刻只有一个线程在访问
  * 同步代码块 synchronizde(唯一对象，可以是obj){共享内容}
  * 同步函数：当函数内容全部需要同步完成时，就在函数上加synchronized表示同步函数（注意：
如果存在循环语句，需将同步内容封装成函数，再在循环语句中调用该函数）同步函数的锁是本类对象synchronized(this)
  * 静态同步函数应用时需将共享数据也静态，静态同步函数用的锁是：synchronized(类名.class)
  * */
/*火车站多窗口卖票：同步代码块
class Ticket extends Thread//implements Runnable
{
 Ticket(String name)
 {
  super(name);
 }
 private static int n=1000;
 Object obj=new Object();
 public void run()
 {
  for(int x=0;x<1000;x++)
   {
    synchronized(obj)
    {
     if(n>0)
     {
      //try{Thread.sleep(10);}catch(Exception e){}
      System.out.println(Thread.currentThread().getName()+"ticket"+n--);
     }
    }
   } 
 }
}
public class XianChen
{
 public static void main(String[] args)
 {
  Ticket t1=new Ticket("one ");
  Ticket t2=new Ticket("tow ");
  Ticket t3=new Ticket("threa ");
  Ticket t4=new Ticket("four ");
  t1.start();
  t2.start();
  t3.start();
  t4.start();
  //new Thread(t).start();
  //new Thread(t).start();
  //new Thread(t).start();
  //new Thread(t).start();
 }

}*/

 

/*注意：多线程中共享资源必须同步，包括标记的判断，在有两个以上的线程操作共享资源时，判断标记要用while()语句
 * （while()语句不管线程从while()语句下哪里继续都要回来判断while()语句，if()则不用），唤醒语句要用
 * notifyAll()以防止所有线程都处于冻结状态
 * 1.5版本以后Lock已经可以取代synchronized:
 * import java.util.concurrent.locks.*;导入该包里所有的类
 * Lock lock=new ReentrantLock();
 * //可以使用lock.lock();lock.unlock();(lock.unlock()要放在finally{}中)
 * Condition c=lock.newCondition();(可以同时建立多个Condition对象，
 * 不同的对象可以操作不同的线程，一般用于唤醒对方线程，如：生产消费商品的类子)
 * //可以使用c.await();c.signal();c.signalAll();
 * 中断线程：
 * 线程对象.interrupt()（会抛出异常）用于唤醒不能正常唤醒的死线程并在catch(){}语句中终结该线程
 * 如：try{wait()}catch(InterruptedException e){改变标记}
 * 守护线程：
 * 在线程开启前加 ：线程对象.setDaemon(true);
 * 守护线程也叫后台线程，当其主线程结束后自动结束
 * 多线程join（）方法抢夺主线程执行资格：
 * 线程对象.join();必须在该线程执行完之后，主线程才能有执行权
 * main()
 * {
 *   t1.start();
 *   t2.start();
 *   t1.join();
 *  System.out.println("over");
 * }
 * t1开启，t2开启，t1抢夺主线程执行权，主线程停止，t1,t2交替执行，t1执行完主线程继续执行
 * 线程停止:
 * Thread.yield();该语句放在同步中，当线程执行到该语句时会放弃执行权，当下一个线程执行
 * 到该语句时，放弃执行权，本线程重新拥有执行权。作用：减缓一个线程重复执行
 */
class Person
{
 private int y=1;
 private boolean b=false;
 private String name;
 private String sex;
  public synchronized void  set(String name,String sex)
  {
  while(b)//两个以上线程时不能用if()语句
    try{this.wait();}catch(Exception e){}
   this.name=name;
   this.sex=sex;
    System.out.println(Thread.currentThread().getName()+"输入."+name+".."+sex+y++);
    this.notifyAll();
    b=true;
  }
  public synchronized void get()
  {
   while(!b)
    try{this.wait();}catch(Exception e){}
   System.out.println(Thread.currentThread().getName()+"输出                        ."+name+".."+sex+(y-1));
   this.notifyAll();
    b=false;
  }
 
}
class Input implements Runnable
{
 private Person p;
  Input(Person p)
 {
  this.p=p;
 }
  public  void run()
 {
    for(int z=1;z<=100;z++)
  {
     int s=1;
    if(s==1)
     p.set("zhangsan","man");
    else
     p.set("李四","女");
    s=(s+1)%2;
  }
 }
}
class Output implements Runnable
{
 private Person p;
  Output(Person p)
 {
  this.p=p;
 }
 public void run()
 {
  for(int z=1;z<=100;z++)
   {
    p.get();
   }
 }
}

public class XianChen1
{
 public static void main(String[] args)
 {
  Person p=new Person();
  Input in1=new Input(p);
  Input in2=new Input(p);
  Output ot1=new Output(p);
  Output ot2=new Output(p);
  new Thread(in1).start();
  new Thread(in2).start();
  new Thread(ot1).start();
  new Thread(ot2).start();
 }

}

 

* String类的功能：
 * equals在Object类中比较的是地址值，在String类中equals（）功能被
 * 复写，比较字符串是否相同
 * 获取：
 *  1.int length():获取字符串长度
 *  2.char charAt(int index)：返回index上的字符
 *  3.int indexOf(int ch)(ch指的是字符的ASC码值,直接传字符也行)：返回ch第一次在
 *  字符串中出现的位置（如果字符串中不存在ch或str返回的是-1，次功能也可以用于判断是否包含子串）
 *  4. int indexOf(int ch，int fromIndex):从fromIndex位置开始找，并
 *   返回ch在字符串中第一次出现的位置
 *  5. int indexOf(String srt):返回str第一次在字符串中出现的位置
 *  6. int indexOf(String str，int fromIndex):从fromIndex位置开始找，并
 *   返回str在字符串中第一次出现的位置
        判断：（返回值类型全是boolean）
 *  1.判断字符串中是否有某个子串
 *  boolean contains(str)
 *  2.判断字符串是否有内容
 *  boolean isEmpty()
 *  3.判断字符串是否以某某开头
 *  boolean starstWith(str)
 *  4.判断字符串是否以某某结尾
 *  boolean endsWith(str)
 *  5.判断内容是否相同
 *  boolean equals(str)
 *  6.判断内容是否相同并忽略大小写
 *  boolean equalsIgnoreCase()
 *转换：
 * 1.将字符数组转换成字符串
 *  构造函数： String String(char[]);
 *   String String(char[],offset,count);
 *  （off转换的开始坐标，count转换字符的个数）
 *  静态方法：
 * 1.static String copyValueOf(char[]);
 * static String copyValueOf(char[],offset,count);
 * static String valueOf(char[]);
 * 2.将字符串转换成字符数组
 * char[] toCharArry();
  *3.将字节数组转换成字符串
 * String String(byte[]);
 * String String(byte[],offset,count);
 * 4.将字符串转换成字节数组
 * byte[] getBytes();
 * 5.将基本数据类型转换成字符串
 * 如：3+“”一般写法
 * 正常转换
 * static String valueOf(int/double)
 *替换
 * String replace(oldchar,newchar);
 * String replace(oldString,newString);
 * 如果要替换的字符不存在，返回的还是原串
 *切割
 * String[] split(regex);
 * regex指的是切割点，返回的是字符串数组
 *子串
 * String subString(begin);
 * String subString(begin,end);
 * 注意：包含头不包含尾 。如：获取全部数组substring(0,str.length());
 * 如果开始的角标不存在，报角标越界异常
 *转换，去除空格，比较。
 * 字符串大小写转换String toUpperCase();String toLowerCase();
 * 去除字符串两端的多个空格String trim();
 * 对两个字符串进行自然顺序的比较 int compareTo(string);
 * */

public class StringLei
{
 public static void main(String[] args)
 {
  

 }
 public void print(Object o)
 {
  System.out.println(o);
 }

}

/*
 * StringBuffer是字符串缓冲区，是一个字符串容器，可以多次向里面赋值，
 * 添加内容而地址值不变
 * StringBuffer特点：
 * 1.StringBuffer中字符串的长度不确定
 * 2.可以直接操作多个数据类型
 * 3.最终会通过toString()方法变成字符串
 * 1.存储：
 *    添加：StringBuffer append(任意类型参数，执行时它自动转换为字符串)
 *        将参数添加到StringBuffer中字符串的结尾
 *    插入： StringBuffer insert(index,任意类型参数)将指定内容插入到index角标位置
 * 2.删除：
 *   StringBuffer delete(start,end):删除指定角标位的字符串
 *   （包含头，不包含尾）
 *   StringBuffer deleteCharAt(index):删除指定位置的字符
 * 3.获取
 *  char charAt(int index)
 *  int indexOf(String str)
 *  int lastIndexOf(String str)
 *  int length()
 *  String substring(int start,int end)
 * 4.修改
 *  StringBuffer replace(int start,int end,String str)
 *  void setCharAt(int index, char ch)
 * 5.反转
 * StringBuffer reverse();
 * 6.将缓冲区中指定数据存储到指定字符数组中
 * viod getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
 *
 * JDK1.5版本之后出现了StringBuilder
 * StringBuilder不同步，一般用于单线程，增加执行速度
 * StrintgBuffer同步，一般用于多线程，保证安全
 *
 * 所有的数据类型将首字母大写就变成了类，这些类在API中都已经封装好了，有自己的特有功能
 * int和char有点不同：int=Integer
 *       char=character
 * Integer.MAX_VALUE int的最大值2的32次方减1
 * Integer.MIN_VALUE int的最小值
 * 该功能最大的作用是用于基本数据类型和字符串之间的转换
 * 基本数据类型转字符串：
 *               基本数据类型+“”
 *      基本数据类型.toString(基本数据类型的值)
 *     如：Integer.toString(34)结果是“34”
 *字符串转成基本数据类型：
 *    xxx a=Xxx.parseXxx(String);//必须传入数字格式的字符串，否则报错
 *              如：int a=Integer.parseInt("123");
 *                double b=Double.parseDouble("12.23"
  十进制转成其他进制：
     toBinaryString(要转换的十进制数);//二进制
     toHexString(要转换的十进制数);//十六进制
     toOctalString(要转换的十进制数);//十进制
 其他进制转成十进制：
      parseInt(String,radix)//返回十进制数
      String字符串数，如：“3c”，“110”
      radix对前一个参数字符串的说明
      如：“3c”对应的是16进制，radix=16
       "110"对应的是2进制，radix=2
       "110"对应的是10进制，radix=10
 * */

public class StringBuffer
{

 public static void main(String[] args)
 {
  //int t=Integer.parseInt("60");
  //String t=Integer.toBinaryString(60);
   int t=Integer.parseInt("110",10);
   System.out.println(t);
 }

}

 

/*
 * 数组合集合的区别：
 * 数组也可以存储对象，但是数组长度是固定的，集合长度是可变的，数组中可以存储
 * 基本数据类型，集合却不行，只能存储对象(地址)（任意类型的对象都可以）.
 * 集合（Collection）是一个根接口（没有构造函数，不能建立对象，只有抽象方法），
 * 其子接口有List，Set，Map等.而List又被ArrayList,LinkedList和Vector等
 * 容器实现；Set被HashSet和TreeSet容器实现
 * 容器（集合对象）.add(对象)；添加元素
 * 容器（集合对象）.addAll(集合)；添加一个集合中的所有元素
 * 容器（集合对象）.size()；返回集合中的元素个数
 * 容器（集合对象）.remove(对象)；删除集合中的某个元素
 * 容器（集合对象）.clear()；清空集合,返回的是一个空集合
 * 容器（集合对象）.contains(对象)；判断集合中是否有某个元素，返回值为boolean型
 * 容器（集合对象）.containsAll(集合)；判断集合中是否有某个集合的全部元素，返回值为boolean型
 * 容器（集合对象）.isEmpty(对象)；判断集合是否为空
 * 容器（集合对象）.retainAll(集合)；取交集并清空容器将交集存入容器中
 * 在容器中取出元素用迭代器Iterator（是个接口）直接打印的局限性太大一般不用
 * Iterator接口中有三个方法 hasNext()判断集合中是否有元素,
 *        next()返回迭代的下一个元素,
 *        remove()从迭代器指向的集合中移除迭代的最后一个元素
 * 当迭代器在对集合中的元素进行操作时，不能同时使用集合中的方法对其元素进行操作会发生异常
 * Iterator it=（集合对象）.iterator（）
 * //父类接口引用指向了子类方法，每一个集合都默认实现了Iterator并静态实现了其方法
 * while(it.hasNext())
 * {
 *   System.out.println(it.next())
 * }循环取出语句
 * List集合，Set集合和Map集合的区别（List集合和Set集合用Iterator（）取出，Map有自己的方法）
 *   List集合中的元素是有序的（怎么存怎么取），而且可以存在重复元素，因为List集合有索引（脚标）
 *   List集合判断元素是否相同底层默认调用的是object中equals()方法，比较地址值（每个对象的地址值都不同，所以可以存在内容相同的对象）
 *   HashSet集合中的元素是无序的(无序指的是取出无序)，元素不可以重复
 *   HashSet集合判断元素是否相同底层默认调用的是object中hashCode()方法，如果地址值相同再通过equals()方法比较对象的内容
 *   所以，当我们定义的对象将要存入set集合中的时候需要先复写hashCode()方法和equals(这里的参数一般是Objiect obj)方法
 *   （一般用对象内容定义hashCode()方法,如int hashCode(){return name.hashCode()+age*40}hashCode()方法）
 *   TreeSet集合中的元素默认按字母在ASC码中的值排序，如果要自定义对象需自定义排序方法，自定义对象类需实现Comparable接口，复写
 *   CompareTo()方法，CompareTo()方法中如果主要条件相同需判断次要条件，两都相同就不往里面存直接删除。CompareTo()方法也是
 *   集合默认调用的。底层数据结构是二叉树CompareTo()方法中的返回值（-1；0；1）决定存储顺序，取出顺序是从下向上，从左向右，
 *      TreeSet集合的第二种排序方式，当元素自身不具备比较性或者想替换其原有比较方法时 就需要让集合在初始化时自身就具备比较性
 *      定义一个比较器，将比较器对象作为参数传到TreeSet集合的构造函数中。注意：传入的是比较器对象
 *      自定义比较器实现Comparator接口，复写Compare(Object o1，Object o2)方法(方法内注意类型转换)
 *      当两者都存在时，以集合比较器优先，集合比较器不存在时再用对象自身的比较方法
 *    接口Map(K key,V value)存的都是有映射关系的键值对
 *   Map的添加：
 *    put(K key,V value)如果添加的键有重复则之前该键对应的值会被覆盖（保证映射关系的唯一性）
 *    putAll(Map<?extends K,?extends V> m)
 *   Map删除：
 *    clear()
 *    remove(object key)删除集合中的键值对返回Value
 *   Map判断：
 *    containsValue(Object value)
 *    containsKey(Object k)
 *    isEmpty()
 *   Map获取
 *    get(Object key)返回Value
 *    size()
 *    values()返回集合中的所有Value，返回值是一个Collection<>集合
 *    
 *  entrySet()包含映射关系的Set()集合
 *   Map<String,String>  map=new HashMap<String,String>
 *    map.put(....... , ........);
 *    Set<Map.Entry<String,String>> entrySet=map.entrySet();
 *    Iterator<Map.Entry<String,String>> it=entrySet.iterator();
 *    while(it.hasNext())
 *    {
 *     Map.Entry<String.String> me=it.next();
 *     //Map.Entry<String.String>是一个封装好的对象，有其特有的方法
 *      //其实Entry是Map接口中的一个静态内部接口
 *     String value=me.getValue();
 *     String key=me.getKey();
 *    }
 *  keySet()包含键的Set()集合
 *   Map<String,String>  map=new HashMap<String,String>
 *    map.put(....... , ........);
 *    Set<String> keySet=map.keySet();
 *    Iterator<String> it=keySet.iterator();
 *    while(it.hasNext())
 *    {
 *     String key=it.next();
 *     String value=map.get(key);
 *    }
 *      Hashtable集合底层是哈希表数据结构，不可以存入null键和null值，该集合是线程同步的
 *      HashMap集合底层是哈希表数据结构，并允许存入null键和null值，该集合是非线程同步的
 *    TreeMap集合底层数据结构是二叉树，可以给集合中的Key排序，线程不同步，和set很像，
 *    set底层其实是使用了Map集合
 *   凡是可以操作脚标的方法都是List体系特有的
 *   增： add(index,element);在指定位置添加一个元素，其他元素顺延
 *      addAll(index,Collection);
 *   删：remove(index);删除指定位置元素
 *   改：set(index,element);替换掉指定位置的元素
 *   查：get(index);获取指定位置的元素
 *      subList(from,to);获取子集合返回类型是集合
 *      listIterator();
 *   ListIterator列表迭代器继承Iterator接口是List集合的特有迭代器
 *   由于Iterator方法有限，只能对元素进行判断，取出，删除的操作，如果想进行
 *   其他操作如：添加，修改等就必须用其子接口ListIterator
 *   ListIterator li=集合对象.listIterator();
 *   while(li.hasNext())
 *   {
 *    object obj=li.next();
 *    if(li.next().equals("集合中的某个元素"))
 *     li.set（“一个对象”）；//用一个对象替换集合中的某个元素
 *   }
 *   获取集合长度：size（）；
 *   ArrayList,LinkedList和Vector的区别
 *   ArrayList：底层使用数组结构，遍历查询速度很快，增删较慢
 *   LinkedList：底层使用链表结构，遍历查询速度比较慢，增删很快
 *   Vector：底层是数组数据结构和线程同步，安全性高，遍历查询，增删速度都相当慢
 *  LinkedList的特有方法：
 *          offer/addFirst();
 *          offer/addLast();
 *          peek/getFirst();如果集合中没有元素1.6版本后返回null/之前返回NosuchelementException
 *       peek/getLast();如果集合中没有元素返回null/NosuchelementException
 *          poll/removeFirst();如果集合中没有元素返回null/NosuchelementException
 *      poll/removeLast();如果集合中没有元素返回null/NosuchelementException
 *set:元素无序（存入和取出的顺序不一致），元素不可以重复
 * HashSet:底层数据结构是哈希表结构，哈希值相同(用的是hashCode()比较)，内容不同(用的是equals()比较)，就把这两个对象都存在同一哈希地址下
 * TreeSet:可以对元素进行排序（按字母排序）
 *泛型：是JDK1.5版本以后出现的新特性，用于解决安全问题的安全机制，一般用于集合中
 *泛型类：类名后加<Object>，在要操作的引用数据类型不确定的时候定义，在建立该类对象时在<>中确定*引用*的数据类型，类中方法的参数和<>中一致
 *泛型也可以定义在方法上：当同一个类中的不同方法要操作不同对象时，不定义泛型类，而是在函数修饰符后返回值类型前加<Object>,建立泛型方法，参数也和<>中一致
 *泛型类中也可以定义泛型方法（没有定义泛型的方法默认和类中泛型一致）
 *静态方法不可以访问类上定义的泛型，如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上
 * 接口也可以定义泛型，引用对象类型可以由其实现子类来确定，其实现子类也可以定义相同泛型，泛型可以由其调用者确定
 * 泛型中也可以定义<?>和<?extends 类名>泛型可以是类和其子类。<？super 类名>类和其父类
 *Collections是一个工具类，里面没有特有数据全部是静态方法，是专门用于操作集合的类
 *Arrays是一个操作数组的工具类，其内方法都是静态的（将数组变成集合后，可以用集合中的方法来操作数组中的元素很方便
 *但是不能对其元素进行增删，因为数组的长度是一定的）
 *用法：
 * 1.导包
 * 2.在程序中直接调用Collections的方法Collections.方法（集合）；
 * */

import java.util.Calendar;

/*
 * Collections类是一个操作集合的工具类，其内方法都是静态的，没有特有数据
 * Collections.sort（List<T> list）是其中一个可以对List集合进行自然排序（字符在ASC表中的大小顺序）的方法
 * eg:public static<T extendsComparable<? super T>>void sort(List<T> list)
 * Collections.sort（List<T> list，Comparator<T> comparator）自定义比较顺序排序
 * Collections.max(List<T> list)求自然顺序的最大值
 * Collections.binarySearch(List<T> list,T t)二分查找（注意，元素必须是有序的）
 * Collections.binarySearch(List<T> list,T t,Comparator<T> comparator)
 * 该查找方法查找的集合需要是按照comparator（）方法进行排序的Collections.sort（List<T> list，Comparator<T> comparator）
 * Collections.fill(List<T> list,String str)将集合中的所有元素替换成str
 * Collections.replaceAll(List<T> list,T t,String str)将集合中的所有t元素替换成str
 * Collections.reverse(List<T> list)将集合中的元素反转
 * Collections.reverseOrder(Comparator<T> comparator)返回的是一个与原序相反的比较器
 * Collections.synchronizedCollection(Collection collection)将集合作为参数传进来返回一个同步的集合
 * 该方法的Collection可以是任何类集合（List，Set，Map）
 * Collections.swap(List<T> list,int i,int j)互换指定角标元素的位置
 * Collections.shuffle(List<T> list)随机排列集合中的元素
 * Arrays.binarySearch()
 * Arrays.copyOf()
 * Arrays.copyOfRange(List<T> list,int from, int to)
 * Arrays.equals(List<T> list，List<O> list)比较两个数组中的元素是否相同
 * Arrays.deepEquals(List<T> list，List<O> list)如果元素是对象的话除了比较元素是否相同外还要比较对象内容是否相同
 * Arrays.fill（List<T> list，int fromindex,int toindex,String str）将一段角标间的元素替换成str
 * Arrays.asList(Array[] arr)将数组变成String类型的集合，返回的是一个集合（集合功能强大）
 * 将数组变成集合后不能用集合中的增删方法，因为数组的长度是固定的
 * 如果数组中的元素都是对象，则转换成集合后对象直接变成集合中的元素
 * 如果数组中的元素都是基本数据类型，则转换成集合后该数组会变成一个对象成为集合中的元素（集合中存储的是对象的地址值）
 * eg：int[] arr={1,2,3}和Integer[] arr={1,2,3}变成集合的结果是不一样的
 * Iterable<T>可迭代的接口从Iterator中抽取出来的
 * 增强for循环：for(T t ：List<T> list){}只能对集合中的元素进行取出操作，不能对集合进行其他操作
 * Iterator（）除了获取还能进行remove操作,ListIterator()可以对集合进行增，删，改，查任意操作
 * 可变参数
 * public void show(int... arr){}不确定数组的元素和长度，由调用者来确定,自动将这些元素封装成数组
 * public void main()
 * {
 *   show(1,2,3,4)
 * }
 * public void show(String str,int... arr){}这是可以的，其他参数必须定义在可变参数前面
 * public void show(int... arr,String str){}这是不行的，可变参数会默认将其后面出现的参数封装进数组
 * 静态导入
 * import static java.util.类名.*;调用静态方法是可以省略“类名.”当方法重名时，类名不能省
 * 常用对象
 * System类
 * 没有构造函数它的方法都是静态的，它不能实例化直接“类名.”调用
 * Properties类是Map下的HashTable的子类（properties是属性的意思）
 * getProperties()返回的是一个Properties集合
 * System.out()标准输出，对应的是控制台
 * System.in()标准输入，对应的是键盘
 * Properties prop=System.getProrerties()；prop是Map集合的子类可以用迭代器获取
 * for(Object obj：prop.keySet())
 * {
 *   String value=(String)prop.keySet().get(obj);
 *   System.out.println(obj+"=="+value);
 * }
 * System.stringPropertyNames()返回系统属性类表中的键集返回的是一个Set<String>集合
 * System.setProperty(String str1,String str2 )向系统属性中添加自己的东西
 * Runtime类
 * 没有构造函数，应用了单例设计模式
 * 每一个Java应用程序都有一个Runtime类实例，使应用程序能够和其运行的环境相连接，应用程序
 * 不能建立自己的Runtime类实例，可以通过getRuntime()来获取其内封装的方法
 * exec（String commend）在单独的进程中执行指定命令，返回的是一个Process进程exec是execute的简写是执行的意思
 * 调用模式： Runtime r=Runtime.getRuntime();
 *     r.exec(执行路径加执行文件字符串)//r.exec(执行工具   执行文件)用某某工具打开某某文件
 * Process类
 * 是一个抽象类，所有的方法都是抽象的，没有子类实现这个类，它的方法全部是由计算机底层实现和调用
 * 有一个方法destroy();杀掉子进程 eg:Process p=r.exec(执行路径加执行文件字符串)
 *          p.destroy();
 * Date类
 * 有构造函数，可以new对象
 * Date d=new Date();//打印的时间是英文版
 * DateFormat日期格式化，是一个抽象类,一般使用其子类SimpleDateFormat（）该类在java.text包中
 * SimpleDateFormat sdf=new SimpleDateFormat("yyy年MM月dd日")；
 * Calendar日历是抽象类，其实现子类是GregorianCalendar,一般用Calendar c=Calendar.getInstance();直接获取调用
 * TimeZone时区
 * Math类，数学运算工具类，里面全部是静态方法
 */

public class QiTaDuiXiang
{

 public static void main(String[] args)
 {
  Calendar c=Calendar.getInstance();
  /*
  c.set(2013,4,19);//直接设置时间
  c.add(Calendar.DAY_OF_MONTH,int offset(时间的偏移量))
  sop(c.get(Calendar.YEAR));
  sop(c.get(Calendar.MONTH)+1);//月份是从开始的
  sop(c.get(Calendar.DAY_OF_MONTH));//星期从周日开始的
  sop(c.get(Calendar.DAY_OF_WEEK));
  */
  sop(c.get(Calendar.YEAR));
  QiTaDuiXiang q=new QiTaDuiXiang();
  q.myCalendar(c);
 }
 public void myCalendar(Calendar c)
 {
  
  String[] month={ "一月","二月","三月","四月","五月",
    "六月","七月","八月","九月","十月","十一月","十二月"};
  String[] weeks={"星期日","星期一","星期二","星期二","星期三","星期四","星期五"
      ,"星期六"};
  int index1=c.get(Calendar.MONTH);
  int index2=c.get(Calendar.DAY_OF_WEEK);
   String myMonth=month[index1];
   String myWeek=weeks[index2];
   sop(myMonth);
   sop(c.get(Calendar.DAY_OF_MONTH));
   sop(myWeek);
 }
 public static void sop(Object o)
 {
  System.out.println(o);
 }
}