java基础训练

一、编程题：Java多线程简单应用 编写一个程序，在不同时段进行多线程消息显示。创建3 个线程，每个线程都显示一个消息，指出它即将进入睡眠状态，线程的睡眠时间为0~5秒之间的随机数，随后进入睡眠状态。当一个线程被唤醒，首先显示该线程的名称，并指出它已经完成睡眠，然后线程终止并进入死亡状态。

程序运行结果如下： 第一次运行： 线程开始

线程1进入睡眠时间2427 线程2进入睡眠时间1828 线程开始,main方法结束

线程3进入睡眠时间4803 线程2正在睡眠... 线程1正在睡眠... 线程3正在睡眠... 第二次运行： 线程开始

线程1进入睡眠时间1010 线程开始,main方法结束

线程2进入睡眠时间225 线程3进入睡眠时间3338 线程2正在睡眠... 线程1正在睡眠... 线程3正在睡眠...

实验步骤：

1、用MyEclipse或记事本工具按照Java编码规范创建Java程序，输入程序代码后，进行编译和运行。

2、用JDK工具（javac.exe、java.exe）、MyEclipse或其他工具对上述程序进行编译和运行。

代码如下：

import java.util.Random;

class MyThread implements Runnable{ private String name; private int time; public MyThread(String name,int time){ this.name=name; this.time=time; } public MyThread(){} public void run(){ System.out.println(this.name+\进入睡眠时间\+this.time); try{ Thread.sleep(this.time); }catch(InterruptedException e){ e.printStackTrace(); } System.out.println(this.name+\正在睡眠...\); }

public void info(){ System.out.println(\线程开始，main方法结束\); System.out.println(\); } }

public class Demo1 { public static void main(String[] args) { System.out.println(\线程开始\); Random r=new Random(); int a=r.nextInt(5000); int b=r.nextInt(5000); int c=r.nextInt(5000); MyThread my1=new MyThread(\线程1\,a); MyThread my2=new MyThread(\线程2\,b); MyThread my3=new MyThread(\线程3\,c); new Thread(my1).start(); new Thread(my2).start(); new Thread(my3).start(); MyThread my=new MyThread(); my.info(); } }

一、编程题：

编写一个程序，完成在银行的取款和存款操作。在定义银行类时，若取钱数大于余额，则做异常处理。控制台输出如下： ? 你当前的余额为:4000

? 请选择你要办理的业务种类（输入1或者2）：1、取款，2、存款 ? 1

? 请输入金额（精确到元）： ? 2000

? 对不起你的余额不足……

代码如下：

import java.util.Scanner; public class BankMoney { public static void main(String[] args) { Scanner scan1=new Scanner(System.in); System.out.println(\您当前的金额为：\); float mon1=scan1.nextFloat();

System.out.println(\您当前的金额为：\+mon1);

System.out.println(\请输入你要办理的业务种类（输入1或者2）：1、取款，2、存款\);

Scanner scan2=new Scanner(System.in); int a=scan2.nextInt();

System.out.println(\请输入金额：\);

Scanner scan3=new Scanner(System.in); float mon2=scan3.nextFloat(); if(a==1){

if(mon2>mon1){ try{ throw new Exception(\对不起你的余额不足！\); }catch(Exception e){

System.out.println(e); }

}else{ System.out.println(\你所剩余额为：\+(mon1-mon2)); } }

if(a==2){ System.out.println(\你所剩余额为：\+(mon1+mon2)); } } }

显示结果一：

您当前的金额为： 4000

您当前的金额为：4000.0

请输入你要办理的业务种类（输入1或者2）：1、取款，2、存款 1

请输入金额： 2000

你所剩余额为：2000.0

显示结果二：

您当前的金额为： 4000

您当前的金额为：4000.0

请输入你要办理的业务种类（输入1或者2）：1、取款，2、存款 1

请输入金额： 5000

