java之路（五） 转载

五 JAVA的接口
1.  第四次课作业：
  (1)容器的使用

 package TEST;

import java.util.*;
public class Test {
    public Test() {
    }

    public static void main(String[] args) {
      List<String> list=new ArrayList<String>();
      list.add("ibm");
      list.add("db2");
      list.add("java");
      list.add("eclipse");
      /*for(String elem:list)
      {
         System.out.println(elem);
      }
     
      for (int i = 0; i < list.size(); i++) {
          System.out.println(list.get(i));  
      }*/
      //进行排序；
      java.util.Collections.sort(list);
      Iterator it=list.iterator();
      while(it.hasNext())
      {
         System.out.println(it.next());
      }
      list.remove(0);
     
     
    }
}
  (2)键盘的输入和输出：
    package TEST;

import java.util.*;
import java.io.*;

public class Test {
    public Test() {
    }

    public static void main(String[] args) {
        String name;
        //JDK 1.5新添的方法：
        java.util.Scanner scanner = new Scanner(System.in);
        System.out.println("input the name");
        name = scanner.next();
        System.out.println(name);

        //JDK1.5之前常用的方法：
        java.io.BufferedReader in = new BufferedReader(new InputStreamReader(
                System.in));
        System.out.println("input the second name");
        try {
            name = in.readLine();
            System.out.println(name);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        //第三种方法：
        name=javax.swing.JOptionPane.showInputDialog("输入名字：");
        System.out.println(name);
    }
}

 (3)包装类的使用：
   package TEST;

import java.util.*;
import java.io.*;

public class Test {
    public Test() {
    }
    public static int add(int a,int b)
    {
       return a+b;
    }
    public static void main(String[] args) {
       ArrayList list=new ArrayList();
       list.add(10);    //JDK1.5 后的包装类和原始类型的默认转换
       list.add(new Integer(20));
       list.add(new Integer(30));
       for(Object o:list)
       {
          Integer i=(Integer)o;
         
          int j=i.intValue();
          j++;
          System.out.println(add(i,i++));
       }
    }
}

  Integer  ------------------------>int
  Character ----------------------->char
  Boolean--------------------------->boolean
  Float ------------------------------>float
  Double----------------------------->double
  Byte-------------------------------->byte
  Short------------------------------->short
  Long-------------------------------->long
 (4)类型之间的转换：
   int--------------------------->String
   String str=(new Integer(a)).toString
   String str=""+a;
   String ----------------------->int
   int i=Integer.ParseInt("123");

   double------------------------->String
   String str=""+3.14;
   String str=(new Dobule(3.14)).toString();
   String ------------------------>Double
   double d=Double.ParseDouble("3.14");

2.接口
  (1)如果一个类中的所有的方法都是抽象方法，那么这个类是一个接口类：
  (2)定义接口使用关键字Interface
  (3)接口中所有的方法都是抽象方法，因此abstract关键字可以省略
  (4)接口不能定义接口的事例，但是可以定义接口的变量。
  (5)只有实现接口中的所有的方法才可以定义类的事例。
  (6)接口的方法必须是公有的，因此public可以省略。
  (7)如果一个类要实现一个接口，那么使用关键字implements
  (8)接口中只有方法没有域，但是可以静态常量。
  (9)一个类可以实现多个接口
3.接口和抽象类
  (1)一个类只能继承一次，但是可以实现多次。
  (2)接口中的方法都是抽象方法。
  (3)接口中没有域的定义，只有方法和常量，而抽象类中可以定义域      也可以定义方法。
  (4)接口侧重于需求规范的描述，而抽象类侧重于is-a关系（继承）   关系的描述。
4.举例：
   //接口的定义：
   package com.pengcheng;

public interface Comparable {
    int compareTo(Object o);
}

/********************************************************/
  //排序类的定义：
  package com.pengcheng;

public class Arrays {
    public Arrays() {
    }

    public static void main(String[] args) {
        Arrays arrays = new Arrays();
    }
   
    public static void sort(Comparable arrays[])
    {
          for(int i=0;i<arrays.length;i++)
          {
             for(int j=0;j<arrays.length-1-i;j++)
             {
                  if(arrays[j].compareTo(arrays[j+1])>0)
                  {
                        Comparable temp=arrays[j+1];
                        arrays[j+1]=arrays[j];
                        arrays[j]=temp;
                  }
             }
          }
    }
}

/**********************************************************/
//测试类的定义：

package com.pengcheng;

public class Employee implements Comparable {

    public Employee() {
    }

    public Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }
    private int age;
    private String name;

    public static void main(String[] args) {
        Employee[] ems = new Employee[3];
        ems[0] = new Employee("rose", 50);
        ems[1] = new Employee("tom", 40);
        ems[2] = new Employee("jack", 36);
        Arrays.sort(ems);
        for(Employee e:ems)
        {
           System.out.println(e.toString());
        }
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public int compareTo(Object o) {
         return  this.name.compareTo(((Employee)o).name);
       
                
    }
    public String toString()
    {
       return "name is"+name +"  age is:"+ age;
    }
}

5.Clone(克隆)
  (1)Object 的clone()方法是保护的，因此我们要使用clone()方法，实现Cloneable()接口，要重写clone() 并设置为公有的方法。
  (2)Object的clone()是一种浅克隆，简单按照位模式进行。
  (3)如果类中存在类类型的域，要进行深克隆。
  (4)clone中要抛出CloneNotSupportedException 异常。
  public Object clone() throws CloneNotSupportedException {
        //默认系统的克隆
        Employee e=(Employee) super.clone();
        //对类类型进行克隆
        e.Birthday=(Date) (this.Birthday).clone();
        return e;
    }

 //浅克隆的方式：
  public Object clone() throws CloneNotSupportedException {
       
        return super.clone();
     
    }

6.作业：
 (1)如何实现让一个类既可以按照名字排序也可以按照年龄排序
    Collections.sort(list,Comparator com)
 (2)默写Comparable接口和排序，测试类。
 (3)利用Map实现电话本系统。
 (4)验证：
    接口是否可以继承接口？
    抽象类是否可以实现接口？
    接口是否可以继承实体类，是否可以继承抽象类？
    抽象类是否可以继承实体类？