Java笔记3(泛型、异常、成绩评分程序)

[color=blue][size=x-large]文件结构 [/size][/color]
[img]http://images.cnblogs.com/cnblogs_com/luowei010101/201106/201106071714569221.png[/img]
[color=blue][size=x-large]泛型与异常 [/size][/color]
[img]http://images.cnblogs.com/cnblogs_com/luowei010101/201106/201106071714587420.png[/img]
[img]http://images.cnblogs.com/cnblogs_com/luowei010101/201106/201106071714595402.png[/img]
[color=blue][size=x-large]异常[/size][/color]
[img]http://images.cnblogs.com/cnblogs_com/luowei010101/201106/201106071714599796.png[/img]

Class7b / com.test1 / Test.java 

/*   
 * 功能：泛型的必要性   
 */   

package com.test1;    

import java.util.ArrayList;    

public class Test {    

    /**   
     * @param args   
     */   
    public static void main(String[] args) {    
        //泛型    
        //System.out.println("a="+(1>>>2));    
        ArrayList<Dog> al=new ArrayList<Dog>();//将ArrayList转成对Dog的泛型    
        //创建一只狗    
        Dog dog1=new Dog();    
        //放入到集合    
        al.add(dog1);    
        //取出    
        //Dog temp=(Dog)al.get(0);    
        //Cat temp2=(Cat)al.get(0);//类型转换错误    
        Dog temp=al.get(0);//因为前定义了ArrayList对Dog泛型，所以不报错    
    }    

}    

class Dog    
{    
    private String name;    
    private int age;    
    public String getName() {    
        return name;    
    }    
    public void setName(String name) {    
        this.name = name;    
    }    
    public int getAge() {    
        return age;    
    }    
    public void setAge(int age) {    
        this.age = age;    
    }    

}    

class Cat    
{    
    private String color;    
    private int age;    
    public String getColor() {    
        return color;    
    }    
    public void setColor(String color) {    
        this.color = color;    
    }    
    public int getAge() {    
        return age;    
    }    
    public void setAge(int age) {    
        this.age = age;    
    }    
}  
Class7b / com.test1 / Test2.java 

/*   
 * java的反射机制，泛型的经典应用   
 */   

package com.test1;    

import java.lang.reflect.Method;    

public class Test2 {    

    /**   
     * @param args   
     */   
    public static void main(String[] args) {    
        //     
        Gen<String> gen1=new Gen<String>("aaa");    
        gen1.showTypeName(gen1);    
        Gen<Integer> gen2=new Gen<Integer>(1);    
        gen2.showTypeName(gen2);    

        Gen<Bird> gen3=new Gen<Bird>(new Bird());    
        gen3.showTypeName(gen3);    
    }    

}    

//定义一个类    
class Gen<T> //定义的一种未知类型T，即泛型    
{    
    private T o;//用泛型定义一个变量(或对象)    
    //构造函数    
    public Gen(T a)    
    {    
        o=a;    
    }    

    //得到T的类型名称    
    public void showTypeName(Gen<T> obj)//参数是泛型    
    {    
        System.out.println("类型是："+o.getClass().getName());    
        //通过反射机制，可以得到T这个类型的很多信息    
        Method[] m=o.getClass().getDeclaredMethods();//得到某个类型的函数    
        //打印    
        for(int i=0;i<m.length;i++)    
        {    
            System.out.println(m[i].getName());    
        }    
    }    
}    

//定义一个Bird    
class Bird    
{    
    public void test1()    
    {    
        System.out.println("aa");    
    }    
    public void count(int a,int b)    
    {    
        System.out.println(a+b);    
    }    
}    

/*   
 *泛型的优点   
 *1.类型安全   
 *2.向后兼容   
 *3. 层次清晰   
 *4.性能较高，用Gj编写的代码可以为java编译器和虚拟机带来更多的类型信息。   
 *   
 *泛型主要解决安全和代码重用的问题   
 *在没有泛型之前，通过对类型Object的引用来实现参数的"任意化"，"任意化"   
 *带来的缺点是要做显式的类型转换，而这种转换是要求开发者对实际参数类型   
 *可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示   
 *错误 ，在运行时才出现异常，这是一个安全隐患。   
 *泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐   
 *式的，提高代码的重用率。   
*/ 
Class7b / com.test1 / Test3.java 