java.lang.Exception: 对不起你的余额不足！

显示结果三： 您当前的金额为： 4000

您当前的金额为：4000.0

请输入你要办理的业务种类（输入1或者2）：1、取款，2、存款 2

请输入金额： 2000

你所剩余额为：6000.0

二、编程题：Java异常处理简单应用

通过图形界面从键盘输入两个数，进行相除，显示商。当输入串中含有非数字时或除数为0时，通过异常处理机制，使程序能正确运行。

public class ExceptionDemo1 { public static void main(String[] args) {

String str1=javax.swing.JOptionPane.showInputDialog(\请输入被除数\);

String str2=javax.swing.JOptionPane.showInputDialog(\请输入除数\); int a=0; try{ int s1=Integer.parseInt(str1); int s2=Integer.parseInt(str2); a=s1/s2;

}catch(ArithmeticException e){ javax.swing.JOptionPane.showMessageDialog(null,\算数异常：\+e); }catch(NumberFormatException e){ javax.swing.JOptionPane.showMessageDialog(null,\数字转换异常：\+e); }catch(Exception e){ javax.swing.JOptionPane.showMessageDialog(null,\其他异常：\+e); }

javax.swing.JOptionPane.showMessageDialog(null,\计算结果是：\+a ); } }

显示结果： 结果一：

结果二：

结果三：

一、列出指定属性

public class Demo3 { public static void main(String[] args) { //System.getProperties().list(System.out); //列出系统的全部属性 System.out.println(\系统版本为：

\+System.getProperty(\)+System.getProperty(\)+System.getProperty(\)); System.out.println(\系统给用户为：\+System.getProperty(\)); System.out.println(\当前用户目录：\+System.getProperty(\)); System.out.println(\当前用户工作目录：\+System.getProperty(\)); long startTime=System.currentTimeMillis(); int sum=0; for(int i=0;i<30000000;i++){ sum+=i; } long endTime=System.currentTimeMillis(); System.out.println(\计算所花费的时间：\+(endTime-startTime)+\毫秒。\); } }

显示结果：

系统版本为：Windows Vista6.1x86 系统给用户为：lenovo

当前用户目录：C:\\Users\\lenovo

当前用户工作目录：E:\\实验\\Java实验\\seven\\seven 计算所花费的时间：80毫秒。

二、观察对象释放

class Person{ private String name; private int age; public Person(String name,int age){ this.name=name; this.age=age; } public String toString(){ return \姓名：\+this.name+\，年龄：\+this.age; } public void finalize() throws Throwable{ System.out.println(\对象被释放——>\+this); } }

public class Demo4 { public static void main(String[] args) { Person per=new Person(\张三\,20); per=null; System.gc(); } }

显示结果：

对象被释放——>姓名：张三，年龄：20

三、编程题：

某超市门口为顾客准备了100辆手推车，每位顾客在购物时需一辆推车，在购物后把推车还回去。编写一个多线程程序，模拟超市购物。 运行结果：

超市模拟购物开始

第1001号顾客进入等车购物 第1001号顾客正在购物

第1002号顾客进入等车购物 第1001号顾客把推车还回去 第1002号顾客正在购物

第1002号顾客把推车还回去

例中假设就2辆小车，处理特殊情况，当小车不够时；如果小车多时只将sum的只修改一下即可。

class Car{ public static int sum=2; public synchronized void getCar(){ if(sum==0){ try{ super.wait(); }catch(InterruptedException e){ e.printStackTrace(); } } if(sum>0&&sum<=2){ try{ System.out.println(Thread.currentThread().getName()+\顾客正在购物\); Thread.sleep(1000); }catch(InterruptedException e){ e.printStackTrace(); } sum--; } } public synchronized void sedCar(){ if(sum>=0&&sum<2){ try{ System.out.println(Thread.currentThread().getName()+\顾客把推车还回去\); Thread.sleep(1000); }catch(InterruptedException e){

e.printStackTrace(); } sum++; super.notify(); } } }

