知不知

Java-Java基础03之开发小评分系统与成绩统计查询

项目文件结构

主要内容有：Java基础中的泛型使用，小评分系统与成绩统计。

泛型与异常

泛型

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");
        }
    }
}

知不知

知不知 是一个代码爱好者的技术知识分享部落格。

Java-Java基础03之开发小评分系统与成绩统计查询

泛型与异常

两个练习

知不知是一个代码爱好者的技术知识分享部落格。