/*   
 * 异常   
 */   

package com.test1;    

import java.io.FileNotFoundException;    
import java.io.FileReader;    
import java.io.IOException;    
import java.net.Socket;    
import java.net.UnknownHostException;    

public class Test3 {    

    /**   
     * @param args   
     */   
    public static void main(String[] args) {    
        //检查异常     
        //1.打开文件    
        FileReader fr=null;    
        try {    
            fr=new FileReader("d:\\1.txt");    
            //在出现异常的地方，就终止执行代码,然后进入到catch    
            System.out.println("继续！");    
            Socket s=new Socket("192.168.111.111",78);    
        } catch (Exception e1) {//采用Exception可以捕获所有异常，因为它是父类    
            //把异常的信息输出，利于排除bug    
            System.out.println("\nException 内部");    
            System.out.println("message:="+e1.getMessage());    
            //System.exit(-1); //退出JVM    
            e1.printStackTrace();    
            //处理    
        }    
        finally //这个语句块，不管有没有异常都会执行    
        {    
            System.out.println("\n进入finally!");    
            //一般说，把需要关闭的资源[文件，连接，内存....]    
            if(fr!=null)    
            {    
                try {    
                    fr.close();    
                } catch (Exception e) {    
                    e.printStackTrace();    
                }    
            }    
        }    

        //2.连接一个192.168.12.12 ip的端口号4567    
        try {    
            Socket s=new Socket("192.168.1.23",78);    
        } catch (UnknownHostException e) {    
            System.out.println("\nUnknownHostException 内部");    
            e.printStackTrace();    
        } catch (IOException e) {    
            //如果有多个catch语句，则进入匹配异常的那个    
            System.out.println("\nIOException 内部");    
            e.printStackTrace();    
        }    

        //3.运行异常    
        try   
        {    
            int a=4/0;    
        }catch(ArithmeticException e)    
        {    
            e.printStackTrace();    
        }    
        System.out.println("ok1");    
    }    
} 
Class7b / com.test1 / Test4.java 

package com.test1;    

import java.io.FileNotFoundException;    
import java.io.FileReader;    

public class Test4 {    

    /**   
     * @param args   
     * @throws Exception    
     */   
    public static void main(String[] args) throws Exception {    
        //异常抛给JVM去处理    
        //创建一个Father    
        Father father=new Father();    
        father.test1();    
    }    

}    

class Father    
{    
    private Son son=null;    
    public Father()    
    {    
        son=new Son();    
    }    
    public void test1() throws Exception    
    {    
        //异常抛给调用者(main函数)去处理    
        System.out.println("1");    
        /*   
        try {   
            son.test2();   
        } catch (Exception e) {   
            System.out.println("\n父亲在处理！");   
            e.printStackTrace();   
        }   
        */   
        son.test2();    
    }    
}    

class Son    
{    
    public void test2() throws FileNotFoundException    
    {    
        //异常抛给调用者(Father.test1函数)去处理    
        FileReader fr=null;    
        fr=new FileReader("d:\\dd.txt");    
    }    
}  
两个练习 

HomeWork / com.test1 / Test1.java 

/*   
 * 跳水比赛，8个评委打分。运动员的成绩是8个成绩取掉一个最高分，   
 * 去掉一个最低分，剩下的6个分数的平均分就是最后得分。使用一维   
 * 数组实现打分功能。   
 * 找出最佳与最差评委   
 */   

package com.test1;    

import java.io.BufferedReader;    
import java.io.IOException;    
import java.io.InputStreamReader;    

public class Test1 {    