class Buy implements Runnable{ private Car c; public Buy(Car c){ this.c=c; } public void setC(Car c){ this.c=c; } public Car getC(){ return c; } public void run(){ System.out.println(Thread.currentThread().getName()+\顾客进入等车购物\); c.getCar(); c.sedCar(); } }

public class Two { public static void main(String[] args) { System.out.println(\超市模拟购物开始\); Car c=new Car(); Buy b1=new Buy(c); Buy b2=new Buy(c); Buy b3=new Buy(c); new Thread(b1,\第1001号\).start(); new Thread(b2,\第1002号\).start(); new Thread(b3,\第1003号\).start(); } }

其中一个显示结果：

超市模拟购物开始

第1001号顾客进入等车购物 第1001号顾客正在购物 第1002号顾客进入等车购物 第1003号顾客进入等车购物 第1001号顾客把推车还回去 第1003号顾客正在购物 第1002号顾客正在购物 第1002号顾客把推车还回去 第1003号顾客把推车还回去

四、设计一个生产电脑和搬运电脑类，要求生产出一台电脑就搬走一台电脑，如果没有新的电脑生产出来，则搬运工要等待新电脑产出；如果生产出的电脑没有搬走，则要等待电脑搬走之后再生产，并统计出生产的电脑数量.

class Computer{ int num=0;

boolean flag=false; public synchronized void set(){ if(flag){ //不能生产，等待取走 try{ super.wait(); }catch(InterruptedException e){ e.printStackTrace(); } } try{ Thread.sleep(1000); }catch(InterruptedException e){ e.printStackTrace(); } num++; System.out.println(\生产了第\+num+\台电脑。\); flag=true; super.notify(); } public synchronized void get(){ if(!flag){ //不能取走，等待生产 try{ super.wait(); }catch(InterruptedException e){ e.printStackTrace(); } } try{ Thread.sleep(1000); }catch(InterruptedException e){ e.printStackTrace(); } System.out.println(\取走了第\+num+\台电脑。\); flag=false; super.notify(); } }

class Customer implements Runnable{ private Computer com; public void setCompu(Computer compu){ this.com=compu; } public Computer getCompu(){ return this.com; } public Customer(Computer com){ this.com=com; } public void run(){ for(int i=0;i<10;i++){ com.set(); com.get(); } } }

public class Four { public static void main(String[] args) { Computer a=new Computer(); Customer cus=new Customer(a); new Thread(cus).start(); } }

显示结果：

生产了第1台电脑。 取走了第1台电脑。 生产了第2台电脑。 取走了第2台电脑。 生产了第3台电脑。 取走了第3台电脑。 生产了第4台电脑。 取走了第4台电脑。 生产了第5台电脑。 取走了第5台电脑。 生产了第6台电脑。 取走了第6台电脑。 生产了第7台电脑。 取走了第7台电脑。 生产了第8台电脑。 取走了第8台电脑。 生产了第9台电脑。 取走了第9台电脑。 生产了第10台电脑。 取走了第10台电脑。

一、线程的休眠

class MyThread2 implements Runnable{ public void run(){ for(int i=0;i<5;i++){ try{ Thread.sleep(500); }catch(Exception e){} System.out.println(Thread.currentThread().getName()+\运行——>\+i); } } }

public class ThreadSheepDemo { public static void main(String[] args) { MyThread2 mt=new MyThread2(); Thread t=new Thread(mt,\线程\); t.start(); } }

//以上程序在执行时，每次的输出都会间隔500ms，达到了延迟操作的效果

结果如下：

线程运行——>0 线程运行——>1 线程运行——>2 线程运行——>3 线程运行——>4

二、中断线程

class MyThread3 implements Runnable{ public void run(){ System.out.println(\、进入run方法\); try{ Thread.sleep(10000); System.out.println(\、已经完成休眠\); }catch(Exception e){ System.out.println(\、休眠被终止\); return; //让程序返回被调用处 } System.out.println(\、run 方法正常结束\); } }

public class ThreadInterruptDemo { public static void main(String[] args) { MyThread3 mt=new MyThread3(); Thread t=new Thread(mt,\线程\); t.start(); try{ Thread.sleep(2000);//稍微停2s在进行中断 }catch(Exception e){} t.interrupt(); } }

显示结果：

1、进入run方法 3、休眠被终止

三、后台线程。

//在线程MyThread中，尽管run()方法是死循环的方式，但是程序依然可以执行完，因为方法中死循环的线程操作已经设置成后台运行了

class MyThread4 implements Runnable{ public void run(){ while(true){ System.out.println(Thread.currentThread().getName()+\在运行。\); } } }

public class ThreadDaemonDemo { public static void main(String[] args) { MyThread4 mt=new MyThread4(); Thread t=new Thread(mt,\线程1\);

t.setDaemon(true); //此线程在后台运行 t.start(); //启动线程 } }

四、线程A，休眠1秒；线程B，休眠3秒；线程C，休眠4秒，继承Thread类

class MyThread5 extends Thread{ private int time; public MyThread5(String name,int time){ super(name); this.time=time; } public void run(){ try{ Thread.sleep(this.time); }catch(InterruptedException e){ e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+\线程，休眠\+this.time+\毫秒。\); } }

public class ExecDemo { public static void main(String[] args) { MyThread5 mt1=new MyThread5(\线程A\,1000); MyThread5 mt2=new MyThread5(\线程B\,3000); MyThread5 mt3=new MyThread5(\线程C\,4000); mt1.start(); mt2.start(); mt3.start(); } }

五、如果使用Runnable接口实现多线程，则不像Thread类那样可以直接使用Thread类中的name属性，需要在类中单独定义一个name是想以保存线程名称

class MyThread6 implements Runnable{ private String name; private int time; public MyThread6(String name,int time){ this.name=name; this.time=time; } public void run(){ try{ Thread.sleep(this.time); }catch(InterruptedException e){ e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+\线程，休眠\+this.time+\毫秒。\); } }

public class ExecDemo1 { public static void main(String[] args) { MyThread6 mt1=new MyThread6(\线程A\,1000);

}

}

MyThread6 mt2=new MyThread6(\线程B\,3000); MyThread6 mt3=new MyThread6(\线程C\,4000); new Thread(mt1).start(); new Thread(mt2).start(); new Thread(mt3).start();

六、解除死锁代码。

class Zhangsan{ public void say(){ System.out.println(\张三对李四说：“你给我画，我就把书给你！”\); } public void get(){ System.out.println(\张三得到画了。\); } }

class Lisi{ public void say(){ System.out.println(\李四对张三说：“你给我书，我就把画给你！”\); } public void get(){ System.out.println(\李四得到书了。\); } }

public class DeadLock implements Runnable{ private static Zhangsan zs=new Zhangsan(); private static Lisi ls=new Lisi(); private boolean flag=false; public void run(){ if(flag){ synchronized (zs){ zs.say(); try{ Thread.sleep(500); }catch(InterruptedException e){ e.printStackTrace(); } synchronized(ls){ zs.get(); } } }else{ synchronized (zs){ ls.say(); try{ Thread.sleep(500); }catch(InterruptedException e){ e.printStackTrace(); } synchronized(ls){ ls.get(); } } } } public static void main(String[] args){

DeadLock t1=new DeadLock(); DeadLock t2=new DeadLock(); t1.flag=true; t2.flag=false; Thread thA=new Thread(t1); Thread thB=new Thread(t2); thA.start(); thB.start(); } }

显示结果：

张三对李四说：“你给我画，我就把书给你！” 张三得到画了。

李四对张三说：“你给我书，我就把画给你！” 李四得到书了。

一、实现Runnable接口可以资源共享

class MyThread implements Runnable{ private int ticket=5; public void run(){ for(int i=0;i<100;i++){ if(ticket>0){ System.out.println(\卖票：ticket=\+ticket--); } } } }

public class RunnableDemo1 { public static void main(String[] args) { MyThread my=new MyThread(); new Thread(my).start(); new Thread(my).start(); new Thread(my).start(); } }

结果显示不止下列三个：

卖票：ticket=5 卖票：ticket=3 卖票：ticket=4 卖票：ticket=1 卖票：ticket=2 卖票：ticket=3 卖票：ticket=4 卖票：ticket=1 卖票：ticket=2 卖票：ticket=5 卖票：ticket=3 卖票：ticket=2 卖票：ticket=1 卖票：ticket=4 卖票：ticket=5

二、观察程序的输出

class MyThread1 implements Runnable{ }

public class CurrentThreadDemo1 { }

//在java中所有的线程都是同时启动的，哪个线程先抢到CPU资源，哪个线程就先运行，所以显示结果不唯一

public static void main(String[] args) { }

MyThread1 my =new MyThread1(); new Thread(my,\线程\).start(); public void run(){ }

for(int i=0;i<3;i++){ }

System.out.println(Thread.currentThread().getName()+\运行，

i=\+i);

my.run();

三、线程的强制执行，用join（）方法，线程强制执行期间，其他线

程无法运行，必须等到线程完成之后才可以继续执行。

class MyThread1 implements Runnable{ }

public class ThreadJoinDemo {

public static void main(String[] args) {

MyThread1 mt=new MyThread1(); Thread t=new Thread(mt,\线程\); public void run(){ }

for(int i=0;i<8;i++){ }

System.out.println(Thread.currentThread().getName()+\运行

——>\+i);

t.start();

for(int i=0;i<8;i++){ if(i>4){ }

try{

t.join();

}catch(Exception e){}

System.out.println(\线程运行——>\+i); } }

}

显示结果如下：（结果不唯一，不止以下结果，仅复制此三个作说明）

四、判断线程是否启动

class MyThread implements Runnable{ }

public class ThreadAliveDemo {

public static void main(String[] args) { }

MyThread mt=new MyThread(); Thread t=new Thread(mt,\线程\);

System.out.println(\线程执行之前——>\+t.isAlive()); t.start();

System.out.println(\线程执行之后——>\+t.isAlive()); for(int i=0;i<3;i++){ }

System.out.println(\代码执行之后——>\+t.isAlive());

System.out.println(\运行——>\+i);

public void run(){ }

for(int i=0;i<3;i++){ }

System.out.println(Thread.currentThread().getName()+\运行

——>\+i);

}

显示结果如下（结果不知此几个）：

一、 设计一个宠物商店，宠物商店中可以有多种（有用户决定数量）宠物，试表示出

此种关系，并要求可以根据宠物的关键字查询到相应的宠物信息。所需宠物信息自行设

计。具体分析如下：

（1） 本要求中提示宠物信息可以自行设计，所以此时简单设计出名字、颜色、年龄3

个属性。

（2） 宠物的种类很多，如猫、狗等都属于宠物，所以宠物应当是一个标准。 （3） 在宠物商店中，只要是符合此宠物标准的就应该可以放进宠物商店中。

（4） 宠物商店要保存多种宠物，则肯定应该是宠物的对象数组，如果宠物个数由用

户决定，则应该创建宠物商店时，就分配好所能保存的宠物个数。

代码如下：

interface Pet{ }

class Cat implements Pet{

private String name; private String color; private int age;

public Cat(String name,String color,int age){ }

public String getName(){ }

public String getColor(){ }

return this.color; return this.name; this.setName(name); this.setColor(color); public String getName(); public String getColor(); public int getAge();

this.setAge(age);

}

public int getAge(){ }

public void setName(String name){ }

public void setColor(String color){ }

public void setAge(int age){ }

this.age=age; this.color=color; this.name=name; return this.age;

class Dog implements Pet{ }

class PetShop{

private Pet[] pets; private int foot; private String name;

private String color; private int age;

public Dog(String name,String color,int age){ }

public String getName(){ }

public String getColor(){ }

public int getAge(){ }

public void setName(String name){ }

public void setColor(String color){ }

public void setAge(int age){ }

this.age=age; this.color=color; this.name=name; return this.age; return this.color; return this.name; this.setName(name); this.setColor(color);

this.setAge(age);

}

public PetShop(int len){ }

public boolean add(Pet pet){ }

public Pet[] search(String keyWord){ //关键字查找

Pet p[]=null; int count=0;

//确认开辟的空间大小，看有多少个宠物符合查询条件 for(int i=0;i

if(this.pets[i]!=null){ if(this.foot

this.pets[this.foot]=pet; this.foot++; return true; return false; if(len>0){ }

this.pets=new Pet[len];

this.pets=new Pet[1]; //至少开辟一个空间 }else{

}else{

if(this.pets[i].getName().indexOf(keyWord)!=-1||this.pets[i].getC

}

p=new Pet[count];

int f=0;//设置增加的位置标记

for(int i=0;i

if(this.pets[i]!=null){ }

}

count++; //符合条件的宠物个数

olor().indexOf(keyWord)!=-1){

if(this.pets[i].getName().indexOf(keyWord)!=-1||this.pets[i].getC }

}

return p;

}

}

p[f]=this.pets[i];//将符合查询条件的宠物信息保存 f++;

olor().indexOf(keyWord)!=-1){

public class PetShopDemo {

public static void main(String[] args) {

PetShop ps=new PetShop(5);

ps.add(new Cat(\白猫\,\白色的\,2));//增加宠物，成功 ps.add(new Cat(\黑猫\,\黑色的\,3));//增加宠物，成功 ps.add(new Cat(\花猫\,\花色的\,3));//增加宠物，成功 ps.add(new Dog(\拉布拉多\,\黄色的\,3));//增加宠物，成功 ps.add(new Dog(\金毛\,\金色的\,3));//增加宠物，成功 ps.add(new Dog(\黄狗\,\黄色的\,3));//增加宠物，失败 print(ps.search(\黄\)); }

}

public static void print(Pet p[]){

for(int i=0;i

if(p[i]!=null){

System.out.print(p[i].getName()+\+p[i].getAge()+\+p[i].getAge }

}

}

());

显示结果：

拉布拉多,3,3

二、 对象的比较

Object类提供的equals（）方法默认是比较地址的，并不能对内容进行比较。

class Persona{

private String name; private int age;

public Persona(String name,int age){ }

public boolean equals(Object obj){//覆写Object类中的equals()方法

if(this==obj){ //如果两个而对象的地址相等，则肯定是同一个 }

if(!(obj instanceof Persona)){//判断传进来的对象是否是Person的实例

return true; this.name=name; this.age=age;

对象

}

}

}

return false; //如果不是,则直接返回false

Persona per=(Persona)obj;//将传进来的对象向下转型

if(per.name.equals(this.name)&&per.age==this.age){ }

return true; return false; }else{

public String toString(){ }

return \姓名：\+this.name+\年龄：\+this.age;

public class ObjectDemo1 { }

public static void main(String[] args) { }

Persona per1=new Persona(\小明\,20); Persona per2=new Persona(\小强\,22); Persona per3=new Persona(\小强\,22);

System.out.println(per1.equals(per2)?\是同一个人！\:\不是同一个人！System.out.println(per2.equals(per3)?\是同一个人！\:\不是同一个人！System.out.println(per1.equals(\)?\是同一个人！\:\不是同一个

\); \); 人！\);

显示结果：

不是同一个人！ 是同一个人！ 不是同一个人！

一、使用面向对象的概念表示出下面的生活场景：

小明去超市买东西，所有买到的东西都放在了购物车之中，最后到收银台一起结账。

class Customer{

private String name;

public Customer(String name){ this.name=name;

System.out.println(\顾客姓名：\+name); } }

class Goods{

private String gname; private double price;

}

private static float countPrice; private static int countGoods;

public Goods(String gname,double price ){ }

public String getGname(){ }

public double getPrice(){ }

public void getGood(){ }

public String getCount(){ }

return \商品总数：\+countGoods+\商品总额：\+countPrice+\元\; System.out.println(\商品名称：\+gname+\商品价格\+price+\元\); return price; return gname; this.gname=gname; this.price=price; countPrice+=price; countGoods++;

class Cart{ }

public class Buy {

public static void main(String[] args) {

Customer cus=new Customer(\小明\); private Goods good; public Cart(Goods good){ }

public void getInfo(){

System.out.println(good.getCount()); }

this.good=good;

Goods good1=new Goods(\面包\,2.00); good1.getGood();

Goods good2=new Goods(\苹果\,4.20); good2.getGood();

Goods good3=new Goods(\可乐\,3.00); good3.getGood();

Cart cart=new Cart(good3); cart.getInfo(); }

}

显示结果：

顾客姓名：小明

商品名称：面包,商品价格2.0元 商品名称：苹果,商品价格4.2元 商品名称：可乐,商品价格3.0元 商品总数：3, 商品总额：9.2元

1. 异常处理。

public class Exception { }

public static void main(String args[]){ }

System.out.println(\计算开始****\); int i=0; int j=0; try{ }

catch(ArithmeticException e){ }

catch(NumberFormatException e){ }

catch(ArrayIndexOutOfBoundsException e){ }

finally{

System.out.println(\不管是否出现异常，此句都将执行！\); }

System.out.println(\数组越界异常：\+e); System.out.println(\数字装转换异常：\+e); System.out.println(\算数异常：\+e); String str1=args[0]; String str2=args[1]; i=Integer.parseInt(str1); j=Integer.parseInt(str2); int temp=i/j;

System.out.println(\两个数字相处的结果是：\+temp); System.out.println(\);

2. throws 关键字 处理异常。使用throws 声明的方法表示此方法不处理异常，

而交给方法的调用处进行处理。

class Math{ }

public class Exception1 {

public static void main(String[] args) {

Math m=new Math();

try{ //因为有throws ，不管是否有异常，都必须处理 System.out.println(\除法操作：\+m.div(10, 2)); }

public int div(int i,int j)throws Exception{ //此方法中不处理异常 int temp=i/j; }

return temp;

catch(Exception e){

e.printStackTrace(); //打印异常 } }

显示结果：

}

除法操作：5 《二》

class Math2{ }

public class Exception2 { }

显示结果： 除法操作：5

public static void main(String[] args )throws Exception { }

Math2 m=new Math2();

System.out.println(\除法操作：\+m.div(10, 2)); public int div(int i,int j)throws Exception{ }

int temp=i/j; return temp;

3. throw 关键字抛出一个异常，抛出时直接抛出异常类的实例化对象即可。

public class Exception3 { }

public static void main(String[] args) { }

try{

throw new Exception(\自己抛出的异常!\); }catch(Exception e){ }

System.out.println(e);

显示结果：

java.lang.Exception: 自己抛出的异常! 4. 范例——throw class Math3{

public int div(int i,int j) throws Exception{

System.out.println(\计算开始****\); int temp =0; try{ }

return temp;

temp=i/j;

throw e; //把异常交给被调用处

System.out.println(\计算结束****\); }catch(Exception e){ }finally{

与throws的应用。

}

}

public class Exception4 { }

public static void main(String[] args) { }

Math3 m=new Math3(); try{ }

System.out.println(\除法操作：\+m.div(10,0)); System.out.println(\异常处理：\+e); }catch(Exception e){

显示结果:

****计算开始**** ****计算结束****

异常处理：java.lang.ArithmeticException: / by zero

一、 对象的向下转型。

例：

class A{ }

class B extends A{ }

public class Passdown {

public static void main(String[] args) { A a=new B(); B b=(B)a; b.fun1();

public void fun1(){ }

public void fun3(){ }

System.out.println(\); System.out.println(\); public void fun1(){ }

public void fun2(){ }

public void fun(){ }

this.fun1();

System.out.println(\); System.out.println(\);

}

b.fun2(); b.fun3(); b.fun(); }

显示结果：

B→public void fun1(){} A→public void fun2(){} B→public void fun3(){} B→public void fun1(){}

解释：fun1()已经被子类覆写，则此时调用的方法是被子类覆写过的方法。 二、 抽象类的实际应用。 例：

abstract class Person{ }

class Student extends Person{

private float score; public float getScore(){ }

public void setScore(float score){ }

public Student(String name,int age,float score){ }

public String getContent(){

super(name,age); this.setScore(score); this.score=score; return score; private String name; private int age;

public Person(String name,int age){ }

public String getName(){ }

public int getAge(){ }

public void say(){

System.out.println(this.getContent()); }

public abstract String getContent();

return age; return name; this.name=name; this.age=age;

}

}

return \学生信息：姓名：\+super.getName()+\，年龄：\+super.getAge()+\

分数：\+this.getScore();

class Worker extends Person{ }

public class Pattern { }

显示结果：

学生信息：姓名：张三，年龄：19,分数：99.0 学生信息：姓名：李斯，年龄：20,工资：5000.0

public static void main(String[] args) { }

Person per1=new Student(\张三\,19,99); Person per2=null;

per2=new Worker(\李斯\,20,5000.00f); per1.say(); per2.say();

private float salary;

public Worker(String name,int age,float salary){ }

public String getContent(){ }

return \学生信息：姓名：\+super.getName()+\，年龄：\+super.getAge()+\super(name,age); this.salary=salary;

工资：\+this.salary;

一、 接口的实际应用——制定标准。

例如：U盘和打印机都可以插在计算机上，是因为二者均实现了USB的接口，对于计

算机来说，只要是符合了USB接口标准设备的就都可以插进来。 接口就是规定了一个标准，计算机认得只是接口，而对于具体的设备计算机本身并不关心。代码如下：

interface USB{ //定义usb接口

public void start(); //usb 设备开始工作 public void stop(); //usb 设备结束工作 }

class Computer{

public static void plugin(USB usb){ //只要是USB的设备就都可以插入

usb.start(); //让USB设备开始工作 System.out.println(\设备工作*****\); usb.stop(); //让USB设备停止工作

}

}

class Flash implements USB{ //U盘 public void start(){ }

class Print implements USB{ //打印机 }

public class Upan { }

显示结果： U盘开始工作。

*****USB设备工作***** U盘停止工作。 打印机开始工作。 *****USB设备工作***** 打印机停止工作。

二、使用Object接收接口实例 interface A1{ }

class B1 implements A1{ }

public class ObjectDemo {

public static void main(String[] args) { A1 a=new B1();//为接口实例化 public String getInfo(){ }

return \;

public String getInfo();//定义抽象方法 public static void main(String[] args) { }

Computer.plugin(new Flash()); //插入U盘 Computer.plugin(new Print()); //插入打印机 public void start(){

System.out.println(\打印机开始工作。\); }

public void stop(){ }

System.out.println(\打印机停止工作。\); }

public void stop(){

System.out.println(\盘停止工作。\); }

System.out.println(\盘开始工作。\);

}

Object obj=a;//对象向上转型 A1 x=(A1)obj;//对象向下转型

System.out.println(x.getInfo()); }

显示结果： Hello World!

本文来源：https://www.bwwdw.com/article/obw7.html