文件结构
泛型与异常
泛型
异常
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");
- }
- }
- }