• Java基础3


    文件结构

    泛型与异常

    泛型

    异常

    Class7b / com.test1 / Test.java

    1. /*  
    2.  * 功能:泛型的必要性  
    3.  */  
    4.   
    5. package com.test1;   
    6.   
    7. import java.util.ArrayList;   
    8.   
    9. public class Test {   
    10.   
    11.     /**  
    12.      * @param args  
    13.      */  
    14.     public static void main(String[] args) {   
    15.         //泛型   
    16.         //System.out.println("a="+(1>>>2));   
    17.         ArrayList<Dog> al=new ArrayList<Dog>();//将ArrayList转成对Dog的泛型   
    18.         //创建一只狗   
    19.         Dog dog1=new Dog();   
    20.         //放入到集合   
    21.         al.add(dog1);   
    22.         //取出   
    23.         //Dog temp=(Dog)al.get(0);   
    24.         //Cat temp2=(Cat)al.get(0);//类型转换错误   
    25.         Dog temp=al.get(0);//因为前定义了ArrayList对Dog泛型,所以不报错   
    26.     }   
    27.   
    28. }   
    29.   
    30. class Dog   
    31. {   
    32.     private String name;   
    33.     private int age;   
    34.     public String getName() {   
    35.         return name;   
    36.     }   
    37.     public void setName(String name) {   
    38.         this.name = name;   
    39.     }   
    40.     public int getAge() {   
    41.         return age;   
    42.     }   
    43.     public void setAge(int age) {   
    44.         this.age = age;   
    45.     }   
    46.        
    47. }   
    48.   
    49. class Cat   
    50. {   
    51.     private String color;   
    52.     private int age;   
    53.     public String getColor() {   
    54.         return color;   
    55.     }   
    56.     public void setColor(String color) {   
    57.         this.color = color;   
    58.     }   
    59.     public int getAge() {   
    60.         return age;   
    61.     }   
    62.     public void setAge(int age) {   
    63.         this.age = age;   
    64.     }   

    Class7b / com.test1 / Test2.java

    1. /*  
    2.  * java的反射机制,泛型的经典应用  
    3.  */  
    4.   
    5. package com.test1;   
    6.   
    7. import java.lang.reflect.Method;   
    8.   
    9. public class Test2 {   
    10.   
    11.     /**  
    12.      * @param args  
    13.      */  
    14.     public static void main(String[] args) {   
    15.         //    
    16.         Gen<String> gen1=new Gen<String>("aaa");   
    17.         gen1.showTypeName(gen1);   
    18.         Gen<Integer> gen2=new Gen<Integer>(1);   
    19.         gen2.showTypeName(gen2);   
    20.            
    21.         Gen<Bird> gen3=new Gen<Bird>(new Bird());   
    22.         gen3.showTypeName(gen3);   
    23.     }   
    24.   
    25. }   
    26.   
    27. //定义一个类   
    28. class Gen<T> //定义的一种未知类型T,即泛型   
    29. {   
    30.     private T o;//用泛型定义一个变量(或对象)   
    31.     //构造函数   
    32.     public Gen(T a)   
    33.     {   
    34.         o=a;   
    35.     }   
    36.        
    37.     //得到T的类型名称   
    38.     public void showTypeName(Gen<T> obj)//参数是泛型   
    39.     {   
    40.         System.out.println("类型是:"+o.getClass().getName());   
    41.         //通过反射机制,可以得到T这个类型的很多信息   
    42.         Method[] m=o.getClass().getDeclaredMethods();//得到某个类型的函数   
    43.         //打印   
    44.         for(int i=0;i<m.length;i++)   
    45.         {   
    46.             System.out.println(m[i].getName());   
    47.         }   
    48.     }   
    49. }   
    50.   
    51. //定义一个Bird   
    52. class Bird   
    53. {   
    54.     public void test1()   
    55.     {   
    56.         System.out.println("aa");   
    57.     }   
    58.     public void count(int a,int b)   
    59.     {   
    60.         System.out.println(a+b);   
    61.     }   
    62. }   
    63.   
    64. /*  
    65.  *泛型的优点  
    66.  *1.类型安全  
    67.  *2.向后兼容  
    68.  *3. 层次清晰  
    69.  *4.性能较高,用Gj编写的代码可以为java编译器和虚拟机带来更多的类型信息。  
    70.  *  
    71.  *泛型主要解决安全和代码重用的问题  
    72.  *在没有泛型之前,通过对类型Object的引用来实现参数的"任意化","任意化"  
    73.  *带来的缺点是要做显式的类型转换,而这种转换是要求开发者对实际参数类型  
    74.  *可以预知的情况下进行的。对于强制类型转换错误的情况,编译器可能不提示  
    75.  *错误 ,在运行时才出现异常,这是一个安全隐患。  
    76.  *泛型的好处是在编译的时候检查类型安全,并且所有的强制转换都是自动和隐  
    77.  *式的,提高代码的重用率。  
    78. */

    Class7b / com.test1 / Test3.java

    1. /*  
    2.  * 异常  
    3.  */  
    4.   
    5. package com.test1;   
    6.   
    7. import java.io.FileNotFoundException;   
    8. import java.io.FileReader;   
    9. import java.io.IOException;   
    10. import java.net.Socket;   
    11. import java.net.UnknownHostException;   
    12.   
    13. public class Test3 {   
    14.   
    15.     /**  
    16.      * @param args  
    17.      */  
    18.     public static void main(String[] args) {   
    19.         //检查异常    
    20.         //1.打开文件   
    21.         FileReader fr=null;   
    22.         try {   
    23.             fr=new FileReader("d:\\1.txt");   
    24.             //在出现异常的地方,就终止执行代码,然后进入到catch   
    25.             System.out.println("继续!");   
    26.             Socket s=new Socket("192.168.111.111",78);   
    27.         } catch (Exception e1) {//采用Exception可以捕获所有异常,因为它是父类   
    28.             //把异常的信息输出,利于排除bug   
    29.             System.out.println("\nException 内部");   
    30.             System.out.println("message:="+e1.getMessage());   
    31.             //System.exit(-1); //退出JVM   
    32.             e1.printStackTrace();   
    33.             //处理   
    34.         }   
    35.         finally //这个语句块,不管有没有异常都会执行   
    36.         {   
    37.             System.out.println("\n进入finally!");   
    38.             //一般说,把需要关闭的资源[文件,连接,内存....]   
    39.             if(fr!=null)   
    40.             {   
    41.                 try {   
    42.                     fr.close();   
    43.                 } catch (Exception e) {   
    44.                     e.printStackTrace();   
    45.                 }   
    46.             }   
    47.         }   
    48.            
    49.         //2.连接一个192.168.12.12 ip的端口号4567   
    50.         try {   
    51.             Socket s=new Socket("192.168.1.23",78);   
    52.         } catch (UnknownHostException e) {   
    53.             System.out.println("\nUnknownHostException 内部");   
    54.             e.printStackTrace();   
    55.         } catch (IOException e) {   
    56.             //如果有多个catch语句,则进入匹配异常的那个   
    57.             System.out.println("\nIOException 内部");   
    58.             e.printStackTrace();   
    59.         }   
    60.            
    61.         //3.运行异常   
    62.         try  
    63.         {   
    64.             int a=4/0;   
    65.         }catch(ArithmeticException e)   
    66.         {   
    67.             e.printStackTrace();   
    68.         }   
    69.         System.out.println("ok1");   
    70.     }   
    71. }

    Class7b / com.test1 / Test4.java

    1. package com.test1;   
    2.   
    3. import java.io.FileNotFoundException;   
    4. import java.io.FileReader;   
    5.   
    6. public class Test4 {   
    7.   
    8.     /**  
    9.      * @param args  
    10.      * @throws Exception   
    11.      */  
    12.     public static void main(String[] args) throws Exception {   
    13.         //异常抛给JVM去处理   
    14.         //创建一个Father   
    15.         Father father=new Father();   
    16.         father.test1();   
    17.     }   
    18.   
    19. }   
    20.   
    21. class Father   
    22. {   
    23.     private Son son=null;   
    24.     public Father()   
    25.     {   
    26.         son=new Son();   
    27.     }   
    28.     public void test1() throws Exception   
    29.     {   
    30.         //异常抛给调用者(main函数)去处理   
    31.         System.out.println("1");   
    32.         /*  
    33.         try {  
    34.             son.test2();  
    35.         } catch (Exception e) {  
    36.             System.out.println("\n父亲在处理!");  
    37.             e.printStackTrace();  
    38.         }  
    39.         */  
    40.         son.test2();   
    41.     }   
    42. }   
    43.   
    44. class Son   
    45. {   
    46.     public void test2() throws FileNotFoundException   
    47.     {   
    48.         //异常抛给调用者(Father.test1函数)去处理   
    49.         FileReader fr=null;   
    50.         fr=new FileReader("d:\\dd.txt");   
    51.     }   

    两个练习

    HomeWork / com.test1 / Test1.java

    1. /*  
    2.  * 跳水比赛,8个评委打分。运动员的成绩是8个成绩取掉一个最高分,  
    3.  * 去掉一个最低分,剩下的6个分数的平均分就是最后得分。使用一维  
    4.  * 数组实现打分功能。  
    5.  * 找出最佳与最差评委  
    6.  */  
    7.   
    8. package com.test1;   
    9.   
    10. import java.io.BufferedReader;   
    11. import java.io.IOException;   
    12. import java.io.InputStreamReader;   
    13.   
    14. public class Test1 {   
    15.   
    16.     /**  
    17.      * @param args  
    18.      */  
    19.     public static void main(String[] args) {   
    20.         //   
    21.         Judge judge=new Judge();   
    22.         System.out.println("平均分是:"+judge.lastFen());   
    23.         System.out.println("最差的裁判是:"+(judge.getWorst()+1));   
    24.     }   
    25.   
    26. }   
    27.   
    28. class Judge   
    29. {   
    30.     //定义可以存放8个小数的数组   
    31.     float fens[]=null;   
    32.     int size=3;   
    33.     //构造函数   
    34.     public Judge()   
    35.     {   
    36.         fens=new float[size];   
    37.         //初始化   
    38.         InputStreamReader isr=new InputStreamReader(System.in);//读取控制台数据存到输入流   
    39.         BufferedReader br=new BufferedReader(isr);//将数据从输入流存到Buf流中   
    40.         try {   
    41.             for(int i=0;i<fens.length;i++)   
    42.             {   
    43.                 System.out.println("请输入第"+(i+1)+"裁判的分数:");   
    44.                 fens[i]=Float.parseFloat(br.readLine());   
    45.             }   
    46.         } catch (Exception e) {   
    47.             e.printStackTrace();   
    48.         }   
    49.         finally //关闭IO流   
    50.         {   
    51.             try {   
    52.                 br.close();   
    53.             } catch (IOException e) {   
    54.                 e.printStackTrace();   
    55.             }   
    56.         }   
    57.     }   
    58.   
    59.     //1.去掉最低分(目的找到最低分的下标)   
    60.     public int getLowFenIndex()   
    61.     {   
    62.         //选择法   
    63.         //认为第一个就是最低   
    64.         float minFen=fens[0];   
    65.         int minIndex=0;   
    66.         for(int i=1;i<fens.length;i++)   
    67.         {   
    68.             if(minFen>fens[i]);   
    69.             {   
    70.                 //修改最低分   
    71.                 minFen=fens[i];   
    72.                 minIndex=i;   
    73.             }   
    74.         }   
    75.         return minIndex;   
    76.     }   
    77.     //2.去掉最高分(目的找到最高分的下标)   
    78.     //2.去掉最高分(目的找到最高分的下标)   
    79.     public int getHighFenIndex()   
    80.     {   
    81.         //选择法   
    82.         //认为第一个就是最高   
    83.         float maxFen=fens[0];   
    84.         int maxIndex=0;   
    85.         for(int i=1;i<fens.length;i++)   
    86.         {   
    87.             if(maxFen<fens[i])   
    88.             {   
    89.                 //修改最高分   
    90.                 maxFen=fens[i];   
    91.                 maxIndex=i;   
    92.             }   
    93.         }   
    94.         return maxIndex;   
    95.     }   
    96.     //3.得到平均分   
    97.     //3.得到运动员的最后得分   
    98.     public float lastFen()   
    99.     {   
    100.         float allFen=0;   
    101.         int minIndex=this.getLowFenIndex();   
    102.         int maxIndex=this.getHighFenIndex();   
    103.         for(int i=0;i<fens.length;i++)   
    104.         {   
    105.             if(i!=minIndex&&i!=maxIndex)   
    106.             {   
    107.                 allFen+=fens[i];   
    108.             }   
    109.         }   
    110.         return allFen/(fens.length-2);   
    111.     }   
    112.     //4.得到最差评委   
    113.     public int getWorst()   
    114.     {   
    115.         //假设第一个评委是最差的   
    116.         int worstIndex=0;   
    117.         float tempCai=0f;   
    118.         float cai=Math.abs(fens[0]-lastFen());   
    119.         for(int i=1;i<fens.length;i++)   
    120.         {   
    121.             tempCai=Math.abs(fens[0]-lastFen());   
    122.             if(cai<tempCai)   
    123.             {   
    124.                 worstIndex=i;   
    125.                 cai=tempCai;   
    126.             }   
    127.         }   
    128.         return worstIndex;   
    129.     }   

    HomeWork / com.test1 / Test2.java

    1. /*  
    2.  * 三个同学考试,共考三门课:语文、数学、英语。使用二维整数   
    3.  * 数组存放三个同学的学号和所有科目的考试成绩。如下表:  
    4.  * 学号       语文      数学      英语  
    5.  * 1002     78      92      76  
    6.  * 1003     67      88      80  
    7.  * 1007     90      95      80  
    8.  */  
    9.   
    10. package com.test1;   
    11.   
    12. public class Test2 {   
    13.   
    14.     /**  
    15.      * @param args  
    16.      */  
    17.     public static void main(String[] args) {   
    18.         //定义一个二维数组   
    19.         int[][] stus=   
    20.         {{1002,78,23,56},{1003,23,89,34},{1007,78,89,90}};   
    21.         for(int i=0;i<3;i++)   
    22.         {   
    23.             for(int j=0;j<4;j++)   
    24.             {   
    25.                 if(i==0&&j==0)   
    26.                 {   
    27.                     System.out.println("学号\t语文\t数学\t英语\t");   
    28.                 }   
    29.                 System.out.print(stus[i][j]+"\t");   
    30.             }   
    31.             System.out.print("\n");   
    32.         }   
    33.     }   
    34. }
  • 相关阅读:
    (CSDN迁移)js中的判空
    (CSDN迁移) 输入一个链表,从尾到头打印链表每个节点的值
    (CSDN迁移) 替换字符串中的空格
    (CSDN迁移) Java路径获取
    Apache JMeter 做接口并发测试
    用Postman做接口测试
    高并发或高负载下的系统设计
    编译时异常与运行时异常的区别
    使用JUNIT进行单元测试
    hexo 博客如何更换电脑
  • 原文地址:https://www.cnblogs.com/luowei010101/p/2074481.html
Copyright © 2020-2023  润新知