    /**   
     * @param args   
     */   
    public static void main(String[] args) {    
        //    
        Judge judge=new Judge();    
        System.out.println("平均分是："+judge.lastFen());    
        System.out.println("最差的裁判是："+(judge.getWorst()+1));    
    }    

}    

class Judge    
{    
    //定义可以存放8个小数的数组    
    float fens[]=null;    
    int size=3;    
    //构造函数    
    public Judge()    
    {    
        fens=new float[size];    
        //初始化    
        InputStreamReader isr=new InputStreamReader(System.in);//读取控制台数据存到输入流    
        BufferedReader br=new BufferedReader(isr);//将数据从输入流存到Buf流中    
        try {    
            for(int i=0;i<fens.length;i++)    
            {    
                System.out.println("请输入第"+(i+1)+"裁判的分数：");    
                fens[i]=Float.parseFloat(br.readLine());    
            }    
        } catch (Exception e) {    
            e.printStackTrace();    
        }    
        finally //关闭IO流    
        {    
            try {    
                br.close();    
            } catch (IOException e) {    
                e.printStackTrace();    
            }    
        }    
    }    

    //1.去掉最低分(目的找到最低分的下标)    
    public int getLowFenIndex()    
    {    
        //选择法    
        //认为第一个就是最低    
        float minFen=fens[0];    
        int minIndex=0;    
        for(int i=1;i<fens.length;i++)    
        {    
            if(minFen>fens[i]);    
            {    
                //修改最低分    
                minFen=fens[i];    
                minIndex=i;    
            }    
        }    
        return minIndex;    
    }    
    //2.去掉最高分(目的找到最高分的下标)    
    //2.去掉最高分(目的找到最高分的下标)    
    public int getHighFenIndex()    
    {    
        //选择法    
        //认为第一个就是最高    
        float maxFen=fens[0];    
        int maxIndex=0;    
        for(int i=1;i<fens.length;i++)    
        {    
            if(maxFen<fens[i])    
            {    
                //修改最高分    
                maxFen=fens[i];    
                maxIndex=i;    
            }    
        }    
        return maxIndex;    
    }    
    //3.得到平均分    
    //3.得到运动员的最后得分    
    public float lastFen()    
    {    
        float allFen=0;    
        int minIndex=this.getLowFenIndex();    
        int maxIndex=this.getHighFenIndex();    
        for(int i=0;i<fens.length;i++)    
        {    
            if(i!=minIndex&&i!=maxIndex)    
            {    
                allFen+=fens[i];    
            }    
        }    
        return allFen/(fens.length-2);    
    }    
    //4.得到最差评委    
    public int getWorst()    
    {    
        //假设第一个评委是最差的    
        int worstIndex=0;    
        float tempCai=0f;    
        float cai=Math.abs(fens[0]-lastFen());    
        for(int i=1;i<fens.length;i++)    
        {    
            tempCai=Math.abs(fens[0]-lastFen());    
            if(cai<tempCai)    
            {    
                worstIndex=i;    
                cai=tempCai;    
            }    
        }    
        return worstIndex;    
    }    
}  
HomeWork / com.test1 / Test2.java 

/*   
 * 三个同学考试，共考三门课：语文、数学、英语。使用二维整数    
 * 数组存放三个同学的学号和所有科目的考试成绩。如下表：   
 * 学号       语文      数学      英语   
 * 1002     78      92      76   
 * 1003     67      88      80   
 * 1007     90      95      80   
 */   

package com.test1;    

public class Test2 {    

    /**   
     * @param args   
     */   
    public static void main(String[] args) {    
        //定义一个二维数组    
        int[][] stus=    
        {{1002,78,23,56},{1003,23,89,34},{1007,78,89,90}};    
        for(int i=0;i<3;i++)    
        {    
            for(int j=0;j<4;j++)    
            {    
                if(i==0&&j==0)    
                {    
                    System.out.println("学号\t语文\t数学\t英语\t");    
                }    
                System.out.print(stus[i][j]+"\t");    
            }    
            System.out.print("\n");    
        }    
    }    
}