Java基础3

文件结构

泛型与异常

泛型

异常

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